Beiträge von BugFix

Vorschlag für folgende Funktion:

; #include <WinAPIGdi.au3>
; #include <StructureConstants.au3>
Func CheckCoordinatesInRange($Parm_CheckCoordinatesArray, $Parm_DisplayArray)
    Local $tPt = DllStructCreate($tagPoint)
    $tPt.X = $Parm_CheckCoordinatesArray[0]
    $tPt.Y = $Parm_CheckCoordinatesArray[1]
    Local $tRect = DllStructCreate($tagRECT)
    $tRect.Left = $Parm_DisplayArray[0]
    $tRect.Top = $Parm_DisplayArray[1]
    $tRect.Right = $Parm_DisplayArray[2]
    $tRect.Bottom = $Parm_DisplayArray[3]
    Return _WinAPI_PtInRect($tRect, $tPt)
EndFunc

Zitat von Bitnugger

So bekomme ich allerdings ein Problem angezeigt...

Hab ich eigentlich nicht als Problem verstanden, sondern als reinen Hinweis: "ererbt von einem genaueren Ausnahmetyp wie ValueError, IOError oder OSError"

Ich habe mich jetzt mal etwas intensiver in das Thema eingelesen. Das Thema ist schon sehr vielfältig. Ich habe jetzt mal ein einfach zu handhabendes Szenario als Bsp. erstellt.

Grundsätzlich gibt es ja 2 Möglichkeiten:

a) Ich lasse das Programm/die Funktion in einen Fehler laufen und fange diesen dann ab

b) Ich prüfe vor Ausführung ob z.B. Parameter fehlerhaft sind und generiere sofort selbst einen Fehler, der dann im Errorhandling weiter bearbeitet wird.

Hier soll z.B. eine Datei eingelesen werden. Ich prüfe jetzt vorher, ob sie überhaupt existiert und generiere einen Fehler, falls nicht. Wenn Prozeduren Fehler generieren, ist die Art des Fehlers in den entsprechenden Modulen vermerkt (IOError, wImageError, ..). Fehler enden immer auf ..Error.

Meine Dateiprüfung liefert aber keinen Fehler, sondern true/false. Somit ist es erforderlich einen eigenen Fehlertyp zu erstellen, dem ich dann auch einen entsprechenden Text beim Setzen mitgebe.

Falls z.B. ein Dateihandle existiert, weil eine Datei zum Schreiben geöffnet wurde und dort ein Fehler auftrat, muss dem "except:" ein "finally:" folgen mit (in diesem Fall) close(f). Wichtig!: Der finally-Zweig wird IMMER ausgeführt (unabhängig ob Fehler oder nicht), also muss diese Aktion auch ausführbar sein und nicht selbst in einen Fehler laufen.

import os

type
  FileExistsError* = object of Exception  # User-exeption, muss auf "..Error" enden!

let datei = r".\gibt-es-nicht.txt"

try:
  if not fileExists(datei):   # wenn Datei nicht existiert wird eine exception generiert (vergleichbar mit "[au3] SetError()")
    raise newException(FileExistsError, "FILE DOESN'T EXIST")
  else:
    echo readFile(datei)
except FileExistsError:       # wenn FileExistsError auftritt (vergleichbar mit "[au3] If @error"):
  echo getCurrentExceptionMsg()

Doku: Raise & Try

P.S.

Falls ihr noch weitere Bsp. zum Errorhandling habt, bitte hier posten. Das Thema ist so komplex, da ist eine Sammlung sicher hilfreich.

Zitat von HansJ54

Kann man die Breite der MsgBox vergrößern? Bricht meine Ausgaben, falls zu lang, immer um. Habe nichts dazu gefunden.

Und die Schrift ist proportional in der MsgBox - kann man die umstellen?

Da brauchst du eine eigene Msgbox. Findest du ganz sicher einiges hier oder im EN Forum.

Zitat von Bitnugger

Jetzt wäre es für mich überaus interessant zu wissen, wie ich Fehler abfangen und mit echo ausgeben kann, wenn das Verzeichnis oder eines der *.bmp nicht gefunden wird.

In einem fertigen Programm mit Verweisen auf lokale Dateien kann es natürlich zu Fehlern kommen, wenn diese fehlen.

Ich würde das Laden der Ressourcen somit als eigenständigen Part vor dem Hauptprogramm ausführen.

Im folgenden Bsp. siehst du die Fehlerbehandlung. Im Falle eines Fehlers (hier wImageError) wird das Programm verlassen. Fehlermeldung in der Konsole: "Image Creation Failed".

import wNim, os

