Mausklick in Abhängigkeit der Koordinaten Topic is solved

[Scr1pter]

Hallo,

ich schreibe gerade ein Skript, das den Mauszeiger von einem Anfangspunkt schrittweise zum Endpunkt führt.
(1 Schritt = je 1 Pixel in x-Richtung)
Gleichzeitig soll die linke Maustaste gedrückt werden.

Als Demonstration hab ich mal Paint genommen, die Füllwerkzeuge könnt ihr also ignorieren.
Ziel ist es, dass die grüne Fläche ausgefüllt wird, die rote aber unangetastet bleibt.
Im "echten Computerleben" soll mir das Skript in Programmen helfen, in denen bestimmte Bereiche geklickt werden müssen,
andere aber unangetastet bleiben müssen.

Mit meinem aktuellen Skript schaffe ich es, dass es zumindest teilsweise ausgefüllt wird:

Code: Select all

F1::
xStart := 278, yStart := 256, xEnde := 675, yEnde := 493 ; Anfangs- und Endpunkte (wird später mithilfe einer GUI festgelegt)
differenzX := xEnde - xStart ; Pixel, die horizontal gezeichnet werden müssen
differenzY := yEnde - yStart ; Pixel, die vertikal gezeichnet werden müssen
MouseMove, xStart, yStart, 0 ; Mauszeiger auf Startposition befördern
Loop, %differenzX% ; So oft wiederholen, wie der Unterschied der beiden x-Punkte ist
{
  Sleep, 2 ; Kurzer Puffer, damit der Loop pausiert werden kann
  MouseGetPos, x, y ; Aktuelle Mauszeigerposition ermitteln
  if x between 373 and 582 ; Befindet sich der Mauszeiger innerhalb der x-"Sperrzone":
  {
    Send {lbutton up} ; Linke Maustaste loslassen
  }
  else ; Für alle anderen Zonen:
  {
    Send {lbutton down} ; Linke Maustaste gedrückt halten
  }
  MouseMove, 0, %differenzY%, 0, R ; Mauszeiger relativ nach unten bewegen (zum y-Endpunkt)
  MouseMove, 1, -%differenzY%, 0, R ; Mauszeiger relativ um 1 Pixel nach rechts und wieder nach oben bewegen (zum y-Startpunkt)
} ; Nach Abschluss der Schleife:
Send {lbutton up} ; Linke Maustaste loslassen
return

.
.
Ich bekomme das mit den y-Punkten aber nicht hin.
Variante 1: Nichts wird gezeichnet:
if (x between 373 and 582) and (y between 316 and 428) ; Befindet sich der Mauszeiger innerhalb der x oder y-"Sperrzone":

Variante 2: Wie im bisherigen Skript
if x between 373 and 582 and y between 316 and 428 ; Befindet sich der Mauszeiger innerhalb der x oder y-"Sperrzone":

Variante 3: Nichts wird gezeichnet:
if (x between 373 and 582 and y between 316 and 428) ; Befindet sich der Mauszeiger innerhalb der x oder y-"Sperrzone":

Variante 4: Alles wird gezeichnet (also zu viel)

Code: Select all

  if x between 373 and 582 ; Befindet sich der Mauszeiger innerhalb der x-"Sperrzone":
  {
    if y between 316 and 428 ; Und auch innerhalb der y-"Sperrzone":
    {
      Send {lbutton up} ; Linke Maustaste loslassen
    }    
  }

Hier nochmal ein grafischer Überblick, mit Erklärung und den 4 Varianten ausprobiert:


Danke für jede Hilfe!

Grüße

[Gerdi]

Probier mal

Code: Select all

((373 < x AND x < 582))  AND    ((316 < y AND y < 428))

bzw. Vereinfacht

Code: Select all

(373 < x) AND (x < 582) AND (316 < y) AND (y < 482)

d.h. gruen zeichnest Du bei Gesamt-Ausdruck = false
weis bei true. ich vermute dass beim 2. Ausdruck auch alle Klammern optional sind.

[SL5]

kennst du das schon
https://autohotkey.com/docs/commands/MouseClickDrag.htm
?

