Window management

From Rosetta Code

Treat windows or at least window identities as first class objects.

• Store window identities in variables, compare them for equality.
• Provide examples of performing some of the following:
  • hide, show, close, minimize, maximize, move, and resize a window.

The window of interest may or may not have been created by your program.

Contents 1 AutoHotkey 2 HicEst 3 Oz 4 PureBasic 5 Tcl

[edit] AutoHotkey

F1::  ;; when user hits the F1 key, do the following
WinGetTitle, window, A  ; get identity of active window into a variable
WinMove, %window%, , 100, 100, 800, 800 ; move window to coordinates, 100, 100
                                        ; and change size to 800 x 800 pixels
sleep, 2000
WinHide, % window    ; hide window
TrayTip, hidden, window is hidden, 2
sleep, 2000
WinShow, % window  ; show window again
loop,
{
  inputbox, name, what was the name of your window? 
  if (name = window) ; compare window variables for equality
  {
    msgbox you got it
    break
  }
; else try again
}
WinClose, % window     
return

[edit] HicEst

CHARACTER title="Rosetta Window_management"
REAL :: w=-333, h=25, x=1, y=0.5 ! pixels < 0,  relative window size 0...1,  script character size > 1
 
  WINDOW(WINdowhandle=wh, Width=w, Height=h, X=x, Y=y, TItle=title) ! create, on return size/pos VARIABLES are set to script char
  WINDOW(WIN=wh, MINimize)    ! minimize
  WINDOW(WIN=wh, SHowNormal)  ! restore
  WINDOW(WIN=wh, X=31, Y=7+4) !<-- move upper left here (col 31, row 7 + ~4 rows for title, menus, toolbar. Script window in upper left screen)
  WINDOW(WIN=wh, MAXimize)    ! maximize (hides the script window)
  WINDOW(Kill=wh)             ! close
END

[edit] Oz

We use QTk, Oz' default GUI toolkit. QTk takes a declarative description of the GUI and from this creates objects which represent the GUI parts. So windows are represented by objects and thus have an identity.

We create two windows with a simple GUI. The user can use each window to send messages to the window or its neighboring window. (Sending messages is the same as 'calling methods' in Oz.)

We also wrap the Window objects in a procedure in order to extend their functionality. This is interesting because it shows how to extend an object's interface even when we don't have control over object creation.

declare
  [QTk] = {Module.link ['x-oz://system/wp/QTk.ozf']}
 
  %% The messages that can be sent to the windows.
  WindowActions =
  [hide show close
   iconify deiconify
   maximize restore
   set(minsize:minsize(width:400 height:400))
   set(minsize:minsize(width:200 height:200))
   set(geometry:geometry(x:0 y:0))
   set(geometry:geometry(x:500 y:500))
  ]
 
  %% Two windows, still uninitialized.
  Windows = windows(window1:_
                    window2:_)
 
  fun {CreateWindow}
     Message = {NewCell WindowActions.1}
     ReceiverName = {NewCell {Arity Windows}.1}
     fun {ButtonText}
        "Send"#"  "#{ValueToString @Message}#"  to  "#@ReceiverName
     end
     Button
     Desc =
     td(title:"Window Management"
        lr(listbox(init:{Arity Windows}
                   glue:nswe
                   tdscrollbar:true
                   actionh:proc {$ W}
                              ReceiverName := {GetSelected W}
                              {Button set(text:{ButtonText})}
                           end
                  )
           listbox(init:{Map WindowActions ValueToString}
                   glue:nswe
                   tdscrollbar:true
                   actionh:proc {$ A}
                              Message := {GetSelected A}
                              {Button set(text:{ButtonText})}
                           end
                  )
           glue:nswe
          )
        button(text:{ButtonText}
               glue:we
               handle:Button
               action:proc {$}
                         {Windows.@ReceiverName @Message}
                      end
              )
       )
     Window = {Extend {QTk.build Desc}}
  in
     {Window show}
     Window
  end
 
  %% Adds two methods to a toplevel instance.
  %% For maximize and restore we have to interact directly with Tk
  %% because that functionality is not part of the QTk library.
  fun {Extend Toplevel}
     proc {$ A}
        case A of maximize then
           {Tk.send wm(state Toplevel zoomed)}
        [] restore then
           {Tk.send wm(state Toplevel normal)}
        else
           {Toplevel A}
        end
     end
  end
 
  %% Returns the current entry of a listbox
  %% as an Oz value.
  fun {GetSelected LB}
     Entries = {LB get($)}
     Index = {LB get(firstselection:$)}
  in
     {Compiler.virtualStringToValue {Nth Entries Index}}
  end
 
  fun {ValueToString V}
     {Value.toVirtualString V 100 100}
  end
