Beiträge von BugFix

import wNim/[wApp, wFrame, wPanel, wListCtrl]

# ------------------------------------------------------------------------------
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="List Control",size=(600,300))
  panel = frame.Panel()
  list = panel.ListCtrl(size=(560,240), pos=(10,10), style=wLcReport or wBorderDouble or wLcSingleSel)

list.setExtendedStyle(0x1 or 0x8) # 0x1 LVS_EX_GRIDLINES, 0x8 LVS_EX_TRACKSELECT
list.setListColumns([
     ("Spalte 1",wListFormatLeft,150),
     ("Spalte 2",wListFormatCenter,150),
     ("Spalte 3",wListFormatRight,wListAutosizeUseHeader)])
list.setListText([
     @["A","B","C"], @["D","E","F"], @["G","H","I"], @["J","K","L"]])

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

frame.center()
frame.show()

app.mainLoop()

# ------------------------------------------------------------------------------
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)]])
# ------------------------------------------------------------------------------

import wNim/[wApp, wFrame, wPanel, wListCtrl, wImageList, wBitmap]
import os

let
  imgPath = r"C:\CODE\nim\_myExamples_\bmp_pur_16x16"  # PFAD ANPASSEN !!!
  app = App()
  frame = Frame(title="Test ImageList",size=(600,300))
  panel = frame.Panel()
  # list = panel.ListCtrl(size=(560,240), pos=(10,10), style=wLcReport or wBorderDouble or wLcSingleSel or wLcSmallIcon)
  list = panel.ListCtrl(size=(560,240), pos=(10,10), style=wLcReport or wBorderDouble or wLcSingleSel) # *****
var il = ImageList(size=(16,16), mask=false, initialCount=0)
il.add(Bitmap(joinPath(imgPath, "green.bmp")))
il.add(Bitmap(joinPath(imgPath, "red.bmp")))

# list.setImageList(il)
list.appendColumn(text="Column 0", width=150)
list.setColumnFormat(0, wListFormatLeft)
list.appendColumn(text="Column 1", width=110, format=wListFormatRight)
list.appendColumn(text="Column 2", width=110, format=wListFormatRight)
list.appendColumn(text="Column 3", width=wListAutosizeUseHeader)

var imgIndex: int
for i in 0..10:
  if (i mod 2) == 0: imgIndex = 0 else: imgIndex = 1
  # list.appendItem([$i&"-0", $i&"-1", $i&"-2", $i&"-3"], imgIndex)
  list.appendItem([$i&"-0", $i&"-1", $i&"-2", $i&"-3"])   # *****

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

frame.center()
frame.show()

app.mainLoop()

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

# compile: nim c -d:ssl nimble_up_check

import os, strutils, re, httpClient, strformat

let pkgsPath = r"C:\Users\BugFix\.nimble\pkgs"  # PFAD ANPASSEN !!

type
  Packages = tuple
    path: string
    name: string
    version: string
  PkgsHighest = object
    name: string
    version: string
    path: string
    url: string
    versionOnline: string

var 
  pkgsAll: seq[Packages]      # alle Pakete in allen Versionen
  pkgsTmp: seq[string]        # temporär nur Paketnamen (unique)
  pkgsHigh: seq[PkgsHighest]  # Pakete mit höchster Versionsnummer
  client = newHttpClient()    # Client für Online Versionsabfrage

# ------------------------------------------------------------------------------
# get: 'name', 'version'
proc pkg(path, get: string): string =
  let tsplit = path.splitPath().tail.split('-') 
  case get
  of "name": result = tsplit[0]
  of "version": result = tsplit[1]

proc getUrl(path: string): string =
  let 
    jsonFile = joinPath(path, "nimblemeta.json")
    jsonRead = jsonFile.readFile()
    pattern = re("{\"url\":\"([^\"]+)\"")
  var match: array[1, string]
  if match(jsonRead, pattern, match):
    for s in match: return s
  else: return ""

proc getOnlineVersion(url: string): string =
  try:
    let 
      readNimble = client.getContent(url)
      patt = re(r"version\s+=\s\x22([^\x22]+)", {reIgnoreCase, reMultiLine})
    var match = re.findAll(readNimble, patt)
    if match.len > 0:
      var
        line = match[0]
        pos = line.find('"')
        ver = line[pos+1..line.len-1]
      return ver
    else: return "0"  
  except OSError:
    return "CONNECTION ERROR"
# ------------------------------------------------------------------------------
  
# vergleichbar mit "nimble list -i", alle Versionen
for kind, path in walkDir(pkgsPath):
  if kind == pcDir: 
    pkgsAll.add((path: path, name: path.pkg("name"),
                 version: path.pkg("version")))
  else: discard

# nur höchste Versionen ausfiltern
# 1. nur Namen in Tmp-Sequence schreiben
for e in pkgsAll: 
  if not (e.name in pkgsTmp): pkgsTmp.add(e.name)
  else: discard
# 2. zu jedem Namen die höchste Version suchen und in pkgsHigh schreiben
var v, p: string
for n in pkgsTmp:
  v = ""
  p = ""
  for i in 0..pkgsAll.len - 1:
    if pkgsAll[i].name == n and pkgsAll[i].version > v:
      v = pkgsAll[i].version
      p = pkgsAll[i].path
    else: discard
  pkgsHigh.add(PkgsHighest(name: n, version: v, path: p))


# Url auslesen und in "../raw/...nimble" ändern
# und Online Version abfragen
var 
  u, needUp, output: string
   
