Sammlung: Nim Snippets / Procedures

**Oscar** · 27. Juli 2020

Ich habe auch mal wieder ein Snippet!

Das sind alles so Nebenprodukte vom meinem MP3-Player.

Und wenn ich dafür sonst kein Beispiel ergoogeln konnte, muss ich halt selbst eines erstellen.

Dieses Mal geht es um das Sortieren von einem Listview (bei wNim List-Ctrl):

Code

import wNim

let app = App()
let frame = Frame(title="ListviewSort", size=(640, 480))
let panel = Panel(frame)

let idPlaylist = ListCtrl(panel, style=wLcReport or wBorderSimple, pos=(10, 10), size=(600, 400))
idPlaylist.font = Font(14, faceName="Arial", weight=wFontWeightNormal)
idPlaylist.setBackgroundColor(0x00DDDDDD)
idPlaylist.appendColumn("Interpret", width=200)
idPlaylist.appendColumn("Titel", width=200, format=wListFormatLeft)
idPlaylist.appendColumn("Laufzeit", width=110, format=wListFormatRight)

# Ein paar Beispieldaten in das Listview eintragen
idPlaylist.appendItem(["ZZ Down", "Gimme All", "03:53"])
idPlaylist.appendItem(["Johnson Twins", "Bla bla", "04:16"])
idPlaylist.appendItem(["Kniff Richard", "Yeah", "05:11"])
idPlaylist.appendItem(["Roller Stones", "Gimme Shelter", "04:03"])
idPlaylist.appendItem(["Ralph a Ville", "Moin", "03:46"])

let hImgList = ImageList(16, 16) # Imagelist erstellen
hImgList.add(Icon("shell32.dll,246")) # up-Icon
hImgList.add(Icon("shell32.dll,247")) # down-Icon
idPlaylist.setImageList(hImgList) # die Imagelist dem Listview zuordnen

var
  iSortCol, iOldCol: int = -1
  bSortDir: bool = false

# Callback-Funktion zum sortieren der Eintraege
proc sortCmp(item1: int; item2: int; data: int): int =
  result = cmp(idPlaylist.getItemText(item1, iSortCol), idPlaylist.getItemText(item2, iSortCol))
  if bSortDir: result *= -1

# Beim Klick auf ein Spalten-Header
idPlaylist.wEvent_ListColClick do (event: wEvent):
  iSortCol = event.getColumn() # die Spalte ermitteln
  if iSortCol == iOldCol: # wenn die gleiche Spalte wie vorher
    bSortDir = not bSortDir # dann Sortier-Richtung umdrehen
  else: # ansonsten
    bSortDir = false # Sortier-Richtung auf aufsteigend setzen
    idPlaylist.setColumnImage(iOldCol, -1) # und das vorherige Sortier-Image entfernen
  iOldCol = iSortCol # die Spalte merken
  idPlaylist.setColumnImage(iSortCol, if bSortDir: 1 else: 0) # Sortier-Image entsprechend der Richtung setzen
  idPlaylist.sortItemsByIndex(sortCmp) # und das Listview sortieren (Callback fuer den Vergleich)

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

Alles anzeigen

**Oscar** · 1. August 2020

Weil es mich interessierte, wie das mit den Icons aus der System-ImageList im Listview funktioniert, habe ich mich mal reingekniet und ein Beispiel erarbeitet.

Damit werden die Icons zu den Dateien/Verzeichnissen im Listview (funktioniert auch beim Treeview) wie im Explorer dargestellt, also mit den passenden Icons.

Erklärungen gibt es noch bei den Kommentaren:

Code

import wNim, os, strutils, winim

var 
  hAppIml = ImageList(32, 32)
  hSystemIml: HIMAGELIST

# System-ImageList holen (Big oder Small Icons)
Shell_GetImageLists(hSystemIml.addr, NULL) # Big Icons (32 x 32)
# Shell_GetImageLists(NULL, hSystemIml.addr) # Small Icons (16 x 16)

