CloudFlare suffered a massive security issue affecting all of its customers, including Rosetta Code. All passwords not changed since February 19th 2017 have been expired, and session cookie longevity will be reduced until late March.--Michael Mol (talk) 05:15, 25 February 2017 (UTC)

Window management

From Rosetta Code
Task
Window management
You are encouraged to solve this task according to the task description, using any language you may know.

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.

AutoHotkey[edit]

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

BBC BASIC[edit]

      SWP_NOMOVE = 2
SWP_NOZORDER = 4
SW_MAXIMIZE = 3
SW_MINIMIZE = 6
SW_RESTORE = 9
SW_HIDE = 0
SW_SHOW = 5
 
REM Store window handle in a variable:
myWindowHandle% = @hwnd%
 
PRINT "Hiding the window in two seconds..."
WAIT 200
SYS "ShowWindow", myWindowHandle%, SW_HIDE
WAIT 200
SYS "ShowWindow", myWindowHandle%, SW_SHOW
PRINT "Windows shown again."
 
PRINT "Minimizing the window in two seconds..."
WAIT 200
SYS "ShowWindow", myWindowHandle%, SW_MINIMIZE
WAIT 200
SYS "ShowWindow", myWindowHandle%, SW_RESTORE
PRINT "Maximizing the window in two seconds..."
WAIT 200
SYS "ShowWindow", myWindowHandle%, SW_MAXIMIZE
WAIT 200
SYS "ShowWindow", myWindowHandle%, SW_RESTORE
PRINT "Now restored to its normal size."
 
PRINT "Resizing the window in two seconds..."
WAIT 200
SYS "SetWindowPos", myWindowHandle%, 0, 0, 0, 400, 200, \
\ SWP_NOMOVE OR SWP_NOZORDER
 
PRINT "Closing the window in two seconds..."
WAIT 200
QUIT

HicEst[edit]

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

Icon and Unicon[edit]

The demo program opens three windows, one with a running commentary on the action.

link graphics
 
procedure main()
 
Delay := 3000
 
W1 := open("Window 1","g","resize=on","size=400,400","pos=100,100","bg=black","fg=red") |
stop("Unbale to open window 1")
W2 := open("Window 2","g","resize=on","size=400,400","pos=450,450","bg=blue","fg=yellow") |
stop("Unbale to open window 2")
W3 := open("Window 3","g","resize=on","size=400,400","pos=600,150","bg=orange","fg=black") |
stop("Unbale to open window 3")
WWrite(W3,"Opened three windows")
 
WWrite(W3,"Window 1&2 with rectangles")
every Wx := W1 | W2 | W3 do
if Wx ~=== W3 then
FillRectangle(Wx,50,50,100,100)
 
delay(Delay)
WWrite(W3,"Window 1 rasied")
Raise(W1)
 
delay(Delay)
WWrite(W3,"Window 2 hidden")
WAttrib(W2,"canvas=hidden")
 
delay(Delay)
WWrite(W3,"Window 2 maximized")
WAttrib(W2,"canvas=maximal")
Raise(W3)
 
delay(Delay)
WWrite(W3,"Window 2 restored & resized")
WAttrib(W2,"canvas=normal")
WAttrib(W2,"size=600,600")
 
delay(Delay)
WWrite(W3,"Window 2 moveded")
WAttrib(W2,"posx=700","posy=300")
 
delay(Delay)
WWrite(W3,"Window 2 minimized")
WAttrib(W2,"canvas=iconic")
 
delay(Delay)
WWrite(W3,"Window 2 restored")
WAttrib(W2,"canvas=normal") # restore as maximal, possible bug
 
delay(Delay)
WWrite(W3,"Enter Q or q here to quit")
WDone(W3)
end

graphics.icn provides graphics

Java[edit]

Java cannot (easily) manipulate windows created by other programs. This code manipulates windows that it has created, but any window created in the same JVM can be controlled similarly. This example uses Swing - for AWT or SWT go figure.

import java.awt.BorderLayout;
import java.awt.EventQueue;
import java.awt.Frame;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.lang.reflect.InvocationTargetException;
import javax.swing.AbstractAction;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
 
