A-M baby

Task/GUI-component-interaction/0DESCRIPTION

@@ -0,0 +1,20 @@
+Almost every application needs to communicate with the user in some way.
+Therefore, a substantial part of the code deals with the interaction of program
+logic with GUI components. Typically, the following is needed:
+
+* put values into input fields under program control
+* read and check input from the user
+* pop up dialogs to query the user for further information
+
+The task: For a minimal "application", write a program that presents a form with
+three components to the user: A numeric input field ("Value") and two buttons
+("increment" and "random").
+
+The field is initialized to zero. The user may manually enter a new value into
+the field, or increment its value with the "increment" button. Entering a
+non-numeric value should be either impossible, or issue an error message.
+
+Pressing the "random" button presents a confirmation dialog, and resets the
+field's value to a random value if the answer is "Yes".
+
+(This task may be regarded as an extension of the task [[Simple windowed application]]).

Task/GUI-component-interaction/1META.yaml

@@ -0,0 +1,4 @@
+---
+note: GUI
+requires:
+- Graphics

Task/GUI-component-interaction/Ada/gui-component-interaction.ada

@@ -0,0 +1,158 @@
+with Ada.Numerics.Discrete_Random;
+with Ada.Strings.Fixed;
+with Gtk.Main;
+with Gtk.Handlers;
+with Gtk.Button;
+with Gtk.Window;
+with Gtk.GEntry;
+with Gtk.Editable;
+with Gtk.Box;
+with Gtk.Widget;
+with Glib.Values;
+with Gtkada.Dialogs;
+
+procedure Interaction is
+
+   The_Value : Natural := 0;
+
+   package Natural_Random is new Ada.Numerics.Discrete_Random (Natural);
+   RNG : Natural_Random.Generator;
+
+   Main_Window      : Gtk.Window.Gtk_Window;
+   Content          : Gtk.Box.Gtk_Vbox;
+   Increment_Button : Gtk.Button.Gtk_Button;
+   Random_Button    : Gtk.Button.Gtk_Button;
+   Entry_Field      : Gtk.GEntry.Gtk_Entry;
+
+   package Entry_Callbacks is new Gtk.Handlers.Callback
+     (Gtk.GEntry.Gtk_Entry_Record);
+
+   package Button_Callbacks is new Gtk.Handlers.Callback
+     (Gtk.Button.Gtk_Button_Record);
+
+   package Window_Callbacks is new Gtk.Handlers.Return_Callback
+     (Gtk.Window.Gtk_Window_Record, Boolean);
+
+   --  update displayed text
+   procedure Update_Entry is
+   begin
+      Gtk.GEntry.Set_Text
+        (The_Entry => Entry_Field,
+         Text      =>
+           Ada.Strings.Fixed.Trim
+             (Source => Natural'Image (The_Value),
+              Side   => Ada.Strings.Both));
+   end Update_Entry;
+
+   --  read from text entry
+   procedure Update_Value is
+   begin
+      The_Value := Natural'Value (Gtk.GEntry.Get_Text (Entry_Field));
+   exception
+      when Constraint_Error =>
+         The_Value := 0;
+   end Update_Value;
+
+   --  make sure that only numbers are entered
+   procedure On_Insert_Text
+     (Object : access Gtk.GEntry.Gtk_Entry_Record'Class;
+      Params : Glib.Values.GValues)
+   is
+      Length : constant Glib.Gint :=
+        Glib.Values.Get_Int (Glib.Values.Nth (Params, 2));
+      Text   : constant String    :=
+        Glib.Values.Get_String (Glib.Values.Nth (Params, 1), Length);
+   begin
+      declare
+         Number : Natural;
+      begin
+         Number := Natural'Value (Text);
+      exception
+         when Constraint_Error =>
+            --  refuse values that are not parsable
+            Gtk.Handlers.Emit_Stop_By_Name
+              (Object => Object,
+               Name   => Gtk.Editable.Signal_Insert_Text);
+      end;
+   end On_Insert_Text;
+
+   --  Callback for click event
+   procedure On_Increment_Click
+     (Object : access Gtk.Button.Gtk_Button_Record'Class)
+   is
+   begin
+      Update_Value;
+      The_Value := The_Value + 1;
+      Update_Entry;
+   end On_Increment_Click;
+
+   --  Callback for click event
+   procedure On_Random_Click
+     (Object : access Gtk.Button.Gtk_Button_Record'Class)
+   is
+      use type Gtkada.Dialogs.Message_Dialog_Buttons;
+   begin
+      if Gtkada.Dialogs.Message_Dialog
+        (Msg            => "Really reset to random value?",
+         Dialog_Type    => Gtkada.Dialogs.Confirmation,
+         Buttons        => Gtkada.Dialogs.Button_Yes or
+           Gtkada.Dialogs.Button_No,
+         Default_Button => Gtkada.Dialogs.Button_Yes) =
+        Gtkada.Dialogs.Button_Yes
+      then
+         The_Value := Natural_Random.Random (RNG);
+         Update_Entry;
+      end if;
+   end On_Random_Click;
+
+   --  Callback for delete event
+   function On_Main_Window_Delete
+     (Object : access Gtk.Window.Gtk_Window_Record'Class)
+      return   Boolean
+   is
+   begin
+      Gtk.Main.Main_Quit;
+      return True;
+   end On_Main_Window_Delete;
+
+begin
+   --  initialize random number generator
+   Natural_Random.Reset (RNG);
+
+   Gtk.Main.Init;
+
+   Gtk.GEntry.Gtk_New (Widget => Entry_Field);
+   Update_Entry;
+   Entry_Callbacks.Connect
+     (Widget => Entry_Field,
+      Name   => Gtk.Editable.Signal_Insert_Text,
+      Cb     => On_Insert_Text'Access);
+
+   Gtk.Button.Gtk_New (Button => Increment_Button, Label => "Increment");
+   Gtk.Button.Gtk_New (Button => Random_Button, Label => "Random");
+
+   Button_Callbacks.Connect
+     (Widget => Increment_Button,
+      Name   => Gtk.Button.Signal_Clicked,
+      Marsh  => Button_Callbacks.To_Marshaller (On_Increment_Click'Access));
+   Button_Callbacks.Connect
+     (Widget => Random_Button,
+      Name   => Gtk.Button.Signal_Clicked,
+      Marsh  => Button_Callbacks.To_Marshaller (On_Random_Click'Access));
+
+   Gtk.Box.Gtk_New_Vbox (Box => Content);
+   Gtk.Box.Add (Container => Content, Widget => Entry_Field);
+   Gtk.Box.Add (Container => Content, Widget => Increment_Button);
+   Gtk.Box.Add (Container => Content, Widget => Random_Button);
+
+   Gtk.Window.Gtk_New (Window => Main_Window);
+   Gtk.Window.Add (Container => Main_Window, Widget => Content);
+
+   Window_Callbacks.Connect
+     (Widget => Main_Window,
+      Name   => Gtk.Widget.Signal_Delete_Event,
+      Cb     => On_Main_Window_Delete'Access);
+   Gtk.Window.Show_All (Widget => Main_Window);
+
+   Gtk.Main.Main;
+end Interaction;

Task/GUI-component-interaction/AutoHotkey/gui-component-interaction.ahk

@@ -0,0 +1,56 @@
+GUI, add, Edit,Number w50 vUserInput, 0          ; Number Specifies Numbers-only, but other characters can still be pasted in,
+						 ; Making our own check necessary. (MakeSure)
+
+GUI, add, Button, gIncrement, Increment 	 ; Instead of an increment button, the UpDown control could be used, but this was not specified.
+GUI, add, Button, gRando, Random		
+Gui, Show, W200 y200, Title			 ; Shows the GUI with a width and height of 200px
+SetTimer, MakeSure, 1000 			 ; Runs MakeSure every second
+return 						 ; End Auto-Execute Section
+
+
+Increment:
+Gui, Submit, NoHide
+; The above line assigns all variables associated with controls to the state of that control, but leaves the GUI visible.
+If UserInput is not Number
+{
+	MsgBox, %userInput% is not a number.
+	GUIControl,,UserInput, 0 ; Reset the Edit control to 0
+}
+Else
+{
+	UserInput++
+	GUIControl,, UserInput, %UserInput% ; Sets the value of the Edit control
+}
+return
+
+
+
+Rando:
+MsgBox, 4, Title, Are you sure you want to randomize? ; Specify your own title. 4 means YesNo
+IfMsgBox, Yes
+{
+	Random, UserInput, 1, 999		      ; random number from 1-999
+	GUIControl,, UserInput, %UserInput%	      ; Sets the value of the Edit control
+}
+return
+
+
+
+MakeSure:
+Gui, Submit, NoHide
+If UserInput is not Number
+{
+	If (UserInput<>"")
+	{
+	Msgbox Error! Numbers Only!
+	GUIControl,, UserInput, 0
+	}
+}
+return
+
+
+
+GUIClose:
+ExitApp  ; Makes sure the script exits when the window is closed,
+	 ; Otherwise the script is persistent because it contains
+	 ; a timer.

Task/GUI-component-interaction/BBC-BASIC/gui-component-interaction.bbc

@@ -0,0 +1,30 @@
+      INSTALL @lib$+"WINLIB2"
+      INSTALL @lib$+"WINLIB5"
+
+      IDYES = 6
+      ES_NUMBER = 8192
+      MB_YESNO = 4
+
+      form% = FN_newdialog("Rosetta Code", 100, 100, 100, 52, 8, 1000)
+      PROC_static(form%, "Value:", 100, 10, 10, 24, 14, 0)
+      PROC_editbox(form%, "0", 101, 40, 8, 52, 14, ES_NUMBER)
+      PROC_pushbutton(form%, "Increment", FN_setproc(PROCinc), 7, 30, 40, 16, 0)
+      PROC_pushbutton(form%, "Random", FN_setproc(PROCrandom), 52, 30, 40, 16, 0)
+      PROC_showdialog(form%)
+
+      REPEAT
+        WAIT 1
+      UNTIL !form% = 0
+      QUIT
+
+      DEF PROCinc
+      LOCAL number%
+      SYS "GetDlgItemInt", !form%, 101, 0, 1 TO number%
+      SYS "SetDlgItemInt", !form%, 101, number% + 1, 1
+      ENDPROC
+
+      DEF PROCrandom
+      LOCAL reply%
+      SYS "MessageBox", !form%, "Set to a random value?", "Confirm", MB_YESNO TO reply%
+      IF reply% = IDYES THEN SYS "SetDlgItemInt", !form%, 101, RND(10000), 1
+      ENDPROC

Task/GUI-component-interaction/C++/gui-component-interaction-1.cpp

@@ -0,0 +1,22 @@
+#ifndef INTERACTION_H
+#define INTERACTION_H
+#include <QWidget>
+
+class QPushButton ;
+class QLineEdit ;
+class QVBoxLayout ;
+class MyWidget : public QWidget {
+   Q_OBJECT
+
+public :
+   MyWidget( QWidget *parent = 0 ) ;
+private :
+   QLineEdit *entryField ;
+   QPushButton *increaseButton ;
+   QPushButton *randomButton ;
+   QVBoxLayout *myLayout ;
+private slots :
+   void doIncrement( ) ;
+   void findRandomNumber( ) ;
+} ;
+#endif

Task/GUI-component-interaction/C++/gui-component-interaction-2.cpp

@@ -0,0 +1,48 @@
+#include <QPushButton>
+#include <QLineEdit>
+#include <QMessageBox>
+#include <QString>
+#include <QRegExpValidator>
+#include <QVBoxLayout>
+#include <QRegExp>
+#include <ctime> //for the srand initialization
+#include <cstdlib> //for the random number
+#include "interaction.h"
+
+MyWidget::MyWidget (QWidget *parent ) : QWidget( parent ) {
+   myLayout = new QVBoxLayout( ) ;
+   entryField = new QLineEdit( "0" ) ;
+   QRegExp rx( "\\d+" ) ;
+   QValidator *myvalidator = new QRegExpValidator( rx , this ) ;
+   entryField->setValidator( myvalidator ) ;
+   increaseButton = new QPushButton( "increase" ) ;
+   connect( increaseButton, SIGNAL( clicked( ) ) ,
+	 this , SLOT( doIncrement( ) )) ;
+   randomButton = new QPushButton( "random" ) ;
+   connect( randomButton , SIGNAL( clicked( ) ) ,
+	 this , SLOT ( findRandomNumber( ) )) ;
+   myLayout->addWidget( entryField ) ;
+   myLayout->addWidget( increaseButton ) ;
+   myLayout->addWidget( randomButton ) ;
+   setLayout( myLayout ) ;
+}
+
+void MyWidget::doIncrement( ) {
+   bool ok ;
+   int zahl = entryField->text( ).toInt( &ok, 10 ) ;
+   entryField->setText( QString( "%1").arg( ++zahl ) ) ;
+}
+
+void MyWidget::findRandomNumber( ) {
+   QMessageBox msgBox( this ) ;
+   msgBox.setText( "Do you want to create a random number ?" ) ;
+   msgBox.setStandardButtons( QMessageBox::Yes | QMessageBox::No ) ;
+   int ret = msgBox.exec( ) ;
+   switch ( ret ) {
+      case QMessageBox::Yes :
+	 srand( time( 0 ) ) ;
+	 int zahl = random( ) ;
+	 entryField->setText( QString( "%1" ).arg( zahl )) ;
+	 break ;
+   }
+}

Task/GUI-component-interaction/C++/gui-component-interaction-3.cpp

@@ -0,0 +1,9 @@
+#include <QApplication>
+#include "interaction.h"
+
+int main( int argc , char *argv[ ] ) {
+   QApplication app( argc, argv ) ;
+   MyWidget theWidget ;
+   theWidget.show( ) ;
+   return app.exec( ) ;
+}

Task/GUI-component-interaction/Delphi/gui-component-interaction-1.delphi

@@ -0,0 +1 @@
+FILE: Unit1.pas

Task/GUI-component-interaction/Delphi/gui-component-interaction-2.delphi

@@ -0,0 +1,51 @@
+unit Unit1;
+
+interface
+
+uses
+  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
+  Dialogs, StdCtrls;
+
+type
+  TForm1 = class(TForm)
+    EditInputField: TEdit;
+    ButtonRandom: TButton;
+    ButtonIncrement: TButton;
+    procedure EditInputFieldChange(Sender: TObject);
+    procedure ButtonIncrementClick(Sender: TObject);
+    procedure ButtonRandomClick(Sender: TObject);
+  private
+    { Private declarations }
+  public
+    { Public declarations }
+  end;
+
+var
+  Form1: TForm1;
+
+implementation
+
+{$R *.dfm}
+
+procedure TForm1.EditInputFieldChange(Sender: TObject);
+begin
+   TRY
+      StrToInt(EditInputField.Text);
+   EXCEPT
+      ShowMessage('Error! The Input Value is not numeric!');
+      EditInputField.Text := '0';
+   END;
+end;
+
+procedure TForm1.ButtonIncrementClick(Sender: TObject);
+begin
+   EditInputField.text := IntToStr(StrToInt(EditInputField.Text) + 1);
+end;
+
+procedure TForm1.ButtonRandomClick(Sender: TObject);
+begin
+   Randomize;
+   EditInputField.Text := IntToStr(Random(High(Integer)));
+end;
+
+end.

Task/GUI-component-interaction/Delphi/gui-component-interaction-3.delphi

@@ -0,0 +1 @@
+FILE: Unit1.dfm (No manual interaction!!! Will automatically be generated/modified when editing the GUI)

Task/GUI-component-interaction/Delphi/gui-component-interaction-4.delphi

@@ -0,0 +1,43 @@
+object Form1: TForm1
+  Left = 1899
+  Top = 212
+  Width = 266
+  Height = 172
+  Caption = 'Form1'
+  Color = clBtnFace
+  Font.Charset = DEFAULT_CHARSET
+  Font.Color = clWindowText
+  Font.Height = -11
+  Font.Name = 'MS Sans Serif'
+  Font.Style = []
+  OldCreateOrder = False
+  PixelsPerInch = 96
+  TextHeight = 13
+  object EditInputField: TEdit
+    Left = 16
+    Top = 16
+    Width = 121
+    Height = 21
+    TabOrder = 0
+    Text = '0'
+    OnChange = EditInputFieldChange
+  end
+  object ButtonRandom: TButton
+    Left = 96
+    Top = 56
+    Width = 75
+    Height = 25
+    Caption = 'Random'
+    TabOrder = 1
+    OnClick = ButtonRandomClick
+  end
+  object ButtonIncrement: TButton
+    Left = 16
+    Top = 56
+    Width = 75
+    Height = 25
+    Caption = 'Increment'
+    TabOrder = 2
+    OnClick = ButtonIncrementClick
+  end
+end

Task/GUI-component-interaction/Fantom/gui-component-interaction.fantom

@@ -0,0 +1,65 @@
+using fwt
+using gfx
+
+class GuiComponent
+{
+  public static Void main ()
+  {
+    Window
+    {
+      title = "Rosetta Code: Gui component"
+      size = Size(350, 200)
+      textField := Text
+      {
+        onModify.add |Event e|
+        {
+          Text thisText := e.widget
+          if (thisText.text != "") // if nonempty string
+          {
+            try (thisText.text.toInt) // try converting to int
+            catch thisText.text = ""  // clear field if does not work
+          }
+        }
+      }
+      GridPane
+      {
+        numCols = 1
+        textField,
+        Button
+        {
+          text = "increment"
+          onAction.add |Event e|
+          { // make sure there is a number to increment, else set field to 0
+            if (textField.text == "")
+            {
+              textField.text = "0"
+            }
+            else
+            {
+              try
+              {
+                Int x := textField.text.toInt
+                textField.text = (x+1).toStr
+              }
+              catch
+              {
+                textField.text = "0"
+              }
+            }
+          }
+        },
+        Button
+        {
+          text = "random"
+          onAction.add |Event e|
+          {
+            if (Dialog.openQuestion(e.window, "Make number random?", null, Dialog.yesNo) == Dialog.yes)
+            {
+              textField.text = Int.random(1..10000).toStr
+            }
+          }
+        },
+      },
+    }.open
+  }
+}

Task/GUI-component-interaction/Haskell/gui-component-interaction-1.hs

@@ -0,0 +1,26 @@
+import Graphics.UI.WX
+import System.Random
+
+main :: IO ()
+main = start $ do
+    frm   <- frame [text := "Interact"]
+    fld   <- textEntry frm [text := "0", on keyboard := checkKeys]
+    inc   <- button frm [text := "increment", on command := increment fld]
+    ran   <- button frm [text := "random", on command := (randReplace fld frm)]
+    set frm [layout := margin 5 $ floatCentre $ column 2
+            [centre $ widget fld, row 2 [widget inc, widget ran]]]
+
+increment :: Textual w => w -> IO ()
+increment field = do
+    val <- get field text
+    when ((not . null) val) $ set field [text := show $ 1 + read val]
+
+checkKeys :: EventKey -> IO ()
+checkKeys (EventKey key _ _) =
+    when (elem (show key) $ "Backspace" : map show [0..9]) propagateEvent
+
+randReplace :: Textual w => w -> Window a -> IO ()
+randReplace field frame = do
+    answer <- confirmDialog frame "Random" "Generate a random number?" True
+    when answer $ getStdRandom (randomR (1,100)) >>= \num ->
+                  set field [text := show (num :: Int)]

Task/GUI-component-interaction/Haskell/gui-component-interaction-2.hs

@@ -0,0 +1,107 @@
+import gui
+$include "guih.icn"
+
+# Provides a basic message dialog
+class MessageDialog : Dialog (message)
+  method component_setup ()
+    label := Label ("label="||message, "pos=20,20")
+    add (label)
+    button := TextButton("label=OK", "pos=100,60")
+    button.connect (self, "dispose", ACTION_EVENT)
+    add (button)
+
+    connect (self, "dispose", CLOSE_BUTTON_EVENT)
+    attrib ("size=200,100", "bg=light gray")
+  end
+
+  initially (message)
+    self.Dialog.initially()
+    self.message := message
+end
+
+# Provides a basic yes/no question dialog
+class QuestionDialog : Dialog (answer, message)
+  method answered_yes ()
+    return answer == "yes"
+  end
+
+  method answer_yes ()
+    answer := "yes"
+    dispose ()
+  end
+
+  method answer_no ()
+    answer := "no"
+    dispose ()
+  end
+
+  method component_setup ()
+    label := Label ("label="||message, "pos=20,20")
+    add (label)
+    buttonYes := TextButton("label=Yes", "pos=40,60")
+    buttonYes.connect (self, "answer_yes", ACTION_EVENT)
+    add (buttonYes)
+    buttonNo := TextButton("label=No", "pos=120,60")
+    buttonNo.connect (self, "answer_no", ACTION_EVENT)
+    add (buttonNo)
+
+    connect (self, "dispose", CLOSE_BUTTON_EVENT)
+    attrib ("size=200,100", "bg=light gray")
+  end
+
+  initially (message)
+    self.Dialog.initially()
+    self.answer := "no"
+    self.message := message
+end
+
+# The main window, displays the different components
+class WindowApp : Dialog (field, value)
+  method increment ()
+    value +:= 1
+    field.set_contents (string(value))
+  end
+
+  method random ()
+    query := QuestionDialog ("Set to random?")
+    query.show_modal ()
+    if query.answered_yes () then {
+      value := ?100
+      field.set_contents (string(value))
+    }
+  end
+
+  method handle_text_field ()
+    if not(integer(field.get_contents ()))
+      then {
+        warning := MessageDialog ("Not a number")
+        warning.show_modal ()
+        field.set_contents (string(value))
+      }
+      else {
+        value := integer(field.get_contents ())
+      }
+  end
+
+  method component_setup ()
+    value := 0
+    field := TextField("contents="||value, "pos=20,20", "size=150")
+    field.connect (self, "handle_text_field", TEXTFIELD_CHANGED_EVENT)
+    add (field)
+    button1 := TextButton("label=Increment", "pos=20,60", "size=70")
+    button1.connect (self, "increment", ACTION_EVENT)
+    add (button1)
+    button2 := TextButton("label=Random", "pos=100,60", "size=70")
+    button2.connect (self, "random", ACTION_EVENT)
+    add (button2)
+
+    connect (self, "dispose", CLOSE_BUTTON_EVENT)
+    attrib ("size=200,100", "bg=light gray")
+  end
+end
+
+# create and show the window
+procedure main ()
+  w := WindowApp ()
+  w.show_modal ()
+end

Task/GUI-component-interaction/J/gui-component-interaction-1.j

@@ -0,0 +1,32 @@
+INTERACT=: 0 : 0
+pc interact closeok;
+xywh 6 6 48 12;cc Value edit;
+xywh 6 18 48 12;cc increment button;cn "+";
+xywh 6 30 48 12;cc random button;cn "?";
+pas 6 6;pcenter;
+rem form end;
+)
+
+interact_run=: 3 : 0
+ wd INTERACT
+ wd 'set Value 0;'
+ wd 'pshow;'
+)
+
+interact_close=: 3 : 0
+ wd'pclose'
+)
+
+interact_Value_button=: 3 : 0
+ wd 'set Value ' , ": {. 0 ". Value
+)
+
+interact_increment_button=: 3 : 0
+ wd 'set Value ' , ": 1 + {. 0 ". Value
+)
+
+interact_random_button=: 3 : 0
+ if. 0 = 2 wdquery 'Confirm';'Reset to random number?' do.
+  wd 'set Value ' , ": ?100
+ end.
+)

Task/GUI-component-interaction/J/gui-component-interaction-2.j

@@ -0,0 +1 @@
+interact_run''

Task/GUI-component-interaction/Java/gui-component-interaction.java

@@ -0,0 +1,93 @@
+import java.awt.GridLayout;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.KeyEvent;
+import java.awt.event.KeyListener;
+
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JTextField;
+
+public class Interact extends JFrame{
+	final JTextField numberField;
+	final JButton incButton, randButton;
+	
+	public Interact(){
+		//stop the GUI threads when the user hits the X button
+		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+		
+		numberField = new JTextField();
+		incButton = new JButton("Increment");
+		randButton = new JButton("Random");
+		
+		numberField.setText("0");//start at 0
+		
+		//listen for button presses in the text field
+		numberField.addKeyListener(new KeyListener(){
+			@Override
+			public void keyTyped(KeyEvent e) {
+				//if the entered character is not a digit
+				if(!Character.isDigit(e.getKeyChar())){
+					//eat the event (i.e. stop it from being processed)
+					e.consume();
+				}
+			}
+			@Override
+			public void keyReleased(KeyEvent e){}
+			@Override
+			public void keyPressed(KeyEvent e){}
+		});
+		
+		//listen for button clicks on the increment button
+		incButton.addActionListener(new ActionListener(){
+			@Override
+			public void actionPerformed(ActionEvent e) {
+				String text = numberField.getText();
+				if(text.isEmpty()){
+					numberField.setText("1");
+				}else{
+					numberField.setText((Long.valueOf(text) + 1) + "");
+				}
+			}
+		});
+		
+		//listen for button clicks on the random button
+		randButton.addActionListener(new ActionListener(){
+			@Override
+			public void actionPerformed(ActionEvent e) {
+				//show a dialog and if they answer "Yes"
+				if(JOptionPane.showConfirmDialog(null, "Are you sure?") ==
+					JOptionPane.YES_OPTION){
+					//set the text field text to a random positive long
+					numberField.setText(Long.toString((long)(Math.random()
+							* Long.MAX_VALUE)));
+				}
+			}
+		});
+		
+		//arrange the components in a grid with 2 rows and 1 column
+		setLayout(new GridLayout(2, 1));
+		
+		//a secondary panel for arranging both buttons in one grid space in the window
+		JPanel buttonPanel = new JPanel();
+		
+		//the buttons are in a grid with 1 row and 2 columns
+		buttonPanel.setLayout(new GridLayout(1, 2));
+		//add the buttons
+		buttonPanel.add(incButton);
+		buttonPanel.add(randButton);
+		
+		//put the number field on top of the buttons
+		add(numberField);
+		add(buttonPanel);
+		//size the window appropriately
+		pack();
+		
+	}
+
+	public static void main(String[] args){
+		new Interact().setVisible(true);
+	}
+}

Task/GUI-component-interaction/Liberty-BASIC/gui-component-interaction-1.liberty

@@ -0,0 +1,56 @@
+nomainwin
+    textbox #demo.val, 20, 50, 90, 24
+    button #demo.inc, "Increment", [btnIncrement], UL, 20, 90, 90, 24
+    button #demo.rnd, "Random", [btnRandom], UL, 20, 120, 90, 24
+    open "Rosetta Task: GUI component interaction" for window as #demo
+    #demo "trapclose [quit]"
+    validNum$ = "0123456789."
+    #demo.val 0
+wait
+
+[quit]
+    close #demo
+end
+
+[btnIncrement]
+    #demo.val "!contents? nVal$"
+    nVal$ = trim$(nVal$)
+    if left$(nVal$, 1) = "-" then
+        neg = 1
+        nVal$ = mid$(nVal$, 2)
+    else
+        neg = 0
+    end if
+    validNum = 1
+    nDecs = 0
+    for i = 1 to len(nVal$)
+        if instr(validNum$, mid$(nVal$, i, 1)) = 0 then
+            validNum = 0
+        end if
+        if mid$(nVal$, i, 1) = "." then
+            nDecs = nDecs + 1
+        end if
+    next i
+    if nDecs > 1 then
+        validNum = 0
+    end if
+    if neg = 1 then
+        nVal$ = "-";nVal$
+    end if
+    if validNum = 0 then
+        notice nVal$;" does not appear to be a valid number.  " + _
+            "(Commas are not allowed.)"
+    else
+        nVal = val(nVal$)
+        nVal = nVal + 1
+    end if
+    #demo.val nVal
+wait
+
+[btnRandom]
+    confirm "Reset value to random number";yn$
+    if yn$ = "yes" then
+        nVal = int(rnd(1) * 100) + 1
+        #demo.val nVal
+    end if
+wait

Task/GUI-component-interaction/Liberty-BASIC/gui-component-interaction-2.liberty

@@ -0,0 +1,27 @@
+nomainwin
+    stylebits #demo.val, _ES_NUMBER, 0, 0, 0
+    textbox #demo.val, 20, 50, 90, 24
+    button #demo.inc, "Increment", [btnIncrement], UL, 20, 90, 90, 24
+    button #demo.rnd, "Random", [btnRandom], UL, 20, 120, 90, 24
+    open "Rosetta Task: GUI component interaction" for window as #demo
+    #demo "trapclose [quit]"
+    #demo.val 0
+wait
+
+[quit]
+    close #demo
+end
+
+[btnIncrement]
+    #demo.val "!contents? nVal"
+    nVal = nVal + 1
+    #demo.val nVal
+wait
+
+[btnRandom]
+    confirm "Reset value to random number";yn$
+    if yn$ = "yes" then
+        nVal = int(rnd(1) * 100) + 1
+        #demo.val nVal
+    end if
+wait

Task/GUI-component-interaction/Mathematica/gui-component-interaction.mathematica

@@ -0,0 +1,8 @@
+Manipulate[Null, {{value, 0}, InputField[Dynamic[value], Number] &},
+ Row@{Button["increment", value++],
+   Button["random",
+    If[DialogInput[
+      Column@{"Are you sure?",
+        Row@{Button["Yes", DialogReturn[True]],
+          Button["No", DialogReturn[False]]}}],
+     value = RandomInteger@10000], Method -> "Queued"]}]

Task/GUI-component-interaction/PicoLisp/gui-component-interaction.l

@@ -0,0 +1,18 @@
+#!/usr/bin/picolisp /usr/lib/picolisp/lib.l
+
+(load "@ext.l" "@lib/http.l" "@lib/xhtml.l" "@lib/form.l")
+
+(de start ()
+   (and (app) (zero *Number))
+   (action
+      (html 0 "Increment" "@lib.css" NIL
+         (form NIL
+            (gui '(+Var +NumField) '*Number 20 "Value")
+            (gui '(+JS +Button) "increment"
+               '(inc '*Number) )
+            (gui '(+Button) "random"
+               '(ask "Reset to a random value?"
+                  (setq *Number (rand)) ) ) ) ) ) )
+
+(server 8080 "!start")
+(wait)

Task/GUI-component-interaction/Prolog/gui-component-interaction.pro

@@ -0,0 +1,81 @@
+dialog('GUI_Interaction',
+       [ object        :=
+	   GUI_Interaction,
+	 parts         :=
+	   [ GUI_Interaction :=
+	       dialog('Rosetta Code'),
+	     Input_field     :=
+	       text_item(input_field),
+	     Increment       :=
+	       button(increment),
+	     Random          :=
+	       button(random)
+	   ],
+	 modifications :=
+	   [ Input_field := [ label  := 'Value :',
+			      length := 28
+			    ]
+	   ],
+	 layout        :=
+	   [ area(Input_field,
+		  area(54, 24, 251, 24)),
+	     area(Increment,
+		  area(54, 90, 80, 24)),
+	     area(Random,
+		  area(230, 90, 80, 24))
+	   ],
+	 behaviour     :=
+
+	   [
+	     Increment := [
+			 message := message(@prolog,
+					    increment,
+					    Input_field )
+		       ],
+	     Random := [
+			 message := message(@prolog,
+					    my_random,
+					    Input_field)
+			  ],
+	     Input_field := [
+			 message := message(@prolog,
+					    input,
+					    GUI_Interaction,
+					    Increment,
+					    @receiver,
+					    @arg1)
+			  ]
+	   ]
+
+       ]).
+
+gui_component :-
+	make_dialog(S, 'GUI_Interaction'),
+	send(S, open).
+
+
+increment(Input) :-
+	get(Input, selection, V),
+	atom_number(V, Val),
+	Val1 is Val + 1,
+	send(Input, selection, Val1).
+
+my_random(Input) :-
+        new(D, dialog('GUI Interaction')),
+        send(D, append(label(lbl,'Confirm your choice !'))),
+        send(D, append(button(ok, message(D, return, ok)))),
+        send(D, append(button(cancel, message(D, return, ko)))),
+        send(D, default_button(ok)),
+        get(D, confirm, Rval),
+        free(D),
+        (   Rval = ok
+	->  X is random(10000),
+	    send(Input, selection, X)
+	).
+
+
+input(Gui, Btn, Input, Selection) :-
+	catch( (term_to_atom(T, Selection), number(T), send(Gui, focus, Btn)),
+	       _,
+	       (   send(@display, inform, 'Please type a number !'),
+		   send(Input,clear))).

Task/GUI-component-interaction/R/gui-component-interaction.r

@@ -0,0 +1,30 @@
+library(gWidgets)
+options(guiToolkit="RGtk2") ## using gWidgtsRGtk2
+
+w <- gwindow("Interaction")
+
+g <- ggroup(cont=w, horizontal=FALSE)
+e <- gedit(0, cont=g, coerce.with=as.numeric)
+bg <- ggroup(cont=g)
+
+inc_btn <- gbutton("increment", cont=bg)
+rdm_btn <- gbutton("random", cont=bg)
+
+addHandlerChanged(e, handler=function(h,...) {
+  val <- svalue(e)
+  if(is.na(val))
+    galert("You need to enter a number", parent=w)
+})
+
+addHandlerChanged(inc_btn, handler=function(h,...) {
+  val <- svalue(e)
+  if(is.na(val))
+    galert("Can't increment if not a number", parent=w)
+  else
+    svalue(e) <- val + 1
+})
+
+addHandlerChanged(rdm_btn, handler=function(h,...) {
+  if(gconfirm("Really replace value?"))
+    svalue(e) <- sample(1:1000, 1)
+})

Task/GUI-component-interaction/Ruby/gui-component-interaction.rb

@@ -0,0 +1,19 @@
+Shoes.app do
+  stack do
+    @textbox = edit_line
+
+    @textbox.change do
+      @textbox.text = @textbox.text.gsub(/[^\d]/, '') and alert "Input must be a number!" if @textbox.text !~ /^\d*$/
+    end
+
+    flow do
+      button "Increment" do
+        @textbox.text = @textbox.text.to_i + 1
+      end
+
+      button "Random" do
+        @textbox.text = rand 5000 if confirm "Do you want a random number?"
+      end
+    end
+  end
+end

Task/GUI-component-interaction/Scala/gui-component-interaction.scala

@@ -0,0 +1,46 @@
+import scala.swing._
+import scala.swing.Swing._
+import scala.swing.event._
+
+object Interact extends SimpleSwingApplication {
+  def top = new MainFrame {
+    title = "Rosetta Code >>> Task: component interaction | Language: Scala"
+
+    val numberField = new TextField { text = "0" } // start at 0
+
+    val incButton  = new Button { text = "Increment" }
+    val randButton = new Button { text = "Random" }
+
+    // arrange buttons in a grid with 1 row, 2 columns
+    val buttonPanel = new GridPanel(1, 2) {
+      contents ++= List(incButton, randButton)
+    }
+
+    // arrange text field and button panel in a grid with 2 row, 1 column
+    contents = new GridPanel(2, 1) {
+      contents ++= List(numberField, buttonPanel)
+    }
+
+    // listen for keys pressed in numberField and button clicks
+    listenTo(numberField.keys, incButton, randButton)
+    reactions += {
+      case kt: KeyTyped if (!kt.char.isDigit) => // if the entered char isn't a digit ...
+        kt.consume // ... eat the event (i.e. stop it from being processed)
+      case ButtonClicked(`incButton`) =>
+        if (numberField.text.isEmpty()) numberField.text = "0"
+        // we use BigInt to avoid long overflow/number format exception
+        val biNumber = new BigInt(new java.math.BigInteger(numberField.text))
+        numberField.text = "" + (biNumber+1)
+      case ButtonClicked(`randButton`) =>
+        import Dialog._
+        numberField.text = showOptions(buttonPanel,
+                        message = "Are you sure?",
+                        title = "Choose an option!",
+                        entries = List("Yes", "No", "Cancel"),
+                        initial = 2) match {
+              case Result.Yes => (Long.MaxValue * Math.random).toLong.toString
+              case _ => numberField.text
+        }
+    }
+  }
+}

Task/GUI-component-interaction/Smalltalk/gui-component-interaction.st

@@ -0,0 +1,18 @@
+|top input vh incButton rndButton|
+
+vh := ValueHolder with:0.
+
+top := StandardSystemView label:'Rosetta GUI interaction'.
+top extent:300@100.
+top add:((Label label:'Value:') origin: 0 @ 10 corner: 100 @ 40).
+top add:(input := EditField origin: 102 @ 10 corner: 1.0 @ 40).
+input model:(TypeConverter onNumberValue:vh).
+input acceptOnLostFocus:true; acceptOnReturn:true.
+
+top add:((incButton := Button label:'Inc') origin: 10 @ 50 corner: 100 @ 80).
+top add:((rndButton := Button label:'Rnd') origin: 110 @ 50 corner: 210 @ 80).
+
+incButton action:[ vh value: (vh value + 1) ].
+rndButton action:[ vh value: Random nextInteger ].
+
+top open

Task/GUI-component-interaction/Tcl/gui-component-interaction.tcl

@@ -0,0 +1,35 @@
+package require Tk
+
+###--- Our data Model! ---###
+# A single variable will do just fine
+set field 0
+
+###--- Lay out the GUI components in our View ---###
+# We use the Ttk widget set here; it looks much better on Windows and OSX
+
+# First, a quick hack to make things look even nicer
+place [ttk::frame .bg] -relwidth 1 -relheight 1
+
+# A labelled frame containing an entry field constrained to use numbers
+pack [ttk::labelframe .val -text "Value"]
+pack [ttk::entry .val.ue -textvariable field \
+	-validate key -invalidcommand bell \
+	-validatecommand {string is integer %P}]
+# Now, a pair of buttons
+pack [ttk::button .inc -text "increment" -command step]
+pack [ttk::button .rnd -text "random" -command random]
+
+###--- Now we define the behaviors, the Controller ---###
+# How to respond to a click on the "increment" button
+proc step {} {
+    global field
+    incr field
+}
+# How to respond to a click on the "random" button
+proc random {} {
+    global field
+    if {[tk_messageBox -type yesno -parent . \
+	    -message "Reset to random?"] eq "yes"} {
+	set field [expr {int(rand() * 5000)}]
+    }
+}