User input/Graphical

From Rosetta Code
Task
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

Ada[edit]

Library: GTK version GtkAda
Library: GtkAda
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_Table;
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[edit]

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

InputBox[edit]

InputBox, String, Input, Enter a string:
InputBox, Int, Input, Enter an int:
Msgbox, You entered "%String%" and "%Int%"

Gui Edit[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

BBC BASIC[edit]

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

Library: GTK
#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++[edit]

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

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

Library: CAPI
Works with: LispWorks

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

Delphi[edit]

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.

Frink[edit]

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.

Haskell[edit]

Using
Library: gtk
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[edit]

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

Unicon can open a window directly with open.

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

graphics.icn provides WOpen

J[edit]

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

Library: Swing
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[edit]

Works with: FireFox
or any JavaScript-enabled browser
var str = prompt("Enter a string");
var value = 0;
while (value != 75000) {
value = parseInt( prompt("Enter the number 75000") );
}

Kotlin[edit]

// version 1.1
 
import javax.swing.JOptionPane
 
fun main(args: Array<String>) {
do {
val number = JOptionPane.showInputDialog("Enter 75000").toInt()
} while (number != 75000)
}

LabVIEW[edit]

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.
LabVIEW User input Graphical.png

Liberty BASIC[edit]

'   [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

Mathematica[edit]

str = InputString["Input a string"]; nb = 
InputString["Input a number"]; Print[str, " " , [email protected]]

Example usage:

->Hello World 75000

NetRexx[edit]

Translation of: Java
/* 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[edit]

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

Newlisp-input-gui.png

Oz[edit]

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

Library: Perl/Wx
[edit]

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;

Library: XUL::GuiGui
[edit]

use XUL::Gui;
 
display Window
title => 'Input Window',
width => 250,
height => 150,
TextBox( id => 'txt' ),
TextBox( id => 'num', type => 'number' ),
Button(
label => 'OK',
oncommand => sub {
print "String: " . ID(txt)->value . "\n"
. "Number: " . ID(num)->value . "\n";
quit;
},
);

Perl 6[edit]

Library: GTK
use GTK::Simple;
 
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;

Phix[edit]

shipped with the compiler as 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
 
function esc_close(Ihandle /*ih*/, atom c)
return iff(c=K_ESC?IUP_CLOSE:IUP_CONTINUE)
end function
 
IupOpen("demo/pGUI/")
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")
IupSetAttribute(input2,"MASK",IUP_MASK_INT)
OK = IupButton("OK", "ACTION", Icallback("ok_cb"))
Cancel = IupButton("Cancel", "ACTION", Icallback("ok_cb"))
dlg = IupDialog(IupVbox({IupHbox({label1,input1},"ALIGNMENT=ACENTER, PADDING=5"),
IupHbox({label2,input2},"ALIGNMENT=ACENTER, PADDING=5"),
IupHbox({IupFill(),OK,Cancel,IupFill()},"PADDING=15")},
"GAP=5,MARGIN=5x5"))
IupSetAttribute(dlg,"TITLE","User Input/Graphical")
IupSetCallback(dlg, "K_ANY", Icallback("esc_close"))
IupDestroy(IupNormalizer({OK,Cancel},"NORMALIZE=BOTH"))
IupShow(dlg)
IupMainLoop()
IupClose()

PicoLisp[edit]

(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[edit]

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

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.

UserInputGraphical.png

#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 }

PureBasic[edit]

string$=InputRequester("Some Title","Enter a string","")
variable=Val(InputRequester("Some other Title","Enter a Number","75000"))

Python[edit]

Works with: Python version 2.5
Library: Tkinter
import Tkinter,tkSimpleDialog
 
root = Tkinter.Tk()
root.withdraw()
 
number = tkSimpleDialog.askinteger("Integer", "Enter a Number")
string = tkSimpleDialog.askstring("String", "Enter a String")

R[edit]

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

 
#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")))
 

Rascal[edit]

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:

UserInput.JPG

REBOL[edit]

Useringui rebol.png

rebol [
Title: "Graphical User Input"
Author: oofoe
Date: 2009-12-07
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.
]
]

Ring[edit]

 
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:

CalmoSoftInput.jpg

Ruby[edit]

Unlike most other solutions, this validates the input number to be 75,000.

Library: Ruby/Tk
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
Library: Shoes
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

Scala[edit]

Library: 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[edit]

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.

Scratch User Input Graphical.png

Sidef[edit]

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>

Tcl[edit]

Library: Tk
# 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[edit]

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

strUserIn = InputBox("Enter Data")
Wscript.Echo strUserIn

Vedit macro language[edit]

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

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.