Beiträge von BugFix

import wNim/[wApp,wFrame,wPanel,wStaticText,wButton]
import asyncdispatch, asyncfutures

var
  bStart: bool = false
  iCount: int = 0

let app = App()
let frame = Frame(title="Test", size=(400, 300))
let panel = Panel(frame)
let idLabel = StaticText(panel, label= $iCount, pos=(10, 10), size=(380, 20))
let idButton = Button(panel, label="Start/Stop", pos=(10, 50), size=(100, 25))

# click wird mit Zielwert aufgerufen, bei dem die Asyn-Proc aktiv werden soll
proc click(b: bool): Future[bool]   # generiert das Future-Objekt

proc is_click(b: bool) {.async.} =  # Aufruf mit Zielwert
  let clicked = await click(b)      # wartet bis Wert von click == b ist
  # echo "do smth."
  iCount += 1
  idLabel.label = $iCount  

proc click(b: bool): Future[bool] {.async.} =
  # echo "proc_click"
  return b


idButton.wEvent_Button do (): 
  discard is_click(true)      # ruft die Async-Proc auf
  bStart = not bStart


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

import times, os

type
  Timer = object
    t0: Time

proc timerInit(): Timer = 
  var t = Timer(t0: getTime())
  return t

proc timerDiff(t: Timer, unit: string = "ns", T: type = int): T =
  let 
    t1 = getTime()
    td = int((t1 - t.t0).inNanoseconds)
  case unit
    of "ns": return T(td)
    of "µs": return T(td / 1_000)
    of "ms": return T(td / 1_000_000)
    of "s": return T(td / 1_000_000_000)
    else: return T(td)



let start = timerInit()
sleep(2500)
echo "diff ns: ", start.timerDiff()
echo "diff µs: ", start.timerDiff("µs")
echo "diff ms: ", start.timerDiff("ms")
echo "diff  s: ", start.timerDiff("s", float)

#==>:
#==> diff ns: 2500143000
#==> diff µs: 2500143
#==> diff ms: 2500
#==> diff  s: 2.500143

import wNim/[wApp, wFrame]

# ============ TIMER MANAGEMENT ============================================= #
type
  TimedProcedure = object
    tpPause: bool   # marks procedure timer as paused (only for information)
    tpFrame: wFrame # the frame, which holds the timer
    tpID: int       # Timer-Id
    tpProc: proc()  # timed procedure
    tpTime: float   # poll time in sec

var 
  sTimer = newSeq[TimedProcedure]() # sequence with registered procedures
  timerID = int(wIdUser)            # the last assigned timerID


# returns the index of the object in the management sequence by the procedure
# if the procedure is'nt registered, the return is: -1
proc TimedProcGet(tProc: proc): int =
  for i in 0..sTimer.len - 1:
    if sTimer[i].tpProc == tProc: return i
  return -1

# same as above, but works with ID as parameter
proc TimedProcGet(tID: int): int =
  for i in 0..sTimer.len - 1:
    if sTimer[i].tpID == tID: return i
  return -1
# ----------------------------------------------------------------------------

# registers a procedure (parameterless) for timed call
proc TimedProcRegister(fr: wFrame, tProc: proc, fsec: float): int {.discardable.} =
  timerID += 1
  sTimer.add(TimedProcedure(tpPause: false, tpFrame: fr,
             tpID: timerID, tpProc: tProc, tpTime: fsec))
  fr.startTimer(fsec, timerID)
  result = timerID
# ----------------------------------------------------------------------------

# deletes a registered  procedure from management
proc TimedProcUnRegister_Main(idx: int): bool {.discardable.} =
  sTimer[idx].tpFrame.stopTimer(sTimer[idx].tpID)
  sTimer.delete(idx)
  return true

# call with procedure
proc TimedProcUnRegister(tProc: proc): bool {.discardable.} =
  let idx = TimedProcGet(tProc)
  if idx == -1: return false
  return TimedProcUnRegisterMain(idx)

# call with timer ID
proc TimedProcUnRegister(tID: int): bool {.discardable.} =
  let idx = TimedProcGet(tID)
  if idx == -1: return false
  return TimedProcUnRegisterMain(idx)
# ----------------------------------------------------------------------------

# pauses the timed call of a registered procedure
proc TimedProcPause_Main(idx: int): bool {.discardable.} =
  sTimer[idx].tpFrame.stopTimer(sTimer[idx].tpID)
  sTimer[idx].tpPause = true
  return true

# call with procedure
proc TimedProcPause(tProc: proc): bool {.discardable.} =
  let idx = TimedProcGet(tProc)
  if idx == -1: return false
  return TimedProcPauseMain(idx)

# call with timer ID
proc TimedProcPause(tID: int): bool {.discardable.} =
  let idx = TimedProcGet(tID)
  if idx == -1: return false
  return TimedProcPauseMain(idx)