proc loadRessources(dir: string, files: seq[string]): seq[wImage] =
  var simg = newSeq[wImage]()
  try:
    for i in 0..files.len() - 1:
      let path = joinPath(dir, files[i])
      simg.add(Image(path))
  except wImageError:
    quit(errormsg="Image Creation Failed", errorcode=1)
  finally:
    result = simg

let
  p = r".\bmp_state_16x1" # falscher Pfad
  sf = @[r"yellow_unchecked_enabled.bmp", r"yellow_right_enabled.bmp", r"yellow_left_enabled.bmp"]
  simg = loadRessources(p, sf)

proc Main(simg: seq[wImage]) =
  # the main stuff
  # ...
  # ...
  echo "Anzahl geladene Images: ", simg.len()

Main(simg)

Hier Werden die Status-Images bei Expanded/Collapsed jeweils getauscht. Die Images habe ich hier gepostet.

import wnim/[wApp, wFrame, wPanel, wStaticText, wNoteBook, wTreeCtrl, wImageList, wBitmap]

###############################################
proc getSelectedItem(wTree: wTreeCtrl): seq = 
  var ssel = newSeq[wTreeItem]()
  if not isEmpty(wTree):
    for item in wTree.allItems():
      if isSelected(item): 
        ssel.add(item)
        break
  result = ssel
###############################################


let app = App()
let frame = Frame(title="TreeCtrl", size=(300,250))
let panel = Panel(frame)

var il = ImageList(size=(16,16), mask=false, initialCount=0)
il.add(Bitmap(r".\bmp_state_16x16\yellow_unchecked_enabled.bmp"))
il.add(Bitmap(r".\bmp_state_16x16\yellow_right_enabled.bmp"))
il.add(Bitmap(r".\bmp_state_16x16\yellow_left_enabled.bmp"))

let tc = TreeCtrl(panel)
let tri = tc.getRootItem()
tc.setImageList(il)
let ti1 = tc.appendItem(tri, text="Item_1", image=1)
tc.appendItem(ti1, text="Item_1_1", image=0)
tc.appendItem(ti1, text="Item_1_2", image=0)
let ti13 = tc.appendItem(ti1, text="Item_1_3", image=1)
tc.appendItem(ti13, text="Item_1_3_1", image=0)
tc.appendItem(ti13, text="Item_1_3_2", image=0)
tc.appendItem(ti1, text="Item_1_4", image=0)
tc.appendItem(tri, text="Item_2", image=0)
tc.appendItem(tri, text="Item_3", image=0)
let ti4 = tc.appendItem(tri, text="Item_4", image=1)
tc.appendItem(ti4, text="Item_4_1", image=0)
let ti42 = tc.appendItem(ti4, text="Item_4_2", image=1)
tc.appendItem(ti42, text="Item_4_2_1", image=0)
tc.appendItem(ti42, text="Item_4_2_2", image=0)
tc.appendItem(ti42, text="Item_4_2_3", image=0)
tc.appendItem(tri, text="Item_5", image=0)

proc changeImage(index: int) =
  let item = tc.getSelectedItem()[0]
  item.setImage(image=index)  
  
tc.wEvent_TreeItemExpanding do ():
  changeImage(2)

tc.wEvent_TreeItemCollapsed do ():
  changeImage(1)

proc layout() =
  panel.layout:
    tc:
      left = 10
      top = 10
      right = panel.right - 10
      bottom = panel.bottom - 10

panel.wEvent_Size do ():
  layout()

frame.wIdExit do ():
  frame.delete()

layout()
frame.center()
frame.show()
app.mainLoop()

Zitat von HansJ54

aber warum macht es einen Unterschied, ob da "UBound($aArray1Dim,$UBOUND_ROWS)-1" oder "0" steht?

Ubound liefert die Anzahl der Elemente. Die Adressierung (Index) beginnt aber bei 0! Somit ist der letzte Index 1 kleiner als die Anzahl der Elemente (Ubound) - ergo: Ubound(..) -1

Zitat von HansJ54

ich brauche die erste Zeile, nicht die erste Spalte.

Soll dann jeder Spaltenwert aus dieser "Zeile" als Einzelwert in das Array1D eingefügt werden?

Zitat von HansJ54

Wie kann ich leere Einträge ( = " " oder = "" ) in der ersten Zeile von $Array2Dim rausfiltern, so dass $aArray1Dim nur nicht-leere Einträge enthält und auch Ubound entsprechend kleiner ist?

Beim Iterieren über die Einträge abfragen und ggf. verwerfen. Aber bevor du da ran gehst, lies bitte mein Array-Tut (Signatur). Dann sollte es für dich einfacher werden.

