Logitech K350 MediaKeys mit AIMP und MPC-HC

Nach dem ich mir nun die K350 von Logitech zugelegt habe, hatte ich zuerst schon bedenken, dass ich wieder vom AIMP-MediaPlayer zu Winamp oder gar Windows Media Player wechseln muss, da im AIMP die MediaKeys von der Tastatur nicht funktionierten.

Glücklicherweise fand ich aber im Internet die Lösung, und zwar muss in der Player-Ini des SetPoint-Programmes AIMP nur nachgetragen werden. Wichtig dabei ist darauf zu achten, welche Version von AIMP installiert ist. Hatte hier ein paar Probleme da ich mit einer falsche Version gearbeitet hatte.

Die Ini findet man nach der Standard-Installation unter folgenden Pfad:

%ProgramFiles%\Logitech\SetPointP\players.ini

Die INI muss um die Zeilen 2-4 erweitert werden, die der Sektion „Players“ hinzugefügt werden müssen:

[Players]
AIMP2=cmd,AIMP2.exe,Winamp v1.x,xxx,xxx,40045,40046,40047,40044,40048,0,1,WinAmp 5
AIMP3=cmd,AIMP3.exe,Winamp v1.x,xxx,xxx,40045,40046,40047,40044,40048,0,1,WinAmp 5
AIMP4=cmd,AIMP.exe,Winamp v1.x,xxx,xxx,40045,40046,40047,40044,40048,0,1,WinAmp 5
mplayerc=wac,mpc-hc64.exe,MediaPlayerClassicW,Windows Media Player,xxx,xxx,xxx,xxx,xxx,xxx,0,1,Media Player Classic
...

Alle anderen Einträge müssen nicht angepasst werden. Die markierte Zeile 5 zeigt, wie der Eintrag definiert ist, damit der Media Player Classic (MPC-HC) von der SetPoint-Software zu erkennen wird.

VMware Player 6 unter Windows 10

Nach dem erfolgreichen Update von Windows 8.1 auf Windows 10 hat leider der VMware Player nicht richtig funktioniert.

Zuerst konnte die VM’s zwar gestartet werden, aber keine der gestarteten VM’s ist mehr ins Netzwerk gekommen. Bei „Configure Adapaters“ bei der Bridge-Einstellung, war auch keine der Netzwerkkarten mehr anzuwählen. Nach etwas Recherche bin ich darauf gestoßen, dass der Bridge-Dienst nicht mehr auf der Netzwerkkarte installiert ist.

Um dies zu beheben, muss man zu den Netzwerkeinstellungen. Öffnet dort das Eigenschaftsfenster der physikalischen Netzwerkkarte und dort kann man über die Schaltfläche „Installatieren…“ neue Komponenten einrichten. Nach dem Klick auf die Schalftfläche „Dienst“ auswählen und mit „Hinzufügen…“ bestätigen. Dann unter dem Hersteller VMware den „VMware Bridge Protocol“ Eintrag auswählen und mit „OK“ bestätigen. Nach dem installieren, können dann die Netzwerkkarten bei Bridge wieder konfiguriert werden und eine Verbindung ins Netzwerk ist wieder möglich.

Nach einen Neustart des Host ist dann ein andere Fehler aufgetaucht, und zwar wurde beim versuch eine VM zu starten die Fehlermeldung „error while powering on: internal error“ angezeigt.

Um diese Problem zu lösen, muss der Dienst „VMware Authorization Service“ manuell nach gestartet werden. Er steht zwar auf Automatisch, ist beim hochfahren aber nicht gestartet worden oder wieder abgestürzt. Nach dem Start des Dienstes funktioniert jede VM wieder

Windows 8 Energiesparmodus

Da ich immer wieder Probleme mit automatischen Aufwachen aus dem Energiesparmodus in Windows 8 hatte, hab ich mich im Internet etwas umgeschaut und bin auf folgenden Befehl gestoßen:

powercfg -devicequery wake_armed

Mit diesen, werden alle Geräte aufgelistet, die den Rechner aus den Energiesparmodus aufwecken dürfen. Und mit nachfolgenden Befehl, können einzelne Geräte entfernt werden:

powercfg -devicedisablewake [device_name]