[Scr1pter]

@Gerdi:
Danke für den Vorschlag, aber in beiden Fällen wird das komplette Rechteck gefüllt, also auch der rote Bereich.
(Wie in der 4. Variante, die ich oben erwähnte.)

Code: Select all

 if (373 < x) AND (x < 582) AND (316 < y) AND (y < 482) ; Befindet sich der Mauszeiger innerhalb der "Sperrzone":
  {
    Send {lbutton up} ; Linke Maustaste loslassen        
  }

@SL5:
Na klar, das hatte ich doch erst neulich in meinem Maus-Recorder.
MouseClickDrag, L, startX, startY, zielX, zielY ; Mauszeiger auf Anfangspunkt befördern, Linksklick halten, auf Zielpunkt setzen und loslassen
Diese Methode hatte ich auch im Kopf, aber inwiefern soll es das Problem lösen?

Grüße

[Gerdi]

setz mal gedanklich x und y = 400 ein, da wird der Ausdruck true.

Code: Select all

 if ((373 < x) AND (x < 582) AND (316 < y) AND (y < 482)) ; Befindet sich der Mauszeiger innerhalb der "Sperrzone":
  {
    Send {lbutton up} ; Linke Maustaste loslassen        
  }
  else
    Send {lbutton down}

d.h. wenn's da trotzdem zeichnet liegt der Fehler woanders!
Beispiesweise sende nur wenn der Wahrheitswert wechselt.

[just me]

Moin,

Dein Code bewegt die Maus auf der oberen Kante des Rechtecks pixelweise von links nach rechts

Code: Select all

Loop, %differenzX%

und außerdem einmal hin und wieder zurück über die komplette Höhe des Rfechtecks.

Code: Select all

  MouseMove, 0, %differenzY%, 0, R ; Mauszeiger relativ nach unten bewegen (zum y-Endpunkt)
  MouseMove, 1, -%differenzY%, 0, R ; Mauszeiger relativ um 1 Pixel nach rechts und wieder nach oben bewegen (zum y-Startpunkt)

Y hat deshalb immer den Wert yStart. Wenn Du einen Bereich aussparen willst, musst Du dort vertikal 3 Bewegungen ausführen.

[Scr1pter]

Hi,

und Danke für eure Antworten.
Bin genau auf das gleiche gekommen, was just me geschrieben hat
Das Skript springt ja nur zwischen 2 Punkten.

Ich hab mir sowieso überlegt, dass das Skript nicht gut ist.
Die Punkte stehen bereits alle fest.
Wozu dann überhaupt die Positionen prüfen?

Hab's jetzt viel besser gemacht und werde es heute oder morgen posten.
Es funktioniert bereits einwandfrei und läuft gefühlt 10x schneller.
(Ich möchte es nur noch etwas schlanker machen.)

Ich hatte nämlich ursprünglich einen loop für die y Achse erzeugt und musste feststellen, dass es übel langsam läuft.

Grüße

[Scr1pter]

Gut, das ist die neue Version:

Code: Select all