public class WindowController extends JFrame {
// Create UI on correct thread
public static void main( final String[] args ) {
EventQueue.invokeLater (
new Runnable() {
public void run() {
new WindowController();
}
}
);
}
 
private JComboBox list;
 
// Button class to call the right method
private class ControlButton extends JButton {
private ControlButton( final String name ) {
super(
new AbstractAction( name ) {
public void actionPerformed( final ActionEvent e ) {
try {
WindowController.class.getMethod( "do" + name )
.invoke ( WindowController.this );
} catch ( final Exception x ) { // poor practice
x.printStackTrace(); // also poor practice
}
}
}
);
}
}
 
// UI for controlling windows
public WindowController() {
super( "Controller" );
 
final JPanel main = new JPanel();
final JPanel controls = new JPanel();
 
setLocationByPlatform( true );
setResizable( false );
setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
setLayout( new BorderLayout( 3, 3 ) );
getRootPane().setBorder( new EmptyBorder( 3, 3, 3, 3 ) );
add( new JLabel( "Add windows and control them." ), BorderLayout.NORTH );
main.add( list = new JComboBox() );
add( main, BorderLayout.CENTER );
controls.setLayout( new GridLayout( 0, 1, 3, 3 ) );
controls.add( new ControlButton( "Add" ) );
controls.add( new ControlButton( "Hide" ) );
controls.add( new ControlButton( "Show" ) );
controls.add( new ControlButton( "Close" ) );
controls.add( new ControlButton( "Maximise" ) );
controls.add( new ControlButton( "Minimise" ) );
controls.add( new ControlButton( "Move" ) );
controls.add( new ControlButton( "Resize" ) );
add( controls, BorderLayout.EAST );
pack();
setVisible( true );
}
 
// These are the windows we're controlling, but any JFrame would do
private static class ControlledWindow extends JFrame {
private int num;
 
public ControlledWindow( final int num ) {
super( Integer.toString( num ) );
this.num = num;
setLocationByPlatform( true );
getRootPane().setBorder( new EmptyBorder( 3, 3, 3, 3 ) );
setDefaultCloseOperation( JFrame.DISPOSE_ON_CLOSE );
add( new JLabel( "I am window " + num + ". Use the controller to control me." ) );
pack();
setVisible( true );
}
 
public String toString() {
return "Window " + num;
}
}
 
// Here comes the useful bit - window control code
// Everything else was just to allow us to do this!
 
public void doAdd() {
list.addItem( new ControlledWindow( list.getItemCount () + 1 ) );
pack();
}
 
public void doHide() {
( ( JFrame ) list.getSelectedItem() ).setVisible( false );
}
 
public void doShow() {
( ( JFrame ) list.getSelectedItem() ).setVisible( true );
}
 
public void doClose() {
( ( JFrame ) list.getSelectedItem() ).dispose();
}
 
public void doMinimise() {
( ( JFrame ) list.getSelectedItem() ).setState( Frame.ICONIFIED );
}
 
public void doMaximise() {
( ( JFrame ) list.getSelectedItem() ).setExtendedState( Frame.MAXIMIZED_BOTH );
}
 
public void doMove() {
( ( JFrame ) list.getSelectedItem() ).setLocation
(
Integer.parseInt( JOptionPane.showInputDialog( "Horizontal position?" ) ),
Integer.parseInt( JOptionPane.showInputDialog( "Vertical position?" ) )
);
}
 
public void doResize() {
final JFrame window = ( JFrame ) list.getSelectedItem();
 
window.setBounds
(
window.getX(),
window.getY(),
Integer.parseInt( JOptionPane.showInputDialog( "Width?" ) ),
Integer.parseInt( JOptionPane.showInputDialog( "Height?" ) )
);
}
}
 

Mathematica[edit]

Mathematica can only easily access and control windows created by itself.

nb=NotebookCreate[]; (*Create a window and store in a variable*)
nb===nb2 (*test for equality with another window object*)
SetOptions[nb,Visible->False](*Hide*)
SetOptions[nb,Visible->True](*Show*)
NotebookClose[nb] (*Close*)
SetOptions[nb,WindowMargins->{{x,Automatic},{y,Automatic}}](*Move to x,y screen position*)
SetOptions[nb,WindowSize->{100,100}](*Resize*)