(device_name, durch den Namen des zu entfernenden Gerät ersetzen. Vorsicht, wenn der Gerätename Leerzeichen beinhaltet, muss der Namen mit „“ umschlossen werden)

C# Dienst mit eigener Installationsroutine (per /i)

Nach langer suche und vielen Zusammenstückeln, habe ich nun endlich ein komplettes Paket um einen Dienst die Möglichkeit zu implementieren sich selbst per Kommandozeilenparameter zu installieren.

Ebenso wird zeitgleich eine Konsolenausgabe mit implementiert. Das einzige Problem hier ist, solange der Projekt-Typ nach Standard auf „Windows Anwendung“ steht, funktionieren das Attachen nicht ganz komplikationslos, da die Anwendung in der Konsole direkt zurückkehrt ohne aufs Ende des Prozesses zu warten. Um diese Problem wegzubekommen, muss der Projekt-Typ auf „Konsolen Anwendung“ umgestellt werden.

Dieser Quellcode hat einen großen Vorteil gegenüber anderen die noch vorhanden sind, da hier beim installieren und deinstallieren das gleiche durchgeführt wird, was auch das InstallUtil Programm durchführt. Daher kann das Array welches bei Install und Deinstall übergeben wird, entsprechend der Parameter die am InstallUtil vorhanden sind erweitert werden.

(Vorne weg noch ein kleiner Tip, sollte die using-Direktive zu einer Klasse fehlen und die Klasse wurde richtig geschrieben, dann kann per [Strg]+[.] die Direktive automatisch ermittelt und hinzugefügt werden. Für den Fall das ich welche vergessen habe.)

Zuerst einmal die Konstanten und die Imports, welche innerhalb der „static class Program“ eingefügt werden müssen:

const uint ATTACH_PARENT_PROCESS = 0x0ffffffff;
const int ERROR_ACCESS_DENIED = 5; // Process ist schon attached von einer anderen Konsole
[DllImport("kernel32", SetLastError = true)]
static extern bool AllocConsole();
[DllImport("kernel32", SetLastError = true)]
static extern bool FreeConsole();
[DllImport("kernel32", SetLastError = true)]
static extern bool AttachConsole(uint dwProcessID);

Die Main-Prozedur (der noch der Paramter „string[] args“ hinzugefügt werden muss, wenn nicht vorhanden) muss nun folgender weise erweitert werden:

ServiceBase[] ServicesToRun;
ServicesToRun = new ServiceBase[] { new MyNewService() };
if (System.Environment.UserInteractive)
{
  if(!AttachConsole(ATTACH_PARENT_PROCESS) || Marshal.GetLastWin32Error() == ERROR_ACCESS_DENIED)
    AllocConsole();
  // Uebergabe Parameter
  bool install = false;
  bool uninstall = false;
  bool debug = false;
  string value = "";
  int pos = -1;
  for (int i = 0; i < args.Length; i++)
  {
    var arg = args[i];
    value = "";
    pos = arg.IndexOf('=');
    if (pos > 0)
    {
      value = arg.Substring(pos + 1);
      arg = arg.Substring(0, pos);
    }
    switch(arg.ToLower())
    {
      case "/i": install = true; break;
      case "/u": uninstall = true; break;
      case "/c": debug = true; break;
      case "/account": /*Account-Typ aus der Variable value speichern*/ break;
      case "/user": /*Benutzer aus der Variable value speichern*/ break;
      case "/passwd": /*Passwort aus der Variable value speichern*/ break;
      default:
        Console.WriteLine("Argument nicht verstanden: {0}", arg);
        break;
    }
  }
  try
  {
    if (install)
    {
      var combArgs = new string[] { Assembly.GetExecutingAssembly().Location };
      System.Configuration.Install
        .ManagedInstallerClass.InstallHelper(combArgs);
    }
    else if (uninstall)
    {
      var combArgs = new string[] { "/u", Assembly.GetExecutingAssembly().Location };
      System.Configuration.Install
        .ManagedInstallerClass.InstallHelper(combArgs);
    }
    else if (debug)
    {
      var svc = ServicesToRun[0] as MyNewService;
      svc.OnStartDebug(args);
      Console.WriteLine("[Return] fürs beenden drücken...");
      Console.ReadLine();
      svc.OnStopDebug();
    }
  }
  catch (Exception exc)
  {
    Console.WriteLine(exc.Message);
  }
  // Konsole wieder freigeben
  FreeConsole();
}
else
{
  // Wenn das Programm nicht ueber die Konsole gestartet wurde dann als Dienst starten lassen
  ServiceBase.Run(ServicesToRun);
}