in
  {Record.forAll Windows CreateWindow}

[edit] PureBasic

;- Create a linked list to store created windows.
NewList Windows()
Define i, j, dh, dw, flags, err$, x, y
 
;- Used sub-procedure to simplify the error handling
Procedure HandleError(Result, Text.s,ErrorLine=0,ExitCode=0)
  If Not Result
    MessageRequester("Error",Text)
    End ExitCode
  EndIf
  ProcedureReturn Result
EndProcedure
 
;- Window handling procedures
Procedure Minimize(window)
  SetWindowState(window,#PB_Window_Minimize)
EndProcedure
 
Procedure Normalize(window)
  SetWindowState(window,#PB_Window_Normal)
EndProcedure
 
;- Get enviroment data
HandleError(ExamineDesktops(),  "Failed to examine you Desktop.") 
dh=HandleError(DesktopHeight(0),"Could not retrieve DesktopHight")/3
dw=HandleError(DesktopWidth(0), "Could not retrieve DesktopWidth")/3
 
;- Now, creating 9 windows
flags=#PB_Window_SystemMenu 
err$="Failed to open Window"
For i=0 To 8
  j=HandleError(OpenWindow(#PB_Any,i*10,i*10+30,10,10,Str(i),flags),err$)
  SmartWindowRefresh(j, 1) 
  AddElement(Windows())
  Windows()=j
Next i
Delay(1000)
 
;- Call a sub-routine for each Window stored in the list.
ForEach Windows()
  Minimize(Windows())
Next
Delay(1000)
;- and again
ForEach Windows()
  Normalize(Windows())
Next
Delay(1000)
 
;- Spread them evenly
ForEach Windows()
  ResizeWindow(Windows(),x*dw,y*dh,dw-15,dh-35)
  x+1
  If x>2
    x=0: y+1
  EndIf
Next
Delay(2000)
 
End

[edit] Tcl

Library: Tk

package require Tk
 
# How to open a window
proc openWin {} {
    global win
    if {[info exists win] && [winfo exists $win]} {
        # Already existing; just reset
        wm deiconify $win
        wm state $win normal
        return
    }
    catch {destroy $win} ;# Squelch the old one
    set win [toplevel .t]
    pack [label $win.label -text "This is the window being manipulated"] \
        -fill both -expand 1
}
# How to close a window
proc closeWin {} {
    global win
    if {[info exists win] && [winfo exists $win]} {
        destroy $win
    }
}
# How to minimize a window
proc minimizeWin {} {
    global win
    if {[info exists win] && [winfo exists $win]} {
        wm state $win iconic
    }
}
# How to maximize a window
proc maximizeWin {} {
    global win
    if {[info exists win] && [winfo exists $win]} {
        wm state $win zoomed
        catch {wm attribute $win -zoomed 1} ;# Hack for X11
    }
}
# How to move a window
proc moveWin {} {
    global win
    if {[info exists win] && [winfo exists $win]} {
        scan [wm geometry $win] "%dx%d+%d+%d" width height x y
        wm geometry $win +[incr x 10]+[incr y 10]
    }
}
# How to resize a window
proc resizeWin {} {
    global win
    if {[info exists win] && [winfo exists $win]} {
        scan [wm geometry $win] "%dx%d+%d+%d" width height x y
        wm geometry $win [incr width 10]x[incr height 10]
    }
}
 
grid [label .l -text "Window handle:"] [label .l2 -textvariable win]
grid [button .b1 -text "Open/Reset" -command openWin] -
grid [button .b2 -text "Close" -command closeWin] -
grid [button .b3 -text "Minimize" -command minimizeWin] -
grid [button .b4 -text "Maximize" -command maximizeWin] -
grid [button .b5 -text "Move" -command moveWin] -
grid [button .b6 -text "Resize" -command resizeWin] -