Nim[edit]

Library: Gtk2
[edit]

import
gdk2, glib2, gtk2,
os
 
proc thisDestroy(widget: pWidget, data: pgpointer){.cdecl.} =
main_quit()
proc thisMax(widget: pWidget, data: pgpointer){.cdecl.} =
maximize(get_parent_window(widget))
proc thisUnmax(widget: pWidget, data: pgpointer){.cdecl.} =
unmaximize(get_parent_window(widget))
proc thisIcon(widget: pWidget, data: pgpointer){.cdecl.} =
iconify(get_parent_window(widget))
proc thisDeicon(widget: pWidget, data: pgpointer){.cdecl.} =
deiconify(get_parent_window(widget))
proc thisHide(widget: pWidget, data: pgpointer){.cdecl.} =
hide(get_parent_window(widget))
sleep(5)
show(get_parent_window(widget))
 
proc thisShow(widget: pWidget, data: pgpointer){.cdecl.} =
show(get_parent_window(widget))
 
var isshifted: bool = false
 
proc thisMove(widget: pWidget, data: pgpointer){.cdecl.} =
var w, h: gint
get_size(get_parent_window(widget), Addr(w), Addr(h))
if isshifted:
move(get_parent_window(widget), w-10, h-10)
else:
move(get_parent_window(widget), w+10, h+10)
isshifted = not isshifted
 
 
nim_init()
var window = window_new(gtk2.WINDOW_TOPLEVEL)
discard allow_grow(window)
set_title(window,"Window management")
var stackbox = vbox_new(TRUE, 10)
var bmax = button_new("maximize")
var bunmax = button_new("unmaximize")
var bicon = button_new("iconize")
var bdeicon = button_new("deiconize")
var bhide = button_new("hide")
var bshow = button_new("show")
var bmove = button_new("move")
var bquit = button_new("Quit")
 
pack_start(stackbox, bmax, TRUE, TRUE, 0)
pack_start(stackbox, bunmax, TRUE, TRUE, 0)
pack_start(stackbox, bicon, TRUE, TRUE, 0)
pack_start(stackbox, bdeicon, TRUE, TRUE, 0)
pack_start(stackbox, bhide, TRUE, TRUE, 0)
pack_start(stackbox, bshow, TRUE, TRUE, 0)
pack_start(stackbox, bmove, TRUE, TRUE, 0)
pack_start(stackbox, bquit, TRUE, TRUE, 0)
set_border_width(Window, 5)
add(window, stackbox)
discard signal_connect(window, "destroy",
SIGNAL_FUNC(thisDestroy), nil)
 
discard signal_connect(bicon, "clicked",
SIGNAL_FUNC(thisIcon), nil)
discard signal_connect(bdeicon, "clicked",
SIGNAL_FUNC(thisDeicon), nil)
discard signal_connect(bmax, "clicked",
SIGNAL_FUNC(thisMax), nil)
discard signal_connect(bunmax, "clicked",
SIGNAL_FUNC(thisUnmax), nil)
discard signal_connect(bhide, "clicked",
SIGNAL_FUNC(thisHide), nil)
discard signal_connect(bshow, "clicked",
SIGNAL_FUNC(thisShow), nil)
discard signal_connect(bmove, "clicked",
SIGNAL_FUNC(thismove), nil)
discard signal_connect(bquit, "clicked",
SIGNAL_FUNC(thisDestroy), nil)
show_all(window)
main()

Library: IUP
[edit]

import iup
 
# assumes you have the iup .dll or .so installed
 
proc toCB(fp: proc): ICallback =
return cast[ICallback](fp)
 
discard iup.open(nil,nil)
 
var btnRestore = button("restore","")
var btnFull = button("Full screen","")
var btnMin = button("minimize","")
var btnMax = button("maximize","")
var btnHide = button("Transparent","")
#var btnHide = button("Hide (close)","")
var btnShow = button("Show","")
 