for i in 0..pkgsHigh.len - 1:
  u = pkgsHigh[i].path.getUrl()
  if u[u.len-4..u.len-1] == ".git": u = u[0..u.len-5]
  pkgsHigh[i].url = u & "/raw/master/" & pkgsHigh[i].name & ".nimble"
  pkgsHigh[i].versionOnline = pkgsHigh[i].url.getOnlineVersion()
  if (pkgsHigh[i].versionOnline > pkgsHigh[i].version): 
    needUp = "[NEUE VERSION!]"
  else: 
    needUp = "[OK]"
  output = output & fmt"{pkgsHigh[i].name:<20}ver offline: {pkgsHigh[i].version:>7} - ver online: {pkgsHigh[i].versionOnline:>7}  {needUp}{'\n'}"

echo output

# compile: nim c -d:ssl nimble_up_check

import os, strutils, re, httpClient, strformat

let pkgsPath = getEnv("HOMEDRIVE") & getEnv("HOMEPATH") & r"\.nimble\pkgs"

type
  Packages = tuple
    path: string
    name: string
    version: string
  PkgsHighest = object
    name: string              # package name
    versions: seq[string]     # all installed version numbers 
    version: string           # highest version number
    path: string              # installation directory
    repo: string              # url of the repository
    url: string               # url of ".../raw/master/PACKAGE.nimble"
    versionOnline: string     # version number from current repository
    newup: bool               # indicates that a higher version is available

var 
  pkgsAll: seq[Packages]      # all packages in all versions
  pkgsTmp: seq[string]        # temporary only unique package names
  pkgsHigh: seq[PkgsHighest]  # packages with highest version number
  client = newHttpClient()    # client for online version request

# ------------------------------------------------------------------------------
proc pkg(path, get: string): string =
  # gets from package folder the name and version
  let tsplit = path.splitPath().tail.split('-') 
  case get
  of "name": result = tsplit[0]
  of "version": result = tsplit[1]

proc getUrl(path: string): string =
  # reads from package folder the meta file and extracts the repository-url
  let 
    jsonFile = joinPath(path, "nimblemeta.json")
    jsonRead = jsonFile.readFile()
    pattern = re("{\"url\":\"([^\"]+)\"")
  var match: array[1, string]
  if match(jsonRead, pattern, match):
    for s in match: return s
  else: return ""

proc getOnlineVersion(url: string): string =
  # reads from repository the "package-name.nimble" and extracts the version
  try:
    let 
      readNimble = client.getContent(url)
      patt = re(r"version\s+=\s\x22([^\x22]+)", {reIgnoreCase, reMultiLine})
    var match = re.findAll(readNimble, patt)
    if match.len > 0:
      var
        line = match[0]
        pos = line.find('"')
        ver = line[pos+1..line.len-1]
      return ver
    else: return "0"  # can't read version number
  except OSError:
    return "CONNECTION ERROR"
# ------------------------------------------------------------------------------


# ------------------------------------------------------------------------------
proc getAllPkgInfo() =
  # comparable to "nimble list -i", all versions
  for kind, path in walkDir(pkgsPath):
    if kind == pcDir: 
      pkgsAll.add((path: path, name: path.pkg("name"),
                  version: path.pkg("version")))
    else: discard

  # filter highest versions
  # 1. write unique package names in temporary sequence
  for e in pkgsAll: 
    if not (e.name in pkgsTmp): pkgsTmp.add(e.name)
    else: discard
  # 2. for each package name search highest version
  # store all version numbers
  var 
    v, p: string
    h: seq[string]
  for n in pkgsTmp:
    v = ""
    p = ""
    h = newSeq[string]()
    for i in 0..pkgsAll.len - 1:
      if pkgsAll[i].name == n:
        if pkgsAll[i].version > v:
          v = pkgsAll[i].version
          p = pkgsAll[i].path
        h.add(pkgsAll[i].version)  
      else: discard
    pkgsHigh.add(PkgsHighest(name: n, versions: h, version: v, path: p))

  # read out repository url, change to "../raw/...nimble"
  # ask for online version number
  var u: string
  for i in 0..pkgsHigh.len - 1:
    u = pkgsHigh[i].path.getUrl()
    pkgsHigh[i].repo = u
    if u[u.len-4..u.len-1] in [".git", ".nim"]: u = u[0..u.len-5] # remove file suffix if any
    pkgsHigh[i].url = u & "/raw/master/" & pkgsHigh[i].name & ".nimble"
    pkgsHigh[i].versionOnline = pkgsHigh[i].url.getOnlineVersion()
    if (pkgsHigh[i].versionOnline > pkgsHigh[i].version): 
      pkgsHigh[i].newup = true
    else: 
      pkgsHigh[i].newup = false
# ------------------------------------------------------------------------------


# ------------------------------------------------------------------------------
proc outputPkgInfo() =
  # collect all information
  getAllPkgInfo()
  var needUp, output: string
  for i in 0..pkgsHigh.len - 1:
    if pkgsHigh[i].newup:
      needUp = "[NEW!]"
    else: 
      needUp = "[OK]"
    output &= fmt"{pkgsHigh[i].name:<20}{needUp:<8}current:{pkgsHigh[i].version:>8}   online:{pkgsHigh[i].versionOnline:>8}  installed:  {$pkgsHigh[i].versions}{'\n'}"
  echo output
# ------------------------------------------------------------------------------

outputPkgInfo()