Zusätzlich müssen die 2 Funktionen (OnStartDebug/OnStopDebug) angelegt werden, die einzig die gleichnamigen (ohne Debug am Ende) protected Methoden aufrufen, wenn der Debug-Modus gewünscht ist. Wenn nicht, dann einfach diesen Teil aus den obigen Quellcode entfernen.

Mit Munin ein Windows-System überwachen

Wichtige Informationen zu beiden Wegen

Der Name des Windowsrechners muss vom Linux System immer auflösbar sein. Wichtig ist dies bei Einstellungen in der munin.conf, das dort immer der richtige Rechnername verwendet wird. Funktioniert die Namensauflösung nicht, oder nicht richtig, dann ist es sinnvoller die Namen mit Verknüpfung auf die IP Adresse in die „/etc/hosts“-Datei einzutragen.

Alle Werte, welche mit {}-Klammern umrahmt sind, sind entsprechend durch die passenden Informationen auszutauschen und die {}-Klammern zu entfernen. Bei anderen Werten handelt es sich um feste Werte die nur bei entsprechendem Fachwissen ausgetauscht werden sollten.

Überwachen mit SNMP

Arbeiten auf Seite des Master-Servers (Debian Squezzy)

In der Datei „/etc/munin/munin.conf“ muss der Name des Windowscomputers hinterlegt werden (MeineGruppe ist der Name einer frei definierbaren Gruppe [wird für Gruppenweite Einstellungsmöglichkeiten benötigt], MeinComputer ist der Rechnername von Windows. Beides ist entsprechend anzupassen):

[{MeineGruppe};{MeinComputer}]
address 127.0.0.1

Die Datei „/etc/munin/plugin-conf/munin-node“ muss noch um einen Abschnitt erweitert werden, damit der munin-node weiß von welcher Addresse er die Information beziehen soll (IP ist entsprechend anzupassen, MeinComputer muss genauso wie im Abschnitt drüber angepasst werden):

[snmp_{MeinComputer}*]
env.ip {x.x.x.x}
env.port 161
env.community public

Im Verzeichnis „/usr/share/munin/plugins/“ sind verschiedene Scripte für SNMP vorhanden, diese müssen nun noch in den „/etc/munin/plugins/“-Ordner gelinkt werden, mit der Namenskonvention snmp_MeinComputer_*. Damit dies nicht alles per Hand durchgeführt werden muss, existiert folgender Befehl (MeinComputer wieder entsprechend oben angegeben anpassen):

munin-node-configure -snmp {MeinComputer} --shell | sh -x

Dadurch werden Shell-Befehle ausgeben welche durch „| sh -x“ direkt ausgeführt werden und alle SymLinks erstellen, welche noch nicht existieren.

Dann noch mit folgenden Befehl, den munin-node neustarten lassen und schon wurde auf Master-Seite alles durchgeführt:

/etc/init.d/munin-node restart

Arbeiten auf Seiten des Client Computers (Windows)

Windows XP

Hier muss „nur“ ein SNMP-Dienst installiert werden. Dieser wird ab Windows XP von Microsoft direkt mitgeliefert und muss nur noch installiert werden. Die Installation findet man unter „Systemsteuerung“-> „Software“ -> „Windows-Komponenten hinzufügen/entfernen“ -> „Verwaltungs- und Überwachungsprogramme“ -> „SNMP (Simple Network Management Protocol)“ (Hier kann man auch gleich den „WMI SNMP-Anbieter“ mit aktivieren). Hacken aktivieren und mit Ok und Weiter die Installation starten.

In der Dienste-Verwaltung (Start -> Ausführen -> „services.msc“ -> OK drücken) am „SNMP-Dienst“ die Eigenschaften öffnen, auf der Tabreiter „Sicherheit“ den Hacken bei „Authentifizierungstrap senden“ aktivieren, „SNMP-Pakete von jedem Host annehmen“ aktivieren und als Communitynamen public mit Standardberechtigung erstellen wenn nicht vorhanden. Nach den verändern der Einstellung nochmal den Dienst neu starten.

Windows 7

