Gerne!
Falls ihr - wie angedeutet - eine große Firma seid... Wenn ihr mit meinem Beitrag viel Geld gespart habt, spendet doch zumindest nen Bruchteil dem Forum hier!
Gerne!
Falls ihr - wie angedeutet - eine große Firma seid... Wenn ihr mit meinem Beitrag viel Geld gespart habt, spendet doch zumindest nen Bruchteil dem Forum hier!
Ok, sortieren wir das mal. Du hast i Eingabedateien, für jede Eingabedatei sollen j Queries ausgeführt werden. Normalerweise würde man das im Datenbankkontext mit Prepared Statements lösen, aber ich denke, AdoDB bzw. MS Access können das nicht. Daher behelfen wir uns mit StringFormat, um unsere Queries zu bauen. Außerdem habe ich einfach mal die For-To-Next-Schleifen durch For-In-Next-Schleifen ersetzt, das lässt sich für dich vielleicht leichter lesen. Damit spart man sich den Indexzugriff auf das Array. In jedem Durchlauf der inneren Schleife wird der Query neu zusammengesetzt. Kannst du das nachvollziehen?
Ich möchte aber auch anmerken, dass du, sollte es wirklich nur um fünf SELECTs gehen, die auch in einem Query ausführen kannst.
Ich hab dein Skript auch mal grob aufgeräumt, sonst finde ich mich selber da nicht zurecht.
#include
#include
$sDBName = "C:\datei_vergleich.mdb"
$oAdo = ObjCreate("ADODB.Connection")
$oAdo.Open("Driver=Microsoft Access Driver (*.mdb); DBQ=" & $sDBName)
$oAdoRS = ObjCreate("ADODB.RecordSet")
$sInputPath = "C:\eingabedateien\"
Local $aNumbers[] = ["0001", "0002", "0003", "0004", "0005"] ;_FileListToArray($sInputPath, "*", 1)
Local $aQueries[] = ["select A_Nr, Afo from tmp_abf1 where wert_ist='%s'", _
"select A_Nr, Afo from tmp_abf2 where wert_ist='%s'", _
"select A_Nr, Afo from tmp_abf3 where wert_ist='%s'", _
"select A_Nr, Afo from tmp_abf4 where wert_ist='%s'", _
"select A_Nr, Afo from tmp_abf5 where wert_ist='%s'"]
$sResult = ""
;Geht alle Einträge von $aNumbers durch.
For $sNumber In $aNumbers
;Geht alle Einträge von $aQueries durch.
For $sQuery In $aQueries
;Wir bauen uns mit StringFormat unseren eigentlichen Query zusammen.
$sExecQuery = StringFormat($sQuery, $sNumber)
;Zur Kontrolle lassen wir uns den Query mal ausgeben.
ConsoleWrite("Query: " & $sExecQuery & @CRLF)
$oAdoRS.Open($sExecQuery, $oAdo)
While Not $oAdoRS.EOF
;Die Zwischenvariablen ($uebergabe1/2) kannst du dir sparen...
$sResult &= $oAdoRS.Fields(0).Value & "-" & $oAdoRS.Fields(1).Value & "; "
$oAdoRS.MoveNext()
WEnd
Next
Next
$sResult = StringTrimRight($sResult, 2)
MsgBox(0, "", $sResult)
Alles anzeigen
Achso, hab überlesen, dass es wirklich 5 unterschiedliche Queries sind. Pack die doch auch einfach in ein Array.
Du kannst auch einfach WM_DROPFILES überwachen. Das Drop-Event in WParam enthält einerseits alle Dateinamen, andererseits auch die Koordinaten des "Loslassens". Über ChildWindowFromPoint kannst du dir dann das entsprechende Control-Handle holen und schauen, ob es deine Toolbar ist.
#include <AutoItConstants.au3>
#include <GUIConstantsEx.au3>
#include <GuiReBar.au3>
#include <GuiToolbar.au3>
#include <RebarConstants.au3>
#include <StructureConstants.au3>
#include <ToolbarConstants.au3>
#include <WindowsConstants.au3>
#include <Array.au3>
#include <WinAPISys.au3>
Opt('GUIOnEventMode', 1)
Global $hMainGui = GUICreate('Test', 1020, 480, -1, -1, BitOR($WS_OVERLAPPEDWINDOW, $WS_CLIPCHILDREN), $WS_EX_WINDOWEDGE + $WS_EX_ACCEPTFILES)
GUISetOnEvent($GUI_EVENT_CLOSE, '_CloseMainGui')
Global $hDrivesRebar = _GUICtrlRebar_Create($hMainGui, BitOR($CCS_TOP, $CCS_NODIVIDER, $RBS_VARHEIGHT, $RBS_BANDBORDERS))
Global $hUserToolbar = _GUICtrlToolbar_Create($hMainGui, BitOR($TBSTYLE_FLAT, $CCS_NOPARENTALIGN, $WS_CHILD, $WS_CLIPSIBLINGS, $WS_VISIBLE, $TBSTYLE_REGISTERDROP))
_GUICtrlRebar_AddToolBarBand($hDrivesRebar, $hUserToolbar, '', 0, $RBBS_NOGRIPPER)
GUISetState()
GUIRegisterMsg($WM_DROPFILES, "WM_DROPFILES")
WinWaitClose($hMainGui)
Exit
Func _CloseMainGui()
GUIDelete($hMainGui)
EndFunc ;==>_CloseMainGui
Func WM_DROPFILES($hWnd, $msgID, $wParam, $lParam)
Local $nSize, $pFileName
$tPoint = _WinAPI_DragQueryPoint($wParam)
If Not DllStructGetSize($tPoint) Then Return ;window border
$hCtrl = _WinAPI_ChildWindowFromPointEx($hWnd, $tPoint)
ConsoleWrite("File drop to coordinates (" & $tPoint.X & "|" & $tPoint.Y & "), this is child window handle " & $hCtrl & "." & @CRLF)
If $hCtrl <> $hDrivesRebar Then Return ;not the target control, abort
$aFiles = _WinAPI_DragQueryFileEx($wParam)
ConsoleWrite("Drop to our toolbar registered, containing " & $aFiles[0] & " files." & @CRLF)
For $i = 1 To $aFiles[0]
ConsoleWrite("- " & $aFiles[$i] & @CRLF)
Next
EndFunc
Alles anzeigen
Wie soll Zeile 27 denn auch funktionieren? $test = "$query"&$j - Lass dir sowas zum Debuggen einfach mal in der Konsole ausgeben. Das "$query" ist kein Variablenzugriff, sondern nur ein Text (durch die Anführungszeichen). In $test steht also nach dem ersten Durchlauf $query1.
Und gerade in dem Moment, in dem ich das schreibe, verstehe ich, was du vor hast. Du willst so direkt auf die jeweilige Variable (Z. 20 bis 24) zugreifen, richtig? Oh je, dein ganzes Skript ist etwas durcheinander... Probier es mal mit folgendem Grundaufbau: Du benutzt nur EINE For-Schleife, welche durch das Array $array_tagaktuelle iteriert (ACHTUNG! Nicht von 1 bis 5, sondern von 0 bis 4!). In dieser setzt du den jeweiligen Query aus dem Basisquery select A_Nr, Afo from tmp_abf1 where wert_ist= und deinem jeweiligen Array-Element $array_tagaktuelle[$i] zusammen. Dann direkt ausführen und Ergebnisse verarbeiten. Dann im nächsten For-Schleifendurchlauf der nächste Query.
"Nicht möglich" - Das gibt es bei uns nicht! ![]()
Windows kennt mehrere Desktops, wobei ein Desktop intern eine Art "Ansicht" darstellt, also nicht die Schreibtischanalogie mit Icons meint. Diese Desktops sind auch mit verschiedenen Zugriffsrechten versehen.
Standardmäßig gibt es drei Stück davon, nämlich einmal den normalen User-Desktop, auf dem alle normalen Programme ausgeführt werden. Dann gibt es noch den ScreenSaver-Desktop, der mit seiner Existenz verhindern soll, dass über den Bildschirmschoner auf die laufenden Programme zugegriffen wird. Und zu guter letzt bleibt noch der Winlogon-Desktop, unser Sperrbildschirm (noch dazu läuft über diesen Desktop jeder UAC-Dialog). Auch diese Trennung dient eigentlich dazu, die Programme, die im User-Desktop-Kontext laufen, vor Zugriff zu schützen.
Prinzipiell kann ich bei dem Starten eines Prozesses (Win32 CreateProcess) über die STARTUPINFO-Struktur einen Desktop angeben, auf dem der Prozess gestartet wird. Allerdings darf ein normaler Benutzer nicht auf die beiden gesicherten Desktops ScreenSaver und Winlogon zugreifen. Interessanterweise darf dies nicht mal der Administrator-Account, egal ob lokal oder aus der Domäne. In einem Absatz im MSDN wird nur nebenbei erwähnt, dass nur ganz wenige Benutzer auf Winlogon Zugriff haben, der einzige namentlich genannte ist der "LocalSystem account". Dabei handelt es sich um den lokalen Standard-Benutzer "SYSTEM". Ich habe es nicht getestet, aber ich nehme an, solche Benutzer wie TrustedInstaller haben auch Zugriff.
Zitat von MSDNThe Winlogon desktop's security descriptor allows access to a very restricted set of accounts, including the LocalSystem account. Applications generally do not carry any of these accounts' SIDs in their tokens and therefore cannot access the Winlogon desktop or switch to a different desktop while the Winlogon desktop is active.
Die erste Aufgabe besteht also darin, meinen Prozess als SYSTEM auszuführen. wraithdu aus dem EN-Forum hat dafür eine sehr schöne und elegante Lösung gefunden, die ohne Zusatzprogramme wie PsExec auskommt. Dabei registriert sich das Au3-Programm selber als Dienst, welcher als SYSTEM ausgeführt wird. Etwas tricky, aber funktioniert wunderbar. Wohlgemerkt nur bei einem kompilierten AutoIt-Skript. Sobald mein Programm also unter dem SYSTEM-Account läuft, kann ich einen Prozess starten, der als Desktop Winlogon nutzt. Was dieses Programm dann macht, ist komplett dem Programmierer überlassen.
Ich habe mal exemplarisch eine kleine Uhr programmiert, die auf dem Sperrbildschirm angezeigt wird. Im Anhang sind alle Binärdateien und Skriptdateien enthalten. LogonMsgStarter ist letztendlich wraithdus Skript, welches am Ende einfach nur LogonMsg im Systemkontext auf dem Winlogon-Desktop startet. LogonMsg selber ist letztendlich nichts anderes als eine stinknormale AutoIt-Anwendung, da ist nix dabei. Getestet habe ich das ganze unter Windows 10, funktioniert einwandfrei. Lediglich der "Sperrbildschirm-Schoner", also das Bild, was die Anmeldemaske verdeckt, liegt über meiner GUI. Und die GUI wird auch im Hintergrund von UAC-Dialogen angezeigt. ![]()
Prinzipiell (vereinfacht) funktioniert ein Website-Aufruf wie folgt:
Client: GET /index.html
Server: 200 OK <Inhalt der Seite>
Die 200 ist dabei der Statuscode und heißt konkret "Anfrage OK, Content folgt". Ein Webserver kann natürlich auch andere Codes schicken. Ein relevantes Beispiel wäre 303 (See other). Das ist nichts anderes als deine Weiterleitung. Du müsstest also nix anderes machen, als einen Raw HTTP Request (bspw. per TCP-Funktionen) senden und dann schauen, welcher Statuscode zurückkommt.
Naja, eine verschlüsselte, ausführbare Datei im Ressourcenfeld zu haben, ist ja (verständlicherweise) irgendwie verdächtig. Aber von den großen Scannern schlägt ja nichts an, unser Panda in der Firma auch nicht.
Zum Thema Sicherheit an sich habe ich auch noch eine kleine Idee, das muss ich aber erst selber testen...
Okay, das habe ich hiermit erledigt. Daher will ich meine Idee jetzt mal etwas ausführen.
Was ist das gefährliche an einer "normalen" Zugangskontrolle? Man kann disassemblieren und die Sicherheitsabfrage einfach "überspringen", grob erklärt. Oder sogar noch einfacher: Man könnte sogar mit einem einfachen Texteditor alle hartkodierten Strings aus einer ausführbaren Datei auslesen, wo dann auch Benutzername und Passwort bei wären. Man müsste also eine Situation schaffen, in der die Sicherheitsabfrage obligatorisch für den Betrieb des Programmes ist. Man könnte also hergehen, und die eigentliche ausführbare Datei verschlüsseln. Der Schlüssel besteht dann aus dem Benutzername und dem Passwort. So liegt in dem ausgelieferten Skript keine Information über die richtigen Zugangsdaten vor. Wenn man sie falsch eingibt, wird trotzdem entschlüsselt, nur das Ergebnis ist unbrauchbar.
Ich habe die Idee mal in einem Beispiel umgesetzt. Dabei wird aus Benutzername:Passwort zunächst ein SHA256-Hash gebildet. Dieser wird dann als Schlüssel für eine AES256-Verschlüsselung genutzt. Damit wird das eigentliche Skript in kompilierter Form verschlüsselt. Die verschlüsselte EXE wird dann per FileInstall in das Zugangskontrollprogramm gepackt. Dieses fragt beim Start Zugangsdaten ab, packt das eigentliche Skript aus, entschlüsselt es mit den eingegebenen Daten und überprüft dann nur kurz, ob eine ausführbare Datei entstanden ist. Wenn ja => Ausführen. Wenn nein => Fehlermeldung. Nach Ausführung werden dann wieder alle temporären Daten gelöscht.
Natürlich krankt auch diese Idee an ein, zwei Punkten. Nach der korrekten Eingabe der Zugangsdaten kann man theoretisch innerhalb der Laufzeit der Software einfach die entschlüsselte Datei sichern und nachher separat starten. Eine EXE direkt aus dem Prozessspeicher auszuführen, dürfte etwas komplexer sein. Soweit ich weiß, sieht Windows keine Standardfunktion dafür vor, man müsste also selber einen PE-Loader basteln... Ansonsten sollte das aber schon halbwegs sicher sein.
Im Beispiel enthalten sind 4 Dateien:
- acl.au3: Enthält die Passwortabfrage und die Entschlüsselungsroutinen.
- script.au3: Das eigentliche Skript, welches geschützt werden soll. Beliebiger Inhalt.
- mkau3.au3: Dieses Skript baut aus den anderen beiden die endgültige Datei.
- myprogram.exe: Beispieldatei zum rumprobieren, kann durch ./mkau3.au3 neu erzeugt werden.
Ich würde die Werte mal als grob realistisch einstufen. Das ist eine Class 10 Karte, was bedeutet, dass die Schreibgeschwindigkeit bei mindestens 10 MB/s liegt.
Habe aber ansonsten nicht so viel mit der Materie zutun, meine einzigen SD-Karten sind zur Multitrack-Aufnahme im X32. ![]()
Zum Thema Sicherheit an sich habe ich auch noch eine kleine Idee, das muss ich aber erst selber testen...
Ansonsten hab ich aber noch einen schönen Dialog für einen Login gehabt und eben mal in eine passende Funktion gepackt:
#include <EditConstants.au3>
#include <ButtonConstants.au3>
If Not AccessControl("MaxMustermann", "top!secret123") Then Exit 1
MsgBox(0, "Mein Skript", "Hallo Welt!")
; Return Values:
; - 0 (@extended = 0) => Cancel Button or Close Button pressed
; - 0 (@extended = 1) => Incorrect Username/Password entered
; - 1 => Login successfull
Func AccessControl($sAUser, $sAPass)
Local $hWnd
Local $cUser, $cPass, $cCancel, $cOK
$hWnd = GUICreate("Zugangskontrolle", 300, 170, -1, -1)
GUISetBkColor(0xffffff)
GUISetFont(8.5, 400, 0, "Segoe UI")
GUISetIcon("user32.dll", -7)
GUICtrlCreateIcon("user32.dll", -7, 10, 10, 32, 32)
GUICtrlCreateLabel("Bitte Zugangsdaten eingeben:", 55, 18, 200, 20)
GUICtrlCreateLabel("Benutzername:", 10, 50, 140, 20)
$cUser = GUICtrlCreateInput("", 150, 50 - 2, 140, 20)
GUICtrlCreateLabel("Passwort:", 10, 85, 140, 20)
$cPass = GUICtrlCreateInput("", 150, 85 - 2, 140, 20, $ES_PASSWORD)
$cOK = GUICtrlCreateButton("Anmelden", 10, 120, 135, 40, $BS_DEFPUSHBUTTON)
$cCancel = GUICtrlCreateButton("Beenden", 155, 120, 135, 40)
GUISetState()
While True
Switch GUIGetMsg()
Case -3, $cCancel
GUIDelete($hWnd)
Return SetExtended(0, 0)
Case $cOK
If (GUICtrlRead($cUser) == $sAUser) And _
(GUICtrlRead($cPass) == $sAPass) Then
GUIDelete($hWnd)
Return 1
Else
MsgBox(16, "Zugangskontrolle", "Die eingegebenen Zugangsdaten sind inkorrekt.", 0, $hWnd)
GUIDelete($hWnd)
Return SetExtended(1, 0)
EndIf
EndSwitch
WEnd
EndFunc
Alles anzeigen
Zunächst: Wirklich sicher ist das natürlich nicht. So eine simple Abfrage lässt sich mit einem Disassembler (bzw. Debugger) relativ leicht umgehen, im Falle von AutoIt reicht auch ein Decompiler und ein anschließendes Entfernen der Abfrage, da der Code im Klartext vorliegt. Jedoch wird es wohl für den simplen Zweck, Kollegen am Rumschnüffeln zu hindern, reichen. Wobei es da wohl einfacher wäre, bei Verlassen des Arbeitsplatzes den Rechner kurz mit Win+L zu sperren... Aber gut, davon mal abgesehen ist das ganze simpel umsetzbar.
Am schönsten liest es sich vermutlich, wenn du deine ganze Zugangskontrolle in eine Funktion packst. Abhängig vom Erfolg der Benutzerdatenabfrage gibst du dann einfach True (bei korrekten Daten) oder False (bei inkorrekten Daten oder Abbruch) zurück. Dann kannst du direkt am Anfang des Skriptes einfach so eine Zeile einfügen:
Liest sich sehr angenehm und ist eigentlich selbsterklärend für den Code-Leser. Wenn die Zugangskontrolle nicht erfolgreich ist, terminiert das Skript an dieser Stelle. Wenn sie erfolgreich ist, läuft es ab diesem Punkt einfach normal weiter.
Edit:
Zwecks Kapselung und Wiederverwendbarkeit würde ich ALLES, was mit der Authentifizierung zutun hat, in diese eine Funktion packen, inklusive GUI-Erstellung.
Hi,
ich hätte da noch ein oder zwei Tipps, du entdeckst ja gerade fleißig, wie das Subclassing mit Win32 funktioniert. ![]()
Also... Erstens: Im Moment bewahrst du die ganzen Daten eines Controls in einem globalen Array auf. Das geht zwar - muss aber nicht sein. Die WinAPI bietet extra Mechanismen für das "Mitschleppen" von Benutzerdaten an. Am einfachsten und elegantesten geht das direkt in der Fenstertabelle mittels SetWindowLong (bzw. SetWindowLongPtr !!!) in dem Feld GWL_USERDATA, da kannst du exakt einen 32/64 bit Wert hinterlegen. Einfach alle relevanten Daten in eine C-Struktur packen (Speicher mit MemVirtualAlloc alloziieren) und dann den Pointer in die Fenstertabelle schreiben. Dann später in der WndProc auslesen, fertig. Du hast immer die instanzspezifischen Daten, ganz ohne globales Array. Ansonsten könnte man auch eine Fenstereigenschaft verwenden, siehe SetProp. Das ist aber ehrlich gesagt auch eher eine Stilsache.
Der zweite Verbesserungsvorschlag betrifft die WndProc an sich. Du hast ja zwei Funktionen zum Lesen/Schreiben der Sterne-Anzahl geschrieben. Kann man so machen - ist aber nicht die feine englische Art. Denn AutoIt hat ja schon zwei Funktionen dafür, nämlich GUICtrlRead und GUICtrlSetData. DIese beiden Funktionen "zaubern" auch nicht, sie senden im Hintergrund einfach die entsprechenden Window Messages an das jeweilige Control. Nämlich WM_SETTEXT, WM_GETTEXT und WM_GETTEXTLENGTH (zur Bestimmung der Buffergröße). Verarbeitest du diese Nachrichten in deiner WndProc korrekt, dann kannst du dir die beiden extra Funktionen sparen. Wirkt außerdem eleganter, wenn sich das Control wie ein natives Kontrollelement ansprechen lässt.
All das habe ich nebenbei auch in meinem letzten User Control umgesetzt, wenn du mal schauen möchtest: GuiCtrlColorChooser - Moderne Farbauswahl (Version 1.0)
(Achtung, der Fix aus Beitrag 6 ist für Win10 nötig. Muss ich mal updaten!)
Ansonsten: Sehr schön gemacht. Allemal schicker als eine ComboList. ![]()
Hi,
das ist ein generelles Problem mit Tab Controls... Child Windows generell werden dort nicht richtig angezeigt. Es gibt einen Trick, wie man das lösen kann, aber frag mich jetzt nicht, wie genau. Ich würde das einfach mit einem kleinen Workaround lösen:
;
; This example shows the usage of the UDF shipped with this package.
; The data are from the election polls before the elections in Germany in September 2005
; (Yes we DO have more than 2 parties *g*)
;
#include "statistics.au3"
#include <GUIConstants.au3>
#include <File.au3>
Dim $values[6], $_names[6], $short_names[6], $win_loss[6]
$values[0] = 43
$values[1] = 6
$values[2] = 5
$values[3] = 10
$values[4] = 8
$values[5] = 28
$win_loss[0] = 7
$win_loss[1] = -1
$win_loss[2] = -2
$win_loss[3] = 5
$win_loss[4] = -1
$win_loss[5] = -8
$short_names[0] = "CDU"
$short_names[1] = "FDP"
$short_names[2] = "Son."
$short_names[3] = "PDS"
$short_names[4] = "B90"
$short_names[5] = "SPD"
$_names[0] = "CDU / CSU"
$_names[1] = "FDP"
$_names[2] = "Sonstige"
$_names[3] = "Die Linkspartei"
$_names[4] = "Bündnis '90/Die Grünen"
$_names[5] = "SPD"
$colors_parteien = "0x666666.0xffff00.0xffffff.0xcc3399.0x00ff00.0xff0000"
Dim $random[10]
For $z = 0 to 9
$random[$z] = Random(-500, 500, 1)
Next
$gui = GUICreate('Demo of "statistics.au3" - by peethebee, 2005', 600, 400)
GUISetState()
;#cs
; relative data
$hSubWnd = GUICreate("SubWindow", 150, 150, 25, 25, $WS_CHILD, -1, $gui)
GUISetBkColor(0xff00ff)
$id = _stat_draw_half_pie($values, 0, 0, 150, 150, 0, $colors_parteien)
GUISwitch($gui)
$cTabControl = GUICtrlCreateTab(0, 0, 600, 400)
$cMainTab = GUICtrlCreateTabItem("Main Tab")
$cSubTab = GUICtrlCreateTabItem("Sub Tab")
GUICtrlCreateTabItem("")
While True
Switch GUIGetMsg()
Case -3
Exit
Case $cTabControl
$cTab = GUICtrlRead($cTabControl, True)
Switch $cTab
Case $cMainTab
GUISetState(@SW_SHOW, $hSubWnd)
Case $cSubTab
GUISetState(@SW_HIDE, $hSubWnd)
EndSwitch
EndSwitch
WEnd
Alles anzeigen
Man kann ja bei einem solchen Projekt durchaus auch mehrere Repositories pflegen. Das ähnelt ja etwas einer klassischen Linux-Paketverwaltung, da gibt es auch zig Repos.
Ich habe leider (oder zum Glück? :D) schon länger nicht mehr an einem Windows-Rechner gearbeitet. Ich meine aber, dass man ab Win7 relativ bequem über bereits vorhandene Tastenkombinationen dieses Problem lösen könnte. Und zwar kann man per [Win] + [1] das erste Fenster in der Taskleiste nach vorne holen, per [Win] + [2] das zweite usw...
Einfacher zu lesen ist die Variante gewiss nicht. Allerdings kommt es ansonsten auch gerne schon mal zu Fehlern, auf die man als Anfänger gar nicht kommt. Zum Beispiel... Es gibt auch eine ListView-UDF, die $WM_MOUSEWHEEL über GUIRegisterMsg registriert. Ein beliebiger DAU verwendet diese UDF und möchte dazu noch deinen Code verwenden. Bamm, Kollision, nur eins von beiden wird funktionieren. Und da kommt man nicht ganz so leicht drauf, das kann einen dann schon ein paar Stunden Fehlersuchen kosten. Das wollte ich mit der Anmerkung verhindern. ![]()
Nur eine kurze Anmerkung... Gerade für wiederverwendbare Codeschnipsel ist GUIRegisterMsg relativ ungeeignet, weil man eine Nachricht immer nur einmal registrieren kann. Daher in UDFs usw. lieber mit SetWindowLong die WndProc ersetzen. Bietet die selben Möglichkeiten, lässt sich aber mehr oder weniger verschachteln.
Jaja, gerade bei Multiprocessing ist es sau schade, dass Windows die Funktionen exec und fork zusammenfasst... Ein einfaches fork wäre hier schon cool!
Kommunikation geht auch sehr gut über TCP. Das hat den Vorteil, dass das Programm mit wenig Änderungen auch auf mehreren Rechnern (Stichwort "Verteilte Systeme") laufen kann.
Ohne dich von deinem Vorhaben abbringen zu wollen... KV-Diagramme sind zwar eine sehr anschauliche Darstellung von Minimierung und bei weniger als etwa 5 Eingangsvariablen auch noch von Hand annehmbar schnell... Aber sie sind mit Sicherheit nicht das Optimum, wenn du Computerunterstützung hast. Wenn du schon selber eine Minimierungssoftware basteln willst, solltest du vielleicht eher auf Quine-McCluskey setzen. Ich hab's zwar selber noch nie programmiert, aber das sollte sich wesentlich strukturierter schreiben lassen als KV-Diagramme. Und ich meine, mich an die Aussage in "Digitaltechnik" erinnern zu können, dass QM sowieso ein computeroptimierter (für Computer optimiert) Algorithmus ist.
EDIT
Wenn es denn unbedingt KVDs sein müssen... Dann kann man dein konkretes Problem ja darauf reduzieren, dass zwei 2D-Arrays miteinander verglichen werden müssen. Wie komme ich darauf? Naja, die simpleste Herangehensweise wäre, alle möglichen Päckchen für ein Diagramm der Größe XxX statisch zu speichern und dann diese Liste mit dem Eingangsdiagramm zu vergleichen. Damit das etwas performanter geht, könnte man das 2D-Array durch eine Bitfolge ersetzen und einfach nur ein BitAND durchführen. Sollte gehen.