var hbox = Hbox(btnRestore, btnFull, btnMax, btnMin, btnShow, btnHide, nil)
setAttribute(hbox,"MARGIN", "10x10")
setAttribute(hbox,"PADDING", "5x5")
 
var dlg = Dialog(hbox)
#SetAttribute(dlg, "SIZE", "100x50")
 
proc doFull(ih:PIhandle): cint {.cdecl.} =
setAttribute(dlg,"FULLSCREEN","YES")
return IUP_DEFAULT
 
proc doMax(ih:PIhandle): cint {.cdecl.} =
#setAttribute(dlg,"FULLSCREEN","YES")
setAttribute(dlg,"PLACEMENT","MAXIMIZED")
# this is a work-around to get the dialog minimised (on win platform)
setAttribute(dlg,"VISIBLE","YES")
return IUP_DEFAULT
 
proc doMin(ih:PIhandle): cint {.cdecl.} =
setAttribute(dlg,"PLACEMENT","MINIMIZED")
# this is a work-around to get the dialog minimised (on win platform)
setAttribute(dlg,"VISIBLE","YES")
return IUP_DEFAULT
 
proc doRestore(ih:PIhandle): cint {.cdecl.} =
setAttribute(dlg,"OPACITY","255")
setAttribute(dlg,"FULLSCREEN","NO")
setAttribute(dlg,"PLACEMENT","NORMAL")
setAttribute(dlg,"VISIBLE","YES")
return IUP_DEFAULT
 
proc doHide(ih:PIhandle): cint {.cdecl.} =
#setAttribute(dlg,"VISIBLE","NO")
setAttribute(dlg,"OPACITY","60")
return IUP_DEFAULT
 
proc doShow(ih:PIhandle): cint {.cdecl.} =
setAttribute(dlg,"OPACITY","255")
setAttribute(dlg,"VISIBLE","YES")
return IUP_DEFAULT
 
discard setCallback(btnRestore,"ACTION", toCB(doRestore))
discard setCallback(btnFull,"ACTION", toCB(doFull))
discard setCallback(btnMax,"ACTION", toCB(doMax))
discard setCallback(btnMin,"ACTION", toCB(doMin))
discard setCallback(btnShow,"ACTION", toCB(doShow))
discard setCallback(btnHide,"ACTION", toCB(doHide))
 
discard dlg.show()
discard mainloop()
iup.Close()

Oz[edit]

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}

Perl[edit]

Library: Perl/Tk
[edit]

This is a translation of the Tcl solution for this task.

The preferred way of using Tk with perl is through the (relatively modern) Tkx module, not the (quite old) Tk module (also known as perl/tk), which my code uses.

I wrote the code using the Tk module, as that's what I had on my computer, and I was too lazy to install Tkx. Translating from perl/tk to Tkx should be fairly trivial.

#!perl
use strict;
use warnings;
use Tk;
 
my $mw;
my $win;
my $lab;
 
# How to open a window.
sub openWin {
if( $win ) {
$win->deiconify;
$win->wm('state', 'normal');
} else {
eval { $win->destroy } if $win;
$win = $mw->Toplevel;
$win->Label(-text => "This is the window being manipulated")
->pack(-fill => 'both', -expand => 1);
$lab->configure(-text => "The window object is:\n$win");
}
}
 
# How to close a window
sub closeWin {
return unless $win;
$win->destroy;
$lab->configure(-text => '');
undef $win;
}
 
# How to minimize a window
sub minimizeWin {
return unless $win;
$win->iconify;
}
 
# How to maximize a window
sub maximizeWin {
return unless $win;
$win->wm('state', 'zoomed');
eval { $win->wmAttribute(-zoomed => 1) }; # Hack for X11
}
 
# How to move a window
sub moveWin {
return unless $win;
my ($x, $y) = $win->geometry() =~ /\+(\d+)\+(\d+)\z/ or die;
$_ += 10 for $x, $y;
$win->geometry("+$x+$y");
}
 
# How to resize a window
sub resizeWin {
return unless $win;
my ($w, $h) = $win->geometry() =~ /^(\d+)x(\d+)/ or die;
$_ += 10 for $w, $h;
$win->geometry($w . "x" . $h);
}
 