# ----------------------------------------------------------------------------

# continues a previously paused procedure
proc TimedProcResume_Main(idx: int): bool {.discardable.} =
  sTimer[idx].tpFrame.startTimer(sTimer[idx].tpTime, sTimer[idx].tpID)
  sTimer[idx].tpPause = false
  return true

# call with procedure
proc TimedProcResume(tProc: proc): bool {.discardable.} =
  let idx = TimedProcGet(tProc)
  if idx == -1: return false
  return TimedProcResumeMain(idx)

# call with timer ID
proc TimedProcResume(tID: int): bool {.discardable.} =
  let idx = TimedProcGet(tID)
  if idx == -1: return false
  return TimedProcResumeMain(idx)
# ----------------------------------------------------------------------------

# stops the timed procedure, sets the new time and starts again
proc TimedProcChangeTime_Main(idx: int, fsec: float): bool {.discardable.} =
  sTimer[idx].tpFrame.stopTimer(sTimer[idx].tpID)
  sTimer[idx].tpTime = fsec
  sTimer[idx].tpFrame.startTimer(fsec, sTimer[idx].tpID)
  return true

# call with procedure
proc TimedProcChangeTime(tProc: proc, fsec: float): bool {.discardable.} =
  let idx = TimedProcGet(tProc)
  if idx == -1: return false
  return TimedProcChangeTimeMain(idx, fsec)

# call with timer ID
proc TimedProcChangeTime(tID: int, fsec: float): bool {.discardable.} =
  let idx = TimedProcGet(tID)
  if idx == -1: return false
  return TimedProcChangeTimeMain(idx, fsec)
# =========================================================================== #

let
  app = App()
  frame = Frame(title="Timed Call",size=(300,300))

proc every2sec() = echo "2 sec finished"
proc every3sec() = echo "3 sec finished"
proc every5sec() = echo "5 sec finished"

let
  id2 = frame.TimedProcRegister(every2sec, 2.0)
  id3 = frame.TimedProcRegister(every3sec, 3.0)
  id5 = frame.TimedProcRegister(every5sec, 5.0)

var counter = 0


frame.wEvent_Timer do (event: wEvent): # hier wird der Timer-Event ausgewertet
  counter += 1
  let 
    id = event.getTimerId()
    idx = TimedProcGet(id)

  if counter == 5:
    TimedProcPause(every2sec)
    echo "[PAUSED] 2 sec"
  elif counter == 8:
    TimedProcPause(every3sec)
    echo "[PAUSED] 3 sec"
  elif counter == 10:
    TimedProcResume(every2sec)
    TimedProcResume(every3sec)
    echo "[RESUMED] 2 sec"
    echo "[RESUMED] 3 sec"
  elif counter == 15:
    TimedProcUnRegister(every3sec)
    TimedProcUnRegister(every5sec)
    echo "[UNREGISTERED] 3 sec"
    echo "[UNREGISTERED] 5 sec"
  elif counter == 18:
    TimedProcChangeTime(id2, 4.0)
    echo "[TIME_CHANGED] 2 sec >> 4 sec"
  else:
    sTimer[idx].tpProc()

frame.show()
app.mainLoop()

import nsiface, sciteConstants, strutils
import wNim/[wApp, wFrame, wPanel, wTextCtrl]


ClearOutput()

CurrentFile()
OutputConsole(">> Current file: " & received & r"\n")

#                    Lua-Func,  Func-Parse-Result, Type-Parse-Result
let lcp = LuaFuncGet(LuaCurrPos, ParseLuaCurrPos, EditorPosition)
OutputConsole("+> CurrentPosition Data: " & $lcp)

#                    Lua-Func,  Func-Parse-Result, Type-Parse-Result, Pos.
let lcp2 = LuaFuncGet(LuaCurrPos, ParseLuaCurrPos, EditorPosition, $(lcp.pos - 50))
OutputConsole(r"\n+> CurrentPosition -50 Data: " & $lcp2)

let hScite = MyFindWindow("SciTEWindow")
SetForegroundWindow(hScite)

nsiFrame.center()
nsiFrame.show()
nsiApp.mainLoop()

include winim/[inc\winuser]
import re
import wNim/[wApp, wFrame]

let           
  nsiApp = App() 
  nsiFrame = Frame(title="Nim-SciTE interface", size=(320,220))

proc MyFindWindow(class = "", title = ""): HWND = 
  let 
    className = newWideCString(class, class.len)
    titleName = newWideCString(title, title.len)
  result = FindWindowW(if class.len > 0: cast[LPWSTR](className) else: nil,
                       if title.len > 0: cast[LPWSTR](titleName) else: nil)


let hRecv = nsiFrame.handle

