User input/Graphical: Difference between revisions
(Added Wren) |
|||
| Line 2,147: | Line 2,147: | ||
</lang> |
</lang> |
||
=={{header|Mathematica}}== |
=={{header|Mathematica}}/{{header|Wolfram Language}}== |
||
<lang Mathematica>str = InputString["Input a string"]; nb = |
<lang Mathematica>str = InputString["Input a string"]; nb = |
||
InputString["Input a number"]; Print[str, " " , ToString@nb]</lang> |
InputString["Input a number"]; Print[str, " " , ToString@nb]</lang> |
||
Example usage: |
Example usage: |
||
<pre> |
<pre> |
||
Revision as of 11:40, 5 September 2021
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
<lang 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: </lang>
Ada
<lang 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;</lang>
AppleScript
<lang applescript>set input to text returned of (display dialog "Enter text:" default answer "")</lang> <lang applescript>set input to text returned of (display dialog "Enter a number:" default answer "") as integer</lang>
AutoHotkey
InputBox
<lang AutoHotkey>InputBox, String, Input, Enter a string: InputBox, Int, Input, Enter an int: Msgbox, You entered "%String%" and "%Int%"</lang>
Gui Edit
<lang AutoHotkey>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</lang>
BaCon
Requires BaCon version 4.0.1 or higher, using GTK3. <lang bacon>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"</lang>
BBC BASIC
<lang bbcbasic> 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</lang>
C
<lang 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;
}</lang>
C++
using library Qt 4.4 , first using qmake -project, then qmake -o Makefile <projectfile> and then make
task.h
<lang cpp>#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</lang>
task.cpp
<lang 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 ) ;
}</lang>
main.cpp
<lang cpp>#include <QApplication>
- include "task.h"
int main( int argc , char *argv[ ] ) {
QApplication app( argc , argv ) ; EntryWidget theWidget ; theWidget.show( ) ; return app.exec( ) ;
}</lang>
Clojure
Pretty much a straight port of the code for Java.
<lang Clojure>(import 'javax.swing.JOptionPane) (let [number (-> "Enter an Integer"
JOptionPane/showInputDialog
Integer/parseInt)
string (JOptionPane/showInputDialog "Enter a String")]
[number string])</lang>
Common Lisp
Prompt for a string:
<lang lisp>(capi:prompt-for-string "Enter a string:")</lang>
Repeatedly prompt for an integer until either the user presses 'Cancel' (instead of 'OK') or the integer is 75,000.
<lang lisp>(do ((number 0) (okp t))
((or (not okp) (= 75000 number)))
(multiple-value-setq (number okp)
(capi:prompt-for-integer "Enter an integer:")))</lang>
Alternatively, display a prompt where the 'OK' button will not be enabled until the input is 75,000:
<lang lisp>(capi:prompt-for-integer "Enter an integer:"
:ok-check #'(lambda (n) (= n 75000)))</lang>
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: <lang lisp>(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))))</lang>
Then a function to extract the string and integer: <lang lisp>(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)))))</lang>
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. <lang lisp>(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))))</lang>
Dart
Displays two text fields, a button and an output label, copy paste it into dartpad for viewing! - https://dartpad.github.io
<lang javascript>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
]
)
)
)
);
}
} </lang>
Delphi
<lang 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.</lang>
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. <lang frink> s = input["Enter a string: "] i = parseInt[input["Enter an integer: "]] </lang>
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):
<lang frink> [s,i] = input["Dialog title", ["Enter a string", "Enter an integer"]] i = parseInt[i] </lang> More information about Frink's multi-input, including specifying default values.
Gambas
<lang 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</lang>
Click here for a picture of the running program
Go
<lang 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()
}</lang>
Groovy
Solution: <lang groovy>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</lang>
Haskell
Using
from HackageDB
<lang haskell>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 ()</lang>
Run in GHCi: <lang haskell>*Main> main</lang>
HicEst
<lang 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 </lang>
Icon and Unicon
Unicon can open a window directly with open.
<lang Icon>procedure main() WOpen("size=800,800") | stop("Unable to open window") WWrite("Enter a string:") s := WRead() WWrite("You entered ",image(s)) WWrite("Enter the integer 75000:") i := WRead() if i := integer(i) then
WWrite("You entered: ",i)
else
WWrite(image(i)," isn't an integer")
WDone() end
link graphics</lang>
J
J 8.x <lang j>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</lang>
J 6.x A revision of the script posted at the Simple Windowed Application
<lang j>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 </lang>
The program stores the values entered as the variables simpleGui_text and simpleGui_integer.
Java
<lang 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");
}
}</lang>
JavaScript
or any JavaScript-enabled browser
<lang javascript>var str = prompt("Enter a string"); var value = 0; while (value != 75000) {
value = parseInt( prompt("Enter the number 75000") );
}</lang>
Julia
<lang 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() </lang>
Kotlin
<lang scala>// version 1.1
import javax.swing.JOptionPane
fun main(args: Array<String>) {
do {
val number = JOptionPane.showInputDialog("Enter 75000").toInt()
} while (number != 75000)
}</lang>
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
<lang lb>' [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</lang>
M2000 Interpreter
Simple InputBox
<lang M2000 Interpreter> 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"
</lang>
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
<lang M2000 Interpreter> 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 </lang>
Mathematica/Wolfram Language
<lang Mathematica>str = InputString["Input a string"]; nb =
InputString["Input a number"]; Print[str, " " , ToString@nb]</lang>
Example usage:
->Hello World 75000
Nanoquery
<lang 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()</lang>
NetRexx
<lang 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 </lang>
NewLISP
<lang 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.
</lang>
Nim
To input the integer, we use a Gtk SpinBox as is done in the C version. <lang Nim>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()</lang>
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". <lang oz>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</lang>
Perl
<lang 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;</lang>
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
<lang 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 @))) )</lang>
Output:
-> ("Hello world" . 12345)
PowerBASIC
<lang 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</lang>
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.
<lang PowerShell>#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 }</lang>
Processing
<lang java>import javax.swing.JOptionPane;
int number = int(JOptionPane.showInputDialog ("Enter an Integer")); println(number);
String string = JOptionPane.showInputDialog ("Enter a String"); println(string);</lang>
Processing Python mode
<lang Python>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)</lang>
PureBasic
<lang PureBasic>string$=InputRequester("Some Title","Enter a string","") variable=Val(InputRequester("Some other Title","Enter a Number","75000"))</lang>
Python
<lang python>import Tkinter,tkSimpleDialog
root = Tkinter.Tk() root.withdraw()
number = tkSimpleDialog.askinteger("Integer", "Enter a Number") string = tkSimpleDialog.askstring("String", "Enter a String") </lang>
<lang python>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}") </lang>
Quackery
<lang 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$</lang>
R
<lang 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)
}) </lang>
Racket
<lang 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")))
</lang>
Raku
(formerly Perl 6)
<lang perl6>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;</lang>
Rascal
<lang 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])); }</lang>
Output:
REBOL
<lang 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. ] ]</lang>
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. <lang rexx>/*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. */</lang>
Ring
<lang 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
</lang> Output:
Ruby
Unlike most other solutions, this validates the input number to be 75,000.
<lang ruby>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</lang>
<lang ruby>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</lang>
Run BASIC
<lang runbasic>html "
| Please input a string and a number | |
| String | <input type=text name=str size=18> |
| Number | <input type=number name=num size=18 value=75000> |
| "
button #go, "Accept", [go] button #ex, "Exit", [ex] html " | |
"
Wait
[go] print #request get$("str") print val(#request get$("num")) wait
[ex] end</lang>
Scala
<lang 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)
}</lang>
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
<lang ruby>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"/>
<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></lang>
Standard ML
Works with PolyML <lang Standard ML>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 () ;</lang> 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
<lang tcl># create entry widget: pack [entry .e1]
- read its content:
set input [.e get]</lang>
Alternatively, the content of the widget can be tied to a variable: <lang tcl>pack [entry .e1 -textvar input]
- show the content at any time by
puts $input</lang> 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.
<lang ti89b>Prgm
Dialog
Title "Rosetta Code"
Request "A string", s
DropDown "An integer", {"75000"}, n
EndDlog
74999 + n → n
EndPrgm</lang>
VBScript
<lang vbscript>strUserIn = InputBox("Enter Data") Wscript.Echo strUserIn</lang>
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.)
<lang vedit>Dialog_Input_1(1, "`User Input example`,
`??Enter a string `,
`??Enter a number `")</lang>
#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.
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. <lang ecmascript>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()</lang>
- 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
- 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
- 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