[EF] This page is devoted to an initial (and incomplete) attempt to provide a low-level layer to access and manipulate the Windows API. The library is built directly on top of [Ffidl]. It tries to provide wrappers around the various flags and constants that are used in Windows. So far, the library contains commands to fiddle with Windows and simulate input. Feel free to add anything to the code and/or modify it. The license is do whatever, don't blame me. [APN] Just so we don't duplicate work, please take a look at [TWAPI] which already provides both low level and high level access to over 350 Windows functions. One limitation however is that TWAPI is NT 4.0 and above only. [EF] [winapi] is Windows 95 compliant (so far) and above all, only requires [Ffidl], while [TWAPI] is an extension that needs to be loaded. I really wish [Ffidl] or DLL [http://wiki.tcl.tk/12264] were part of the core. [TWAPI] also has a disturbing interface, in the manner that it is '''so''' different from the standard Windows API. The procedures declared by [winapi] tend to be very similar to the names and conventions that are introduced by the standard Windows API. [APN] EF, I hope you didn't take my note above as a criticism or a suggestion that [winapi] was not worth doing. Also, in addition to the much easier to use high level interface, [TWAPI] also provides direct win32 access so you can call twapi::GetWindowText directly just as you do in [winapi]. Do a twapi::list_raw_api to list the win32 functions supported. The higher level documented interface is only disturbing as you put it because it is ''vastly'' easier and more convenient to use than raw Win32 (IMHO of course). Just as Tcl is ''vastly'' easier and more convenient than C++ :-) Anyways, use of [Ffidl] v/s [TWAPI] is a common topic so I've started a page [Comparing TWAPI and Ffidl on Windows] summarizing my views. ---- # winapi.tcl -- # # This modules provides an interface to a number of low level # WIN32 functions. # # Copyright (c) 2004-2006 by the Swedish Institute of Computer Science. # # See the file "license.terms" for information on usage and redistribution # of this file, and for a DISCLAIMER OF ALL WARRANTIES. # We need Ffidl since we will be creating loads of callouts package require Ffidl # Create the namespace, further initialisation will be done at the end # of this file. namespace eval ::winapi { } # ::winapi::GetClassName -- Get window class name wrapper # # This procedure extracts the class of a window and returns it # # Arguments: # w Handle of window to get information from # bufsize Max number of characters when asking for the class name # # Results: # Returns class of window. # # Side Effects: # None. proc ::winapi::GetClassName { w { bufsize 1024 } } { set buf [binary format x$bufsize] __GetClassName $w buf $bufsize binary scan $buf A* buf return $buf } # ::winapi::GetWindowText -- Get window text # # This procedure extracts the text of a window (usually title bar). # # Arguments: # w Handle of window to get information from # bufsize Max number of characters when asking for the class name # # Results: # Returns text of window. # # Side Effects: # None. proc ::winapi::GetWindowText { w { bufsize 1024 } } { set buf [binary format x$bufsize] __GetWindowText $w buf $bufsize binary scan $buf A* buf return $buf } # ::winapi::GetWindowRect -- Get window rect # # This procedure extracts the rectangle enclosing a window. # # Arguments: # w Handle of window to get information from # # Results: # Return a list form of, respectively, the left, top, right and # bottom pixel position of the rectangle. # # Side Effects: # None. proc ::winapi::GetWindowRect { w } { # Initialise a "RECT" structure, pass it to __GetWindowRect and # extract and return values. set buf [binary format [::ffidl::info format ::winapi::RECT] 0 0 0 0] __GetWindowRect $w buf binary scan $buf [::ffidl::info format ::winapi::RECT] \ left top right bottom return [list $left $top $right $bottom] } # ::winapi::GetClientRect -- Get window rect # # This procedure extracts the rectangle enclosing a window in # client coordinates. # # Arguments: # w Handle of window to get information from # # Results: # Return a list form of, respectively, the left, top, right and # bottom pixel position of the rectangle. left and top always 0 # # Side Effects: # None. proc ::winapi::GetClientRect { w } { # Initialise a "RECT" structure, pass it to __GetClientRect and # extract and return values. set buf [binary format [::ffidl::info format ::winapi::RECT] 0 0 0 0] __GetClientRect $w buf binary scan $buf [::ffidl::info format ::winapi::RECT] \ left top right bottom return [list $left $top $right $bottom] } # ::winapi::GetWindowPlacement -- Get window show state and minimised info # # This procedure retrieves the show state and the restored, # minimized, and maximized positions of the specified window. # # Arguments: # w Handle of window to get information from # # Results: # Return a list ready for an array set command with the # following keys: flags showCmd ptMinPosX ptMinPosY ptMaxPosX # ptMaxPosY rcNormalPosLeft rcNormalPosTop rcNormalPosRight # rcNormalPosBottom, where flags and showCmd are textual list # # Side Effects: # None. proc ::winapi::GetWindowPlacement { w } { set buf [binary format [::ffidl::info format ::winapi::WINDOWPLACEMENT] \ [::ffidl::info sizeof ::winapi::WINDOWPLACEMENT] \ 0 0 0 0 0 0 0 0 0 0] if { [__GetWindowPlacement $w buf] } { binary scan $buf [::ffidl::info format ::winapi::WINDOWPLACEMENT] \ len flags showCmd ptMinPosX ptMinPosY ptMaxPosX ptMaxPosY \ rcPosLeft rcPosTop rcPosRight rcPosBottom set flags_l [__tflags $flags [list \ WPF_ASYNCWINDOWPLACEMENT 4\ WPF_RESTORETOMAXIMIZED 2 \ WPF_SETMINPOSITION 1]] set cmd [__tflag $showCmd [list \ SW_HIDE 0 \ SW_MAXIMIZE 3 \ SW_MINIMIZE 6 \ SW_RESTORE 9 \ SW_SHOW 5 \ SW_SHOWMINIMIZED 2 \ SW_SHOWMAXIMIZED 3 \ SW_SHOWMINNOACTIVE 7 \ SW_SHOWNA 8 \ SW_SHOWNOACTIVATE 4 \ SW_SHOWNORMAL 1 \ SW_NORMAL 1 \ SW_SHOWDEFAULT 10 \ SW_FORCEMINIMIZE 11 \ SW_MAX 11 \ SW_NORMALNA [expr {0xCC}]]] return [list flags "$flags_l" showCmd $cmd \ ptMinPosX $ptMinPosX ptMinPosY $ptMinPosY \ ptMaxPosX $ptMaxPosX ptMaxPosY $ptMaxPosY \ rcNormalPosLeft $rcPosLeft rcNormalPosTop $rcPosTop \ rcNormalPosRight $rcPosRight \ rcNormalPosBottom $rcPosBottom] } return "" } # ::winapi::SetWindowPlacement -- Set window show state and minimised info # # This procedure sets the show state and the restored, # minimized, and maximized positions of the specified window. # # Arguments: # w Handle of window to set information from # wndpl Array describing the window placement, the recognised # values are flags showCmd ptMinPosX ptMinPosY ptMaxPosX # ptMaxPosY rcNormalPosLeft rcNormalPosTop rcNormalPosRight # rcNormalPosBottom, where flags and showCmd are textual. # Missing value will be default to current (GetWindowPlacment) # # Results: # Return boolean telling success. # # Side Effects: # None. proc ::winapi::SetWindowPlacement { w wndpl } { array set placement [GetWindowPlacement $w] array set placement $wndpl set placement(flags) [__flags $placement(flags) [list \ WPF_ASYNCWINDOWPLACEMENT 4\ WPF_RESTORETOMAXIMIZED 2 \ WPF_SETMINPOSITION 1]] set placement(showCmd) [__flag $placement(showCmd) [list \ SW_HIDE 0 \ SW_MAXIMIZE 3 \ SW_MINIMIZE 6 \ SW_RESTORE 9 \ SW_SHOW 5 \ SW_SHOWMINIMIZED 2 \ SW_SHOWMAXIMIZED 3 \ SW_SHOWMINNOACTIVE 7 \ SW_SHOWNA 8 \ SW_SHOWNOACTIVATE 4 \ SW_SHOWNORMAL 1 \ SW_NORMAL 1 \ SW_SHOWDEFAULT 10 \ SW_FORCEMINIMIZE 11 \ SW_MAX 11 \ SW_NORMALNA [expr {0xCC}]]] set buf [binary format [::ffidl::info format ::winapi::WINDOWPLACEMENT] \ [::ffidl::info sizeof ::winapi::WINDOWPLACEMENT] \ $placement(flags) \ $placement(showCmd) \ $placement(ptMinPosX) \ $placement(ptMinPosY) \ $placement(ptMaxPosX) \ $placement(ptMaxPosY) \ $placement(rcNormalPosLeft) \ $placement(rcNormalPosTop) \ $placement(rcNormalPosRight) \ $placement(rcNormalPosBottom)] return [__SetWindowPlacement $w buf] } # ::winapi::SetWindowPlacement -- Set window show state # # This procedure sets the show state # # Arguments: # w Handle of window to set information from # cmd Any valid SW_ command (see win API). # # Results: # Return boolean telling success. # # Side Effects: # None. proc ::winapi::ShowWindow { w cmd } { set cmd [__flag $cmd [list \ SW_HIDE 0 \ SW_MAXIMIZE 3 \ SW_MINIMIZE 6 \ SW_RESTORE 9 \ SW_SHOW 5 \ SW_SHOWMINIMIZED 2 \ SW_SHOWMAXIMIZED 3 \ SW_SHOWMINNOACTIVE 7 \ SW_SHOWNA 8 \ SW_SHOWNOACTIVATE 4 \ SW_SHOWNORMAL 1 \ SW_NORMAL 1 \ SW_SHOWDEFAULT 10 \ SW_FORCEMINIMIZE 11 \ SW_MAX 11 \ SW_NORMALNA [expr {0xCC}]]] __ShowWindow $w $cmd } # ::winapi::GetWindowInfo -- Get window information. # # This procedure retrieves information about the specified window # # Arguments: # w Handle of window to get information from # # Results: # Return a list ready for an array set command with the following keys. # # Side Effects: # None. proc ::winapi::GetWindowInfo { w } { set buf [binary format [::ffidl::info format ::winapi::WINDOWINFO] \ [::ffidl::info sizeof ::winapi::WINDOWINFO] \ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] if { [__GetWindowInfo $w buf] } { array set res {} binary scan $buf [::::ffidl::info format ::winapi::WINDOWINFO] \ len \ res(rcWindowLeft) res(rcWindowTop) \ res(rcWindowRight) res(rcWindowBottom) \ res(rcClientLeft) res(rcClientTop) \ res(rcClientRight) res(rcClientBottom) \ res(dwStyle) res(dwExStyle) res(dwWindowStatus) \ res(cxWindowBorders) res(cyWindowBorders) \ res(atomWindowType) res(wCreatorVersion) set res(dwStyle) [__tflags $res(dwStyle) \ [list \ WS_OVERLAPPED [expr {0x00000000}] \ WS_POPUP [expr {0x80000000}] \ WS_CHILD [expr {0x40000000}] \ WS_MINIMIZE [expr {0x20000000}] \ WS_VISIBLE [expr {0x10000000}] \ WS_DISABLED [expr {0x08000000}] \ WS_CLIPSIBLINGS [expr {0x04000000}] \ WS_CLIPCHILDREN [expr {0x02000000}] \ WS_MAXIMIZE [expr {0x01000000}] \ WS_CAPTION [expr {0x00C00000}] \ WS_BORDER [expr {0x00800000}] \ WS_DLGFRAME [expr {0x00400000}] \ WS_VSCROLL [expr {0x00200000}] \ WS_HSCROLL [expr {0x00100000}] \ WS_SYSMENU [expr {0x00080000}] \ WS_THICKFRAME [expr {0x00040000}] \ WS_GROUP [expr {0x00020000}] \ WS_TABSTOP [expr {0x00010000}] \ WS_MINIMIZEBOX [expr {0x00020000}] \ WS_MAXIMIZEBOX [expr {0x00010000}]]] set res(dwExStyle) [__tflags $res(dwExStyle) \ [list \ WS_EX_DLGMODALFRAME [expr {0x00000001}] \ WS_EX_DRAGDETECT [expr {0x00000002}] \ WS_EX_NOPARENTNOTIFY [expr {0x00000004}] \ WS_EX_TOPMOST [expr {0x00000008}] \ WS_EX_ACCEPTFILES [expr {0x00000010}] \ WS_EX_TRANSPARENT [expr {0x00000020}] \ WS_EX_MDICHILD [expr {0x00000040}] \ WS_EX_TOOLWINDOW [expr {0x00000080}] \ WS_EX_WINDOWEDGE [expr {0x00000100}] \ WS_EX_CLIENTEDGE [expr {0x00000200}] \ WS_EX_CONTEXTHELP [expr {0x00000400}] \ WS_EX_RIGHT [expr {0x00001000}] \ WS_EX_LEFT [expr {0x00000000}] \ WS_EX_RTLREADING [expr {0x00002000}] \ WS_EX_LTRREADING [expr {0x00000000}] \ WS_EX_LEFTSCROLLBAR [expr {0x00004000}] \ WS_EX_RIGHTSCROLLBAR [expr {0x00000000}] \ WS_EX_CONTROLPARENT [expr {0x00010000}] \ WS_EX_STATICEDGE [expr {0x00020000}] \ WS_EX_APPWINDOW [expr {0x00040000}] \ WS_EX_LAYERED [expr {0x00080000}] \ WS_EX_NOINHERITLAYOUT [expr {0x00100000}]\ WS_EX_LAYOUTRTL [expr {0x00400000}] \ WS_EX_COMPOSITED [expr {0x02000000}] \ WS_EX_NOACTIVATE [expr {0x08000000}]]] return [array get res] } return "" } # ::winapi::FindWindow -- Wrapper around FindWindow # # This procedure finds a (toplevel) window that exactly matches # a class (optional) or title (optional). # # Arguments: # class Class of window, can be empty # title Title of window, can be empty # # Results: # Returns the handle of the window or 0 # # Side Effects: # None. proc ::winapi::FindWindow { class title } { if { [string length $class] == 0 && [string length $title] == 0} { __FindWindowTitleNone 0 0 } elseif { [string length $class] == 0 } { __FindWindowTitle 0 $title } elseif { [string length $title] == 0 } { __FindWindowClass $class 0 } else { __FindWindow $class $title } } # ::winapi::FindWindowEx -- Wrapper around FindWindowEx # # This procedure finds a children window that exactly matches # a class (optional) or title (optional). # # Arguments: # parent Parent top window under which to look for window. # child Handle of child window to start search for after. # class Class of window, can be empty # title Title of window, can be empty # # Results: # Returns the handle of the window or 0 # # Side Effects: # None. proc ::winapi::FindWindowEx { parent child class title } { if { [string length $class] == 0 && [string length $title] == 0} { __FindWindowExNone $parent $child 0 0 } elseif { [string length $class] == 0 } { __FindWindowExTitle $parent $child 0 $title } elseif { [string length $title] == 0 } { __FindWindowExClass $parent $child $class 0 } else { __FindWindowEx $parent $child $class $title } } # ::winapi::FindWindows -- Find sub windows by pattern. # # This procedure finds all direct sub windows of a window that # matches a given pattern. # # Arguments: # parent Parent top window under which to look for window. # class Class pattern (string match-like) of window. # title Title pattern (string match-like) of window. # # Results: # Returns the handles of the windows that match the input patterns. # # Side Effects: # None. proc ::winapi::FindWindows { parent class title } { set wins "" set w [FindWindowEx $parent 0 "" ""] for { } { $w != 0 } { set w [FindWindowEx $parent $w "" ""] } { if { [string match $class [GetClassName $w]] \ && [string match $title [GetWindowText $w]] } { lappend wins $w } } return $wins } # ::winapi::WindowTree -- Return whole window tree # # This procedure finds all the windows that are a descendant of # a given window. # # Arguments: # w Parent top window for which to return the tree. # # Results: # Returns the handles of all descendant of the window which # handle is passed as a parameter. # # Side Effects: # None. proc ::winapi::WindowTree { w } { set subs [FindWindows $w * *] set res $subs foreach s $subs { set res [concat $res [WindowTree $s]] } return $res } # ::winapi::FindDescendantWindows -- Find descendant windows by pattern. # # This procedure finds all descendant windows (whole tree!) of a # window that matches a given pattern. # # Arguments: # parent Parent top window under which to look for window. # class Class pattern (string match-like) of window. # text Text pattern (string match-like) of window. # # Results: # Returns the handles of the windows that match the input patterns. # # Side Effects: # None. proc ::winapi::FindDescendantWindows { parent class text } { set wins "" foreach w [WindowTree $parent] { if { [string match $class [GetClassName $w]] \ && [string match $text [GetWindowText $w]] } { lappend wins $w } } return $wins } # ::winapi::__flag -- Transcript a textual flag to its integer value # # This procedure looks in a flag list for a given flag and # return the (integer) value that is associated to it. The flag # specification list is any repetition of key value where the # key is ready for string matching. Matching on incoming flag # and keys is made careless of the case. # # Arguments: # f Flag to convert to integer # specs List of specification key1 val1 key2 val2 ... # # Results: # Returns the first matching value of the flag, if the flag was # already an integer it is returned, empty flags will lead to 0. # # Side Effects: # None. proc ::winapi::__flag { f specs } { # Empty flag if { [string length $f] == 0 } { return 0 } # Already an integer, return it if { [string is integer $f] } { return $f } # Otherwise look for first matching key in specification list and # return it. set f [string toupper $f] foreach {spec val} $specs { if { [string match [string toupper $spec] $f] } { return $val } } return 0 } # ::winapi::__tflag -- Transcript an integer constant to its textual value # # This procedure looks in a flag list for a given flag and # return the (textual) value that is associated to it. The flag # specification list is any repetition of key value where the # key is ready for string matching. # # Arguments: # f Flag to convert to string # specs List of specification key1 val1 key2 val2 ... # # Results: # Returns the first matching value of the flag # # Side Effects: # None. proc ::winapi::__tflag { f specs } { foreach {spec val} $specs { if { $val == $f } { return $spec } } return "" } # ::winapi::__flags -- Transcript a textual flag to its integer value # # This procedure looks in a flag list for several flags (like a # C masked flag) and return the (integer) value that is # associated to them. The flag specification list is any # repetition of key value where the key is ready for string # matching. Matching on incoming flag and keys is made careless # of the case. # # Arguments: # f List of flags to convert to integer # specs List of specification key1 val1 key2 val2 ... # # Results: # Returns the added value of all flags (which is equivalent to # an OR operation), if the flag was already an integer it is # returned, empty flags will lead to 0. # # Side Effects: # None. proc ::winapi::__flags { flagsl specs } { # Empty flag, 0 if { [string length $flagsl] == 0 } { return 0 } # Otherwise perform the addition set flags 0 foreach f $flagsl { incr flags [__flag $f $specs] } return $flags } # ::winapi::__tflags -- Transcript an integer mask flag to its string list # # This procedure considers the incoming integer as a flag mask # and return the list of textual value that is associated to # them. The flag specification list is any repetition of key # value where the key is ready for string matching. # # Arguments: # f Flag mask to convert to list of values # specs List of specification key1 val1 key2 val2 ... # # Results: # Returns the list of flags contained in the mask, empty possibly # # Side Effects: # None. proc ::winapi::__tflags { f specs } { set vals "" foreach {spec val} $specs { if { [expr {$f & $val}] } { lappend vals $spec } } return $vals } # ::winapi::GetSytemMetrics -- Return system metrics # # This procedure is a wrapper around the GetSystemMetrics. It # recognises all the SM_ flags as an argument. # # Arguments: # metric Name of metric to get. # # Results: # The value of the metric or 0 # # Side Effects: # None. proc ::winapi::GetSystemMetrics { metric } { set m [__flag $metric [list *CXSCREEN 0 \ *CYSCREEN 1 \ *CXVSCROLL 2 \ *CYHSCROLL 3 \ *CYCAPTION 4 \ *CXBORDER 5 \ *CYBORDER 6 \ *CXDLGFRAME 7 \ *CYDLGFRAME 8 \ *CYVTHUMB 9 \ *CXHTHUMB 10 \ *CXICON 11 \ *CYICON 12 \ *CXCURSOR 13 \ *CYCURSOR 14 \ *CYMENU 15 \ *CXFULLSCREEN 16 \ *CYFULLSCREEN 17 \ *CYKANJIWINDOW 18 \ *MOUSEPRESENT 19 \ *CYVSCROLL 20 \ *CXHSCROLL 21 \ *DEBUG 22 \ *SWAPBUTTON 23 \ *RESERVED1 24 \ *RESERVED2 25 \ *RESERVED3 26 \ *RESERVED4 27 \ *CXMIN 28 \ *CYMIN 29 \ *CXSIZE 30 \ *CYSIZE 31 \ *CXFRAME 32 \ *CYFRAME 33 \ *CXMINTRACK 34 \ *CYMINTRACK 35 \ *CXDOUBLECLK 36 \ *CYDOUBLECLK 37 \ *CXICONSPACING 38 \ *CYICONSPACING 39 \ *MENUDROPALIGNMENT 40 \ *PENWINDOWS 41 \ *DBCSENABLED 42 \ *CMOUSEBUTTONS 43 \ *CXFIXEDFRAME 7 \ *CYFIXEDFRAME 8 \ *CXSIZEFRAME 32 \ *CYSIZEFRAME 33 \ *SECURE 44 \ *CXEDGE 45 \ *CYEDGE 46 \ *CXMINSPACING 47 \ *CYMINSPACING 48 \ *CXSMICON 49 \ *CYSMICON 50 \ *CYSMCAPTION 51 \ *CXSMSIZE 52 \ *CYSMSIZE 53 \ *CXMENUSIZE 54 \ *CYMENUSIZE 55 \ *ARRANGE 56 \ *CXMINIMIZED 57 \ *CYMINIMIZED 58 \ *CXMAXTRACK 59 \ *CYMAXTRACK 60 \ *CXMAXIMIZED 61 \ *CYMAXIMIZED 62 \ *NETWORK 63 \ *CLEANBOOT 67 \ *CXDRAG 68 \ *CYDRAG 69 \ *SHOWSOUNDS 70 \ *CXMENUCHECK 71 \ *CYMENUCHECK 72 \ *SLOWMACHINE 73 \ *MIDEASTENABLED 74 \ *MOUSEWHEELPRESENT 75 \ *XVIRTUALSCREEN 76 \ *YVIRTUALSCREEN 77 \ *CXVIRTUALSCREEN 78 \ *CYVIRTUALSCREEN 79 \ *CMONITORS 80 \ *SAMEDISPLAYFORMAT 81 \ *IMMENABLED 82 \ *CXFOCUSBORDER 83 \ *CYFOCUSBORDER 84 \ *TABLETPC 86 \ *MEDIACENTER 87 \ *STARTER 88 \ *SERVERR2 89 \ *CMETRICS 90]] __GetSystemMetrics $m } # ::winapi::SendMouseInput -- Send simulated mouse input # # This procedure is a wrapper around (the deprecated) # mouse_event function that is able to understand all the # MOUSEEVENTF_ flags as input. It is called that way to hint to # the (new) SendInput function that replaces mouse_event. # # Arguments: # dx Absolute or relative deplacement in X # dy Absolute or relative deplacement in Y # flagsl List of MOUSEEVENTF_ flags that describe the event. # dwData Additional data to the event. # # Results: # None # # Side Effects: # None. proc ::winapi::SendMouseInput { dx dy flagsl { dwData "" } } { set flags [__flags $flagsl { "*ABSOLUTE" 32768 "*MOVE" 1 \ "*LEFTDOWN" 2 "*LEFTUP" 4 \ "*RIGHTDOWN" 8 "*RIGHTUP" 16 \ "*MIDDLEDOWN" 32 "*MIDDLEUP" 64 \ "*WHEEL" 2048 "*XDOWN" 128 "*XUP" 256}] set dwData [__flags $dwData { "XBUTTON1" 1 "XBUTTON2" 2}] # Ideally, we would like to call SendInput, but it requires a # pointer to an structure that contains itself a pointer to an # array and I don't know how to imlement that with ffidl. mouse_event $flags $dx $dy $dwData 0 } # ::winapi::SendKeyboardInput -- Send simulated keyboard input # # This procedure is a wrapper around (the deprecated) # keybd_event function that is able to understand all the # VK_ flags as input. It is called that way to hint to # the (new) SendInput function that replaces keybd_event. # # Arguments: # vk Virtual key of the event # dwFlags Flags describing the key event # # Results: # None # # Side Effects: # None. proc ::winapi::SendKeyboardInput { vk { dwFlags ""} } { set flags [__flags $dwFlags { "*EXTENDEDKEY" 1 "*KEYUP" 2}] set vk [__flags $vk [list "*LBUTTON" [expr {0x01}] \ "*RBUTTON" [expr {0x02}] \ "*CANCEL" [expr {0x03}] \ "*MBUTTON" [expr {0x04}] \ "*XBUTTON1" [expr {0x05}] \ "*XBUTTON2" [expr {0x06}] \ "*BACK" [expr {0x08}] \ "*TAB" [expr {0x09}] \ "*CLEAR" [expr {0x0C}] \ "*RETURN" [expr {0x0D}] \ "*SHIFT" [expr {0x10}] \ "*CONTROL" [expr {0x11}] \ "*MENU" [expr {0x12}] \ "*PAUSE" [expr {0x13}] \ "*CAPITAL" [expr {0x14}] \ "*KANA" [expr {0x15}] \ "*HANGUEL" [expr {0x15}] \ "*HANGUL" [expr {0x15}] \ "*JUNJA" [expr {0x17}] \ "*FINAL" [expr {0x18}] \ "*HANJA" [expr {0x19}] \ "*KANJI" [expr {0x19}] \ "*ESCAPE" [expr {0x1B}] \ "*CONVERT" [expr {0x1C}] \ "*NONCONVERT" [expr {0x1D}] \ "*ACCEPT" [expr {0x1E}] \ "*MODECHANGE" [expr {0x1F}] \ "*SPACE" [expr {0x20}] \ "*PRIOR" [expr {0x21}] \ "*NEXT" [expr {0x22}] \ "*END" [expr {0x23}] \ "*HOME" [expr {0x24}] \ "*LEFT" [expr {0x25}] \ "*UP" [expr {0x26}] \ "*RIGHT" [expr {0x27}] \ "*DOWN" [expr {0x28}] \ "*SELECT" [expr {0x29}] \ "*PRINT" [expr {0x2A}] \ "*EXECUTE" [expr {0x2B}] \ "*SNAPSHOT" [expr {0x2C}] \ "*INSERT" [expr {0x2D}] \ "*DELETE" [expr {0x2E}] \ "*HELP" [expr {0x2F}] \ 0 [expr {0x30}] \ 1 [expr {0x31}] \ 2 [expr {0x32}] \ 3 [expr {0x33}] \ 4 [expr {0x34}] \ 5 [expr {0x35}] \ 6 [expr {0x36}] \ 7 [expr {0x37}] \ 8 [expr {0x38}] \ 9 [expr {0x39}] \ A [expr {0x41}] \ B [expr {0x42}] \ C [expr {0x43}] \ D [expr {0x44}] \ E [expr {0x45}] \ F [expr {0x46}] \ G [expr {0x47}] \ H [expr {0x48}] \ I [expr {0x49}] \ J [expr {0x4A}] \ K [expr {0x4B}] \ L [expr {0x4C}] \ M [expr {0x4D}] \ N [expr {0x4E}] \ O [expr {0x4F}] \ P [expr {0x50}] \ Q [expr {0x51}] \ R [expr {0x52}] \ S [expr {0x53}] \ T [expr {0x54}] \ U [expr {0x55}] \ V [expr {0x56}] \ W [expr {0x57}] \ X [expr {0x58}] \ Y [expr {0x59}] \ Z [expr {0x5A}] \ "*LWIN" [expr {0x5B}] \ "*RWIN" [expr {0x5C}] \ "*APPS" [expr {0x5D}] \ "*SLEEP" [expr {0x5F}] \ "*NUMPAD0" [expr {0x60}] \ "*NUMPAD1" [expr {0x61}] \ "*NUMPAD2" [expr {0x62}] \ "*NUMPAD3" [expr {0x63}] \ "*NUMPAD4" [expr {0x64}] \ "*NUMPAD5" [expr {0x65}] \ "*NUMPAD6" [expr {0x66}] \ "*NUMPAD7" [expr {0x67}] \ "*NUMPAD8" [expr {0x68}] \ "*NUMPAD9" [expr {0x69}] \ "*MULTIPLY" [expr {0x6A}] \ "*ADD" [expr {0x6B}] \ "*SEPARATOR" [expr {0x6C}] \ "*SUBTRACT" [expr {0x6D}] \ "*DECIMAL" [expr {0x6E}] \ "*DIVIDE" [expr {0x6F}] \ "*F1" [expr {0x70}] \ "*F2" [expr {0x71}] \ "*F3" [expr {0x72}] \ "*F4" [expr {0x73}] \ "*F5" [expr {0x74}] \ "*F6" [expr {0x75}] \ "*F7" [expr {0x76}] \ "*F8" [expr {0x77}] \ "*F9" [expr {0x78}] \ "*F10" [expr {0x79}] \ "*F11" [expr {0x7A}] \ "*F12" [expr {0x7B}] \ "*F13" [expr {0x7C}] \ "*F14" [expr {0x7D}] \ "*F15" [expr {0x7E}] \ "*F16" [expr {0x7F}] \ "*F17" [expr {0x80}] \ "*F18" [expr {0x81}] \ "*F19" [expr {0x82}] \ "*F20" [expr {0x83}] \ "*F21" [expr {0x84}] \ "*F22" [expr {0x85}] \ "*F23" [expr {0x86}] \ "*F24" [expr {0x87}] \ "*NUMLOCK" [expr {0x90}] \ "*SCROLL" [expr {0x91}] \ "*LSHIFT" [expr {0xA0}] \ "*RSHIFT" [expr {0xA1}] \ "*LCONTROL" [expr {0xA2}] \ "*RCONTROL" [expr {0xA3}] \ "*LMENU" [expr {0xA4}] \ "*RMENU" [expr {0xA5}] \ "*BROWSER_BACK" [expr {0xA6}] \ "*BROWSER_FORWARD" [expr {0xA7}] \ "*BROWSER_REFRESH" [expr {0xA8}] \ "*BROWSER_STOP" [expr {0xA9}] \ "*BROWSER_SEARCH" [expr {0xAA}] \ "*BROWSER_FAVORITES" [expr {0xAB}] \ "*BROWSER_HOME" [expr {0xAC}] \ "*VOLUME_MUTE" [expr {0xAD}] \ "*VOLUME_DOWN" [expr {0xAE}] \ "*VOLUME_UP" [expr {0xAF}] \ "*MEDIA_NEXT_TRACK" [expr {0xB0}] \ "*MEDIA_PREV_TRACK" [expr {0xB1}] \ "*MEDIA_STOP" [expr {0xB2}] \ "*MEDIA_PLAY_PAUSE" [expr {0xB3}] \ "*LAUNCH_MAIL" [expr {0xB4}] \ "*LAUNCH_MEDIA_SELECT" [expr {0xB5}] \ "*LAUNCH_APP1" [expr {0xB6}] \ "*LAUNCH_APP2" [expr {0xB7}] \ "*OEM_1" [expr {0xBA}] \ "*OEM_PLUS" [expr {0xBB}] \ "*OEM_COMMA" [expr {0xBC}] \ "*OEM_MINUS" [expr {0xBD}] \ "*OEM_PERIOD" [expr {0xBE}] \ "*OEM_2" [expr {0xBF}] \ "*OEM_3" [expr {0xC0}] \ "*OEM_4" [expr {0xDB}] \ "*OEM_5" [expr {0xDC}] \ "*OEM_6" [expr {0xDD}] \ "*OEM_7" [expr {0xDE}] \ "*OEM_8" [expr {0xDF}] \ "*OEM_102" [expr {0xE2}] \ "*PROCESSKEY" [expr {0xE5}] \ "*PACKET" [expr {0xE7}] \ "*ATTN" [expr {0xF6}] \ "*CRSEL" [expr {0xF7}] \ "*EXSEL" [expr {0xF8}] \ "*EREOF" [expr {0xF9}] \ "*PLAY" [expr {0xFA}] \ "*ZOOM" [expr {0xFB}] \ "*NONAME" [expr {0xFC}] \ "*PA1" [expr {0xFD}] \ "*OEM_CLEAR" [expr {0xFE}]]] keybd_event $vk 0 $flags 0 } # ::winapi::api -- Declare callout for DLL functions. # # This procedure declares a callout in this namespace for a # given function from one DLL. # # Arguments: # apiname Name of command to be created (::winapi:: will be prefixed) # argl List of arguments to the callout # ret Type of value returned # dllname Name of corresponding function in DLL (empty means same as api) # dll DLL in which to get the function from # # Results: # None. # # Side Effects: # None. proc ::winapi::api { apiname argl ret { dllname "" } { dll "user32.dll" } } { if { $dllname == "" } { set dllname $apiname # Get rid of lead underscore whenever possible. if { [string match "__*" $dllname] } { set dllname [string range $dllname 2 end] } } # Look for the function by its name, alernatively by its name # followed by the letter "A" as it seems the case sometimes. foreach n [list $dllname "${dllname}A"] { if { [catch {::ffidl::symbol $dll $n} addr] } { set addr "" } else { break } } if { $addr != "" } { ::ffidl::callout ::winapi::$apiname $argl $ret $addr } } # ::winapi::__init -- Initialise all known callouts # # This procedure initialises this module by declaring a whole # lot of callouts to functions in user32.dll. All callouts # prefixed by __ will be internals for which wrappers are # provided. # # Arguments: # None. # # Results: # Boolean describe success or failure. # # Side Effects: # None. proc ::winapi::__init { } { ::ffidl::typedef ::winapi::RECT long long long long ::ffidl::typedef ::winapi::POINT long long ::ffidl::typedef ::winapi::WINDOWPLACEMENT \ uint32 uint32 uint32 ::winapi::POINT ::winapi::POINT ::winapi::RECT ::ffidl::typedef ::winapi::WINDOWINFO \ uint32 ::winapi::RECT ::winapi::RECT uint32 uint32 uint32 uint32 \ uint32 uint16 uint16 # FindWindow in all its forms to support both empty and non-empty strings api __FindWindow { pointer-utf8 pointer-utf8 } long FindWindow api __FindWindowTitle { long pointer-utf8 } long FindWindow api __FindWindowClass { pointer-utf8 long } long FindWindow api __FindWindowNone { long long } long FindWindow # FindWindowEx in all its forms to support both empty and non-empty strings api __FindWindowEx { long long pointer-utf8 pointer-utf8 } long \ FindWindowEx api __FindWindowExTitle { long long long pointer-utf8 } long FindWindowEx api __FindWindowExClass { long long pointer-utf8 long } long FindWindowEx api __FindWindowExNone { long long long long } long FindWindowEx api GetDesktopWindow {} long api GetWindow { long long } long api __GetClassName {int pointer-var int} int api __GetWindowText {int pointer-var int} int api __GetWindowPlacement {int pointer-var} int api __SetWindowPlacement {int pointer-var} int api __ShowWindow {int int} int api MoveWindow { int int int int int int } int api __GetWindowInfo { int pointer-var } int api __GetWindowRect { long pointer-var } int api __GetClientRect { long pointer-var } int api __GetSystemMetrics { int } int # User Input api SendInput { int pointer-var int } int api mouse_event { int int int int long } void api keybd_event { uint8 uint8 int long } void return 1 } # Now automatically initialises this module, once and only once # through calling the __init procedure that was just declared above. namespace eval ::winapi { variable inited if { ! [info exists inited] } { set inited [::winapi::__init] } } package provide winapi 0.1 ---- [Category Windows]