$mw = MainWindow->new;
for my $label0 ($mw->Label(-text => 'Window handle:')) {
$lab = $mw->Label(-text => '');
$label0->grid($lab);
}
 
my @binit = ('Open/Restore' => \&openWin, Close => \&closeWin,
Minimize => \&minimizeWin, Maximize => \&maximizeWin,
Move => \&moveWin, Resize => \&resizeWin);
 
while( my ($text, $callback) = splice @binit, 0, 2 ) {
$mw->Button(-text => $text, -command => $callback)->grid('-');
}
 
MainLoop();
 
__END__
 

In the Tcl code I translated from, the second label of the main window had a textvariable attribute. For some reason, this didn't work correctly for me, either due to a bug in Tk.pm, or some other reason. Because of that, I kept around a handle to that second label ($lab), and called configure on it when I needed it's text to change.

Doubtless some more modern Tk binding (such as Tkx, or perhaps Tcl::Tk) would handle that better.

Phix[edit]

Translation of: Nim

Included in the distribution as demo\rosetta\Window_management.exw

include pGUI.e
 
Ihandle dlg
 
function doFull(Ihandle /*ih*/)
IupSetAttribute(dlg,"FULLSCREEN","YES")
return IUP_DEFAULT
end function
 
function doMax(Ihandle /*ih*/)
IupSetAttribute(dlg,"PLACEMENT","MAXIMIZED")
-- this is a work-around to get the dialog minimised (on win platform)
IupSetAttribute(dlg,"VISIBLE","YES")
return IUP_DEFAULT
end function
 
function doMin(Ihandle /*ih*/)
IupSetAttribute(dlg,"PLACEMENT","MINIMIZED")
-- this is a work-around to get the dialog minimised (on win platform)
IupSetAttribute(dlg,"VISIBLE","YES")
return IUP_DEFAULT
end function
 
function doRestore(Ihandle /*ih*/)
IupSetAttribute(dlg,"OPACITY","255")
IupSetAttribute(dlg,"FULLSCREEN","NO")
IupSetAttribute(dlg,"PLACEMENT","NORMAL")
IupSetAttribute(dlg,"VISIBLE","YES")
return IUP_DEFAULT
end function
 
function doDim(Ihandle /*ih*/)
IupSetAttribute(dlg,"OPACITY","60")
return IUP_DEFAULT
end function
 
function doShow(Ihandle /*ih*/)
IupSetAttribute(dlg,"OPACITY","255")
return IUP_DEFAULT
end function
 
function doMove(Ihandle /*ih*/)
integer {x,y} = IupGetIntInt(dlg,"SCREENPOSITION")
integer shift = iff(IupGetInt(NULL,"SHIFTKEY")?-10,+10)
IupShowXY(dlg,x+shift,y+shift)
return IUP_DEFAULT
end function
 
procedure main()
IupOpen("../pGUI/")
 
Ihandle hbox = IupHbox({IupButton("restore", Icallback("doRestore")),
IupButton("full screen",Icallback("doFull")),
IupButton("maximize", Icallback("doMax")),
IupButton("minimize", Icallback("doMin")),
IupButton("dim", Icallback("doDim")),
IupButton("show", Icallback("doShow")),
IupButton("move", Icallback("doMove"))})
IupSetAttribute(hbox,"MARGIN", "10x10")
IupSetAttribute(hbox,"PADDING", "5x5")
 
dlg = IupDialog(hbox)
IupSetAttribute(dlg,"OPACITY","255")
 
IupShowXY(dlg,IUP_CENTER,IUP_CENTER)
IupMainLoop()
IupClose()
end procedure
main()

PicoLisp[edit]

The following works on ErsatzLisp, the Java version of PicoLisp.