Arbeitsschritte sind die gleichen wie bei Windows XP nur die Elemente sind anderes benannt. Die Installation ist hier unter „Systemsteuerung“ -> „Programme und Funktionen“ -> „Windows-Funktionen aktivieren oder deaktiveren“ -> „Simple Network Managment-Protokoll (SNMP)“ (auch hier kann „SNMP WMI-Anbieter“ aktiviert werden).

Konfiguration und neu starten des Dienstes nicht vergessen!

Windows 2008 Server

Ebenfalls die selben Schritte. Die Installation findet man unter „Systemsteuerung“ -> „Programme und Funktionen“ -> „Windows-Funktionen aktivieren oder deaktiveren“ -> „Server-Manager\Features“ -> „Features hinfzufügen“ (Rechts oben im eck) -> „SNMP-Dienst“ (anwählen, dadurch werden die 2 Unterpunkte mit aktivieret) mit Weiter und Installieren die Installation starten.

Konfiguration und neu starten des Dienstes nicht vergessen!

Überwachen mit munin-node

Ich finde die Methode über munin-node angenehmer zu konfigurieren. Da hier zum größten Teil alles in der munin-node.ini-Datei (zu erstellen im Verzeichnis der Exe) auf dem Windowscomputer konfiguriert wird. Ebenso ist die Ausbeute bedeutend größer als über SNMP, da hier durch eigene Plugins sowie Performance Counter erweitert werden kann. Der einzige Nachteil, es muss eine zusätzliche Software heruntergeladen und installiert werden.

Arbeiten auf Seite des Master-Servers (Debian Squezzy)

In der Datei „/etc/munin/minun.con“ folgenden eintrage hinzufügen (MeineGruppe ist der Name einer frei definierbaren Gruppe [wird für Gruppenweite Einstellungsmöglichkeiten benötigt], MeinComputer ist der Rechnername von Windows, x.x.x.x ist die IP-Adresse des abzufragen Windowsrechners. Alle 3 sind entsprechend anzupassen):

[{MeineGruppe};{MeinComputer}]
address {x.x.x.x}
use_node_name yes

Zum aktiveren jetzt noch den Dienst neustarten per:

/etc/init.d/munin-node restart

Arbeiten auf Seiten des Client Computers (Windows)

Zuerst muss „munin-node-win32“ installiert werden. Der Download ist unter http://code.google.com/p/munin-node-win32/downloads/list zu finden. Nach der Installation findet man im Installationsverzeichnis nur 2 Dateien, den Dienst selbst und eine Uninstall.exe.

Zur Konfiguration gibt es auf der oben genannten Website noch eine kleine Wiki. Hier aber mal eine vorgefertigte Version (Aufpassen bei der Codierung, muss „UTF-8 ohne BOM“ sein) für ein Deutsches Windows XP (Wichtig ist hier zu beachten, das bei den PerfomanceCountern auf die Sprache zu achten ist!):

 

[Plugins]
; Plugin Section, 1 enables plugin, 0 disables
Disk=1
Memory=1
Processes=1
Network=1
MbmTemp=1
MbmVoltage=1
MbmFan=1
MbmMhz=1
SMART=1
HD=1
Cpu=1
SpeedFan=0
;uptime=1 ;Ist in den Sourcen noch nicht freigeschalten (Stand 1.6.0)
External=0
NewExternal=0
[ExternalPlugin_free]
;Command=c:\1\disk_free.py
;env.foobar=free
[DiskPlugin]
; Default Warning and Critical values for % space used
Warning=92
Critical=98
[ExternalPlugin]
; For External Plugins just add an entry with the path to the program to run
; It doesn't matter what the name of the name=value pair is
;Plugin01=C:\Users\Jory\Documents\Visual Studio Projects\munin-node\src\plugins
python\disk_free.py
[PerfCounterPlugin_disktime]
DropTotal=1
Object=Logischer Datenträger
Counter=Zeit (%)
CounterFormat=double
CounterMultiply=1.000000
GraphTitle=Disk Time
GraphCategory=disk
GraphArgs=--base 1000 -l 0
GraphDraw=LINE
[PerfCounterPlugin_processor]
DropTotal=1
Object=Prozessor
Counter=Prozessorzeit (%)
CounterFormat=double
CounterMultiply=1.000000
GraphTitle=Processor Time
GraphCategory=system
GraphArgs=--base 1000 -l 0
GraphDraw=LINE
[PerfCounterPlugin_uptime]
Object=System
Counter=Systembetriebszeit
GraphTitle=Uptime
GraphCategory=system
GraphDraw=AREA
GraphArgs=--base 1000 -l 0
DropTotal=0
CounterFormat=large
CounterMultiply=1.1574074074074073e-005
[PerfCounterPlugin_processtime]
DropTotal=1
Object=Prozess
Counter=Prozessorzeit (%)
CounterFormat=double
CounterMultiply=1.000000
GrapTitle=Processtime
GraphCategory=system
GraphDraw=AREA
GraphArgs=--base 1000 -l 0
[SpeedFanPlugin]
BroadcastIP=192.168.0.255
UID=FF671100