var 
  received: string  # enthält Ergebnis einer Abfrage
  pattern: Regex    # Pattern zum Aufbereiten von received

nsiFrame.connect(WM_COPYDATA) do (event: wEvent):
  var 
    cds: PCOPYDATASTRUCT = cast[PCOPYDATASTRUCT](event.lParam)
    len: int = cds.cbData
    ret: cstring = cast[cstring](cds.lpData)
  received = $ret
  received.setLen(len)
  received = received.replace(pattern)


proc SendCommand(hwnd: HWND, cmd: string, recv: bool = false): bool {.discardable.} =
  if hwnd == 0: return false
  let hScite = MyFindWindow(class = "DirectorExtension")
  var
    cmdScite = ":" & $hwnd & ":" & cmd
    cds: COPYDATASTRUCT
  cds.dwData = 1
  cds.cbData = DWORD(cmdScite.len + 1)
  cds.lpData = cmdScite[0].addr
  received = ""
  SendMessage(hScite, WM_COPYDATA, cast[WPARAM](hwnd), cast[LPARAM](cds.addr))
  return true


proc CurrentFile(hwnd: HWND): bool {.discardable.} =
  pattern = re"^:\d+:[^:]+:"
  result = hwnd.SendCommand("askfilename:", true)

proc GetProperty(hwnd: HWND, property: string): bool {.discardable.} =
  pattern = re"^:\d+:([^:]+:){2}"
  result = hwnd.SendCommand("askproperty:" & property, true)

proc OutputConsole(hwnd: HWND, value: string): bool {.discardable.} =
  result = hwnd.SendCommand("output:" & value)

proc MenuCmd(hwnd: HWND, cmdID: int): bool {.discardable.} =
  result = hwnd.SendCommand("menucommand:" & $cmdID)

proc ClearOutput(hwnd: HWND): bool {.discardable.} =
  result = hwnd.SendCommand("extender:dostring do output:ClearAll() end")



hRecv.ClearOutput()

hRecv.CurrentFile()
echo "File: ", received
hRecv.OutputConsole(">> current file: " & received & r"\n")

hRecv.GetProperty("UDFCreator")
echo "Prop: ", received
hRecv.OutputConsole(">> UDF-Creator:  " & received)


nsiFrame.center()
nsiFrame.show()
nsiApp.mainLoop()

# Nim-SciTE-Interface

include winim/[inc\winuser]
import wNim/[wApp, wFrame, wPanel, wTextCtrl]
import strformat, strutils, os, re



type
  WndID = object
    pid, tid: int
  EnumWnd = object
    hwnd: HWND
    class: WideCStringObj
    title: WideCStringObj
    pid, tid: int

var 
  received: string
  sEnumWnd = newSeq[EnumWnd]()
  lp: LPARAM
  classfilter = newWideCString("", 256)
  titlefilter = newWideCString("", 4096)


proc MyFindWindow(class = "", title = ""): HWND =
  let 
    className = newWideCString(class, class.len)
    wndName = newWideCString(title, title.len)
  if class == "" and title == "":
    result = FindWindowW(nil, nil)
  elif class != "" and title == "":
    result = FindWindowW(cast[LPWSTR](className), nil)  
  elif class == "" and title != "":
    result = FindWindowW(nil, cast[LPWSTR](wndName))
  else:
    result = FindWindowW(cast[LPWSTR](className), cast[LPWSTR](wndName)) 


# Fensteranwendung für Interface
let           
  nsiApp = App() 
  nsiFrame = Frame(title="Nim-SciTE interface", size=(320,220))
  nsiPanel = Panel(nsiFrame)
  nsiText = TextCtrl(nsiPanel, style=wTeMultiLine, pos=(10,10), size=(300,200))
  hRecv = MyFindWindow(class="wFrame1", title="Nim-SciTE interface")

nsiFrame.wIdExit do ():
  nsiFrame.delete()



proc my_WndEnumProc(hwnd: HWND, lp: LPARAM): WINBOOL {.stdcall.} =
  if GetParent(hwnd) == 0:
    var buflen = GetWindowTextLengthW(hwnd) + 1
    if buflen == 0: return TRUE

    var buf = newWideCString("", buflen)
    discard GetWindowTextW(hwnd, cast[LPWSTR](addr buf[0]), buflen)
    if titlefilter.len > 0:
      if fmt"{buf}" != fmt"{titlefilter}": return TRUE

    var className = newWideCString("", 4096)
    discard GetClassNameW(hwnd, cast[LPWSTR](className), 4096)
    if classfilter.len > 0:
      if fmt"{className}" != fmt"{classfilter}": return TRUE

    var
      pPID: LPDWORD
      pTID = GetWindowThreadProcessId(hwnd, cast[LPDWORD](addr pPID))
      oWndID = WndID(pid: cast[int](pPID), tid: cast[int](pTID))

    sEnumWnd.add(EnumWnd(hwnd: hwnd, 
                        class: className, 
                        title: buf,
                        pid: oWndID.pid,
                        tid: oWndID.tid))
  return TRUE