Was soll denn herauskommen? Und was hast du für Inhalte?

Was macht_ArrayExtract ?

"Extracts an array from the specified element(s) of a 1D or 2D array"

D. h. wenn du Arrays im Array hast, werden diese extrahiert.

Ich habe mir Symbole für Imagelisten erstellt: Unchecked | Checked | Plus | Minus | Dots | Pfeil-Auf | Pfeil-Ab | Pfeil-Rechts | Pfeil-Links

Alles in den Farben: weiß | rot | grün | blau | gelb

Jeweils für Status: Enabled | Disabled

Vielleicht könnt ihr das mal gebrauchen.

Das sind sie:

bmp_state_16x16.PNG

Zitat von Oscar

Aber kannst Du mal diese Zeile genauer erklären (den roten Teil): snames.add(file.path.splitPath().tail.split('.')[0])

Ich weiß, was da passiert, aber nicht wie.

Ich habe das mal auf die einzelnen Schritte aufgedröselt:

let pathImg = r".\png"      # Pfad mit *.png

# Walks over the directory dir and yields for each directory or file in dir. The component type and full path for each item are returned.
for file in pathImg.walkDir():
  # file.path.splitPath().tail.split('.')[0]
  echo "file ", file
  let fullpath = file.path
  let fullpath_split = fullpath.splitPath()
  let tail = fullpath_split.tail
  let name_ext = tail.split('.')
  let name = name_ext[0]

  echo "fullpath ", fullpath
  echo "fullpath_split ", fullpath_split
  echo "tail ", tail
  echo "name_ext ", name_ext
  echo "name ", name

#[
file           (kind: pcFile, path: "png\\Albania.png")
fullpath       png\Albania.png
fullpath_split (head: "png", tail: "Albania.png")
tail           Albania.png
name_ext       @["Albania", "png"]
name           Albania
]#

In der wNim Demo war kein Bsp, für das Treeview. Hier habe ich mal eines erstellt. Ich generiere Item-Namen und Bilder aus dem angehängten PNG-Ordner. Einfach im Pfad der *.nim speichern.

import wnim, os, strutils

var 
  snames = newSeq[string]() # Treeview-Text & StaticText
  sbmp = newSeq[wBitmap]()  # StaticBitmap
  sti = newSeq[wTreeItem]() # Treeview-Item
  il16 = ImageList(size=(16,16), mask=false, initialCount=0) # Image List


let pathImg = r".\png"      # Pfad mit *.png
for file in pathImg.walkDir():    
  snames.add(file.path.splitPath().tail.split('.')[0])  # Name der Datei ohne Suffix
  sbmp.add(Bitmap(Image(file.path).scale(48,48)))  # Bmp für StaticBmp
  il16.add(Bitmap(Image(file.path).scale(16,16)))  # Bmp für Image List

let app = App()
let frame = Frame(title="TreeTab")

let panelHead = Panel(frame)
let sbhead = StaticBitmap(panelHead, bitmap=sbmp[0], size=(48,48))
let fontComic = Font(faceName="Comic Sans MS", weight=wFontWeightBold, pointSize=18)
let sthead = StaticText(panelHead, label=snames[0])
sthead.setFont(fontComic)
let stHeight = sthead.getBestSize().height

let panelTab = Panel(frame)
let nbtab = NoteBook(panelTab) 

let panelTree = Panel(frame)
let tc = TreeCtrl(panelTree)  # Treeview
tc.setImageList(il16)         # Image List zuweisen
let tri = tc.getRootItem()    # Root-Item abfragen
var idx = 0                   # Index für Zugriff auf Sequenzen (Text, Images)
for i in 0..sNames.len() - 1: 
  sti.add(tc.appendItem(tri, text=sNames[i], image=idx))  # Item erstellen und Image anhand des Index in der Image List zuweisen
  idx = idx + 1 

tc.setFocus()

proc layout() =
  frame.layout:
    panelHead:
      left = 0
      top = 0
      height = frame.height / 5
      width = 3 * (frame.width / 5)
    panelTab:
      left = 0
      top = panelHead.bottom
      bottom = frame.bottom
      width = 3 * (frame.width / 5)
    panelTree:
      left = 3 * (frame.width / 5)
      top = 0
      height = frame.height
      width = 2 * (frame.width / 5)
  panelHead.layout:
    sbhead:
      left = panelHead.left + 10 
      centerY = panelHead.centerY
      height = 48
      width = 48
    sthead:
      left = panelHead.left + 70
      centerY = sbhead.centerY
      height = stHeight
      width = panelHead.width - 20
  panelTab.layout:
    nbtab:
      left = panelTab.left + 10
      top = panelTab.top + 10
      width = panelTab.width - 20
      height = panelTab.height - 20
  panelTree.layout:
    tc:
      left = panelTree.left + 10
      top = panelTree.top + 10
      width = panelTree.width - 20
      height = panelTree.height - 20