$ ersatz/pil +
: (setq
JFrame "javax.swing.JFrame"
MAXIMIZED_BOTH (java (public JFrame 'MAXIMIZED_BOTH))
ICONIFIED (java (public JFrame 'ICONIFIED))
Win (java JFrame T "Window") )
-> $JFrame
 
# Compare for equality
: (== Win Win)
-> T
 
# Set window visible
(java Win 'setLocation 100 100)
(java Win 'setSize 400 300)
(java Win 'setVisible T)
 
# Hide window
(java Win 'hide)
 
# Show again
(java Win 'setVisible T)
 
# Move window
(java Win 'setLocation 200 200)
 
# Iconify window
(java Win 'setExtendedState
(| (java (java Win 'getExtendedState)) ICONIFIED) )
 
# De-conify window
(java Win 'setExtendedState
(& (java (java Win 'getExtendedState)) (x| (hex "FFFFFFFF") ICONIFIED)) )
 
# Maximize window
(java Win 'setExtendedState
(| (java (java Win 'getExtendedState)) MAXIMIZED_BOTH) )
 
# Close window
(java Win 'dispose)

PureBasic[edit]

;- 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

Python[edit]

Works with: Python version 3.x
Library: tkinter

Using the tkinter GUI:

 
from tkinter import *
import tkinter.messagebox
 
def maximise():
"""get screenwidth and screenheight, and resize window to that size.
Also move to 0,0"""

root.geometry("{}x{}+{}+{}".format(root.winfo_screenwidth(), root.winfo_screenheight(), 0, 0))
 
def minimise():
"""Iconify window to the taskbar. When reopened, the window is
unfortunately restored to its original state, NOT its most recent state."""

root.iconify()
 
def delete():
"""create a modal dialog. If answer is "OK", quit the program"""
if tkinter.messagebox.askokcancel("OK/Cancel","Are you sure?"):
root.quit()
 
root = Tk()
 
mx=Button(root,text="maximise",command=maximise)
mx.grid()
mx.bind(maximise)
 
mn=Button(root,text="minimise",command=minimise)
mn.grid()
mn.bind(minimise)
 
#catch exit events, including "X" on title bar.
root.protocol("WM_DELETE_WINDOW",delete)
 
mainloop()
 

Racket[edit]

 
#lang racket/gui
 
(define (say . xs) (printf ">>> ~a\n" (apply ~a xs)) (flush-output))
 
(define frame (new frame% [label "Demo"] [width 400] [height 400]))
(say "frame = " frame) ; plain value
 
(say 'Show) (send frame show #t) (sleep 1)
(say 'Hide) (send frame show #f) (sleep 1)
(say 'Show) (send frame show #t) (sleep 1)
(say 'Minimize) (send frame iconize #t) (sleep 1)
(say 'Restore) (send frame iconize #f) (sleep 1)
(say 'Maximize) (send frame maximize #t) (sleep 1)
(say 'Restore) (send frame maximize #f) (sleep 1)
(say 'Move) (send frame move 100 100) (sleep 1)
(say 'Resize) (send frame resize 100 100) (sleep 1)
(say 'Close) (send frame show #f) (sleep 1) ; that's how we close a window
 


Ring[edit]

 
 
Load "guilib.ring"
 
/*
+--------------------------------------------------------------------------
+ Program Name : ScreenDrawOnReSize.ring
+ Date  : 2016.06.16
+ Author  : Bert Mariani
+ Purpose  : Re-Draw Chart after ReSize or move
+--------------------------------------------------------------------------
*/
 
 
###-------------------------------
### DRAW CHART size 1000 x 1000
###
 
###------------------------------
 
### Window Size
WinLeft = 80 ### 80 Window position on screen
WinTop = 80 ### 80 Window position on screen
WinWidth = 1000 ### 1000 Window Size - Horizontal-X WinWidth
WinHeight = 750 ### 750 Window Size - Vertical-Y WinHeight
WinRight = WinLeft + WinWidth ### 1080
WinBottom = WinTop + WinHeight ### 830
 
### Label Box Size
BoxLeft = 40 ### Start corner Label1 Box Start Position inside WIN1
BoxTop = 40 ### Start corner
BoxWidth = WinWidth -80 ### End corner Label1 Box Size
BoxHeight = WinHeight -80 ### End corner
 
###----------------------------
 
 
New qapp {
win1 = new qwidget() {
 
### Position and Size of WINDOW on the Screen
setwindowtitle("DrawChart using QPainter")
setgeometry( WinLeft, WinTop, WinWidth, WinHeight)
 
win1{ setwindowtitle("Initial Window Position: " +" L " + WinLeft +" T " + WinTop +" Width" + width() +" Height " + height() ) }
 
### ReSizeEvent ... Call WhereAreWe function
myfilter = new qallevents(win1)
myfilter.setResizeEvent("WhereAreWe()")
installeventfilter(myfilter)
 
### Draw within this BOX
label1 = new qlabel(win1) {
setgeometry(BoxLeft, BoxTop, BoxWidth, BoxHeight)
settext("We are Here")
}
 
 
### Button Position and Size ... Call DRAW function
new qpushbutton(win1) {
setgeometry( 30, 30, 80, 20)
settext("Draw")
setclickevent("Draw()")
}
 
###---------------
 
show()
}
 
exec()
}
 
 
###-----------------
### FUNCTION Draw
###-----------------
 
Func WhereAreWe
Rec = win1.framegeometry()
 
WinWidth = win1.width() ### 1000 Current Values
WinHeight = win1.height() ### 750
 
WinLeft = Rec.left() +8 ### <<< QT FIX because of Win Title
WinTop = Rec.top() +30 ### <<< QT FIX because of Win Title
WinRight = Rec.right()
WinBottom = Rec.bottom()
 
BoxWidth = WinWidth -80 ### 950
BoxHeight = WinHeight -80 ### 700
 
win1{ setwindowtitle("Window ReSize: Win " + WinWidth + "x" + WinHeight + " --- Box " + BoxWidth + "x" + BoxHeight +
" --- LT " + WinLeft + "-" + WinTop + " --- RB " + WinRight + "-" + WinBottom ) }
 
See "We Are Here - setResizeEvent - "
See " Win " + WinWidth + "x" + WinHeight + " --- Box " + BoxWidth + "x" + BoxHeight
See " --- LT " + Winleft + "-" + WinTop + " --- RB " + WinRight + "-" + WinBottom +nl
 
win1.setgeometry( WinLeft, WinTop, WinWidth, WinHeight )
label1.setgeometry( BoxLeft, BoxTop, BoxWidth, BoxHeight )
 
 
return
 
Func Draw
 
win1{ setwindowtitle("Draw Position: Win " + WinWidth + "x" + WinHeight + " --- Box " + BoxWidth + "x" + BoxHeight +
" --- LT " + WinLeft + "-" + WinTop + " --- RB " + WinRight + "-" + WinBottom ) }
 
See "Draw Position: " + WinWidth + "x" + WinHeight + " --- Box " + BoxWidth + "x" + BoxHeight +
" --- LT " + WinLeft + "-" + WinTop + " --- RB " + WinRight + "-" + WinBottom + nl
 
 
# ##-----------------------------
### PEN Colors
 
p1 = new qpicture()
 
colorBlue = new qcolor() { setrgb(0, 0,255,255) }
penBlue = new qpen() { setcolor(colorBlue) setwidth(1) }
 
 
###-----------------------
### PAINT the Chart
 
new qpainter() {
begin(p1)
setpen(penBlue)
 
###---------------------
### Draw Line Chart
 
drawline( 1 , 1 , BoxWidth , 1 ) ### WinTop line horizonal
drawline( 1 , 1 , 1 , BoxHeight ) ### WinLeft Line vetical
 
drawline( 1 , BoxHeight , BoxWidth , BoxHeight ) ### Bottom Line horizontal
drawline( BoxWidth , 1 , BoxWidth , BoxHeight ) ### WinRight Line vertical
 
drawline( BoxWidth / 2 , 1 , BoxWidth / 2 , BoxHeight ) ### Central vertical
drawline( 1 , BoxHeight / 2 , BoxWidth , BoxHeight / 2 ) ### Central horizontal
 
 
###--------------------------------------------------
 
 
endpaint()
}
 
 
label1 { setpicture(p1) show() }
 
return
###--------------------------------------------
 
 


Tcl[edit]

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