# Um nicht die Original System-ImageList zu veraendern, ein Duplikat erstellen
hAppIml.mHandle = ImageList_Duplicate(hSystemIml)
let upIdx = hAppIml.add(Icon("shell32.dll,307")) # "Pfeil nach oben"-Icon einfuegen

# Gibt einen String zurueck mit vier wichtigen Dateiattributen oder "----"
proc getFileAttrStr(path: string): string =
  let
    sFile = newWideCString(path)
    pFile = cast[LPCWSTR](sFile[0].addr)
  let iAttr = GetFileAttributesW(pFile)
  result.add(if iAttr and 0x00000001'i32: 'r' else: '-') # r = readonly
  result.add(if iAttr and 0x00000020'i32: 'a' else: '-') # a = archive
  result.add(if iAttr and 0x00000004'i32: 's' else: '-') # s = system
  result.add(if iAttr and 0x00000002'i32: 'h' else: '-') # h = hidden

# Holt den Icon-Index aus der System-ImageList
proc getSystemIconIndex(path: string): int =
  let
    sFile = newWideCString(path)
    pFile = cast[LPCWSTR](sFile[0].addr)
  var shfi: SHFILEINFOW
  if SHGetFileInfoW(pFile, 0x00000080'i32, shfi.addr, UINT sizeof(shfi), 
      SHGFI_SYSICONINDEX) != 0: result = shfi.iIcon

# Erstellt im Listview die Items fuer die Verzeichnisse/Dateien.
# Fuer die Dateiendungen kann ein Filter uebergeben werden. Dazu werden
# einfach die erlaubten Dateiendungen als String uebergeben.
# Zum Beispiel: readFolder(list, "c:\", "exe", "au3", "mp3", "pdf", ...)
# Beim uebergeben von einem Leerstring werden alle Dateien angezeigt. 
proc readFolder(list: wListCtrl, sDir: string, sFileExt: varargs[string]) =
  var sFolder: string = sDir
  sFolder.normalizePathEnd(true) # sicherstellen, dass ein Backslash am Ende steht
  SendMessage(list.getHandle, WM_SETREDRAW, FALSE, 0) # Listview-Refresh verbieten
  list.deleteAllItems() # alle Eintraege aus dem Listview entfernen
  if not sFolder.isRootDir(): # wenn nicht RootDir, dann "Pfeil nach oben" einfuegen
    list.appendItem(["..", "", "<DIR>", ""], image = upIdx)
  for path in walkDirs(sFolder & "*"): # zuerst alle Verzeichnisse einlesen
    list.appendItem( # und ins Listview einfuegen
      [lastPathPart(path), "", "<DIR>", getFileAttrStr(path)],
      image = getSystemIconIndex(path)
      )
  for kind, path in walkDir(sFolder): # danach die Dateien
    if kind == pcFile:
      for extension in sFileExt: # anhand des Dateiendungs-Filter
        if path.toLower.endsWith(extension.toLower): # nur die erlaubten Endungen zulassen
          var (dir, name, ext) = path.splitFile
          list.appendItem( # und ins Listview einfuegen
            [name, ext.substr(1), insertSep($getFileSize(path), '.'), getFileAttrStr(path)],
            image = getSystemIconIndex(path)
            )
  SendMessage(list.getHandle, WM_SETREDRAW, TRUE, 0) # Listview-Refresh wieder erlauben


let app = App()
let frame = Frame(title="System-ImageList", size=(900, 800))
let panel = Panel(frame)
let idListview = ListCtrl(panel, style=wLcReport or wBorderSimple, pos=(10, 10), size=(862, 700))
idListview.font = Font(14, faceName="Arial", weight=wFontWeightNormal)
idListview.appendColumn("Dateiname", width=470, format=wListFormatLeft)
idListview.appendColumn("Ext", width=90, format=wListFormatRight)
idListview.appendColumn("Größe", width=180, format=wListFormatRight)
idListview.appendColumn("Attr.", width=90, format=wListFormatRight)
idListview.setBackgroundColor(0x00EEEEEE)
idListview.setImageList(hAppIml)

let sAllowedExt = @["exe", "au3", "mp3", "pdf"] # eine Sequenz mit Strings geht auch
idListview.readFolder(r"d:\downloads", sAllowedExt)
# idListview.readFolder(r"d:\downloads", "") # Leerstring = alle Dateien anzeigen
frame.center()
frame.show()
app.mainLoop()

Alles anzeigen

**Oscar** · 8. August 2020

Wenn man in einer ComboBox dem Benutzer eine Auswahl der verfügbaren Laufwerksbuchstaben zur Verfügung stellen will, so braucht man eine Sequenz von Strings.

Diese kleine Prozedur ermittelt die angemeldeten Laufwerke und generiert die String-Sequenz:

Code

import winim

# Diese Prozedur liefert eine Sequenz von Strings mit den vorhandenen Laufwerksbuchstaben.
# Man kann diese eingrenzen, indem man den/die gewuenschten DriveType(n) uebergibt.
# DRIVE_REMOVABLE = Wechselmedium
# DRIVE_FIXED = Harddisk
# DRIVE_REMOTE = Netzwerk
# DRIVE_CDROM = CD/DVD
# DRIVE_RAMDISK = RamDisk
# DRIVE_ALL = alle Laufwerke
const DRIVE_ALL* = 7
proc getDrives*(reqType: varargs[UINT]): seq[string] =
  let iDrive = GetLogicalDrives() # die Laufwerke auslesen
  var path: string
  for i in 0..25: # Alle Laufwerksbuchstaben testen
    if ((iDrive shr i) and 1): # Laufwerke (Bit 0 = A:, Bit 1 = B:, Bit 2 = C:, usw.)
      path = $chr(65 + i) & $chr(58) & $chr(92)
      if DRIVE_ALL in reqType:
        result.add(path)
      else:
        if GetDriveTypeA(path) in reqType: result.add(path)

# Zum Beispiel:
echo getDrives(DRIVE_FIXED, DRIVE_REMOVABLE, DRIVE_CDROM)

Alles anzeigen

**Oscar** · 15. August 2020

Um zwei Strings nach ihrer Ähnlichkeit zu untersuchen, wird oft die Levenshtein-Distance verwendet.

Hier im AutoIt-Forum hatten wir eine recht kurze Variante von "Lutz Müller, FH Köln Campus Gummersbach".

Die habe ich mal nach Nim konvertiert:

Code

import sequtils

# Basiert auf der Berechnung der Levenshtein-Distanz
# von Lutz Müller, FH Köln Campus Gummersbach

# Levenshtein-Distanz berechnen
proc lsDistance*(s, t: string): int =
  let
    n = s.len
    m = t.len
  if s == t: return 0
  if s == "": return m
  if t == "": return n
  var
    d = newSeqWith(n + 1, newSeq[int](m + 1))
    cost: int
  for i in 0..n: d[i][0] = i
  for i in 0..m: d[0][i] = i
  for i in 1..n:
    for j in 1..m:
      cost = if s[i-1] == t[j-1]: 0 else: 1
      d[i][j] = min([d[i-1][j] + 1, d[i][j-1] + 1, d[i-1][j-1] + cost])
  return d[n][m]

# Levenshtein-Distanz in Prozent berechnen
proc lsDistancePercent*(s, t: string): int =
  let n = max(s.len, t.len)
  if n == 0 or s == t: return 100
  return int(100 / n * float(n - lsDistance(s, t)))

# Beispiel
let
  s1 = "Zuckerkuchen"
  s2 = "Butterkuchen"

echo "Levenshtein-Distanz: ", lsDistance(s1, s2)
echo "Levenshtein-Distanz: ", lsDistancePercent(s1, s2), "%"

Alles anzeigen

**Oscar** · 20. August 2020

Wenn man ein Programm zwei Mal startet, will man vielleicht Nachrichten zwischen diesen beiden Prozessen austauschen (z.B. weil man Dateien an die erste Instanz übergeben will).

Dazu kann man eine NamedPipe verwenden und dazu habe ich hier mal ein Beispiel erstellt:

Code

import winim, wNim, strutils
echo "Nim-Version: ", NimVersion

var
  # Der Pipe-Name darf max. 256 Zeichen lang sein (Gross-/Kleinschreibung wird nicht beachtet).
  pipeName: LPCSTR = r"\\.\pipe\myuniquepipename"
  OL: OVERLAPPED # Overlapped-Struktur erstellen
  pOL: LPOVERLAPPED = OL.addr # Pointer auf die Struktur
  bufSize: DWORD = 4096 # Groesse des Sende-/Empfangsbuffers (in Bytes/Chars)
  buf = newSeq[char](bufSize) # Empfangsbuffer erstellen
  read: DWORD # Variable, um die Anzahl der empfangenen Zeichen aufzunehmen

# Die NamedPipe erstellen.
# Der Parameter "FILE_FLAG_FIRST_PIPE_INSTANCE" verhindert ein mehrfaches erstellen der Pipe.
let hPipe = CreateNamedPipeA(
  pipeName, # Pipename
  PIPE_ACCESS_DUPLEX or FILE_FLAG_FIRST_PIPE_INSTANCE or FILE_FLAG_OVERLAPPED, # OpenMode
  PIPE_TYPE_MESSAGE or PIPE_READMODE_MESSAGE or PIPE_NOWAIT, # PipeMode
  1, # Max. Instances
  bufSize, # Out-Buffersize
  bufSize, # In-Buffersize
  0, # Timeout (0 = default = 50ms)
  NULL # Pointer to SecurityAttributes
  )

# Wenn die Pipe nicht erstellt werden konnte, dann existiert sie bereits.
# Es handelt sich also um die zweite Instanz.
if hPipe == INVALID_HANDLE_VALUE:
  echo "Zweite Instanz"
  var sendMsg: LPCSTR = "Dieser Text wird an die erste Instanz gesendet."
  # Hiermit wird ein String an die erste Instanz gesendet und im Empfangsbuffer
  # steht dann die Rueckmeldung der ersten Instanz.
  CallNamedPipeA(pipeName, sendMsg, DWORD sendMsg.len, 
    buf[0].addr, DWORD buf.len, read.addr, NMPWAIT_USE_DEFAULT_WAIT)
  echo "Empfangen: ", join(buf[0..read-1])
  # Die zweite Instanz beenden
  quit()

# Ab hier nur fuer die erste Instanz
echo "Erste Instanz"

let app = App()
let frame = Frame(title="Named Pipe example", size=(300, 160))

# Timer-Funktion (hier wird auf die Pipe-Nachrichten gewartet)
frame.wEvent_Timer do (event: wEvent):
  # Wenn eine Nachricht auf der Pipe angekommen ist...
  if ReadFile(hPipe, buf[0].addr, DWORD buf.len, read.addr, pOL) == TRUE:
    echo "Bytes empfangen: ", read
    echo "'", join(buf[0..read-1]), "'" # die Nachricht in einen String umwandeln und anzeigen
    # Eine Bestaetigung an die zweite Instanz zuruecksenden
    TransactNamedPipe(hPipe, LPCSTR "Ok.", 4, NULL, 0, read.addr, pOL)
    DisconnectNamedPipe(hPipe) # die Pipe trennen (um die zweite Instanz freizugeben)
    ConnectNamedPipe(hPipe, pOL) # und wieder neu verbinden

# Timer starten (0.1 sek.)
frame.startTimer(0.1)

frame.show()
app.mainLoop()

Alles anzeigen

Um das Beispiel testen zu können, müsst ihr das Programm compilieren und dann zwei Mal starten. Das erste Mal von VSCodium und dann noch mal von einer Kommandozeile aus.

Ich habe den Code ausführlich kommentiert, damit ihr das nachvollziehen könnt.

**Oscar** · 4. September 2020

Hier mal ein Beispiel, wie man ein MouseHover mit Nim realisieren kann:

Code

import wNim, winim

var tme: TTRACKMOUSEEVENT # TrackMouseEvent-Struktur erstellen
tme.cbSize = DWORD sizeof(TTRACKMOUSEEVENT) # Groesse der Struktur eintragen
tme.dwFlags = TME_HOVER or TME_LEAVE # Flags setzen

let iconSize = (64, 64) # Groesse der Icons festlegen

# Icons als wBitmap laden
let
  bmpIcon1 = Bitmap(Icon("imageres.dll,175", size=iconSize)) # Hover-Icon fuer idPic1
  bmpIcon2 = Bitmap(Icon("imageres.dll,4", size=iconSize))   # Leave-Icon fuer idPic1
  bmpIcon3 = Bitmap(Icon("imageres.dll,176", size=iconSize)) # Hover-Icon fuer idPic2
  bmpIcon4 = Bitmap(Icon("imageres.dll,3", size=iconSize))   # Leave-Icon fuer idPic2

let app = App()
let frame = Frame(title="test", size=(320, 240))
let panel = Panel(frame)
let idPic1 = StaticBitmap(panel, pos=(50, 30), size=iconSize, bitmap=bmpIcon2)
let idPic2 = StaticBitmap(panel, pos=(150, 30), size=iconSize, bitmap=bmpIcon4)

# Das Template kann fuer mehrere StaticBitmap-Controls verwendet werden
# Parameter: Control, Hover-Bitmap, Leave-Bitmap, Hover-Time (in ms)
template registerMouseHover(self: wStaticBitmap, bmpHover, bmpLeave: wBitmap, iTime: DWORD = -1) =
  self.wEvent_MouseEnter do (event: wEvent): # MouseEnter wird einmalig beim "betreten" des Controls aufgerufen
    tme.hwndTrack = event.getWindow.mHwnd    # Das Handle und
    tme.dwHoverTime = iTime                  # die Hover-Time in die Struktur eintragen
    TrackMouseEvent(tme)                     # TrackMouseEvent aufrufen
  self.wEvent_MouseHover do (event: wEvent): # MouseHover, wenn die Mouse laenger als die Hover-Time auf dem Control ruht
    self.setBitmap(bmpHover)                 # Die Hover-Bitmap anzeigen
  self.wEvent_MouseLeave do (event: wEvent): # MouseLeave, wenn die Mouse das Control-Element verlaesst
    self.setBitmap(bmpLeave)                 # Die Leave-Bitmap anzeigen

idPic1.registerMouseHover(bmpIcon1, bmpIcon2, 10)  # Hover-Effekt fuer idPic1 festlegen mit 10 ms
idPic2.registerMouseHover(bmpIcon3, bmpIcon4, 800) # Hover-Effekt fuer idPic2 festlegen mit 800 ms

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

Alles anzeigen

**BugFix** · 14. September 2020

Bsp. für Einlesen einer JSON Datei.

Verwendet wird die "\.nimble\packages_official.json", die auf jeden Fall bei allen vorhanden ist.

Code

import os, json, tables

type 
  PkgJson = object        # Objekttyp zum Aufnehmen der JSON Daten
    name: string
    url: string
    methode: string       # in JSON Datei wird "method" verwendet, !Keyword!
    tags: seq[string]     # JArray muss vor Eintrag in Objekt portiert werden
    description: string
    license: string
    web: string
    doc: string
# Der Objekttyp muss die Daten der JSON Datei exakt abbilden! Optionale Item
# sind mittels try-except abzufangen

# Pfad der JSON Datei
let fjson = getEnv("HOMEDRIVE") & getEnv("HOMEPATH") & 
            r"\.nimble\packages_official.json"


# ------------------------------------------------------------------------------
proc jsonToObject(jFile: string): Table[string, PkgJson] =
  # alle JSON Item in Objekte überführen
  # ----------------------------------------------------------------------------
  # Funktionen zum Auslesen der einzelnen Item-Daten
  # ----------------------------------------------------------------------------
  proc getItemJson(jni: JsonNode, name: string, ): string =
    try:
      result = jni[name].str
    except KeyError:
      result = "NONE " & name
  # ----------------------------------------------------------------------------
  proc getItemJsonSeq(jni: JsonNode, name: string, ): seq[string] =
    var jnin: JsonNode
    try:
      jnin = jni[name]
      for jnmi in jnin.mitems(): result.add(jnmi.str)
    except KeyError:
      result.add("NONE " & name)
    except AssertionError:
      result.add(name & ": OBJECT")
  # ----------------------------------------------------------------------------
  var pkgs = initTable[string, PkgJson]() 
  let jn = jFile.parseFile()  # Einlesen der JSON Datei
  var jo: PkgJson             # Variable für Erstellung des Item-Objektes
  for ji in jn.items():       # iterieren über alle Item
    jo = PkgJson(             # alle Itemfelder dem JSON-Objekt zuweisen
      name: ji.getItemJson("name"),
      url: ji.getItemJson("url"),
      methode: ji.getItemJson("method"),
      tags: ji.getItemJsonSeq("tags"),
      description: ji.getItemJson("description"),
      license: ji.getItemJson("license"),
      web: ji.getItemJson("web"),
      doc: ji.getItemJson("doc"))
    pkgs[jo.name] = jo        # Item-Objekt dem Table zuweisen
  result = pkgs
# ------------------------------------------------------------------------------

# Table der JSON Objekte. Alle Item sind einmalig, Zugriff somit möglich mit:
# packages["Package-Name"].Feld
var packages = fjson.jsonToObject()

echo "Tags numnim:      ", packages["numnim"].tags
echo "Description wNim: ", packages["wNim"].description

Alles anzeigen

**BugFix** · 16. September 2020

Um eine variable Anzahl von Elementen an eine Funktion zu übergeben ist (nur als Funktionsparameter) der Datentyp openArray vorhanden.

Im Array bin ich aber grundsätzlich an Daten desselben Typs gebunden.

Um hier flexibel zu sein kann man aber das Array mit Datentypen besetzen, die selbst gemischt sind. Tuple - für eine fixe Anzahl oder Sequencen für veränderliche Anzahl.

Bsp.:

Code

# ------------------------------------------------------------------------------
proc test(oa: openArray[seq[string]]) =
  echo "openArray seq[string]: ", $oa

test([@["A","B"],@["C","D"],@["E","F"]])
# ------------------------------------------------------------------------------


# ------------------------------------------------------------------------------
proc test1(oa: openArray[tuple]) =
  echo "openArray tuple:       ", $oa

test1([("A",100),("C",200),("E",300)])
# ------------------------------------------------------------------------------


# ------------------------------------------------------------------------------
type MyObj = object
  name: string
  vname: string
  alter: int

proc test2(oa: openArray[seq[MyObj]]) =
  echo "openArray seq[object]: ", $oa

test2([@[MyObj(name: "Müller",vname: "Bernd",alter: 41)], 
       @[MyObj(name: "Meier",vname: "Lydia",alter: 28)]])
# ------------------------------------------------------------------------------

Alles anzeigen

**BugFix** · 28. September 2022

ListCtrl mit AlternateColors

Nim

import wNim/[wApp, wWindow, wFrame, wPanel, wListCtrl]
import winim/[inc\commctrl]


# ------------------------------------------------------------------------------
type 
  ListHead = tuple[text: string, format: int, width: int]
  ListText = seq[string]
proc setListColumns(list: wListCtrl, head: openArray[ListHead]) =
  for i in 0..<head.len:
    list.appendColumn(text=head[i][0], width=head[i][2])
    list.setColumnFormat(i, head[i][1])
proc setListText(list: wListCtrl, stuff: openArray[ListText]) =
  var item: int
  for i in 0..<stuff.len:
    item = list.appendItem(stuff[i][0])   
    for j in 1..<stuff[i].len:            
      list.setItem(item, j, stuff[i][j])  
# ------------------------------------------------------------------------------


let 
  app = App()
  frame = Frame(title="Test Alternate Color",size=(500,250))
  panel = frame.Panel()
  lc1 = panel.ListCtrl(style=wLcReport or wBorderDouble or wLcSingleSel or wLcNoSortHeader)
  lc2 = panel.ListCtrl(style=wLcReport or wBorderDouble or wLcSingleSel or wLcNoSortHeader)


lc1.setExtendedStyle(LVS_EX_GRIDLINES)
lc1.setListColumns([
     ("Column 1",wListFormatLeft,110),
     ("Column 2",wListFormatLeft,110)])
lc1.setListText([@["1111","2222"], @["3333","4444"], @["5555","6666"]])

lc2.setExtendedStyle(LVS_EX_GRIDLINES)
lc2.setListColumns([
     ("Column 1",wListFormatLeft,110),
     ("Column 2",wListFormatLeft,110)])
lc2.setListText([@["7777","8888"], @["9999","0000"], @["1122","3344"]])


# Listview 1: even / odd color setzen (ARGB konvertieren zu wColor)
lc1.setBackgroundColor(0x00B0E0E6.wColor)
lc1.setAlternateRowColor(wLightBlue)


# Listview 2: even color setzen, odd color berechnet
lc2.setBackgroundColor(0x00B0E0E6.wColor)
lc2.enableAlternateRowColors()


proc layout() =
  panel.autolayout """
  |-[lc1(==lc2)]-[lc2]-|
  V:|-[lc1]-|
  V:|-[lc2]-|
  """


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


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

Alles anzeigen

**BugFix** · 10. November 2022

• JSON Datei in einer Anwendung erstellen

• Daten Hinzufügen

• Daten Ändern

Nim

import std/[json, os]
import winim/lean # für msgBox

#-------------------------------------------------------------------------------
proc msgBox(caption, text: string, flag: int = 0) =
  let
    lpcaption = newWideCString(caption, caption.len)
    lptext = newWideCString(text, text.len)
    uType = cast[UINT](flag)
  MessageBox(0, cast[LPCWSTR](lptext), cast[LPCWSTR](lpcaption), uType)
#-------------------------------------------------------------------------------


let jsonFile = "test.JSON"
var parsedJson: JsonNode


if fileExists(jsonFile):  # bestehende JSON lesen
  parsedJson = parseFile(jsonFile)
else:                     # JSON erstellen
  parsedJson = %* {"date": "2022-11-10", "author": "BugFix"}


msgBox("Inhalt \"parsedJson\" nach Start", parsedJson.pretty(), 64)


# Daten hinzufügen (wenn noch nicht vorhanden)
if not parsedJson.contains("errorlist"):
  parsedJson["errorlist"] = %* [{"err": 1, "name": "NO_POWER"}, {"err": 2, "name": "DISPLAY_ERR"}]
  msgBox("Inhalt \"parsedJson\" nach Hinzufügen", parsedJson.pretty(), 64)


# Daten ändern: Change "name" bei "err: 1"
for jsne in parsedJson["errorlist"].getElems():
  if jsne["err"].getInt() == 1:
    if jsne["name"].getStr() == "NO_POWER":
      jsne["name"] = newJString("NO_BATTERY")
      msgBox("Inhalt \"parsedJson\" nach Änderung", parsedJson.pretty(), 64)
    break


# in Datei schreiben
writeFile(jsonFile, pretty(parsedJson))

Alles anzeigen

Teilen