tc.wEvent_TreeSelChanged do ():
  for i in 0..len(sti) - 1:
    if isSelected(sti[i]):
      sbhead.setBitmap(sbmp[i])
      sthead.label = replace(replace(sNames[i], "&", "&&"), "-", " ")


frame.wEvent_Size do ():
  layout()

frame.wIdExit do ():
  frame.delete()

frame.minSize = (590,310)
layout()
frame.center()
frame.show()
app.mainLoop()

Und so sieht das aus:

treetab.PNG

Bei einer Vielzahl von Controls ist es manchmal einfacher, diese auf unterschiedlichen Panels zu platzieren. Das macht die Gestaltung des Layouts übersichtlicher und erweitert die Möglichkeiten Controls zu Gruppieren.

import wnim/[wApp, wFrame, wPanel, wButton, wListCtrl]

let app = App()
let frame = Frame(title="Three Panels")
let panel1 = Panel(frame)
let panel2 = Panel(frame)
let panel3 = Panel(frame)

panel1.backgroundColor = 0xFEFEFE
panel2.backgroundColor = 0xF6F6F6
panel3.backgroundColor = 0xF0F0F0

let bt1 = Button(panel1, label="Button 1", pos=(10,10), size=(60,25))
let bt2 = Button(panel2, label="Button 2", pos=(10,10), size=(60,25))
let lc = ListCtrl(panel3, style=wLcReport or wBorderDouble or wLcSingleSel)
lc.appendColumn("Colum", width=wListAutosize)
lc.setColumnFormat(0, wListFormatCenter) 
for i in 1..20:
  lc.appendItem($i)

proc layout() =
  frame.layout:
    panel1:
      left = 0
      top = 0
      height = frame.height / 2
      width = frame.width / 2
    panel2:
      left = 0
      top = frame.height / 2
      height = frame.height / 2
      width = frame.width / 2
    panel3:
      left = frame.width / 2
      top = 0
      height = frame.height
      width = frame.width / 2
  panel3.layout:
    lc:
      left = panel3.left + 10 
      top = panel3.top + 10
      height = panel3.height - 20
      width = panel3.width - 20


frame.wIdExit do ():
  frame.delete()

frame.wEvent_Size do ():
  layout()

layout()
frame.center()
frame.show()
app.mainLoop()

Ich habe grundsätzlich nichts dagegen, wenn die AV Programme Autoit als potentiell gefährlich betrachten. Was aber nicht tolerabel ist, dass ich als Anwender der Möglichkeit beraubt werde das Verhalten der AV Software zu bestimmen. Früher kam eine Meldung "Verdächtige Datei XY gefunden. Soll diese Datei in Quarantäne verschoben werden?"

Heute heißt es lapidar "Die Datei XY wurde in Quarantäne verschoben".

Diese Bevormundung ist eine Frechheit.

Ebenso sieht es bei der Aktualisierung der Virensignaturen aus. Konnte ich früher einstellen, automatisch oder manuell. Heute wundere ich mich, warum plötzlich das System nahezu einfriert. Es gelingt kaum den Taskmanager zu öffnen um den Schuldigen zu suchen. Und dies ist die AV Software, die ungefragt neue Signaturen geladen hat und gleich noch einen Systemscan damit macht.

Von meinem privaten Rechnern habe ich inzwischen AV Software deinstalliert.

Als Nebeneffekt habe ich eine Beschleunigung des Systems, die deutlich spürbar ist bei jeder Dateioperation.

Zitat von Bitnugger

Code Runner wird mit dieser Anleitung auch mit installiert?

Nein. Die Erweiterung Code Runner ist nicht zwingend erforderlich.

Ich wollte mit der Anleitung die minimal lauffähige Umgebung darstellen.

Ich habe meine Installationsanleitung nochmal überarbeitet. Dies ist die einfachste Variante mittels Scoop:

