User input/Graphical
You are encouraged to solve this task according to the task description, using any language you may know.
In this task, the goal is to input a string and the integer 75000, from graphical user interface.
See also: User input/Text
AArch64 Assembly
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program inputWin64.s */
/*******************************************/
/* Constantes file */
/*******************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"
.equ YPOSTEXTINPUT, 18
.equ LGBUFFER, 50
.equ FONTSIZE, 6
/* constantes X11 */
.equ KeyPressed, 2
.equ ButtonPress, 4
.equ ButtonPress, 4
.equ EnterNotify, 7
.equ LeaveNotify, 8
.equ ClientMessage, 33
.equ KeyPressMask, 1
.equ ButtonPressMask, 4
.equ ButtonReleaseMask, 8
.equ ExposureMask, 1<<15
.equ StructureNotifyMask, 1<<17
.equ EnterWindowMask, 1<<4
.equ LeaveWindowMask, 1<<5
.equ CWBorderWidth, 1<<4
/* structures descriptions are in end oh this program */
/*******************************************/
/* Initialized data */
/*******************************************/
.data
szRetourligne: .asciz "\n"
szMessErreur: .asciz "Server X11 not found.\n"
szMessErrfen: .asciz "Error create X11 window.\n"
szMessErrGC: .asciz "Error create Graphic Context.\n"
szMessErrButton: .asciz "Error create button.\n"
szMessErrButtonGC: .asciz "Error create button Graphic Context.\n"
szMessErrInput: .asciz "Error create input window.\n"
szMessErrInputGC: .asciz "Error create input Graphic Context.\n"
//szMessGoodBye: .asciz "There have been no clicks yet"
szCursor: .asciz "_"
szTextButton: .asciz "PUSH"
szMessResult: .asciz "Text : @ Value @ "
szLibText: .asciz "Text :"
szLibValue: .asciz "Value : "
szLibDW: .asciz "WM_DELETE_WINDOW" // message close window
/*******************************************/
/* UnInitialized data */
/*******************************************/
.bss
.align 4
qDisplay: .skip 8 // Display address
qDefScreen: .skip 8 // Default screen address
identWin: .skip 8 // window ident
qCounterClic: .skip 8 // counter clic button
//qLongTexte: .skip 8
//ptZoneS: .skip 8 // pointeur zone saisie
ptMessage: .skip 8 // final message pointer
sZoneConv: .skip 24
wmDeleteMessage: .skip 16 // ident close message
stEvent: .skip 400 // provisional size
stButton: .skip BT_fin
buffer: .skip 500
stInputText: .skip Input_fin
stInputValue: .skip Input_fin
stWindowChge: .skip XWCH_fin
sSaisieCar: .skip LGBUFFER
sTexteSaisi: .skip LGBUFFER
sValueSaisi: .skip LGBUFFER
key: .skip 4 // code touche
/**********************************************/
/* -- Code section */
/**********************************************/
.text
.global main // program entry
main: // INFO: main
mov x0,#0 // open server X
bl XOpenDisplay
cmp x0,#0
beq erreur
// Ok return Display address
ldr x1,qAdrqDisplay
str x0,[x1] // store Display address for future use
mov x28,x0 // and in register 28
ldr x2,[x28,Disp_default_screen] // load default screen
ldr x1,qAdrqDefScreen
str x2,[x1] //store default_screen
mov x2,x28
ldr x0,[x2,Disp_screens] // screen list
//screen areas
ldr x5,[x0,Screen_white_pixel] // white pixel
ldr x3,[x0,Screen_black_pixel] // black pixel
ldr x4,[x0,Screen_root_depth] // bits par pixel
ldr x1,[x0,Screen_root] // root windows
// create window x11
mov x0,x28 //display
mov x2,#0 // position X
mov x3,#0 // position Y
mov x4,600 // weight
mov x5,400 // height
mov x6,0 // bordure ???
ldr x7,0 // ?
ldr x8,qBlanc // background
str x8,[sp,-16]! // argument fot stack
bl XCreateSimpleWindow
add sp,sp,16 // for stack alignement
cmp x0,#0 // error ?
beq erreurF
ldr x1,qAdridentWin
str x0,[x1] // store window ident for future use
mov x27,x0 // and in register 27
// Correction of window closing error
mov x0,x28 // Display address
ldr x1,qAdrszLibDW // atom name address
mov x2,#1 // False create atom if not exist
bl XInternAtom
cmp x0,#0
ble erreurF
ldr x1,qAdrwmDeleteMessage // address message
str x0,[x1]
mov x2,x1 // address atom create
mov x0,x28 // display address
mov x1,x27 // window ident
mov x3,#1 // number of protocoles
bl XSetWMProtocols
cmp x0,#0
ble erreurF
// authorization of seizures
mov x0,x28 // display address
mov x1,x27 // window ident
ldr x2,qFenetreMask // mask
bl XSelectInput
cmp x0,#0
ble 99f
// create Graphic Context
mov x0,x28 // display address
mov x1,x27 // window ident
bl createGC // GC address -> x26
cbz x0,erreurF
// create Graphic Context 1
mov x0,x28 // display address
mov x1,x27 // window ident
bl createGC1 // GC address -> x25
cbz x0,erreurF
// Display window
mov x1,x27 // ident window
mov x0,x28 // Display address
bl XMapWindow
ldr x0,qAdrszLibText
mov x1,x27
mov x2,5
mov x3,70
bl displayText
ldr x0,qAdrszLibValue
mov x1,x27
mov x2,280
mov x3,70
bl displayText
bl createButton // create button on screen
bl createInputText // create input text window
bl createInputValue // create input value window
1: // events loop
bl traitEvents
// other events
cbz x0,1b // and loop
//TODO: close ??
mov x0,0 // end Ok
b 100f
//TODO: close ??
3:
ldr x0,qAdrstEvent // events structure address
bl evtButtonMouse
b 1b
erreurF: // error create window
ldr x0,qAdrszMessErrfen
bl affichageMess
mov x0,1
b 100f
erreur: // error no server x11 active
ldr x0,qAdrszMessErreur
bl affichageMess
mov x0,1
100: // program standard end
mov x8,EXIT
svc 0
qBlanc: .quad 0xF0F0F0F0
qAdrqDisplay: .quad qDisplay
qAdrqDefScreen: .quad qDefScreen
qAdridentWin: .quad identWin
qAdrstEvent: .quad stEvent
qAdrszMessErrfen: .quad szMessErrfen
qAdrszMessErreur: .quad szMessErreur
qAdrwmDeleteMessage: .quad wmDeleteMessage
qAdrszLibDW: .quad szLibDW
//qAdrszMessGoodBye: .quad szMessGoodBye
qAdrszLibText: .quad szLibText
qAdrszLibValue: .quad szLibValue
qFenetreMask: .quad KeyPressMask|ButtonPressMask|StructureNotifyMask|ExposureMask|EnterWindowMask
/********************************************************************/
/* Events ***/
/********************************************************************/
traitEvents: // INFO: traitEvents
stp x20,lr,[sp,-16]! // save registers
mov x0,x28 // Display address
ldr x1,qAdrstEvent // events structure address
bl XNextEvent
ldr x0,qAdrstEvent // events structure address
ldr x1,[x0,#XAny_window] // what window ?
cmp x1,x27 // main window ?
bne 1f
bl evtMainWindow // yes
b 100f
1:
ldr x10,qAdrstInputText // input text window ?
ldr x11,[x10,Input_adresse]
cmp x1,x11
bne 2f
bl evtInputWindowText
mov x0,0 // other events
b 100f
2:
ldr x10,qAdrstInputValue // input value window
ldr x11,[x10,Input_adresse]
cmp x1,x11
bne 3f
bl evtInputWindowValue
mov x0,0 // other events
b 100f
3:
ldr x10,[x0,XAny_window] // window of event
ldr x11,qAdrstButton // load button ident
ldr x12,[x11,BT_adresse]
cmp x10,x12 // equal ?
bne 4f // no
bl evtButton
mov x0,0 // other events
b 100f
4: // other windows
mov x0,0 // other events
100:
ldp x20,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
/******************************************************************/
/* main windows events */
/******************************************************************/
/* x0 contains the events */
/* x1 contains the ident Window */
/* x0 return 0 if continue , 1 if program end */
evtMainWindow: // INFO: evtMainWindow
stp x20,lr,[sp,-16]! // save registers
ldr w0,[x0] // type in 4 first bytes
cmp w0,#ClientMessage // message for close window
beq 2f // yes -> end
mov x0,0 // other events
b 100f // and loop
2:
ldr x0,qAdrstEvent // events structure address
ldr x1,[x0,56] // location message code
ldr x2,qAdrwmDeleteMessage // equal ?
ldr x2,[x2]
mov x0,0
cmp x1,x2
bne 100f // no loop
mov x0,1 // end program
100:
ldp x20,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
/******************************************************************/
/* input text windows events */
/******************************************************************/
/* x0 contains the events */
/* x1 contains the ident Window */
evtButton: // INFO: evtButton
stp x20,lr,[sp,-16]! // save registers
ldr x10,[x0,#XAny_type]
cmp x10,ButtonPress
bne 1f
bl evtButtonMouse
b 100f
1:
cmp x10,#EnterNotify // mouse is on the button
bne 2f
ldr x3,qAdrstWindowChge // and change window border
mov x2,3
str x2,[x3,#XWCH_border_width]
mov x0,x28 // display
ldr x2,qFenSMask
bl XConfigureWindow
b 100f
2:
cmp x10,#LeaveNotify // mouse is off the button
bne 3f
ldr x3,qAdrstWindowChge // and change window border
mov x2,1
str x2,[x3,#XWCH_border_width]
mov x0,x28 // display
ldr x2,qFenSMask
bl XConfigureWindow
b 100f
3: // other event
100:
ldp x20,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
/******************************************************************/
/* input text windows events */
/******************************************************************/
/* x0 contains the events */
/* x1 contains the ident Window */
evtInputWindowText: // INFO: evtInputWindowText
stp x20,lr,[sp,-16]! // save registers
ldr x10,[x0,#XAny_type]
mov x20,x1
cmp x10,#KeyPressed // key character ?
bne 2f
// x0 events x1 window ident
ldr x2,qAdrstInputText
bl traitImput
b 100f
2:
cmp x10,#EnterNotify // mouse is on the window
bne 3f
ldr x0,qAdrstInputText // display text and cursor
bl displayInput
mov x1,x20
ldr x3,qAdrstWindowChge // and change window border
mov x2,3
str x2,[x3,#XWCH_border_width]
mov x0,x28 // display
ldr x2,qFenSMask
bl XConfigureWindow
b 100f
3:
cmp x10,#LeaveNotify // the mouse is out the window
bne 4f
ldr x0,qAdrszCursor // erase the cursor
ldr x2,qAdrstInputText
ldr x2,[x2,Input_cursor]
mov x10,FONTSIZE
mul x2,x2,x10
mov x3,YPOSTEXTINPUT
bl eraseText1
mov x1,x20
ldr x3,qAdrstWindowChge // and chane window border
mov x2,1
str x2,[x3,#XWCH_border_width]
mov x0,x28 // display
ldr x2,qFenSMask
bl XConfigureWindow
b 100f
4: // other event
100:
ldp x20,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
qFenSMask: .quad CWBorderWidth
qAdrstWindowChge: .quad stWindowChge
/******************************************************************/
/* input text windows events */
/******************************************************************/
/* x0 contains the events */
/* x1 contains the ident Window */
evtInputWindowValue: // INFO: evtInputWindowValue
stp x20,lr,[sp,-16]! // save registers
ldr x10,[x0,#XAny_type]
mov x20,x1
cmp x10,#KeyPressed // cas d'une touche
bne 2f
// x0 events x1 window ident
ldr x2,qAdrstInputValue
bl traitImput
b 100f
2:
cmp x10,#EnterNotify // mouse is on the window
bne 3f
ldr x0,qAdrstInputValue // display text and cursor
bl displayInput
mov x1,x20
ldr x3,qAdrstWindowChge // and change window border
mov x2,3
str x2,[x3,#XWCH_border_width]
mov x0,x28 // display
ldr x2,qFenSMask
bl XConfigureWindow
b 100f
3:
cmp x10,#LeaveNotify // the mouse is out the window
bne 4f
ldr x0,qAdrszCursor // erase the cursor
ldr x2,qAdrstInputValue
ldr x2,[x2,Input_cursor]
mov x10,FONTSIZE
mul x2,x2,x10
mov x3,YPOSTEXTINPUT
bl eraseText1
mov x1,x20
ldr x3,qAdrstWindowChge // and chane window border
mov x2,1
str x2,[x3,#XWCH_border_width]
mov x0,x28 // display
ldr x2,qFenSMask
bl XConfigureWindow
b 100f
4: // other event
100:
ldp x20,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
/******************************************************************/
/* traitement Key pressed */
/******************************************************************/
/* x0 contains the event */
/* x1 contains the ident Window */
/* x2 contains address structure window*/
traitImput: // INFO: traitImput
stp x20,lr,[sp,-16]! // save registers
mov x20,x2 // save structure address
mov x21,x1 // save ident window
ldr x1,qAdrsSaisieCar // character input buffer
mov x2,#4 // buffer lenght
ldr x3,qAdrkey // code character
mov x4,0 // Specifies or returns the XComposeStatus structure or NULL.
bl XLookupString
cmp x0,#1 // character key ?
bne 1f
ldr x0,qAdrsSaisieCar // input character area
ldrb w22,[x0] // load byte
cmp x22,#13 // enter ?
beq 1f
ldr x0,[x20,Input_text] // erase input area
mov x1,x21
mov x2,0
mov x3,YPOSTEXTINPUT
bl eraseText1
ldr x0,qAdrszCursor
ldr x2,[x20,Input_cursor] // erase cursor
mov x1,x21
mov x10,FONTSIZE // Font size
mul x2,x2,x10
mov x3,YPOSTEXTINPUT
bl eraseText1
ldr x13,[x20,Input_text]
cmp x22,#8 // back
beq back
// voir autre touche
ldr x4,[x20,Input_cursor] //
strb w22,[x13,x4] // store input character at text end
add x4,x4,1
str x4,[x20,Input_cursor] // maj cursor location
b suiteaff
back:
ldr x4,[x20,Input_cursor] // text size
sub x4,x4,#1
str x4,[x20,Input_cursor] // maj cursor location
suiteaff:
strb wzr,[x13,x4] // zero -> text end
mov x0,x20
bl displayInput
b 100f
1: // other key
mov x0,x28
mov x1,#50
bl XBell // sound on
100:
ldp x20,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
qAdrsSaisieCar: .quad sSaisieCar
qAdrkey: .quad key
qAdrsTexteSaisi: .quad sTexteSaisi
/******************************************************************/
/* create Graphic Context */
/******************************************************************/
/* x0 contains the Display address */
/* x1 contains the ident Window */
createGC: // INFO: createGC
stp x20,lr,[sp,-16]! // save registers
mov x20,x0 // save display address
mov x2,#0
mov x3,#0
bl XCreateGC
cbz x0,99f
mov x26,x0 // save GC
mov x0,x20 // display address
mov x1,x26
ldr x2,qRed // code RGB color
bl XSetForeground
cbz x0,99f
mov x0,x26 // return GC
b 100f
99:
ldr x0,qAdrszMessErrGC
bl affichageMess
mov x0,0
100:
ldp x20,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
qAdrszMessErrGC: .quad szMessErrGC
qRed: .quad 0xFF0000
qGreen: .quad 0xFF00
qBlue: .quad 0xFF
qBlack: .quad 0x0
/******************************************************************/
/* create Graphic Context 1 */
/******************************************************************/
/* x0 contains the Display address */
/* x1 contains the ident Window */
createGC1: // INFO: createGC1
stp x20,lr,[sp,-16]! // save registers
mov x20,x0 // save display address
mov x2,#0
mov x3,#0
bl XCreateGC
cbz x0,99f
mov x25,x0 // save GC
mov x0,x20 // display address
mov x1,x25
ldr x2,qBlanc // code RGB color
bl XSetForeground
cbz x0,99f
mov x0,x25 // return GC1
b 100f
99:
ldr x0,qAdrszMessErrGC
bl affichageMess
mov x0,0
100:
ldp x20,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
/******************************************************************/
/* create button on screen */
/******************************************************************/
createButton: // INFO: createButton
stp x21,lr,[sp,-16]! // save registers
// create button window
mov x0,x28 // display address
mov x1,x27 // ident window
mov x2,500 // X position
mov x3,50 // Y position
mov x4,60 // weight
mov x5,30 // height
mov x6,1 // border
ldr x7,qBlack
ldr x8,qBlanc // background
str x8,[sp,-16]! // argument fot stack
bl XCreateSimpleWindow
add sp,sp,16 // for stack alignement
cmp x0,#0 // error ?
beq 99f
ldr x21,qAdrstButton
str x0,[x21,BT_adresse] // save ident button
str xzr,[x21,BT_cbdata] // for next use
// autorisation des saisies
mov x0,x28 // display address
ldr x1,[x21,BT_adresse] // button address
ldr x2,qButtonMask // mask
bl XSelectInput
// create Graphic Contexte of button
mov x0,x28 // display address
ldr x1,[x21,BT_adresse] // button ident
mov x2,#0
mov x3,#0
bl XCreateGC
cmp x0,#0
beq 98f
str x0,[x21,BT_GC] // store GC
// display button
mov x0,x28 // display address
ldr x1,[x21,BT_adresse] // button address
bl XMapWindow
ldr x0,qAdrszTextButton // text address
ldr x1,[x21,BT_adresse] // ident button
mov x2,#18 // position x
mov x3,#18 // position y
bl displayText
b 100f
98:
ldr x0,qAdrszMessErrButtonGC
bl affichageMess
b 100f
99:
ldr x0,qAdrszMessErrButton
bl affichageMess
100:
ldp x1,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
qAdrstButton: .quad stButton
qAdrszTextButton: .quad szTextButton
qAdrszMessErrButtonGC: .quad szMessErrButtonGC
qAdrszMessErrButton: .quad szMessErrButton
qButtonMask: .quad ButtonPressMask|ButtonReleaseMask|StructureNotifyMask|ExposureMask|LeaveWindowMask|EnterWindowMask
/******************************************************************/
/* create window input text */
/******************************************************************/
createInputText: // INFO: createInputText
stp x21,lr,[sp,-16]! // save registers
// create button window
mov x0,x28 // display address
mov x1,x27 // ident window
mov x2,50 // X position
mov x3,50 // Y position
mov x4,200 // weight
mov x5,30 // height
mov x6,1 // border
ldr x7,qBlack
ldr x8,qBlanc // background
str x8,[sp,-16]! // argument fot stack
bl XCreateSimpleWindow
add sp,sp,16 // for stack alignement
cmp x0,#0 // error ?
beq 99f
ldr x21,qAdrstInputText
str x0,[x21,Input_adresse] // save ident button
// autorisation des saisies
mov x0,x28 // display address
ldr x1,[x21,Input_adresse] // button address
ldr x2,qInputMask // mask
bl XSelectInput
// create Graphic Contexte of button
mov x0,x28 // display address
ldr x1,[x21,Input_adresse] // button ident
mov x2,#0
mov x3,#0
bl XCreateGC
cmp x0,#0
beq 98f
str x0,[x21,Input_GC] // store GC
// display button
mov x0,x28 // display address
ldr x1,[x21,Input_adresse] // button address
bl XMapWindow
ldr x6,qAdrsTexteSaisi
str x6,[x21,Input_text]
str xzr,[x21,Input_cursor]
b 100f
98:
ldr x0,qAdrszMessErrInputGC
bl affichageMess
b 100f
99:
ldr x0,qAdrszMessErrInput
bl affichageMess
100:
ldp x1,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
qAdrstInputText: .quad stInputText
qAdrszMessErrInputGC: .quad szMessErrInputGC
qAdrszMessErrInput: .quad szMessErrInput
qInputMask: .quad KeyPressMask|StructureNotifyMask|ExposureMask|LeaveWindowMask|EnterWindowMask
/******************************************************************/
/* create window input text */
/******************************************************************/
createInputValue: // INFO: createInputValue
stp x21,lr,[sp,-16]! // save registers
// create window
mov x0,x28 // display address
mov x1,x27 // ident main window
mov x2,340 // X position
mov x3,50 // Y position
mov x4,50 // weight
mov x5,30 // height
mov x6,1 // border
ldr x7,qBlack
ldr x8,qBlanc // background
str x8,[sp,-16]! // argument fot stack
bl XCreateSimpleWindow
add sp,sp,16 // for stack alignement
cmp x0,#0 // error ?
beq 99f
ldr x21,qAdrstInputValue
str x0,[x21,Input_adresse] // save ident button
// autorisation des saisies
mov x0,x28 // display address
ldr x1,[x21,Input_adresse] // button address
ldr x2,qInputMask // mask
bl XSelectInput
// create Graphic Contexte of button
mov x0,x28 // display address
ldr x1,[x21,Input_adresse] // button ident
mov x2,#0
mov x3,#0
bl XCreateGC
cmp x0,#0
beq 98f
str x0,[x21,Input_GC] // store GC
// display button
mov x0,x28 // display address
ldr x1,[x21,Input_adresse] // button address
bl XMapWindow
ldr x6,qAdrsValueSaisi
str x6,[x21,Input_text]
str xzr,[x21,Input_cursor]
b 100f
98:
ldr x0,qAdrszMessErrInputGC
bl affichageMess
b 100f
99:
ldr x0,qAdrszMessErrInput
bl affichageMess
100:
ldp x1,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
qAdrstInputValue: .quad stInputValue
qAdrsValueSaisi: .quad sValueSaisi
/******************************************************************/
/* display text on screen */
/******************************************************************/
/* x0 contains the address of text */
/* x1 contains ident window */
/* x2 position X */
/* x3 position Y */
displayText: // INFO: displayText
stp x1,lr,[sp,-16]! // save registers
mov x5,x0 // text address
mov x6,0 // text size
1: // loop compute text size
ldrb w10,[x5,x6] // load text byte
cbz x10,2f // zero -> end
add x6,x6,1 // increment size
b 1b // and loop
2:
mov x0,x28 // display address
mov x4,x3 // position y
mov x3,x2 // position x
mov x2,x26 // GC address
bl XDrawString
100:
ldp x1,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
/******************************************************************/
/* erase text on screen */
/******************************************************************/
/* x0 contains the address of text */
/* x1 window ident */
/* x2 position x */
/* x3 position y */
eraseText1: // INFO: eraseText1
stp x1,lr,[sp,-16]! // save registers
mov x5,x0 // text address
mov x6,0 // text size
1: // loop compute text size
ldrb w10,[x5,x6] // load text byte
cbz x10,2f // zero -> end
add x6,x6,1 // increment size
b 1b // and loop
2:
mov x0,x28 // display address
mov x4,x3
mov x3,x2
mov x2,x25 // GC1 address
bl XDrawString
100:
ldp x1,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
/******************************************************************/
/* events clic mouse button */
/******************************************************************/
/* x0 contains the address of event */
evtButtonMouse: // INFO: evtButtonMouse
stp x20,lr,[sp,-16]! // save registers
ldr x10,[x0,XBE_window] // windows of event
ldr x11,qAdrstButton // load button ident
ldr x12,[x11,BT_adresse]
cmp x10,x12 // equal ?
bne 100f // no
ldr x20,qAdrptMessage // first entry
ldr x0,[x20]
cbz x0,1f
mov x1,x27
mov x2,50
mov x3,200
bl eraseText1 // yes erase the text
1:
ldr x1,qAdrstInputText // input text
ldr x1,[x1,Input_text]
ldrb w2,[x1]
cbz w2,100f // no input text
ldr x0,qAdrszMessResult
bl strInsertAtCharInc // insert text at @ character
mov x5,x0
ldr x1,qAdrstInputValue // input text
ldr x0,[x1,Input_text]
bl conversionAtoD // conversion value to decimal
// x0 contains the input value
ldr x1,qAdrsZoneConv // and decimal conversion
bl conversion10
mov x0,x5
ldr x1,qAdrsZoneConv
bl strInsertAtCharInc // and insert result at @ character
str x0,[x20] // save message address
mov x1,x27
mov x2,50
mov x3,200
bl displayText // and display new text
100:
ldp x20,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
qAdrqCounterClic: .quad qCounterClic
qAdrsZoneConv: .quad sZoneConv
qAdrszMessResult: .quad szMessResult
qAdrptMessage: .quad ptMessage
/******************************************************************/
/* display input area */
/******************************************************************/
/* x0 contains area structure */
displayInput: // INFO: displayInput
stp x1,lr,[sp,-16]! // save registers
mov x10,x0 // save structure
ldr x0,[x10,Input_text] // text
ldr x6,[x10,Input_cursor] // position curseur
cbz x6,1f // if zero no text
mov x0,x28 // display address
ldr x1,[x10,Input_adresse] // ident window
ldr x2,[x10,Input_GC] // GC address
mov x3,0 // position x
mov x4,YPOSTEXTINPUT // position y
ldr x5,[x10,Input_text] // text
bl XDrawString
1: // display cursor
mov x0,x28 // Display address
ldr x1,[x10,Input_adresse] // ident window
ldr x2,[x10,Input_GC] // GC address
ldr x3,[x10,Input_cursor] // position x
mov x10,FONTSIZE
mul x3,x3,x10
mov x4,YPOSTEXTINPUT // position y
ldr x5,qAdrszCursor // cursor text
mov x6,1 // length
bl XDrawString
100:
ldp x1,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
qAdrszCursor: .quad szCursor
/********************************************************/
/* File Include fonctions */
/********************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
/*******************************************/
/* Structures */
/********************************************/
/*************************************************/
/* INFO: Structures */
/*********************************************/
/* Display définition */
.struct 0
Disp_ext_data: /* hook for extension to hang data */
.struct Disp_ext_data + 8
Disp_private1:
.struct Disp_private1 + 8
Disp_fd: /* Network socket. */
.struct Disp_fd + 4
Disp_private2:
.struct Disp_private2 + 4
Disp_proto_major_version: /* major version of server's X protocol */
.struct Disp_proto_major_version + 4
Disp_proto_minor_version: /* minor version of servers X protocol */
.struct Disp_proto_minor_version + 4
Disp_vendor: /* vendor of the server hardware OK*/
.struct Disp_vendor + 8
Disp_private3:
.struct Disp_private3 + 8
Disp_private8:
.struct Disp_private8 + 8
Disp_private5:
.struct Disp_private5 + 8
Disp_private6:
.struct Disp_private6 + 8
Disp_resource_alloc:
.struct Disp_resource_alloc + 8
Disp_byte_order: /* screen byte order, LSBFirst, MSBFirst */
.struct Disp_byte_order+ 4
Disp_bitmap_unit: /* padding and data requirements */
.struct Disp_bitmap_unit + 4
Disp_bitmap_pad: /* padding requirements on bitmaps */
.struct Disp_bitmap_pad + 4
Disp_bitmap_bit_order: /* LeastSignificant or MostSignificant */
.struct Disp_bitmap_bit_order + 4
Disp_nformats: /* number of pixmap formats in list */
.struct Disp_nformats + 8
Disp_pixmap_format: /* pixmap format list */
.struct Disp_pixmap_format + 8
Disp_private28:
.struct Disp_private28 + 4
Disp_release: /* release of the server */
.struct Disp_release + 4
Disp_private9:
.struct Disp_private9 + 8
Disp_private10:
.struct Disp_private10 + 8
Disp_qlen: /* Length of input event queue */
.struct Disp_qlen + 8 /* correction dec19 */
Disp_last_request_read: /* seq number of last event read */
.struct Disp_last_request_read + 8
Disp_request: /* sequence number of last request. */
.struct Disp_request + 8
Disp_private11:
.struct Disp_private11 + 8
Disp_private12:
.struct Disp_private12 + 8
Disp_private13:
.struct Disp_private13 + 8
Disp_private14:
.struct Disp_private14 + 8 /* correction Vim */
Disp_max_request_size: /* maximum number 32 bit words in request*/
.struct Disp_max_request_size + 8
Disp_db:
.struct Disp_db + 8 /* correction Vim */
Disp_private15:
.struct Disp_private15 + 8 /* correction Vim */
Disp_display_name: /* "host:display" string used on this connect*/
.struct Disp_display_name + 8
Disp_default_screen: /* default screen for operations */
.struct Disp_default_screen + 4
Disp_nscreens: /* number of screens on this server*/
.struct Disp_nscreens + 4
Disp_screens: /* pointer to list of screens */
.struct Disp_screens + 8
Disp_motion_buffer: /* size of motion buffer */
.struct Disp_motion_buffer + 8
Disp_private16:
.struct Disp_private16 + 8
Disp_min_keycode: /* minimum defined keycode */
.struct Disp_min_keycode + 4
Disp_max_keycode: /* maximum defined keycode */
.struct Disp_max_keycode + 4
Disp_private17:
.struct Disp_private17 + 8
Disp_private18:
.struct Disp_private18 + 8
Disp_private19:
.struct Disp_private19 + 8
Disp_xdefaults: /* contents of defaults from server */
.struct Disp_xdefaults + 8
Disp_fin:
/*****************************************/
/* Screen définition */
.struct 0
Screen_ext_data: /* hook for extension to hang data */
.struct Screen_ext_data + 8
Screen_Xdisplay: /* back pointer to display structure */
.struct Screen_Xdisplay + 8
Screen_root: /* Root window id. */
.struct Screen_root + 8
Screen_width:
.struct Screen_width + 4
Screen_height:
.struct Screen_height + 4
Screen_mwidth: /* width and height of in millimeters */
.struct Screen_mwidth + 4
Screen_mheight:
.struct Screen_mheight + 4
Screen_ndepths: /* number of depths possible */
.struct Screen_ndepths + 8
Screen_depths: /* list of allowable depths on the screen */
.struct Screen_depths + 8
Screen_root_depth: /* bits per pixel */
.struct Screen_root_depth + 8
Screen_root_visual: /* root visual */
.struct Screen_root_visual + 8
Screen_default_gc: /* GC for the root root visual */
.struct Screen_default_gc + 8
Screen_cmap: /* default color map */
.struct Screen_cmap + 8
Screen_white_pixel:
.struct Screen_white_pixel + 8
Screen_black_pixel:
.struct Screen_black_pixel + 8
Screen_max_maps: /* max and min color maps */
.struct Screen_max_maps + 4
Screen_min_maps:
.struct Screen_min_maps + 4
Screen_backing_store: /* Never, WhenMapped, Always */
.struct Screen_backing_store + 8
Screen_save_unders:
.struct Screen_save_unders + 8
Screen_root_input_mask: /* initial root input mask */
.struct Screen_root_input_mask + 8
Screen_fin:
/**********************************************/
/* Button structure */
.struct 0
BT_cbdata:
.struct BT_cbdata + 8
BT_adresse:
.struct BT_adresse + 8
BT_GC:
.struct BT_GC + 8
BT_Font:
.struct BT_Font + 8
BT_fin:
/****************************************/
/* Input text structure */
.struct 0
Input_adresse:
.struct Input_adresse + 8
Input_GC:
.struct Input_GC + 8
Input_text:
.struct Input_text + 8
Input_cursor:
.struct Input_cursor + 8
Input_Font:
.struct Input_Font + 8
Input_fin:
/***************************************************/
/* structure XButtonEvent */
.struct 0
XBE_type: //event type
.struct XBE_type + 8
XBE_serial: // No last request processed server */
.struct XBE_serial + 8
XBE_send_event: // true if this came from a SendEvent request */
.struct XBE_send_event + 8
XBE_display: // Display the event was read from
.struct XBE_display + 8
XBE_window: // "event" window it is reported relative to
.struct XBE_window + 8
XBE_root: // root window that the event occurred on
.struct XBE_root + 8
XBE_subwindow: // child window
.struct XBE_subwindow + 8
XBE_time: // milliseconds
.struct XBE_time + 8
XBE_x: // pointer x, y coordinates in event window
.struct XBE_x + 8
XBE_y:
.struct XBE_y + 8
XBE_x_root: // coordinates relative to root
.struct XBE_x_root + 8
XBE_y_root:
.struct XBE_y_root + 8
XBE_state: // key or button mask
.struct XBE_state + 8
XBE_button: // detail
.struct XBE_button + 8
XBE_same_screen: // same screen flag
.struct XBE_same_screen + 8
XBE_fin:
/***************************************************/
/* structure XAnyEvent */
.struct 0
XAny_type:
.struct XAny_type + 8
XAny_serial:
.struct XAny_serial + 8 /* # of last request processed by server */
XAny_send_event:
.struct XAny_send_event + 8 /* true if this came from a SendEvent request */
XAny_display:
.struct XAny_display + 8 /* Display the event was read from */
XAny_window:
.struct XAny_window + 8 /* window on which event was requested in event mask */
Xany_fin:
/****************************************/
/* structure de type XWindowChanges */
.struct 0
XWCH_x:
.struct XWCH_x + 4
XWCH_y:
.struct XWCH_y + 4
XWCH_width:
.struct XWCH_width + 4
XWCH_height:
.struct XWCH_height + 4
XWCH_border_width:
.struct XWCH_border_width + 4
XWCH_sibling:
.struct XWCH_sibling + 4
XWCH_stack_mode:
.struct XWCH_stack_mode + 4
XWCH_fin:
Ada
with Gtk.Button; use Gtk.Button;
with Gtk.GEntry; use Gtk.GEntry;
with Gtk.Label; use Gtk.Label;
with Gtk.Window; use Gtk.Window;
with Gtk.Widget; use Gtk.Widget;
with Gtk.Table; use Gtk.Table;
with Gtk.Handlers;
with Gtk.Main;
procedure Graphic_Input is
Window : Gtk_Window;
Grid : Gtk_Tnetable;
Label : Gtk_Label;
Message : Gtk_Label;
Edit : Gtk_GEntry;
Button : Gtk_Button;
package Handlers is new Gtk.Handlers.Callback (Gtk_Widget_Record);
package Return_Handlers is
new Gtk.Handlers.Return_Callback (Gtk_Widget_Record, Boolean);
function Delete_Event (Widget : access Gtk_Widget_Record'Class)
return Boolean is
begin
return False;
end Delete_Event;
procedure Destroy (Widget : access Gtk_Widget_Record'Class) is
begin
Gtk.Main.Main_Quit;
end Destroy;
procedure Clicked (Widget : access Gtk_Widget_Record'Class) is
begin
if Get_Text (Label) = "Enter integer:" then
Set_Text (Message, "Entered:" & Integer'Image (Integer'Value (Get_Text (Edit))));
Set_Sensitive (Button, False);
else
Set_Text (Message, "Entered:" & Get_Text (Edit));
Set_Text (Label, "Enter integer:");
end if;
exception
when Constraint_Error =>
Set_Text (Message, "Error integer input");
end Clicked;
begin
Gtk.Main.Init;
Gtk.Window.Gtk_New (Window);
Gtk_New (Grid, 2, 3, False);
Add (Window, Grid);
Gtk_New (Label, "Enter string:");
Attach (Grid, Label, 0, 1, 0, 1);
Gtk_New (Edit);
Attach (Grid, Edit, 1, 2, 0, 1);
Gtk_New (Button, "OK");
Attach (Grid, Button, 2, 3, 0, 1);
Gtk_New (Message);
Attach (Grid, Message, 0, 3, 1, 2);
Return_Handlers.Connect
( Window,
"delete_event",
Return_Handlers.To_Marshaller (Delete_Event'Access)
);
Handlers.Connect
( Window,
"destroy",
Handlers.To_Marshaller (Destroy'Access)
);
Handlers.Connect
( Button,
"clicked",
Handlers.To_Marshaller (Clicked'Access)
);
Show_All (Grid);
Show (Window);
Gtk.Main.Main;
end Graphic_Input;
AppleScript
set input to text returned of (display dialog "Enter text:" default answer "")
set input to text returned of (display dialog "Enter a number:" default answer "") as integer
AutoHotkey
InputBox
InputBox, String, Input, Enter a string:
InputBox, Int, Input, Enter an int:
Msgbox, You entered "%String%" and "%Int%"
Gui Edit
Gui, Add, Text,, String:
Gui, Add, Text,, Int:
Gui, Add, Button, gGo, Go!
Gui, Add, Edit, vString ym
Gui, Add, Edit, VInt
Gui, Show, Center, Input
Return
Go:
Gui, Submit, NoHide
Msgbox, You entered "%String%" and "%Int%"
ExitApp
Return
BaCon
Requires BaCon version 4.0.1 or higher, using GTK3.
OPTION GUI TRUE
PRAGMA GUI gtk3
DECLARE text TYPE STRING
DECLARE data TYPE FLOATING
gui = GUIDEFINE(" \
{ type=WINDOW name=window callback=delete-event title=\"Rosetta Code\" width-request=300 } \
{ type=BOX name=box parent=window orientation=GTK_ORIENTATION_VERTICAL } \
{ type=ENTRY name=entry parent=box margin=4 callback=activate } \
{ type=SPIN_BUTTON name=spin parent=box margin=4 numeric=TRUE } \
{ type=BUTTON_BOX name=bbox parent=box } \
{ type=BUTTON name=button parent=bbox margin=4 callback=clicked label=\"Exit\" }")
CALL GUISET(gui, "spin", "adjustment", gtk_adjustment_new(75000, 0, 100000, 1, 1, 0))
REPEAT
event$ = GUIEVENT$(gui)
UNTIL event$ = "button" OR event$ = "window"
CALL GUIGET(gui, "entry", "text", &text)
PRINT text FORMAT "Entered: %s\n"
CALL GUIGET(gui, "spin", "value", &data)
PRINT data FORMAT "Entered: %g\n"
BBC BASIC
INSTALL @lib$+"WINLIB2"
INSTALL @lib$+"WINLIB5"
ES_NUMBER = 8192
form% = FN_newdialog("Rosetta Code", 100, 100, 100, 64, 8, 1000)
PROC_static(form%, "String:", 100, 8, 8, 30, 14, 0)
PROC_editbox(form%, "Example", 101, 40, 6, 52, 14, 0)
PROC_static(form%, "Number:", 102, 8, 26, 30, 14, 0)
PROC_editbox(form%, "75000", 103, 40, 24, 52, 14, ES_NUMBER)
PROC_pushbutton(form%, "Read", FN_setproc(PROCread), 30, 43, 40, 16, 0)
PROC_showdialog(form%)
REPEAT
WAIT 1
UNTIL !form% = 0
QUIT
DEF PROCread
LOCAL buffer%, number%
DIM buffer% LOCAL 255
SYS "GetDlgItemText", !form%, 101, buffer%, 255
SYS "GetDlgItemInt", !form%, 103, 0, 1 TO number%
PRINT "String = """ $$buffer% """"
PRINT "Number = " ; number%
ENDPROC
C
#include <gtk/gtk.h>
void ok_hit(GtkButton *o, GtkWidget **w)
{
GtkMessageDialog *msg;
gdouble v = gtk_spin_button_get_value((GtkSpinButton *)w[1]);
const gchar *c = gtk_entry_get_text((GtkEntry *)w[0]);
msg = (GtkMessageDialog *)
gtk_message_dialog_new(NULL,
GTK_DIALOG_MODAL,
(v==75000) ? GTK_MESSAGE_INFO : GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
"You wrote '%s' and selected the number %d%s",
c, (gint)v,
(v==75000) ? "" : " which is wrong (75000 expected)!");
gtk_widget_show_all(GTK_WIDGET(msg));
(void)gtk_dialog_run(GTK_DIALOG(msg));
gtk_widget_destroy(GTK_WIDGET(msg));
if ( v==75000 ) gtk_main_quit();
}
int main(int argc, char **argv)
{
GtkWindow *win;
GtkEntry *entry;
GtkSpinButton *spin;
GtkButton *okbutton;
GtkLabel *entry_l, *spin_l;
GtkHBox *hbox[2];
GtkVBox *vbox;
GtkWidget *widgs[2];
gtk_init(&argc, &argv);
win = (GtkWindow *)gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(win, "Insert values");
entry_l = (GtkLabel *)gtk_label_new("Insert a string");
spin_l = (GtkLabel *)gtk_label_new("Insert 75000");
entry = (GtkEntry *)gtk_entry_new();
spin = (GtkSpinButton *)gtk_spin_button_new_with_range(0, 80000, 1);
widgs[0] = GTK_WIDGET(entry);
widgs[1] = GTK_WIDGET(spin);
okbutton = (GtkButton *)gtk_button_new_with_label("Ok");
hbox[0] = (GtkHBox *)gtk_hbox_new(FALSE, 1);
hbox[1] = (GtkHBox *)gtk_hbox_new(FALSE, 1);
vbox = (GtkVBox *)gtk_vbox_new(TRUE, 1);
gtk_container_add(GTK_CONTAINER(hbox[0]), GTK_WIDGET(entry_l));
gtk_container_add(GTK_CONTAINER(hbox[0]), GTK_WIDGET(entry));
gtk_container_add(GTK_CONTAINER(hbox[1]), GTK_WIDGET(spin_l));
gtk_container_add(GTK_CONTAINER(hbox[1]), GTK_WIDGET(spin));
gtk_container_add(GTK_CONTAINER(vbox), GTK_WIDGET(hbox[0]));
gtk_container_add(GTK_CONTAINER(vbox), GTK_WIDGET(hbox[1]));
gtk_container_add(GTK_CONTAINER(vbox), GTK_WIDGET(okbutton));
gtk_container_add(GTK_CONTAINER(win), GTK_WIDGET(vbox));
g_signal_connect(G_OBJECT(win), "delete-event", (GCallback)gtk_main_quit, NULL);
g_signal_connect(G_OBJECT(okbutton), "clicked", (GCallback)ok_hit, widgs);
gtk_widget_show_all(GTK_WIDGET(win));
gtk_main();
return 0;
}
C++
using library Qt 4.4 , first using qmake -project, then qmake -o Makefile <projectfile> and then make
task.h
#ifndef TASK_H
#define TASK_H
#include <QWidget>
class QLabel ;
class QLineEdit ;
class QVBoxLayout ;
class QHBoxLayout ;
class EntryWidget : public QWidget {
Q_OBJECT
public :
EntryWidget( QWidget *parent = 0 ) ;
private :
QHBoxLayout *upperpart , *lowerpart ;
QVBoxLayout *entryLayout ;
QLineEdit *stringinput ;
QLineEdit *numberinput ;
QLabel *stringlabel ;
QLabel *numberlabel ;
} ;
#endif
task.cpp
#include <QLineEdit>
#include <QLabel>
#include <QHBoxLayout>
#include <QVBoxLayout>
#include <QString>
#include "task.h"
EntryWidget::EntryWidget ( QWidget *parent )
: QWidget( parent ) {
entryLayout = new QVBoxLayout( this ) ;
stringlabel = new QLabel( "Enter a string!" ) ;
stringinput = new QLineEdit( "" ) ;
stringinput->setMaxLength( 20 ) ;
stringinput->setInputMask( QString( "AAAAAAAAAAAAAAAAAAA" ) ) ;
upperpart = new QHBoxLayout ;
upperpart->addWidget( stringlabel ) ;
upperpart->addWidget( stringinput ) ;
numberlabel = new QLabel( "Enter a number!" ) ;
numberinput = new QLineEdit( "0" ) ;
numberinput->setMaxLength( 5 ) ;
numberinput->setInputMask( QString( "99999" ) ) ;
lowerpart = new QHBoxLayout ;
lowerpart->addWidget( numberlabel ) ;
lowerpart->addWidget( numberinput ) ;
entryLayout->addLayout( upperpart ) ;
entryLayout->addLayout( lowerpart ) ;
setLayout( entryLayout ) ;
}
main.cpp
#include <QApplication>
#include "task.h"
int main( int argc , char *argv[ ] ) {
QApplication app( argc , argv ) ;
EntryWidget theWidget ;
theWidget.show( ) ;
return app.exec( ) ;
}
Clojure
Pretty much a straight port of the code for Java.
(import 'javax.swing.JOptionPane)
(let [number (-> "Enter an Integer"
JOptionPane/showInputDialog
Integer/parseInt)
string (JOptionPane/showInputDialog "Enter a String")]
[number string])
Common Lisp
Prompt for a string:
(capi:prompt-for-string "Enter a string:")
Repeatedly prompt for an integer until either the user presses 'Cancel' (instead of 'OK') or the integer is 75,000.
(do ((number 0) (okp t))
((or (not okp) (= 75000 number)))
(multiple-value-setq (number okp)
(capi:prompt-for-integer "Enter an integer:")))
Alternatively, display a prompt where the 'OK' button will not be enabled until the input is 75,000:
(capi:prompt-for-integer "Enter an integer:"
:ok-check #'(lambda (n) (= n 75000)))
And a version which displays one prompt with an area for a string and an area for an integer, and only enables the 'OK' button when the integer is 75,000.
First, define an interface with the text-areas:
(capi:define-interface string/integer-prompt () ()
(:panes
(string-pane
capi:text-input-pane
:title "Enter a string:")
(integer-pane
capi:text-input-pane
:title "Enter an integer:"
:change-callback :redisplay-interface))
(:layouts
(main
capi:column-layout
'(string-pane integer-pane))))
Then a function to extract the string and integer:
(defun string/integer-prompt-value (pane)
(with-slots (string-pane integer-pane) pane
(let* ((string (capi:text-input-pane-text string-pane))
(integer-string (capi:text-input-pane-text integer-pane))
(integer (when (every 'digit-char-p integer-string)
(parse-integer integer-string :junk-allowed t))))
(values (cons string integer)))))
Finally, display a prompt using the defined function to extract a value, and an 'ok-check' to ensure that the integer value is 75,000.
(defun do-prompting ()
(capi:popup-confirmer
(make-instance 'string/integer-prompt)
"Enter some values:"
:value-function 'string/integer-prompt-value
:ok-check #'(lambda (result) (eql (cdr result) 75000))))
Dart
Displays two text fields, a button and an output label, copy paste it into dartpad for viewing! - https://dartpad.github.io
import 'package:flutter/material.dart';
main() => runApp( OutputLabel() );
class OutputLabel extends StatefulWidget {
@override
_OutputLabelState createState() => _OutputLabelState();
}
class _OutputLabelState extends State<OutputLabel> {
String output = "output"; // This will be displayed in an output text field
TextEditingController _stringInputController = TextEditingController(); // Allows us to get the text from a text field
TextEditingController _numberInputController = TextEditingController();
@override
Widget build( BuildContext context ) {
return MaterialApp(
debugShowCheckedModeBanner: false, // Disable debug banner in top right
home: Scaffold ( // Scaffold provides a layout for the app
body: Center ( // Everything in the center widget will be centered
child: Column ( // All the widgets will be in a column
children: <Widget> [
SizedBox( height: 25 ), // Space between top and text field
TextField ( // String input Text Field
controller: _stringInputController, // Add input controller so we can grab text
textAlign: TextAlign.center, // Center text
decoration: InputDecoration( border: OutlineInputBorder(), labelText: 'Enter a string...'), // Border and default text
), // end TextField
SizedBox( height: 10 ), // Space between text fields
TextField ( // Number input Text Field
controller: _numberInputController, // Add input controller so we can grab text
textAlign: TextAlign.center, // Center text
decoration: InputDecoration( border: OutlineInputBorder(), labelText: 'Enter 75000'), // Border and default text
), // end TextField
FlatButton ( // Submit Button
child: Text('Submit Data'), // Button Text
color: Colors.blue[400] // button color
onPressed: () { // On pressed Callback for button
setState( () {
output = ''; // Reset output
int number; // Int to store number in
var stringInput = _stringInputController.text ?? ''; // Get the input from the first field, if it is null set it to an empty string
var numberString = _numberInputController.text ?? ''; // Get the input from the second field, if it is null set it to an empty string
if ( stringInput == '') { // If first field is empty
output = 'Please enter something in field 1\n';
return;
}
if (_numberInputController.text == '') { // If second field is empty
output += 'Please enter something in field 2';
return;
} else { // If we got an input in the second field
try {
number = int.parse( numberString ); // Parse numberString into an int
if ( number == 75000 )
output = 'text output: $stringInput\nnumber: $number'; // Grabs the text from the input controllers and changes the string
else
output = '$number is not 75000!';
} on FormatException { // If a number is not entered in second field
output = '$numberString is not a number!';
}
}
});
}
), // End FlatButton
Text( output ) // displays output
]
)
)
)
);
}
}
Delphi
program UserInputGraphical;
{$APPTYPE CONSOLE}
uses SysUtils, Dialogs;
var
s: string;
lStringValue: string;
lIntegerValue: Integer;
begin
lStringValue := InputBox('User input/Graphical', 'Enter a string', '');
repeat
s := InputBox('User input/Graphical', 'Enter the number 75000', '75000');
lIntegerValue := StrToIntDef(s, 0);
if lIntegerValue <> 75000 then
ShowMessage('Invalid entry: ' + s);
until lIntegerValue = 75000;
end.
FreeBASIC
#include once "windows.bi"
#include once "/win/commctrl.bi"
Dim Shared As zString * 255 textMessage = ""
Dim Shared As zString * 255 valueMessage = ""
Dim Shared As HWND MainWindow
Dim Shared As HWND EditBox, ValueBox, Button, Cancel, LabelBox
Function CreateToolTip(X As hwnd, msg As String = "") As hwnd
Dim As hwnd TT = CreateWindowEx(0, "ToolTips_Class32", "", 64, 0, 0, 0, 0, X, 0, GetModuleHandle(0), 0)
SendMessage(TT, TTM_SETMAXTIPWIDTH, 0, 180)
SendMessage(TT, TTM_SETDELAYTIME, TTDT_INITIAL, 10)
SendMessage(TT, TTM_SETDELAYTIME, TTDT_RESHOW, 60)
Dim bubble As TOOLINFO
bubble.cbSize = Len(TOOLINFO)
bubble.uFlags = TTF_IDISHWND Or TTF_SUBCLASS
bubble.uId = Cast(Uinteger, X)
bubble.lpszText = Strptr(msg)
SendMessage(TT, TTM_ADDTOOL, 0, Cast(LPARAM, @bubble))
Return TT
End Function
Sub CreateMainWindow
MainWindow = CreateWindowEx(NULL, "WindowClass", "User input/Graphical", WS_OVERLAPPEDWINDOW Or WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT, 300, 180, NULL, NULL, NULL, NULL)
EditBox = CreateWindowEx(WS_EX_CLIENTEDGE, "Edit", textMessage, WS_VISIBLE Or WS_CHILD, 10, 10, 250, 24, MainWindow, NULL, NULL, NULL)
ValueBox = CreateWindowEx(WS_EX_CLIENTEDGE, "Edit", valueMessage, WS_VISIBLE Or WS_CHILD Or ES_NUMBER, 10, 40, 250, 24, MainWindow, NULL, NULL, NULL)
Button = CreateWindowEx(NULL, "Button", "Aceptar", WS_VISIBLE Or WS_CHILD, 10, 70, 250, 24, MainWindow, NULL, NULL, NULL)
LabelBox = CreateWindowEx(NULL, "static", "", WS_VISIBLE Or WS_CHILD, 10, 100, 250, 24, MainWindow, NULL, NULL, NULL)
CreateToolTip(EditBox, "Type something in the box")
CreateToolTip(ValueBox, "Type a number in the box")
End Sub
Function WndProc(hWnd As HWND, msg As UINT, wParam As WPARAM, lParam As LPARAM) As LRESULT
Select Case hWnd
Case MainWindow
Select Case msg
Case WM_PAINT
Dim As PAINTSTRUCT ps
BeginPaint(hWnd, @ps)
FillRect(ps.hdc, @ps.rcPaint, CreateSolidBrush(BGR(238, 238, 238)))
EndPaint(hWnd, @ps)
Case WM_CLOSE
DestroyWindow(hWnd)
Case WM_COMMAND
Select Case lParam
Case Button
GetWindowText(EditBox, @textMessage, 255)
GetWindowText(ValueBox, @valueMessage, 255)
SetWindowText(LabelBox, textMessage & " - " & valueMessage)
End Select
End Select
End Select
Return DefWindowProc(hWnd, msg, wParam, lParam)
End Function
Dim As WNDCLASS wcls
With wcls
.style = CS_HREDRAW Or CS_VREDRAW
.lpfnWndProc = Cast(WNDPROC, @WndProc)
.hInstance = GetModuleHandle(NULL)
.hIcon = LoadIcon(NULL, IDI_APPLICATION)
.hCursor = LoadCursor(NULL, IDC_ARROW)
.hbrBackground = GetStockObject(WHITE_BRUSH)
.lpszMenuName = NULL
.lpszClassName = Strptr("WindowClass")
End With
If RegisterClass(@wcls) = False Then
MessageBox(NULL, "RegisterClass('WindowClass') FALLO!", "Error!", MB_OK Or MB_ICONERROR)
End
End If
CreateMainWindow
Dim As MSG uMsg
While GetMessage(@uMsg, NULL, NULL, NULL) <> False
TranslateMessage(@uMsg)
DispatchMessage(@uMsg)
Wend
Frink
Note that the code for getting user input is the same in graphical mode as in text mode. If Frink is running in a graphical mode, it will produce graphical inputs. If running in text mode, it will take input from stdin.
s = input["Enter a string: "]
i = parseInt[input["Enter an integer: "]]
Frink can also produce multiple-field input GUIs. The following works in text mode and in graphical mode, and produces a multi-field input dialog (in Swing, AWT, and Android):
[s,i] = input["Dialog title", ["Enter a string", "Enter an integer"]]
i = parseInt[i]
More information about Frink's multi-input, including specifying default values.
Gambas
hTextBox As TextBox
hValueBox As ValueBox
hLabel As Label
Public Sub Form_Open()
With Me
.Height = 100
.Width = 300
.padding = 5
.Arrangement = Arrange.Vertical
.Title = "User input/Graphical"
End With
hTextBox = New TextBox(Me) As "TextBox1"
hTextBox.Expand = True
hValueBox = New ValueBox(Me) As "ValueBox1"
hValueBox.Expand = True
hLabel = New Label(Me)
hLabel.expand = True
End
Public Sub TextBox1_Change()
hLabel.text = hTextBox.Text & " - " & Str(hValueBox.value)
End
Public Sub valueBox1_Change()
TextBox1_Change
End
Click here for a picture of the running program
Go
package main
import (
"github.com/gotk3/gotk3/gtk"
"log"
"math/rand"
"strconv"
"time"
)
func validateInput(window *gtk.Window, str1, str2 string) bool {
n, err := strconv.ParseFloat(str2, 64)
if len(str1) == 0 || err != nil || n != 75000 {
dialog := gtk.MessageDialogNew(
window,
gtk.DIALOG_MODAL,
gtk.MESSAGE_ERROR,
gtk.BUTTONS_OK,
"Invalid input",
)
dialog.Run()
dialog.Destroy()
return false
}
return true
}
func check(err error, msg string) {
if err != nil {
log.Fatal(msg, err)
}
}
func main() {
rand.Seed(time.Now().UnixNano())
gtk.Init(nil)
window, err := gtk.WindowNew(gtk.WINDOW_TOPLEVEL)
check(err, "Unable to create window:")
window.SetTitle("Rosetta Code")
window.SetPosition(gtk.WIN_POS_CENTER)
window.Connect("destroy", func() {
gtk.MainQuit()
})
vbox, err := gtk.BoxNew(gtk.ORIENTATION_VERTICAL, 1)
check(err, "Unable to create vertical box:")
vbox.SetBorderWidth(1)
hbox1, err := gtk.BoxNew(gtk.ORIENTATION_HORIZONTAL, 1)
check(err, "Unable to create first horizontal box:")
hbox2, err := gtk.BoxNew(gtk.ORIENTATION_HORIZONTAL, 1)
check(err, "Unable to create second horizontal box:")
label, err := gtk.LabelNew("Enter a string and the number 75000 \n")
check(err, "Unable to create label:")
sel, err := gtk.LabelNew("String: ")
check(err, "Unable to create string entry label:")
nel, err := gtk.LabelNew("Number: ")
check(err, "Unable to create number entry label:")
se, err := gtk.EntryNew()
check(err, "Unable to create string entry:")
ne, err := gtk.EntryNew()
check(err, "Unable to create number entry:")
hbox1.PackStart(sel, false, false, 2)
hbox1.PackStart(se, false, false, 2)
hbox2.PackStart(nel, false, false, 2)
hbox2.PackStart(ne, false, false, 2)
// button to accept
ab, err := gtk.ButtonNewWithLabel("Accept")
check(err, "Unable to create accept button:")
ab.Connect("clicked", func() {
// read and validate the entered values
str1, _ := se.GetText()
str2, _ := ne.GetText()
if validateInput(window, str1, str2) {
window.Destroy() // close window if input is OK
}
})
vbox.Add(label)
vbox.Add(hbox1)
vbox.Add(hbox2)
vbox.Add(ab)
window.Add(vbox)
window.ShowAll()
gtk.Main()
}
Groovy
Solution:
import javax.swing.JOptionPane
def number = JOptionPane.showInputDialog ("Enter an Integer") as Integer
def string = JOptionPane.showInputDialog ("Enter a String")
assert number instanceof Integer
assert string instanceof String
Haskell
Using
from HackageDB
import Graphics.UI.Gtk
import Control.Monad
main = do
initGUI
window <- windowNew
set window [windowTitle := "Graphical user input", containerBorderWidth := 10]
vb <- vBoxNew False 0
containerAdd window vb
hb1 <- hBoxNew False 0
boxPackStart vb hb1 PackNatural 0
hb2 <- hBoxNew False 0
boxPackStart vb hb2 PackNatural 0
lab1 <- labelNew (Just "Enter number 75000")
boxPackStart hb1 lab1 PackNatural 0
nrfield <- entryNew
entrySetText nrfield "75000"
boxPackStart hb1 nrfield PackNatural 5
strfield <- entryNew
boxPackEnd hb2 strfield PackNatural 5
lab2 <- labelNew (Just "Enter a text")
boxPackEnd hb2 lab2 PackNatural 0
accbox <- hBoxNew False 0
boxPackStart vb accbox PackNatural 5
im <- imageNewFromStock stockApply IconSizeButton
acceptButton <- buttonNewWithLabel "Accept"
buttonSetImage acceptButton im
boxPackStart accbox acceptButton PackRepel 0
txtstack <- statusbarNew
boxPackStart vb txtstack PackNatural 0
id <- statusbarGetContextId txtstack "Line"
widgetShowAll window
onEntryActivate nrfield (showStat nrfield txtstack id)
onEntryActivate strfield (showStat strfield txtstack id)
onPressed acceptButton $ do
g <- entryGetText nrfield
if g=="75000" then
widgetDestroy window
else do
msgid <- statusbarPush txtstack id "You didn't enter 75000. Try again"
return ()
onDestroy window mainQuit
mainGUI
showStat :: Entry -> Statusbar -> ContextId -> IO ()
showStat fld stk id = do
txt <- entryGetText fld
let mesg = "You entered \"" ++ txt ++ "\""
msgid <- statusbarPush stk id mesg
return ()
Run in GHCi:
*Main> main
HicEst
CHARACTER string*100
DLG(Edit=string, Edit=num_value, Button='&OK', TItle='Enter 75000 for num_value')
WRITE(Messagebox, Name) "You entered", string, num_value
Icon and Unicon
Unicon can open a window directly with open.
J
J 8.x
SIMPLEGUI=: noun define
pc simpleGui;
cc IntegerLabel static;cn "Enter the integer 75000";
cc integer edit;
cc TextLabel static;cn "Enter text";
cc text edit;
cc accept button;cn "Accept";
pshow;
)
simpleGui_run=: wd bind SIMPLEGUI
simpleGui_close=: wd bind 'pclose'
simpleGui_cancel=: simpleGui_close
simpleGui_accept_button=: verb define
ttxt=. text
tint=. _". integer
if. tint ~: 75000 do.
wdinfo 'Integer entered was not 75000.'
else.
simpleGui_close ''
'simpleGui_text simpleGui_integer'=: ttxt;tint
end.
)
simpleGui_run''
J 6.x A revision of the script posted at the Simple Windowed Application
SIMPLEGUI=: noun define
pc simpleGui;
xywh 136 39 44 12;cc accept button;cn "Accept";
xywh 0 14 60 11;cc IntegerLabel static ss_right;cn "Enter an integer";
xywh 65 13 60 12;cc integer edit;
xywh 0 39 60 11;cc TextLabel static ss_right;cn "Enter text";
xywh 64 38 60 12;cc text edit;
pas 6 6;pcenter;
rem form end;
)
simpleGui_run=: verb define
wd SIMPLEGUI
wd 'set integer *', ": 75000
wd 'pshow;'
)
simpleGui_accept_button=: verb define
ttxt=. text
tint=. _". integer NB. invalid integers assigned value _
if. tint ~: 75000 do.
wdinfo 'Integer entered was not 75000.'
else.
simpleGui_close ''
'simpleGui_text simpleGui_integer'=: ttxt;tint
end.
)
simpleGui_close=: wd bind 'pclose'
simpleGui_cancel=: simpleGui_close
simpleGui_run''
The program stores the values entered as the variables simpleGui_text
and simpleGui_integer
.
Java
import javax.swing.*;
public class GetInputSwing {
public static void main(String[] args) throws Exception {
int number = Integer.parseInt(
JOptionPane.showInputDialog ("Enter an Integer"));
String string = JOptionPane.showInputDialog ("Enter a String");
}
}
JavaScript
or any JavaScript-enabled browser
var str = prompt("Enter a string");
var value = 0;
while (value != 75000) {
value = parseInt( prompt("Enter the number 75000") );
}
Julia
using Gtk
function twoentrywindow()
txt = "Enter Text Here"
txtchanged = false
win = GtkWindow("Keypress Test", 500, 100) |> (GtkFrame() |> (vbox = GtkBox(:v)))
lab = GtkLabel("Enter some text in the first box and 7500 into the second box.")
txtent = GtkEntry()
set_gtk_property!(txtent,:text,"Enter Some Text Here")
nument = GtkEntry()
set_gtk_property!(nument,:text,"Enter the number seventy-five thousand here")
push!(vbox, lab, txtent, nument)
function keycall(w, event)
strtxt = get_gtk_property(txtent, :text, String)
numtxt = get_gtk_property(nument, :text, String)
if strtxt != txt && occursin("75000", numtxt)
set_gtk_property!(lab, :label, "You have accomplished the task.")
end
end
signal_connect(keycall, win, "key-press-event")
cond = Condition()
endit(w) = notify(cond)
signal_connect(endit, win, :destroy)
showall(win)
wait(cond)
end
twoentrywindow()
Kotlin
// version 1.1
import javax.swing.JOptionPane
fun main(args: Array<String>) {
do {
val number = JOptionPane.showInputDialog("Enter 75000").toInt()
} while (number != 75000)
}
LabVIEW
This image is a VI Snippet, an executable image of LabVIEW code. The LabVIEW version is shown on the top-right hand corner. You can download it, then drag-and-drop it onto the LabVIEW block diagram from a file browser, and it will appear as runnable, editable code.
Liberty BASIC
' [RC] User input/graphical
' Typical LB graphical input/output example.This shows how LB takes user input.
' You'd usually do more validating of input.
nomainwin ' No console window needed.
textbox#w.tb1, 100, 20, 200, 30
textbox#w.tb2, 100, 60, 200, 30
textbox#w.tb3, 100,160, 200, 30
statictext #w.st1, "String =", 10, 30, 90, 30
statictext #w.st2, "Integer =", 10, 70, 90, 30
button #w.b1, "Read and Show", [buttonClicked], LR, 180, 70
WindowWidth =360
WindowHeight =240
UpperLeftX = 40
UpperLeftY = 40
open "User input of integer & string" for window as #w
#w "trapclose [quit]" ' Clean exit routine.
#w.tb1 "!font courier 12"
#w.tb2 "!font courier 12"
#w.tb3 "!font courier 12 bold"
#w.st1 "!font courier 12"
#w.st2 "!font courier 12"
#w.tb1 "Change this string."
#w.tb2 "Enter an integer here."
#w.tb3 "Display will be here."
#w.tb1 "!selectall"
wait
[buttonClicked] ' Button-clicked routine collects data
#w.tb1 "!contents? in1$"
#w.tb2 "!contents? in2$"
#w.tb3 in1$; " "; int( val( in2$))
wait
[quit]
close #w
end
M2000 Interpreter
Simple InputBox
Module CheckIt {
Def aName$="No Name", Num$
\\ we open a new stack, and hold old
Stack New {
If Ask$("Give your name:",,,,,aName$)="OK" Then Read aName$
If Ask$("Give a Number: (75000)",,,,,"")="OK" Then Read Num$
if Num$<>"75000" or aName$="" Then loop
}
\ now old stack came back
Print Num$, aName$
Print Letter$ \\ Letter$ pop a string from stack
}
CheckIt "Thank You"
Gui User Form and TextBoxes
We use two textboxes in a user form. Each one has an event ValidString. The first textbox as we type display the number of characters that we can add. Also remove any leading space.
Each text box can be used for text, with a prompt (of we want), and a ThisKind at the end. Cursor can be move inside Vartext, the text that we place. Text in textbox may horizontal scroll automatic. We can use Home, End, Delete, Enter, Left and Right Arrows, Ctrl+V to paste (paste replace all text. we can't copy), and Tab and Shift Tab to change focus to other controls. There is no undo (Undo has the EditBox).
The second textbox change sign using + - in any position (we have to press + when sign is -). Only "-" sign displayed. Also except for zero all other numbers have no leading zeros.
Form Form1 open modal, so we can close it clicking a square in title bar, or using Alt+d2F4
Module Checkit {
Declare Form1 Form
Declare Inp1 Textbox Form Form1
Declare Inp2 Textbox Form Form1
With Inp1, "Prompt", "String: ", "MaxCharLength", 30+8, "ShowAlways", 1, "ThisKind" as info$, "VarText" as Aname$
info$=" <write your name>"
With Inp2, "Prompt", "Integer: ", "MaxCharLength", 10+9, "VarText" as Feed$, "ThisKind"," sec", "ShowAlways", 1
feed$="0"
\\ local1, and Event service functions have module visibility.
\\ So they have to use Read New to make new references (shadow old), and use local (the same for SUBS)
\\ Event's service functions can't use parents Subs, but Local1 can be used (exist in a list visible to Events)
Function Local1 (new Feed$) {
\\ this function can be used from other Integer
\\ this$ and thispos, exist just before the call of this function
local sgn$
if feed$="" and this$="-" then thispos-- : exit
if left$(this$,1)="-" then sgn$="-": this$=mid$(this$, 2)
if this$<>Trim$(this$) then this$=Feed$ : thispos-- : exit
If Trim$(this$)="" then this$="0" : thispos=2 : exit
if instr(this$,"+")>0 and sgn$="-" then this$=filter$(this$, "+") : sgn$=""
if instr(this$,"-")>0 and sgn$="" then this$=filter$(this$, "-") : sgn$="-"
if filter$(this$,"0123456789")<>"" then this$=Feed$ : thispos-- : exit
if len(this$)>1 then While left$(this$,1)="0" {this$=mid$(this$, 2)}
this$=sgn$+this$
if this$="-0" then this$="-" : thispos=2
}
Function Inp1.ValidString {
Read New &this$
While left$(this$, 1)=" " { this$=mid$(this$, 2)}
info$=str$(30-Len(This$), "\<0\>")
}
Function Inp2.ValidString {
\\ this function called direct from textbox
Read New &this$, &thispos
Call Local local1(Feed$)
}
Function Form1.Unload {
Read New &Quit
If feed$<>"75000" Or Aname$="" then {
\\ open messagebox, pressing cancel quit Unload
Quit=Ask("Data isn't correct")=2
}
}
Method Inp1, "Move", 2000,2000, 6000, 600
Method Inp2, "Move", 2000,3000, 6000, 600
Method Form1, "Show", 1
If Feed$="75000" and Aname$<>"" Then Print "Thank You"
Declare Form1 Nothing
}
Checkit
Mathematica /Wolfram Language
str = InputString["Input a string"]; nb =
InputString["Input a number"]; Print[str, " " , ToString@nb]
Example usage:
->Hello World 75000
Nanoquery
import Nanoquery.Util.Windows
// a function to handle the main window closing
def finish(caller, event)
exit
end
// create a window
w = new(Window, "Input").setTitle("Input")
w.setSize(320, 190)
w.setHandler(w.closing, finish)
// create two labels to go next to the input boxes
stringlabel = new(Label).setParent(w)
intlabel = new(Label).setParent(w)
stringlabel.setText("String: "); stringlabel.setPosition(20, 25)
intlabel.setText("Integer: "); intlabel.setPosition(20, 75)
// create two textboxes for input
stringbox = new(Textbox).setParent(w)
intbox = new(Textbox).setParent(w)
stringbox.setPosition(100, 20); stringbox.setWidth(200); stringbox.setHeight(30)
intbox.setPosition(100, 70); intbox.setWidth(200); intbox.setHeight(30)
// a function that handles when the 'done' button is clicked
def done_clicked(caller, event)
global stringbox
global intbox
global w
s = stringbox.getText()
i = intbox.getText()
try
if int(i) = 75000
println "String: " + s
println "Integer: " + i
exit
else
w.showMessageBox("Please enter 75000 for the integer value")
end
catch
w.showMessageBox("Please enter 75000 for the integer value")
end
end
// create the 'done' button
done = new(Button).setParent(w)
done.setText("Done"); done.setPosition(250,120)
done.setHandler(done.clicked, done_clicked)
// display the window
w.show()
NetRexx
/* NetRexx */
options replace format comments java crossref symbols nobinary
import javax.swing.JOptionPane
unumber = 0
ustring = ''
do
unumber = Integer.parseInt(JOptionPane.showInputDialog("Enter an Integer"))
ustring = JOptionPane.showInputDialog("Enter a String")
catch ex = Exception
ex.printStackTrace
end
unumber = unumber * 1.0 -- just to prove unumber is really a number
say 'Number:' unumber.right(10)', String:' ustring
return
NewLISP
; file: input-gui.lsp
; url: http://rosettacode.org/wiki/User_input/Graphical
; author: oofoe 2012-02-02
; Colours
(setq ok '(.8 1 .8) fail '(1 .5 .5))
; Load library and initialize GUI server:
(load (append (env "NEWLISPDIR") "/guiserver.lsp"))
(gs:init)
; Validation Callback
; There is a bug in the "gs:get-text" function that causes it to fail
; silently if the text field is empty. Therfore, I set the field
; background to red first and only clear it if the field returns
; correctly.
(define (validate)
(gs:set-color 'string fail)
(if (not (empty? (gs:get-text 'string)))
(gs:set-color 'string ok))
(gs:set-color 'number fail)
(if (= 75000 (int (gs:get-text 'number)))
(gs:set-color 'number ok))
)
; Create main window frame and set layout.
(gs:frame 'main 100 100 256 128 "User Input/Graphical")
(gs:set-flow-layout 'main "left" 4 4)
; Create and add widgets.
(gs:label 'instructions "Please enter a string and the number 75000:")
(gs:text-field 'string 'validate 32)
(gs:text-field 'number 'validate 8)
(gs:button 'check 'validate "validate...")
(gs:add-to 'main 'instructions 'string 'number 'check)
; Show main window.
(gs:set-visible 'main true)
; Start event loop.
(gs:listen)
; No (exit) needed -- guiserver kills program on window close.
Nim
To input the integer, we use a Gtk SpinBox as is done in the C version.
import strutils
import gintro/[glib, gobject, gtk, gio]
type MainWindow = ref object of ApplicationWindow
strEntry: Entry
intEntry: SpinButton
#---------------------------------------------------------------------------------------------------
proc displayValues(strval: string; intval: int) =
## Display a dialog window with the values entered by the user.
let dialog = newDialog()
dialog.setModal(true)
let label1 = newLabel(" String value is “$1”.".format(strval))
label1.setHalign(Align.start)
dialog.contentArea.packStart(label1, true, true, 5)
let msg = " Integer value is $1 which is ".format(intval) &
(if intval == 75000: "right. " else: "wrong (expected 75000). ")
let label2 = newLabel(msg)
dialog.contentArea.packStart(label2, true, true, 5)
discard dialog.addButton("OK", ord(ResponseType.ok))
dialog.showAll()
discard dialog.run()
dialog.destroy()
#---------------------------------------------------------------------------------------------------
proc onOk(button: Button; window: MainWindow) =
## Callback executed when the OK button has been clicked.
let strval = window.strEntry.text()
let intval = window.intEntry.value().toInt
displayValues(strval, intval)
if intval == 75_000:
window.destroy()
#---------------------------------------------------------------------------------------------------
proc activate(app: Application) =
## Activate the application.
let window = newApplicationWindow(MainWindow, app)
window.setTitle("User input")
let content = newBox(Orientation.vertical, 10)
content.setHomogeneous(true)
let grid = newGrid()
grid.setColumnSpacing(30)
let bbox = newButtonBox(Orientation.horizontal)
bbox.setLayout(ButtonBoxStyle.spread)
let strLabel = newLabel("Enter some text")
strLabel.setHalign(Align.start)
window.strEntry = newEntry()
grid.attach(strLabel, 0, 0, 1, 1)
grid.attach(window.strEntry, 1, 0, 1, 1)
let intLabel = newLabel("Enter 75000")
intLabel.setHalign(Align.start)
window.intEntry = newSpinButtonWithRange(0, 80_000, 1)
grid.attach(intLabel, 0, 1, 1, 1)
grid.attach(window.intEntry, 1, 1, 1, 1)
let btnOk = newButton("OK")
bbox.add(btnOk)
content.packStart(grid, true, true, 0)
content.packEnd(bbox, true, true, 0)
window.setBorderWidth(5)
window.add(content)
discard btnOk.connect("clicked", onOk, window)
window.showAll()
#———————————————————————————————————————————————————————————————————————————————————————————————————
let app = newApplication(Application, "Rosetta.UserInput")
discard app.connect("activate", activate)
discard app.run()
Oz
Shows a dialog that asks for both a string and a number. Does not allow to close the dialog until 75000 was entered. Note: "td" is short for "topdown", "lr" for "leftright".
functor
import
Application
QTk at 'x-oz://system/wp/QTk.ozf'
System
define
Number NumberWidget
Text
StatusLabel
WindowClosed
GUI = td(action:OnClose
return:WindowClosed
lr(label(text:"Enter some text:" width:20)
entry(return:Text glue:ew)
glue:ew)
lr(label(text:"Enter a number:" width:20)
numberentry(max:100000 return:Number handle:NumberWidget)
label(handle:StatusLabel width:20)
glue:ew
)
button(text:"Ok" glue:ew
action:OnClose
)
)
proc {OnClose}
if {NumberWidget get($)} \= 75000 then
{StatusLabel set(text:"Invalid value")}
else
{Window close}
end
end
Window = {QTk.build GUI}
{Window show}
{Wait WindowClosed}
{System.showInfo "You entered; "#Text#", "#Number}
{Application.exit 0}
end
Perl
use Wx;
package MyApp;
use base 'Wx::App';
use Wx qw(wxHORIZONTAL wxVERTICAL wxALL wxALIGN_CENTER);
use Wx::Event 'EVT_BUTTON';
our ($frame, $text_input, $integer_input);
sub OnInit
{$frame = new Wx::Frame
(undef, -1, 'Input window', [-1, -1], [250, 150]);
my $panel = new Wx::Panel($frame, -1);
$text_input = new Wx::TextCtrl($panel, -1, '');
$integer_input = new Wx::SpinCtrl
($panel, -1, '', [-1, -1], [-1, -1],
0, 0, 100_000);
my $okay_button = new Wx::Button($panel, -1, 'OK');
EVT_BUTTON($frame, $okay_button, \&OnQuit);
my $sizer = new Wx::BoxSizer(wxVERTICAL);
$sizer->Add($_, 0, wxALL | wxALIGN_CENTER, 5)
foreach $text_input, $integer_input, $okay_button;
$panel->SetSizer($sizer);
$frame->Show(1);}
sub OnQuit
{print 'String: ', $text_input->GetValue, "\n";
print 'Integer: ', $integer_input->GetValue, "\n";
$frame->Close;}
# ---------------------------------------------------------------
package main;
MyApp->new->MainLoop;
Phix
-- demo\rosetta\User_Input_Graphical.exw include pGUI.e Ihandle dlg, label1, input1, label2, input2, OK, Cancel function ok_cb(Ihandle self) if self=OK then string in1 = IupGetAttribute(input1,"VALUE") integer in2 = IupGetInt(input2,"VALUE") string msg = sprintf(`"%s" and %d`,{in1,in2}) IupMessage("You entered",msg) -- (return IUP_CONTINUE if unhappy with input) end if return IUP_CLOSE end function IupOpen() label1 = IupLabel("Please enter a string") input1 = IupText(`VALUE="a string", EXPAND=HORIZONTAL`) label2 = IupLabel("and the number 75000") input2 = IupText("VALUE=75000, EXPAND=HORIZONTAL, MASK="&IUP_MASK_INT) OK = IupButton("OK", "ACTION", Icallback("ok_cb")) Cancel = IupButton("Cancel", "ACTION", Icallback("ok_cb")) sequence buttons = {IupFill(),OK,Cancel,IupFill()} Ihandle strbox = IupHbox({label1,input1},"ALIGNMENT=ACENTER, PADDING=5"), numbox = IupHbox({label2,input2},"ALIGNMENT=ACENTER, PADDING=5"), btnbox = IupHbox(buttons,"PADDING=40"), vbox = IupVbox({strbox, numbox, btnbox}, "MARGIN=5x5") if platform()!=JS then IupSetAttribute(btnbox,"NORMALIZESIZE","BOTH") IupSetAttribute(vbox,"GAP","5") end if dlg = IupDialog(vbox, `TITLE="User Input/Graphical"`) IupShow(dlg) if platform()!=JS then IupMainLoop() IupClose() end if
PicoLisp
(and
(call 'sh "-c"
(pack
"dialog \
--inputbox 'Input a string' 8 60 \
--inputbox 'Input a number' 8 20 \
2>"
(tmp "dlg") ) )
(split (in (tmp "dlg") (line)) "^I")
(cons (pack (car @)) (format (cadr @))) )
Output:
-> ("Hello world" . 12345)
PowerBASIC
FUNCTION PBMAIN () AS LONG
result$ = INPUTBOX$("Enter a string.")
MSGBOX result$
DO
'This assumes that 75000 is the ONLY valid input.
result$ = INPUTBOX$("Enter the number 75000.")
IF VAL(result$) <> 75000 THEN
MSGBOX "You need to enter 75000!"
ELSE
MSGBOX "You entered the right number."
EXIT DO
END IF
LOOP
END FUNCTION
PowerShell
As a scripting/console language PowerShell was not designed for graphical interfaces. However, since PowerShell is a fully qualified .NET language the full functionality of the System.Windows.Forms assembly is available.
#region Define the Windows Form
[Void][Reflection.Assembly]::LoadWithPartialName("System.Windows.Forms")
$Form1 = New-Object System.Windows.Forms.Form
$label1 = New-Object System.Windows.Forms.Label
$label2 = New-Object System.Windows.Forms.Label
$txtInputText = New-Object System.Windows.Forms.TextBox
$txtInputNumber = New-Object System.Windows.Forms.TextBox
$btnAccept = New-Object System.Windows.Forms.Button
$label3 = New-Object System.Windows.Forms.Label
$btnCancel = New-Object System.Windows.Forms.Button
$SuspendLayout
#
# label1
#
$label1.AutoSize = $true
$label1.Location = New-Object System.Drawing.Point(23, 36)
$label1.Name = "label1"
$label1.Size = New-Object System.Drawing.Size(34, 13)
$label1.TabIndex = 0
$label1.Text = "String"
#
# label2
#
$label2.AutoSize = $true
$label2.Location = New-Object System.Drawing.Point(13, 62)
$label2.Name = "label2"
$label2.Size = New-Object System.Drawing.Size(44, 13)
$label2.TabIndex = 1
$label2.Text = "Number"
#
# txtInputText
#
$txtInputText.Location = New-Object System.Drawing.Point(63, 33)
$txtInputText.Name = "txtInputText"
$txtInputText.Size = New-Object System.Drawing.Size(100, 20)
$txtInputText.TabIndex = 0
#
# txtInputNumber
#
$txtInputNumber.Location = New-Object System.Drawing.Point(63, 59)
$txtInputNumber.Name = "txtInputNumber"
$txtInputNumber.Size = New-Object System.Drawing.Size(100, 20)
$txtInputNumber.TabIndex = 1
$txtInputNumber.Text = "75000"
#
# btnAccept
#
$btnAccept.DialogResult = [System.Windows.Forms.DialogResult]::OK
$btnAccept.Location = New-Object System.Drawing.Point(16, 94)
$btnAccept.Name = "btnAccept"
$btnAccept.Size = New-Object System.Drawing.Size(75, 23)
$btnAccept.TabIndex = 2
$btnAccept.Text = "Accept"
$btnAccept.UseVisualStyleBackColor = $true
$btnAccept.add_Click({$rc="Accept"; $Form1.Close()})
#
# label3
#
$label3.AutoSize = $true
$label3.Location = New-Object System.Drawing.Point(13, 9)
$label3.Name = "label3"
$label3.Size = New-Object System.Drawing.Size(173, 13)
$label3.TabIndex = 5
$label3.Text = "Please input a string and a number:"
#
# btnCancel
#
$btnCancel.DialogResult = [System.Windows.Forms.DialogResult]::Cancel
$btnCancel.Location = New-Object System.Drawing.Point(97, 94)
$btnCancel.Name = "btnCancel"
$btnCancel.Size = New-Object System.Drawing.Size(75, 23)
$btnCancel.TabIndex = 3
$btnCancel.Text = "Cancel"
$btnCancel.UseVisualStyleBackColor = $true
#
# Form1
#
$Form1.AcceptButton = $btnAccept
$Form1.CancelButton = $btnCancel
$Form1.ClientSize = New-Object System.Drawing.Size(196, 129)
$Form1.ControlBox = $false
$Form1.Controls.Add($btnCancel)
$Form1.Controls.Add($label3)
$Form1.Controls.Add($btnAccept)
$Form1.Controls.Add($txtInputNumber)
$Form1.Controls.Add($txtInputText)
$Form1.Controls.Add($label2)
$Form1.Controls.Add($label1)
$Form1.Name = "Form1"
$Form1.Text = "RosettaCode"
#endregion Define the Windows Form
### Show the input form
$f = $Form1.ShowDialog()
if ( $f -eq [System.Windows.Forms.DialogResult]::Cancel ) { "User selected Cancel" }
else { "User entered `"{0}`" for the text and {1} for the number" -f $txtInputText.Text, $txtInputNumber.Text }
Processing
import javax.swing.JOptionPane;
int number = int(JOptionPane.showInputDialog ("Enter an Integer"));
println(number);
String string = JOptionPane.showInputDialog ("Enter a String");
println(string);
Processing Python mode
from javax.swing import JOptionPane
def to_int(n, default=0):
try:
return int(n)
except ValueError:
return default
number = to_int(JOptionPane.showInputDialog ("Enter an Integer"))
println(number)
a_string = JOptionPane.showInputDialog ("Enter a String")
println(a_string)
PureBasic
string$=InputRequester("Some Title","Enter a string","")
variable=Val(InputRequester("Some other Title","Enter a Number","75000"))
Python
import Tkinter,tkSimpleDialog
root = Tkinter.Tk()
root.withdraw()
number = tkSimpleDialog.askinteger("Integer", "Enter a Number")
string = tkSimpleDialog.askstring("String", "Enter a String")
import tkinter
import tkinter.simpledialog as tks
root = tkinter.Tk()
root.withdraw()
number = tks.askinteger("Integer", "Enter a Number")
string = tks.askstring("String", "Enter a String")
tkinter.messagebox.showinfo("Results", f"Your input:\n {number} {string}")
Quackery
$ \
import tkinter
import tkinter.simpledialog as tks
root = tkinter.Tk()
root.withdraw()
to_stack(tks.askinteger("Integer", "Enter a Number"))
string_to_stack(tks.askstring("String", "Enter a String"))
\ python
swap echo cr echo$
R
library(gWidgets)
options(guiToolkit="RGtk2") ## using gWidgtsRGtk2
w <- gwindow("Enter a string and a number")
lyt <- glayout(cont=w)
lyt[1,1] <- "Enter a string"
lyt[1,2] <- gedit("", cont=lyt)
lyt[2,1] <- "Enter 75000"
lyt[2,2] <- gedit("", cont=lyt)
lyt[3,2] <- gbutton("validate", cont=lyt, handler=function(h,...) {
txt <- svalue(lyt[1,2])
x <- svalue(lyt[2,2])
x <- gsub(",", "", x)
x <- as.integer(x)
if(nchar(txt) > 0 && x == 75000)
gmessage("Congratulations, you followed directions", parent=w)
else
gmessage("You failed this simple task", parent=w)
})
Racket
#lang racket
(require racket/gui)
(define str (get-text-from-user "Hi" "Enter a string"))
(message-box "Hi" (format "You entered: ~a" str))
(define n (get-text-from-user "Hi" "Enter a number"))
(message-box "Hi" (format "You entered: ~a"
(or (string->number n) "bogus text")))
Raku
(formerly Perl 6)
use GTK::Simple;
use GTK::Simple::App;
my GTK::Simple::App $app .= new( title => 'User Interaction' );
$app.border-width = 20;
$app.set-content(
GTK::Simple::VBox.new(
my $ = GTK::Simple::Label.new( text => 'Enter a string.' ),
my $str = GTK::Simple::Entry.new,
my $string = GTK::Simple::Label.new,
my $ = GTK::Simple::Label.new( text => 'Enter the number 75000' ),
my $val = GTK::Simple::Entry.new,
my $correct = GTK::Simple::Label.new,
)
);
$str.changed.tap: {
$string.text = "You entered: { $str.text }"
}
$val.changed.tap: {
$correct.text = "That's { 'not' unless $val.text ~~ / ^^ <ws> 75000 <ws> $$ / } 75000!"
}
$app.run;
Rascal
import vis::Render;
import vis::Figure;
public void UserInput2(){
integer = "";
string = "";
row1 = [text("Enter a string "),
textfield("",void(str s){string = s;}),
text(str(){return " This input box will give a string by definition.\n You entered <string>";})];
row2 = [text("Enter 75000"),
textfield("",void(str v){integer = v;}),
text(str(){return " <integer == "75000" ? "Correct" : "Wrong">";})];
render(grid([row1, row2]));
}
Output:
REBOL
REBOL [
Title: "Graphical User Input"
URL: http://rosettacode.org/wiki/User_Input_-_graphical
]
; Simple GUI's can be defined with 'layout', a special purpose dialect
; for specifying interfaces. In this case, I describe a gradient
; background with an instruction label, followed by the input fields
; and a validation button. It's possible to check dynamically as the
; user types but I wanted to keep this example as clear as possible.
view layout [
; You can define new widget styles. Here I create a padded label style
; (so that everything will line up) and a simple indicator light to
; show if there's a problem with an input field.
style label vtext 60 "unlabeled"
style indicator box maroon 24x24
backdrop effect [gradient 0x1 black coal]
vtext "Please enter a string, and the number 75000:"
; By default, GUI widgets are arranged top down. The 'across' word
; starts stacking widgets from left to right. 'return' starts a new
; line -- just like on a typewriter!
across
; Notice I'm using my new label and indicator styles here. Widgets
; that I need to access later (the input field and the indicator) are
; assigned to variables.
label "string:" s: field 240 si: indicator return
label "number:" n: field 50 ni: indicator return
pad 66
button "validate" [
; The user may have entered bogus values, so I reset the indicators:
si/color: ni/color: maroon
; Now I check to see if the values are correct. For the string, I just
; care that there is one. For the integer, I make sure that it
; evaluates to an integer and that it's value is 75000. Because I've
; already set the indicator colour, I don't care the integer
; conversion raises an error or not, so I ignore it if anything goes
; wrong.
if 0 < length? get-face s [si/color: green]
error? try [if 75000 = to-integer get-face n [ni/color: green]]
show [si ni] ; Repainting multiple objects at once.
]
]
REXX
This version is modeled after the Mathematica example.
In addition, it checks for errors such as no string entered (or it is blanks or null), and it verifies that the correct number has been entered.
/*REXX pgm prompts (using the OS GUI) for a string & then prompts for a specific number.*/
#= 75000 /*the number that must be entered. */
x=
N=
do while x=' '; say /*string can't be blanks or null string*/
say 'Please enter a string: '
parse pull x
if x='' then say '***error*** No string entered.'
end /*while x···*/
do while N\=#; say /*the number (below) may be ill formed.*/
say 'Please enter the number:' #
parse pull N
if datatype(N, 'N') then N= N / 1 /*normalize the number: 007 4.0 +2 */
if N\=# then say '***error*** The number is not correct: ' N.
end /*while N···*/
say
say 'The string entered is:' x /*echo the values (string and number. */
say 'The number entered is:' N /*stick a fork in it, we're all done. */
Ring
Load "guilib.ring"
MyApp = New qApp {
num = 0
win1 = new qWidget() {
setwindowtitle("Hello World")
setGeometry(100,100,370,250)
btn1 = new qpushbutton(win1) {
setGeometry(130,200,100,30)
settext("Validate")
setclickevent("Validate()")}
lineedit1 = new qlineedit(win1) {
setGeometry(10,100,250,30)
settext("")}
lineedit2 = new qlineedit(win1) {
setGeometry(10,150,50,30)
settext("0")}
label1 = new qLabel(win1) {
setGeometry(270,100,50,30)
setText("")}
label2 = new qLabel(win1) {
setGeometry(70,150,50,30)
setText("")}
label3 = new qLabel(win1) {
setGeometry(10,50,250,30)
setText("Please enter a string, and the number 75000 :")}
show()}
exec()}
func Validate
lineedit1{temp1 = text()}
num1 = isdigit(temp1)
if num1 = 0 label1{settext("OK")} else label1{settext("NOT OK")} ok
lineedit2{temp2 = text()}
num2 = number(temp2)
if num2 = 75000 label2{settext("OK")} else label2{settext("NOT OK")} ok
Output:
Ruby
Unlike most other solutions, this validates the input number to be 75,000.
require 'tk'
def main
root = TkRoot.new
l1 = TkLabel.new(root, "text" => "input a string")
e1 = TkEntry.new(root)
l2 = TkLabel.new(root, "text" => "input the number 75000")
e2 = TkEntry.new(root) do
validate "focusout"
validatecommand lambda {e2.value.to_i == 75_000}
invalidcommand lambda {focus_number_entry(e2)}
end
ok = TkButton.new(root) do
text "OK"
command lambda {validate_input(e1, e2)}
end
Tk.grid(l1, e1)
Tk.grid(l2, e2)
Tk.grid("x",ok, "sticky" => "w")
Tk.mainloop
end
def validate_input(text_entry, number_entry)
if number_entry.value.to_i != 75_000
focus_number_entry(number_entry)
else
puts %Q{You entered: "#{text_entry.value}" and "#{number_entry.value}"}
root.destroy
end
end
def focus_number_entry(widget)
widget \
.configure("background" => "red", "foreground" => "white") \
.selection_range(0, "end") \
.focus
end
main
Shoes.app do
string = ask('Enter a string:')
begin
number = ask('Enter the number 75000:')
end while number.to_i != 75000
para %Q{you entered the string "#{string}" and the number #{number}}
end
Run BASIC
html "<TABLE BORDER=1 BGCOLOR=silver>
<TR><TD colspan=2>Please input a string and a number</TD></TR>
<TR><TD align=right>String</TD><TD><input type=text name=str size=18></TD></TR>
<TR><TD align=right>Number</TD><TD><input type=number name=num size=18 value=75000></TD></TR>
<TR><TD colspan=2 align=center>"
button #go, "Accept", [go]
button #ex, "Exit", [ex]
html "</TD></TR></TABLE>"
Wait
[go]
print #request get$("str")
print val(#request get$("num"))
wait
[ex]
end
Scala
import swing.Dialog.{Message, showInput}
import scala.swing.Swing
object UserInput extends App {
def responce = showInput(null,
"Complete the sentence:\n\"Green eggs and...\"",
"Customized Dialog",
Message.Plain,
Swing.EmptyIcon,
Nil, "ham")
println(responce)
}
Scratch
The Sensing block "ask _____ and wait" pops up a word balloon with a question in it and waits for user input. The input is returned in "answer," essentially a special variable. It can be treated as a string or a number, depending on context. "Answer" cannot be modified, but its value can be stored in other variables.
A slightly fancier version of this example can be tried on-line and downloaded.
Sidef
var gtk2 = require('Gtk2') -> init;
var gui = %s'Gtk2::Builder'.new;
gui.add_from_string(DATA.slurp);
func clicked_ok(*_) {
var entry = gui.get_object('entry1');
var text = entry.get_text;
var spinner = gui.get_object('spinbutton1');
var number = spinner.get_text;
say "string: #{text}";
say "number: #{number}";
number == 75000 ? gtk2.main_quit : warn "Invalid number!";
}
func clicked_cancel(*_) {
gtk2.main_quit;
}
gui.get_object('button1').signal_connect('clicked', clicked_ok);
gui.get_object('button2').signal_connect('clicked', clicked_cancel);
gtk2.main;
__DATA__
<?xml version="1.0" encoding="UTF-8"?>
<interface>
<requires lib="gtk+" version="2.24"/>
<!-- interface-naming-policy project-wide -->
<object class="GtkAdjustment" id="adjustment1">
<property name="upper">100000</property>
<property name="value">75000</property>
<property name="step_increment">1</property>
<property name="page_increment">10</property>
</object>
<object class="GtkWindow" id="window1">
<property name="visible">True</property>
<property name="can_focus">False</property>
<child>
<object class="GtkVBox" id="vbox1">
<property name="visible">True</property>
<property name="can_focus">False</property>
<child>
<object class="GtkLabel" id="label1">
<property name="visible">True</property>
<property name="can_focus">False</property>
<property name="label" translatable="yes">Please insert a string and a number:</property>
</object>
<packing>
<property name="expand">True</property>
<property name="fill">True</property>
<property name="position">0</property>
</packing>
</child>
<child>
<object class="GtkHBox" id="hbox1">
<property name="visible">True</property>
<property name="can_focus">False</property>
<child>
<object class="GtkLabel" id="label2">
<property name="visible">True</property>
<property name="can_focus">False</property>
<property name="label" translatable="yes">string:</property>
</object>
<packing>
<property name="expand">True</property>
<property name="fill">True</property>
<property name="padding">55</property>
<property name="position">0</property>
</packing>
</child>
<child>
<object class="GtkEntry" id="entry1">
<property name="visible">True</property>
<property name="can_focus">True</property>
<property name="invisible_char">•</property>
<property name="primary_icon_activatable">False</property>
<property name="secondary_icon_activatable">False</property>
<property name="primary_icon_sensitive">True</property>
<property name="secondary_icon_sensitive">True</property>
</object>
<packing>
<property name="expand">True</property>
<property name="fill">True</property>
<property name="position">1</property>
</packing>
</child>
</object>
<packing>
<property name="expand">True</property>
<property name="fill">True</property>
<property name="position">1</property>
</packing>
</child>
<child>
<object class="GtkHBox" id="hbox2">
<property name="visible">True</property>
<property name="can_focus">False</property>
<child>
<object class="GtkLabel" id="label3">
<property name="visible">True</property>
<property name="can_focus">False</property>
<property name="label" translatable="yes">number:</property>
</object>
<packing>
<property name="expand">True</property>
<property name="fill">True</property>
<property name="position">0</property>
</packing>
</child>
<child>
<object class="GtkSpinButton" id="spinbutton1">
<property name="visible">True</property>
<property name="can_focus">True</property>
<property name="invisible_char">•</property>
<property name="primary_icon_activatable">False</property>
<property name="secondary_icon_activatable">False</property>
<property name="primary_icon_sensitive">True</property>
<property name="secondary_icon_sensitive">True</property>
<property name="adjustment">adjustment1</property>
<property name="numeric">True</property>
</object>
<packing>
<property name="expand">True</property>
<property name="fill">True</property>
<property name="position">1</property>
</packing>
</child>
</object>
<packing>
<property name="expand">True</property>
<property name="fill">True</property>
<property name="position">2</property>
</packing>
</child>
<child>
<object class="GtkHButtonBox" id="hbuttonbox1">
<property name="visible">True</property>
<property name="can_focus">False</property>
<property name="layout_style">spread</property>
<child>
<object class="GtkButton" id="button1">
<property name="label">gtk-ok</property>
<property name="visible">True</property>
<property name="can_focus">True</property>
<property name="receives_default">True</property>
<property name="use_stock">True</property>
</object>
<packing>
<property name="expand">False</property>
<property name="fill">False</property>
<property name="position">0</property>
</packing>
</child>
<child>
<object class="GtkButton" id="button2">
<property name="label">gtk-cancel</property>
<property name="visible">True</property>
<property name="can_focus">True</property>
<property name="receives_default">True</property>
<property name="use_stock">True</property>
</object>
<packing>
<property name="expand">False</property>
<property name="fill">False</property>
<property name="position">1</property>
</packing>
</child>
</object>
<packing>
<property name="expand">True</property>
<property name="fill">True</property>
<property name="position">3</property>
</packing>
</child>
</object>
</child>
</object>
</interface>
Standard ML
Works with PolyML
open XWindows ;
open Motif ;
val store : string list ref = ref [] ;
val inputWindow = fn () =>
let
val shell = XtAppInitialise "" "demo" "top" [] [ XmNwidth 320, XmNheight 100 ] ;
val main = XmCreateMainWindow shell "main" [ XmNmappedWhenManaged true ] ;
val enter = XmCreateText main "inputarea" [ XmNeditMode XmSINGLE_LINE_EDIT,
XmNscrollHorizontal false ] ;
val getinp = fn (w,s,t) => ( store := XmTextGetString enter :: !store ; t )
in
(
XtSetCallbacks enter [ (XmNactivateCallback , getinp) ] XmNarmCallback ;
XtManageChild enter ;
XtManageChild main ;
XtRealizeWidget shell
)
end ;
inputWindow () ;
enter text, press enter, delete, enter 75000, press enter, result:
!store ; List.map Int.fromString (!store) ;
val it = ["75000", "That string"]: string list val it = [SOME 75000, NONE]: int option list
Tcl
# create entry widget:
pack [entry .e1]
# read its content:
set input [.e get]
Alternatively, the content of the widget can be tied to a variable:
pack [entry .e1 -textvar input]
# show the content at any time by
puts $input
The -validate option can be used to test the contents/edits of the widget at any time against any parameters (including testing string is integer when the user hits <Return> or such)
TI-89 BASIC
This program leaves the requested values in the global variables s and n.
Prgm
Dialog
Title "Rosetta Code"
Request "A string", s
DropDown "An integer", {"75000"}, n
EndDlog
74999 + n → n
EndPrgm
VBScript
strUserIn = InputBox("Enter Data")
Wscript.Echo strUserIn
Vedit macro language
Displays a dialog box with two input fields and default OK button. The values entered are stored in text registers 1 and 2. The value from 2nd field is then converted into numeric value. (Accepts integers or integer expressions.)
Dialog_Input_1(1, "`User Input example`,
`??Enter a string `,
`??Enter a number `")
#2 = Num_Eval_Reg(2)
Visual Basic
Visual Basic can use the above VBScript or PowerBASIC examples unchanged (aside from changing PB's FUNCTION PBMAIN
to Sub Main
).
Alternately, a form could be easily created (using the form designer) to get both values at once, but that is a task almost never done at runtime, instead being done within the IDE while creating the program.
V (Vlang)
import ui
@[heap]
struct App {
mut:
win &ui.Window = unsafe {nil}
txt_1 &ui.TextBox = unsafe {nil}
txt_2 &ui.TextBox = unsafe {nil}
lbl_1 &ui.Label = unsafe {nil}
lbl_2 &ui.Label = unsafe {nil}
btn_1 &ui.Button = unsafe {nil}
instr string = "Enter some text, the number 75000, and press 'Validate'"
txt string
num string
}
fn main() {
mut app := &App{}
// widgets defined and placed here for clarity
app.lbl_1 = ui.label(text: &app.instr, id: "lbl_1", justify: [0.5, 0.0]) // [x, y] for text placement
app.lbl_2 = ui.label(text: "", id: "lbl_2", text_align: .center, justify: [0.5, 0.0])
app.txt_1 = ui.textbox(placeholder: "String", text: &app.txt, id: "txt_1")
app.txt_2 = ui.textbox(placeholder: "Number", text: &app.num, id: "txt_2")
app.btn_1 = ui.button(width: 5, text: "Validate", on_click: app.btn_click)
app.win = ui.window(
height: 150
width: 450
title: "Input Info"
mode: .resizable
children: [
ui.column(
alignment: .center // button's center, relative to UI
spacing: 5 // button's distance from other widgets
widths: [ui.stretch, 150] // button's width relative to UI
margin: ui.Margin{0, 5, 0, 5} // widgets relative to UI's edges, {y, right, x, left}
children: [
ui.column(
alignment: .center
spacing: 5 // distance between widgets in same column
children: [
app.lbl_1
app.lbl_2
app.txt_1
app.txt_2
]
),
// button in and controlled from separate column
app.btn_1
]
),
]
)
ui.run(app.win)
}
fn (mut app App) btn_click(btn &ui.Button) {
app.lbl_2.set_text("${app.txt} ${app.num}")
}
Wren
This script echos the string and number entered in the GUI to the terminal.
In the case of the number, it keeps requesting input until 75000 is entered and then quits.
import "graphics" for Canvas, Color
import "input" for Keyboard, Clipboard
import "dome" for Window, Process
var X = 10
var Y = 28
class Main {
construct new() {}
init() {
_text = ""
_enterNum = false
Keyboard.handleText = true
Keyboard.textRegion(X, Y, 8, 8)
}
update() {
var change = false
if (Keyboard.text.count > 0) {
_text = _text + Keyboard.text
change = true
}
// enable backspace key to delete last character entered
if (Keyboard["backspace"].justPressed && _text.count > 0) {
var codePoints = _text.codePoints
codePoints = codePoints.take(codePoints.count - 1)
_text = ""
for (point in codePoints) {
_text = _text + String.fromCodePoint(point)
}
change = true
}
// enable return key to terminate input
if (Keyboard["return"].justPressed) {
System.print("'%(_text)' was entered.")
if (!_enterNum) {
_text = ""
_enterNum = true
change = true
} else if (_text == "75000") {
Process.exit()
} else {
_text = ""
change = true
}
}
if (change) {
Keyboard.textRegion(X.min(_text.count * 8), Y, 8, 8)
}
}
draw(dt) {
Canvas.cls()
Canvas.rect(X, Y, 8, 8, Color.red)
if (!_enterNum) {
Canvas.print("Enter Text and press return:", 10, 10, Color.white)
} else {
Canvas.print("Enter 75000 and press return:", 10, 10, Color.white)
}
Canvas.print(_text, 10, 20, Color.white)
}
}
var Game = Main.new()
- Output:
Sample input/output:
'Rosetta' was entered. '72000' was entered. '75000' was entered.
- Programming Tasks
- Text processing
- GUI
- Basic language learning
- AArch64 Assembly
- Ada
- GTK
- GtkAda
- AppleScript
- AutoHotkey
- BaCon
- BBC BASIC
- C
- C++
- Clojure
- Common Lisp
- CAPI
- Dart
- Flutter
- Delphi
- FreeBASIC
- Frink
- Gambas
- Go
- Gotk3
- Groovy
- Swing
- Haskell
- Gtk
- HicEst
- Icon
- Unicon
- Icon Programming Library
- J
- Java
- JavaScript
- Julia
- Kotlin
- LabVIEW
- Liberty BASIC
- M2000 Interpreter
- Mathematica
- Wolfram Language
- Nanoquery
- NetRexx
- NewLISP
- Nim
- Gintro
- Oz
- Perl
- Phix
- Phix/basics
- Phix/pGUI
- PicoLisp
- PowerBASIC
- PowerShell
- Processing
- Processing Python mode
- PureBasic
- Python
- Tkinter
- Quackery
- R
- Racket
- Raku
- Rascal
- REBOL
- REXX
- Ring
- Ruby
- Ruby/Tk
- Shoes
- Run BASIC
- Scala
- Scratch
- Sidef
- Standard ML
- Tcl
- Tk
- TI-89 BASIC
- VBScript
- Vedit macro language
- Visual Basic
- V (Vlang)
- Wren
- DOME
- ACL2/Omit
- AWK/Omit
- Batch File/Omit
- Logtalk/Omit
- Lotus 123 Macro Scripting/Omit
- Maxima/Omit
- ML/I/Omit
- PARI/GP/Omit
- Retro/Omit
- SQL PL/Omit
- Unlambda/Omit