F1::
xStart        := 219, yStart := 257, xEnde := 445, yEnde := 428 ; Anfangs- und Endpunkte der Gesamtfläche
xStartSperre  := 288, yStartSperre := 317, xEndeSperre := 380, yEndeSperre := 376 ; Anfangs- und Endpunkte der Sperrfläche, die sich innerhalb der Gesamtfläche befindet
anzahlArray   := [xStartSperre, xStart, xEndeSperre, xStartSperre, xEndeSperre, xStartSperre, xEnde, xEndeSperre] ; Dadurch wird errechnet, wie viele x-Pixel zwischen 2 Punkten liegen
mausArray     := [yEnde, yStart, yStartSperre, yStart, yEnde, yEndeSperre, yEnde, yStart] ; Dies sind die Punkte, die der Mauszeiger passieren muss
positionArray := [xStart, xStartSperre, xStartSperre, xEndeSperre] ; Mauspositionen (Eckpunkte der zwei Flächen)
MouseMove, xStart, yStart, 0 ; Mauszeiger auf Startposition befördern
Loop, 4 ; Insgesamt 4 Flächen, die gefüllt werden müssen
{
  xPosition := positionArray[A_Index] ; Startpositionen für x festlegen
  if A_Index = 1 ; Beim ersten Durchgang:
  {
    i := A_Index ; = 1
    e := A_Index + 1 ; 1 + 1 = 2 
  }
  else ; Für alle anderen Durchgänge:
  {
    i += 2 ; Beim 2. Durchgäng wäre das: 1 + 2 = 3, danach 3 + 2 = 5
    e += 2 ; Beim 2. Durchgäng wäre das: 2 + 2 = 4, danach 4 + 2 = 6
  }
  anzahl := anzahlArray[i] - anzahlArray[e] ; Anzahl der Pixel dem anzahlArray entnehmen
  Loop, %anzahl% ; So oft wiederholen wie die errechnenete Anzahl
  {
    mausX := xPosition + A_Index ; Ermittelte Startposition aus Array + 1 Pixel nach rechts
    Send {lbutton down} ; Linke Maustaste gedrückt halten
    MouseMove, mausX, mausArray[i], 0 ; Mauszeiger in x-Richtung bewegen und y-Richtung in Abhängigkeit vom Array-Wert
    MouseMove, mausX, mausArray[e], 0 ; Mauszeiger in x-Richtung bewegen und y-Richtung in Abhängigkeit vom Array-Wert
  }
  Send {lbutton up} ; Linke Maustaste loslassen
  MouseMove, xStartSperre, yEndeSperre, 0 ; Mauszeiger auf neue Position befördern
}
return

.
.
.
Das Ergebnis ist FAST perfekt (wahrscheinlich nur eine Kleinigkeit, die nicht stimmt).