1. Um Scoop zu installieren ist Powershell 7.0 erforderlich. Ich empfehle die ZIP-Version, da PS7 ohne Installation sofort lauffähig ist.
2. Die Powershell-Konsole öffnen mit: pwsh.exe
3. In die Konsole eingeben: iwr -useb get.scoop.sh | iex
   Falls eine Fehlermeldung erscheint, muss möglicherweise die Ausführungsrichtlinie geändert werden mit

   Set-ExecutionPolicyRemoteSigned -scope CurrentUser

   
   Ist Scoop installiert, sind während der Installation keine weiteren User-Interaktionen erforderlich.
   Scoop speichert Apps unter C:\Users\USER\scoop\apps. Zu jeder installierten App werden Ordner mit den installierten Versionen und einem für die aktuelle Version (current) angelegt.
   Updates für Anwendungen werden mit scoop update ANWENDUNG durchgeführt.
4. Installation von Git (für den Nim Paketmanager "nimble" erforderlich)
   scoop install git
5. Editor VSCodium (ein VSCode Fork ohne die "Nachhause Telefonieren"-Option)
   scoop bucket add extras
   scoop install vscodium
   Folgende Erweiterungen sollten installiert werden ("Strg+Shift+X" öffnet Erweiterungs-Verwaltung)
   • German Language Pack for VSCode [Sprachpaket DE]
   • Nim for Visual Studio Code [Syntaxhervorhebung, etc. für Nim]
6. Nim installieren (gcc und MingW wird mit installiert)
   scoop install nim

Alle erforderlichen Einträge (PATH etc.) werden durch die scoop Installationsroutinen durchgeführt.

• Pakete für Nim werden im Terminal mit nimble install PAKETNAME installiert.
  Die Pakete werden lokal gespeichert unter C:\Users\USER\.nimble\pkgs
• Die erste Anlaufstelle bei der Suche nach Paketen ist: Organisierte Pakete
• Und hier sind die Tutorials zu finden.
• Im Modul wNim (GUI für Nim) kann Layout mittels VFL (Visual Format Language) gestaltet werden. Dazu gibt es einen Online-Editor
• Einen ersten, ganz kurzen Überblick über die Syntax bekommt man hier.

Viel Spaß

EDIT:

Wer nur mal ein wenig mit der Sprache spielen möchte (mit den Basisfunktionen) kann dies auch online tun: glot.io Nim Snippets

EDIT #2:

Um Programme sowohl in 32Bit als auch 64Bit erstellen zu können, beachtet bitte diesen Post .

EDIT #3:

Es gibt einen Stolperstein beim DSL Layout.

Wir nutzen oft Addition in der Form  +5, also ohne Leerzeichen zwischen + und Wert. Das ist in der Layout procedure u.U. falsch! Dort ist manchmal ein Leerzeichen zwischen Operator und Wert erforderlich! Und im Fehlerfall verweist die Fehlermeldung nur auf den Beginn der Prozedur, mit einem Fehlertext, der in keinem Zusammenhang mit der Ursache steht. Hat mich mal 2 Stunden Fehlersuche gekostet.

Also besser immer Operatoren beim DSL mit Leerzeichen umgeben, dann hat man keinen Stress.

Zitat von Oscar

Die Prozedur getSelectedItem habe ich mir selbst geschrieben

Damit erhältst du nur das erste markierte Item. Wenn du Mehrfachauswahl erlaubst, musst du alle abfragen:

proc getSelectedItem(wList: wListCtrl): seq =
  var ssel = newSeq[int]()
  if wList.itemCount() > 0:
    for i, sItem in wList.pairs():
      if (wList.getItemState(i, 0) and wListStateSelected) == wListStateSelected:
        ssel.add(i)
  result = ssel

Was man im Zusammenhang mit ListCtrl immer braucht: Welches Item wurde gerade geklickt (HitTest):

listHighScore.wEvent_LeftDown do ():
  let mouseClient = frame.screenToClient(wGetMousePosition())
  # echo "MousePos ", mouseClient
  echo " Item ", listHighScore.hitTest(pos=mouseClient)

Oscar

Manchmal kann man einfach nur den Kopf schütteln, weil es so einfach ist.

Ich hatte den richtigen Ansatz schon, aber an eines nicht gedacht: Wenn ich einen eigenen Event-Handler für Mouseclick-On-ListCtrl erstelle, überschreibt dieser ja automatisch das normale Verhalten, wenn ich das Event am Ende nicht an das System zurückgebe.

Du willst, dass nichts passiert außer scrollen, also:

listHighScore.wEvent_LeftDown do ():
  discard

Meine Überlegung wäre:

- MouseEvent auf ListCtrl überwachen: listHighScore.wEvent_LeftDown do ():

- auf welchem Item erfolgte der Klick

- Selection für dieses Item aufheben

Nur habe ich vergeblich nach einer Funktion "GetSelectedItem" oder ähnlich gesucht. Muss man wohl über alle Item iterieren und den Status abfragen.