Dienst automatisch neustarten

Sollte sich ein Dienst unter Windows sporatisch verabschieden gibts hier ein kleines Batch-File das man einfach in die Geplanten Tasks hängen kann, um den Dienst wieder starten zu lassen:

@echo off
cls
set SRVNAME=VMwareHostd
for /F " tokens=1,3 usebackq delims= " %%i in (`sc query "%SRVNAME%"`) DO (
  if /i "%%i" == "state" (
    if /i "%%j" == "4" (
      goto RUNNING
    )
    goto STOPPED
  )
)
REM Nichts gefunden, dann einfach zum Ende gehen, ist wohl was schiefgelaufen
goto END
:STOPPED
echo Not Running
sc start "%SRVNAME%"
goto END
:RUNNING
echo Running
:END

Einfach beim SET den jeweiligen Dienstnamen einsetzten, schon funktioniert es. Am besten ist es wenn der Kurzname benutzt wird, mit dem funktionierts immer, mit den Anzeigenamen hab ich es noch nicht getestet.

Dann wird der Dienst automatisch wieder gestarted. Der VMware-Dienst wurde hier ausgewählt, da es schon des öfteren passiert ist das dieser Dienst sich immer mal wieder verabschiedet.

Vielen Dank an Ronny für den Tip.

Notepad++ und LaTeX

Da ich schon seit längerem mich wieder mit LaTeX beschäftigen wollte und ich gerne mit Notepad++ arbeite, habe ich nach einer Möglichkeit gesucht dies zu verbinden. Und ja es gibt eine. Zuerst benötigen wir die entsprechende Software dazu, zu finden unter folgenden Links:

Notepad++ :  Der Texteditor
miktex :  Die bekannste Windowssoftware für LaTeX
pdflatex Kommandos :  Aufrufparameter der Exe

Nach dem Download entsprechend die Software installieren. Bei miktex hab ich mir „nur“ die Portable-Version geholt. Diese reicht auch und muss nur entpackt werden aber bei den Aufrufen im Notepad++ muss entweder der komplette Pfad angegeben werden oder das bin-Verzeichnis muss selbst in die PATH-Variable eingetragen werden.

Nun starten wir Notepad++. Fügen ein kleines Beispiel ein, speichern es und drücken F5. In dem nun erscheinenden Fenster geben Sie folgende Zeile ein (Daran denken wenn Sie die Portable-Version benutzen das pdflatex.exe und texify.exe mit dem kompletten Pfad angeben müssen):

cmd /c cd /d „$(CURRENT_DIRECTORY)“ && „pdflatex.exe“ -shell-escape „$(FILE_NAME)“ && „texify.exe“ –clean –pdf –run-viewer „$(FILE_NAME)“