Ich werde am Wochenende dann das Skript erweitern, so dass ich die Rechtecke mit Gdip zeichne, anstatt sie von vorne rein festzulegen.
(So, wie es jetzt ist, ergibt's ja keinen Sinn.)

Wenn ihr Verbesserungsvorschläge habt, immer her damit!
Vielleicht lässt sich die Sache mit i := A_Index und i += 2 ja auch anders lösen.
(Einen anderen Einfall hatte ich gerade nicht.)

Viele Grüße

[just me]

OK, was willst Du denn wohin zeichnen? Vielleicht gibt es ja noch weitere Alternativen.

[Scr1pter]

Im Prinzip will ich gar nichts zeichnen.
In einigen Programmen (z.B. Modelling) ist es ab und zu notwendig, dass man bestimmte Flächen markieren
und andere unangetastet lässt.
Aus diesem Grund kam ich auf die Idee, das mit 2 Rechtecken zu lösen.

Innerhalb des 1. Rechteckts wird alles geklickt und das andere Rechteck bleibt unangetastet.
Ansonsten müsste man immer ganz vorsichtig arbeiten, damit man ja nicht zu viel auswählt.

Edit
HIer noch schlanker, ohne die sinnlose if-Abfrage.

Code: Select all

F1::
i = 1 ; Zugriff auf jeweils erstes Element im Array
e = 2 ; Zugriff auf jeweils zweites Element im Array
xStart        := 219, yStart := 257, xEnde := 445, yEnde := 428 ; Anfangs- und Endpunkte der Gesamtfläche
xStartSperre  := 288, yStartSperre := 317, xEndeSperre := 380, yEndeSperre := 376 ; Anfangs- und Endpunkte der Sperrfläche, die sich innerhalb der Gesamtfläche befindet
anzahlArray   := [xStartSperre, xStart, xEndeSperre, xStartSperre, xEndeSperre, xStartSperre, xEnde, xEndeSperre] ; Dadurch wird errechnet, wie viele x-Pixel zwischen 2 Punkten liegen
mausArray     := [yEnde, yStart, yStartSperre, yStart, yEnde, yEndeSperre, yEnde, yStart] ; Dies sind die Punkte, die der Mauszeiger passieren muss
positionArray := [xStart, xStartSperre, xStartSperre, xEndeSperre] ; Mauspositionen (Eckpunkte der zwei Flächen)
MouseMove, xStart, yStart, 0 ; Mauszeiger auf Startposition befördern
Loop, 4 ; Insgesamt 4 Flächen, die gefüllt werden müssen
{
  xPosition := positionArray[A_Index] ; Startpositionen für x festlegen
  anzahl := anzahlArray[i] - anzahlArray[e] ; Anzahl der Pixel dem anzahlArray entnehmen
  Loop, %anzahl% ; So oft wiederholen wie die rrrechnenete Anzahl
  {
    mausX := xPosition + A_Index ; Ermittelte Startposition aus Array + 1 Pixel nach rechts
    Send {lbutton down} ; Linke Maustaste gedrückt halten
    MouseMove, mausX, mausArray[i], 0 ; Mauszeiger in x-Richtung bewegen und y-Richtung in Abhängigkeit vom Array-Wert
    MouseMove, mausX, mausArray[e], 0 ; Mauszeiger in x-Richtung bewegen und y-Richtung in Abhängigkeit vom Array-Wert
  }
  Send {lbutton up} ; Linke Maustaste loslassen
  i += 2 ; Beim 2. Durchgäng wäre das: 1 + 2 = 3, danach 3 + 2 = 5
  e += 2 ; Beim 2. Durchgäng wäre das: 2 + 2 = 4, danach 4 + 2 = 6  
  MouseMove, xStartSperre, yEndeSperre, 0 ; Mauszeiger auf Startposition befördern
}
return

Grüße

[just me]

Moin,

der Zweck erschießt sich mir immer noch nicht ganz. Soll das ein Tool werden, das innerhalb vorgegebener Bildschirmereiche jedes Pixel einmal mit der Maus überfährt?

[Scr1pter]

Korrekt.
Nur eben noch mit dem Zusatz, dass bestimmte Pixel nicht überfahren werden.

Grüße

[just me]

OK, dann fällt mir keine Alternative ein.

Grüße, just me

[just me]

@SL5:
Na klar, das hatte ich doch erst neulich in meinem Maus-Recorder.
MouseClickDrag, L, startX, startY, zielX, zielY ; Mauszeiger auf Anfangspunkt befördern, Linksklick halten, auf Zielpunkt setzen und loslassen
Diese Methode hatte ich auch im Kopf, aber inwiefern soll es das Problem lösen?

Moin,

ich habe mal damit herumgespielt. Zumindest in Paint funktioniert das wie Dein bisheriges Skript, nur deutlich schneller, weil man die 'Mausverzögerung' abschalten kann:

Code: Select all

#NoEnv
SetBatchLines, -1 ; Ausführungsgeschwindigkeit auf Maximum setzen
Return

F1::
SetMouseDelay, 0 ; setzt die Verzögerung zwischen zwei Mausaktionen auf das Minimum
; SendMode, Input ;  anscheinend funktionierende Alternative für SetMouseDelay
xStart        := 219, yStart       := 257, xEnde       := 445, yEnde       := 428 ; Anfangs- und Endpunkte der Gesamtfläche
xStartSperre  := 288, yStartSperre := 317, xEndeSperre := 380, yEndeSperre := 376 ; Anfangs- und Endpunkte der Sperrfläche innerhalb der Gesamtfläche
mausx := xStart
; S := A_TickCount
While (mausX <= xEnde) {
   ; If (mausX >= xStartSperre) && (mausX <= xEndeSperre) {
   If mausX Between %xStartSperre% And %xEndeSperre%
   {
      MouseClickDrag, Left, mausX, yStart, mausX, yStartSperre, 0
      MouseClickDrag, Left, mausX, yEndeSperre, mausX, yEnde, 0
   }
   Else
      MouseClickDrag, Left, mausX, yStart, mausX, yEnde, 0
   mausX++
}
MouseMove, xStartSperre, yEndeSperre, 0 ; Mauszeiger auf Startposition befördern ???
; D := A_TickCount - S
; MsgBox, 0, Dauer, %D% ms
Return

Esc::
ExitApp

[Frosti]

Ich hätte da eine Idee für eine halb flexible Lösung, vorausgesetzt ich habe verstanden was die Aufgabe sein soll. Wie ich es verstehe suchst Du die Rahmenbegrenzung für das Rechteck.
Ich nutze dafür die FindText Funktion von feiyue in meinem Signaturskript für PDF-Dateien. Der FoxitReader zeichnet das PDF-Dokument als Grafik. Je nach Bildschirmauflösung, Zoomlevel und der Einstellungen für die Anzahl der Seiten könnte es überall innerhalb des Dokumentenbereichs sein. Ich könnte eventuell ja noch die GDI-Bitmap Handles zu den PDF-Seiten aus dem Speicher suchen lassen. Aber vielleicht ist der Dokumentenbereich nur ein großes Bild. Deshalb habe ich mir mit dieser Funktion die linke obere Ecke umgewandelt und lasse diese mit FindText suchen. Das geht sehr schnell und ist je nach Einstellung auch hervorragend sicher.

Das Bild zeigt in etwa die Größe des Suchfeldes. Das könntest Du auch für jede Ecke machen.


Nun habe ich es auch einfach da der Rahmen nicht skaliert wird. Doch manchmal hatte er doch Probleme den Bereich zu finden und deshalb erhöhe ich vorsichtig die basetolerance je Schritt.
Hast Du alle 4 Ecken musst Du nur noch invertieren und hättest den anderen Bereich. Hochflexibel wäre es wenn man dem Skript sehen bei bringen könnte, sozusagen ObjectRecognition.

Code: Select all

TopLeft:="|<>*210$71.zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzw0000003zzzzs0000007zzzzk000000DzzzzU000000Tzzzz0000000zzzzy0000001zzzzw0000003zzzzs0000007zzzzk000000DzzzzU000000Tzzzz0000000zzzzy0000001zzzzw0000003zzzzs0000007zzzzk000000DzzzzU000000Tzzzz0000000zzzzy0000001"

FindSignatureArea:
basetolerance:=0

if (ok:=FindText(Fwx, Fwy, Fww, Fwh, basetolerance, 0, TopLeft)) {
	X:=ok.1.1, Y:=ok.1.2, W:=ok.1.3, H:=ok.1.4, Comment:=ok.1.5, X+=W//2, Y+=H//2
	MouseClickDrag, Left, % x,  %  y, % x+100, % y+50, 0
} else {
	sleep, 100
	tryCount++
	If (tryCount < 20) {
		basetolerance += 0.1
	        goto FindSignatureArea
	}
}

Eine andere Idee könnte auch das nutzen von FloodFill mit einer gut Kontrast gebenden Farbe sein. Diese läßt Du in den Bereich laufen den Du clickbar machen möchtest. Und dann wandelst Du Dir das ganze per Potrace in ein Vektorformat um. Da steht dann alles drin was Du brauchst.

Noch eine Idee:
Es gibt da eine Funktion die sich AverageColor oder so nennt. Ich habe damit schon mal herumgespielt um in Tiff-Bildern nach dem Verlauf von Textzeilen zu suchen. Habe irgendwann nicht mehr durchgesehen und dann auch noch entdeckt das Tesseract .tsv Dateien ausgeben kann die alle Info's enthalten.
Jedenfalls habe ich eine Rechteckauswahl über das Bild rutschen lassen und da habe nach dem höchsten Anteil schwarz suchen lassen. Hat lustige Zahlenwerte ergeben die in einer Diagrammdarstellung wie Forschungsbilder der Hintergrundstrahlung des Weltraum aussahen.
Ich war eigentlich auf der Suche nach einem schnellen Algorithmus für eine Art "LayoutFingerprint", einer absichtlich 'groben Methode' ohne den Inhalt des Dokumentes lesen zu müssen ein Layout zu lesen um überhaupt ein Dokument ganz schnell zuordnen zu können und um bestimmte Areale kategorisieren zu können.




Habe ich Dich richtig verstanden, also?

[Scr1pter]

@just me :
Wow, klasse!
Too Fast Too Furious
Falls es für die Ziel-Anwendung zu schnell sein sollte, kann man den Wert von 0 immer noch hochsetzen.
Ich hab es wie gesagt noch nicht bei "echten Anwendungen" probiert.

Die 2 hier hab ich rausgenommen und innerhalb des while-loops ein Sleep, 1 gesetzt, da es sonst einfach übel schnell ist.
Ich glaub nicht dass die Anwendungen damit klarkommen würden.
#NoEnv
SetBatchLines, -1 ; Ausführungsgeschwindigkeit auf Maximum setzen

Danke!

@Frosti:
Auch dir danke für deinen Input.
Also diese ganze Sache mit den Farben ist interessant, für meinen Anwendungsbereich aber leider nicht von Vorteil.
Die Farben waren nur als Beispiel.

Wichtig ist schon, dass man 2 Bereiche auswählen kann.
Einen, in dem eine Aktion durchgeführt wird (z.B. Mausklick) und einen, der ignoriert werden soll, sich aber im Hauptbereich befindet.

Ich denke aber, dass just me bereits die perfekte Lösung gefunden hat.
Auch danke an SL5 für den Hinweis.
Ich hatte wie gesagt an MouseClickAndDrag gedacht, aber niemals erwartet, dass es so dermaßen schnell läuft.

Grüße

[Scr1pter]

Hab mich mit Hellbent in Verbindung gesetzt und nun die Gdip-Funktionalität integriert.

Version 2 - Beta1

Code: Select all

#SingleInstance, force ; Nur eine Instanz erlauben und laufende Instanzen überschreiben
CoordMode, Mouse, Screen ; Mauszeigerposition vom Screen ermitteln
#Include, Gdip.ahk ; Gdip-Bibliothek einbinden

+lbutton:: ; Shift+Linksklick
i++ ; Incrementer
Win := Layered_Window_SetUp(4, 0, 0, A_ScreenWidth, A_ScreenHeight, i, "+E0x80000 +E0x20 +LastFound +AlwaysOnTop +ToolWindow") ; GUI erstellen (Spezial-Option, immer im Vordergrund, kein Taskleisten-Symbol)
UpdateLayeredWindow(Win.hwnd, Win.hdc, Win.X, Win.Y, Win.W, Win.H) ; Neue Ebene anhand ermittelten Positionen erstellen
if i = 1 ; Beim 1. Klick:
{
  brush := New_Brush("0000ff") ; Blaue Füllfarbe
}
else ; Bei allen anderen Klicks:
{
  brush := New_Brush("ff0000") ; Rote Füllfarbe
}
MouseGetPos, startX%i%, startY%i% ; Anfangspunkte für diesen Klick ermitteln 
while (GetKeyState("lbutton", "P")) ; Solange linke Maustaste gedrückt gehalten wird:
{
  MouseGetPos, endeX%i%, endeY%i% ; Endpunkte für diesen Klick ermitteln
  Gdip_GraphicsClear(Win.G) ; Alte Grafiken entfernen (wenn das Rechteck transfomiert wird, bevor die Maustaste losgelassen wird)
  if (endeX%i% > startX%i% && endeY%i% > startY%i%) ; Wenn von oben links nach unten rechts gezeichnet wird:
  {
    Gdip_FillRectangle(Win.G, brush, startX%i%, startY%i%, endeX%i% - startX%i%, endeY%i% - startY%i%) ; Rechteck zeichnen
  }
  else if (endeX%i% < startX%i% && endeY%i% > startY%i%) ; Wenn von oben rechts nach unten links gezeichnet wird:
  {
    Gdip_FillRectangle(Win.G, brush, endeX%i%, startY%i%, startX%i% - endeX%i%, endeY%i% - startY%i%) ; Rechteck zeichnen
  }
  else if (endeX%i% < startX%i% && endeY%i% < startY%i%) ; Wenn von unten rechts nach oben links gezeichnet wird:
  {
    Gdip_FillRectangle(Win.G, brush, endeX%i%, endeY%i%, startX%i% - endeX%i%, startY%i% - endeY%i%) ; Rechteck zeichnen
  }
  else if (endeX%i% > startX%i% && endeY%i% < startY%i%) ; Wenn von unten links nach oben rechts gezeichnet wird:
  {
    Gdip_FillRectangle(Win.G, brush, startX%i%, endeY%i%, endeX%i% - startX%i%, startY%i% - endeY%i%) ; Rechteck zeichnen
  }
  UpdateLayeredWindow(Win.hwnd, Win.hdc) ; Fenster aktualisieren
}
return

F1::
SetMouseDelay, 1 ; Setzt die Verzögerung zwischen zwei Mausaktionen auf 1 ms
mausX := startX1 ; mausX = x-Anfangspunkt vom 1. Rechteck
while (mausX <= endeX1) ; Solange mausX <= x-Endpunkt des 1. Rechtecks ist:
{
  if mausX between %startX2% and %endeX2% ; Wenn sich mausX zwischen den x-Punkten des 2. Rechtecks (Sperre) befindet:
  {
    MouseClickDrag, Left, mausX, startY1, mausX, startY2, 0 ; Fläche über des 2. Rechtecks (Sperre) befüllen
    MouseClickDrag, Left, mausX, endeY2, mausX, endeY1, 0  ; Fläche unter des 2. Rechtecks (Sperre) befüllen
  }
  else ; Befindet er sich in keiner Sperrzone:
  {
    MouseClickDrag, Left, mausX, startY1, mausX, endeY1, 0 ; Komplett befüllen
  }     
  mausX++ ; Mauszeiger 1 Pixel nach rechts bewegen
}
return

Esc::
ExitApp
return

Layered_Window_SetUp(Smoothing, Window_X, Window_Y, Window_W, Window_H, Window_Name := 1, Window_Options := "")
{
  Layered         := {} ; Dynamisches assoziatives Array erstellen
  Layered.W       := Window_W
  Layered.H       := Window_H
  Layered.X       := Window_X
  Layered.Y       := Window_Y
  Layered.Name    := Window_Name
  Layered.Options := Window_Options
  Layered.Token   := Gdip_Startup()
  Create_Layered_GUI(Layered)
  Layered.hwnd := winExist()
  Layered.hbm  := CreateDIBSection(Window_W, Window_H)
  Layered.hdc  := CreateCompatibleDC()
  Layered.obm  := SelectObject(Layered.hdc,Layered.hbm)
  Layered.G    := Gdip_GraphicsFromHDC(Layered.hdc)
  Gdip_SetSmoothingMode(Layered.G,Smoothing)
  return Layered
}
Create_Layered_GUI(Layered)
{
  Gui, % Layered.Name ": +E0x80000 +LastFound " Layered.Options 
  Gui, % Layered.Name ":Show",% "x" Layered.X "y" Layered.Y "w" Layered.W "h" Layered.H "NA"
}
Layered_Window_ShutDown(this)
{
  SelectObject(this.hdc, this.obm)
  DeleteObject(this.hbm)
  DeleteDC(this.hdc)
  gdip_deleteGraphics(this.g)
  Gdip_Shutdown(this.Token)
}
New_Brush(color := "000000", Alpha := "66") ; Definierte Farbe und leichte Transparenz
{
  newColor := "0x" Alpha color ; Farbwert berechnen
  return Gdip_BrushCreateSolid(newColor) ; Farbwert zurückgeben
}

Test in MS Paint (mit nicht all zu niedriger Mausverzögerung.)
Die Rechtecke werden mittels Gdip erzeugt und mit F1 wird dann die erlaubte Fläche gefüllt


Bin leider grad zu blöd/müde die Guis zu zerstören und die Gdip-Grafiken zu löschen, ohne dass ich gleich die gesamte App beenden müssen.
Hatte verschiedene Varianten probiert:

Code: Select all

F2::
;Layered_Window_ShutDown(Win)
Layered_Window_ShutDown(Win1)
;Gui, Gui:Win, Destroy
;Gui, Gui:Win1, Destroy
return

Grüße

[SL5]

cool. wunderhübsch

Hab mich mit Hellbent in Verbindung gesetzt und nun die Gdip-Funktionalität integriert.

Version 2 - Beta1
...

[Frosti]

Wozu soll das aber nun gut sein? Ich verstehe noch immer nicht wozu es zu gebrauchen ist.