# callback WM_COPYDATA  - verwenden mit SendMessageCallbackW für SciTE-Antwort
# stimmt so nicht mit Typ: SENDASYNCPROC überein
# proc my_WMCopyData(hwnd: HWND, msg: UINT, dwData: ptr COPYDATASTRUCT, lresult: LRESULT): VOID {.stdcall.} =
#   let
#     cds: COPYDATASTRUCT = dwData[]
#     recvLen = cds.cbData
#   var 
#     buffer: string 
#   buffer = cast[ptr string](cds.lpData)[]
#   received = buffer[0..recvLen - 1]


proc GetIDByWindow(hWnd: HWND): WndID =
  var 
    pPID: LPDWORD
    pTID = GetWindowThreadProcessId(hWnd, cast[LPDWORD](addr pPID))
  result = WndID(pid: cast[int](pPID), tid: cast[int](pTID))


proc GetEnumWindows(cfilter, tfilter: string): int =
  titlefilter = newWideCString(tfilter, tfilter.len + 1)
  classfilter = newWideCString(cfilter, cfilter.len + 1)
  sEnumWnd = newSeq[EnumWnd]()
  EnumWindows(my_WndEnumProc, lp)
  result = sEnumWnd.len


proc GetHwndDirectorExtension(): HWND =
  # let hActive = GetForegroundWindow()         # zum Test auskommentiert
  let hScite = MyFindWindow("SciTEWindow")
  # if hActive != hScite: return 0              # zum Test auskommentiert
  let pidScite = GetIDByWindow(hScite).pid
  let dirExtCount = GetEnumWindows("DirectorExtension", "")
  if dirExtCount == 1: result = sEnumWnd[0].hwnd
  else:
    for i in 0..dirExtCount - 1:
      if pidScite == sEnumWnd[i].pid: return sEnumWnd[i].hwnd


proc SendCommand(hwnd: HWND, cmd: string, recv: bool = false): bool =
  if hwnd == 0: return false
  var 
    cmdScite = ":" & $hwnd & ":" & cmd
    cds: COPYDATASTRUCT
  cds.dwData = 1
  cds.cbData = int32(cmdScite.len + 1)
  cds.lpData = addr cmdScite[0]

  received = ""
  SendMessage(hwnd, WM_COPYDATA, cast[WPARAM](hRecv), cast[LPARAM](addr cds))
  if recv:
    # callback auswerten
    var nWait = 0
    while received == "" or nWait < 100:
      sleep(20)
      nWait += 1    
    if received == "": return false
  return true



# Editor Funktionen:

proc OutputConsole(hwnd: HWND, value: string): bool {.discardable.} =
  result = hwnd.SendCommand("output:" & value)

proc MenuCmd(hwnd: HWND, cmdID: int): bool {.discardable.} =
  result = hwnd.SendCommand("menucommand:" & $cmdID)

proc ClearOutput(hwnd: HWND): bool {.discardable.} =
  result = hwnd.SendCommand("extender:dostring do output:ClearAll() end")

proc CurrentFile(hwnd: HWND): string =
  if hwnd.SendCommand("askfilename:", true):
    result = received.replace(re"^:\d+:[^:]+:")
  else:
    result = ""

proc GetProperty(hwnd: HWND, property: string): string =
  if hwnd.SendCommand("askproperty:" & property, true):
    result = received.replace(re"^:\d+:([^:]+:){2}")
  else:
    result = ""



# Ergebnisse im Fenster anzeigen
proc TextAdd(s: string, nl: bool = true) = 
  var nextline = "\n"
  if not nl: nextline = ""
  nsiText.appendText(s & nextline)

# Scite DirectorExtension
let hScite = GetHwndDirectorExtension()
TextAdd("Handle DirectorExtension: 0x" & $toHex(hScite))


# WM_COPYDATA mit Receive-Window verknüpfen - aber wie?
# var 
#   cdscb: COPYDATASTRUCT
#   wpcb: WPARAM
#   lpcb: LPARAM
# SendMessageCallbackW(hRecv, WM_COPYDATA, wpcb, lpcb, proccb, addr cdscb)


TextAdd("ClearOutput: ", false)   # ==> OK
TextAdd($hScite.ClearOutput())

TextAdd("OutputConsole: ", false) # ==> OK
TextAdd($hScite.OutputConsole(r"! Das ist ein Test\n- TEST\n> TEST"))

# TextAdd("Get CurrentFile: ", false)
# TextAdd(hScite.CurrentFile())

nsiFrame.show()
nsiApp.mainLoop()