Kurze Erklärung zum Aufruf:
cmd /c => Startet eine Shell und führt das nachfolgende Kommando aus und schließt wieder
cd /d „..“ => Wechselt in das Verzeichnis der aktuell gewählten Datei (Damit die pdf-Datei im selben Verzeichnis wie die tex-Datei abliegt
&& => Verknüpft mehrere Befehle
pdflatex … => erstellt die aux-Datei (wird für texify benötigt)
texify … => erstellt die pdf-Datei und öffnet die Datei

Über einen Klick auf Speichern können Sie den Aufruf im Notepad++ speichern und mit einem Namen sowie einem Shortcut versehen. Diese Eintrag finden Sie dann im „Ausführen“-Menü als eigenen Punkt.

Unter Einstellungen->Tastatur->Run commandos(Tablasche im Fenster)  können Sie falsch gespeicherte Kommandos auch ohne Probleme wieder löschen per Rechtsklick.

Boost mit MinGW64

Zuerst brauchen wir eine Lauffähige MinGW64 Umgebung. Eine Installationsleitung findet man dazu hier.

Nachdem man MinGW64 besitzt sollte man sich noch die Quellen von boost holen, am einfachsten von Ihrer Website http://www.boost.org/users/download/ laden. Es wird eigentlich nur die boost-Quellen selbst benötigt, da in diesem auch immer die Quellen von bjam dabei sind. Und hier findet man noch eine Installation zu Perl, wovon boost nicht abhängig ist, aber wenn man Sie installieren möchte dann vor dem übersetzten.

Nun müssen die Quellen noch entpackt werden. Und dann stellen wir uns in den entpackten Ordner mit der Eingabeaufforderung.

Mit dem Nachfolgenden Befehl wird die Pfad Variable so gesetzt das ein direkter Aufruf der Komponenten möglich ist, wobei der Pfad entsprechend angepasst werden muss:

SET PATH=C:\Programme\MinGW64\bin;%PATH%

Nun erstellen wir uns bjam mit folgendem Aufruf direkt im boost-src Ordner:

bootstrap.bat  ‚ Damit hat er bei mir immer den MS Compiler benutzt
oder: tools\jam\src\build.bat [COMPILER] (zB msvc, gcc, ….)

Da bei mir der Aufruf von build.bat mit mingw oder gcc nicht funktioniert hat, hab ich denn die Datei „x86_64-w64-mingw32-gcc.exe“ im bin-Verzeichnis in „gcc.exe“ umbenannt und dann build.bat nochmals mit gcc aufgerufen und schon ging es! Dafür musste ich dann die bjam.exe per Hand aus dem „bin.ntx86_64“-Ordner in die Root des boost-Ordners kopieren.

Und nun wird boost erstellt. Dies wird mit folgenden Befehlen durchgeführt, einer für die statischen Libs und einer für dynamischen Libs:

bjam –prefix=<PfadErstellteDateien> –without-mpi –without-python toolset=gcc address-model=64 variant=release link=static threading=multi install
bjam –prefix=<PfadErstellteDateien> –without-mpi –without-python toolset=gcc address-model=64 variant=release link=static threading=multi install

Die „–without..“-Parameter werden nicht unbedingt gebraucht, so sieht man aber keine Meldungen darüber. Nun müssen entweder die Dateien noch ins MinGW Verzeichnis kopiert werden oder in der IDE die Pfade passend gesetzt werden.

Da ich mir die ganzen Kommandos nicht immer einzeln tippen wollte bei jeder neuen Version hab ich mir ein kleines Batch-File geschrieben, welches eine Ebene höher als die Root der Quellen von boost abgelegt ist. In diesem werden am Anfang alle Pfade gesetzt und die Datei nur noch ausgeführt werden. So muss auch bei jeder neuen Version nur die Pfadangabe angepasst werden und die Datei nochmal ausführen damit mit der aktuellen Version gearbeitet werden kann. Hab die Datei aber immer aus der Eingabeaufforderung gestartet, durch Doppeltklick ging irgendwie immer was schief. Hier die Datei: boost_install.cmd (Das .txt muss durch .bat oder .cmd ersetzt werden, Download am einfachsten über Punkt „Verlinkten Inhalt speichern unter…“ im Kontextmenü)

MinGW64 unter Windows mit Code::Blocks

Zuerst müssen Sie sich die benötigten Paket herunterladen, die unter dieser URL zu finden sind:

http://sourceforge.net/projects/mingw-w64/files/

Aber aufpassen das Sie die Packete im Unterordner „Toolchains targetting Win64“ laden. Unterhalb von Release werden Sie nichts finden, sie müssen zu den „Automated Builds“ gehen und dort einfach das aktuellste Packet nehmen das vom Namen her so aufgebaut sein muss:

mingw-w64-bin_i686-mingw_<Datum>.zip

Dieses Packet einfach an den von Ihnen gewünschten Ort entpacken, zB „C:\Programme\MinGW64\“. Ich habe mir aber noch zusätzlich diese Packet kopiert:

libiconv-1.13.1-win64-20100604.zip
make-3.81-20100428.zip
pthreads-20100604.zip
i686-w64-mingw32-gdb-7.1.50-20100528.zip (Zum Debuggen)

Dies müssen dann entsprechend noch mit in den Ordner kopiert werden. Aber Vorsicht bei manchen nicht einfach die Root entpacken sonder in die entsprechenden Unterordner gehen bis der Aufbau dem vom mingw selbst entspricht. Also ein bin-, include- und weitere Ordner müssen vorhanden sein. (Bei pthreads müssen Sie erst in den mingw64-Ordner)

Sollte nun alles entpackt sein starten sie Code::Blocks und aktivieren Sie das Compiler-Fenster unter „Settings->Compiler und debugger…“. Kopieren Sie den Eintrag „GNU GCC Compiler“ und geben Sie Ihr einen neuen Namen zB „GNU GCC 64 Compiler“. In der „Tablasche Toolchain executables“ geben Sie den Pfad zu ihrem MinGW64 an (In unserem Beispiel oben wäre es der Pfad „C:\Programme\MinGW64\“).

Bei „Program Files“ müssen Sie bei den  Programmen die Namen noch anpassen, folgende müssen angepasst werden:

C compiler: x86_64-w64-mingw32-gcc.exe
C++ compiler: x86_64-w64-mingw32-g++.exe
Linker for dynamic libs: x86_64-w64-mingw32-g++.exe
Linker for static libs: x86_64-w64-mingw32-ar.exe
Debugger: gdb.exe (bleibt gleich)
Ressource compiler: x86_64-w64-mingw32-windres.exe
Make program: mingw32-make.exe

Bei „Additional Paths“ geben Sie noch folgenden Ordner an:

<PfadMinGW64>\libexec\gcc\x86_64-w64-mingw32\<VERSION>\

Bei  „Search directories“ müssen Sie auch noch die Pfade eingetragen werden. Beim Compiler diese:

<PfadMinGW64>\include
<PfadMinGW64>\x86_64-w64-mingw32\include
<PfadMinGW64>\x86_64-w64-mingw32\include\c++\<VERSION>
<PfadMinGW64>\x86_64-w64-mingw32\include\c++\<VERSION>\backward
<PfadMinGW64>\x86_64-w64-mingw32\include\c++\<VERSION>\x86_64-w64-mingw32
<PfadMinGW64>\lib\gcc\x86_64-w64-mingw32\<VERSION>\include

Und bei Linker noch folgende:

<PfadMinGW64>\lib
<PfadMinGW64>\x86_64-w64-mingw32\lib

Und nun bei Ihrem Projekt den neuen Compiler angeben, durch ein Rechtsklick aufs Projekt dann „Build Options…“ auswählen. Nun bei „Selected compiler“ den neuen Compiler auswählen, aber Vorsicht er wird für das „Build target“ definiert welches im linken Baum ausgewählt ist. Um es noch im 64Bit Modus zu kompilieren müssen Sie unter „Compiler settings“->“Other options“ noch ein „-m64“ angeben. Alles mit OK bestätigen und über „Build“->“Rebuild“ (Ctrl + F11) alles neu erstellen lassen, im Dialog noch mit ja bestätigen.

Hier noch einen Link bei dem man auch den Compiler und weitere Biliotheken laden kann: http://www.dragon.org/mingw/

tasklist unter Windows (listdll ohne listdll)

Um in der Shell eine Anzeige der aktuellen Tasks zu haben gibt es in Windows XP den Befehl

tasklist
tasklist /m

Mit diesem wird standardmässig die laufenden Prozesse angezeigt.  Der Parameter /m bewirkt das zu den Prozessen die geladenen Module angezeigt werden. das ganze geht aber auch noch entsprechend einzugrenzen, hier ein paar Beispiele:

tasklist /m /fi „MODULES eq wmi.dll“

Damit finden wir alle Prozesse die das Modul „wmi.dll“ geladen haben und zeigen noch die anderen Module mit an

tasklist /m /fi „IMAGENAME eq vmplayer.exe“

Damit zeigt man alle Prozesse mit den Namen vmplayer.exe und die jeweils genutzten Module an.

Für weitere Informationen einfach mit Parameter „/?“ aufrufen oder in der Windowshilfe nachlesen.