Development/Languages/Ruby/Ruby-Qt/KDE Book/First Steps/Hello World - Revision history

Neverendingo: Text replace - "" to ""

2011-06-29T20:50:20Z

Text replace - "</code>" to "</syntaxhighlight>"

Neverendingo: Text replace - "`" to ""`


2011-06-29T20:42:27Z
Text replace - "<code ruby>" to "<syntaxhighlight lang="ruby">"

				
				
				
				
			
			← Older revision
			Revision as of 20:42, 29 June 2011
			
Line 22:
Line 22:
  Now copy this short code example into the irb session.   Now copy this short code example into the irb session.
    
− <code ruby> + <syntaxhighlight lang="ruby">
  require 'Qt4'   require 'Qt4'
  a = Qt::Application.new ARGV   a = Qt::Application.new ARGV
Line 37:
Line 37:
  Another object <tt>w</tt> of <tt>Qt::PushButton</tt> is created in the third line. <tt>"Hello Ruby"</tt> is the first (and only) argument of the Constructor. If you check the Qt documentation, you would find out, that this is the caption of the button. Ruby would also allow you to write it with brackets.   Another object <tt>w</tt> of <tt>Qt::PushButton</tt> is created in the third line. <tt>"Hello Ruby"</tt> is the first (and only) argument of the Constructor. If you check the Qt documentation, you would find out, that this is the caption of the button. Ruby would also allow you to write it with brackets.
    
− <code ruby> + <syntaxhighlight lang="ruby">
  w = Qt::PushButton.new( "Hello Ruby" )   w = Qt::PushButton.new( "Hello Ruby" )
  </code>   </code>
Line 64:
Line 64:
    
    
− <code ruby> + <syntaxhighlight lang="ruby">
  #!/usr/bin/ruby   #!/usr/bin/ruby
  #file: sayHello.rb   #file: sayHello.rb
Line 111:
Line 111:
  == Say Hello, Ruby - the short version ==   == Say Hello, Ruby - the short version ==
    
− <code ruby> + <syntaxhighlight lang="ruby">
  #!/usr/bin/ruby   #!/usr/bin/ruby
  #file: sayHello.rb   #file: sayHello.rb
Line 135:
Line 135:
  == Say Hello, Ruby - an even shorter version ==   == Say Hello, Ruby - an even shorter version ==
    
− <code ruby> + <syntaxhighlight lang="ruby">
  require 'Qt4'   require 'Qt4'
    
Line 155:
Line 155:
  If you create a new object you can add a code block with some statements that gets executed in the namespace of the new object. You can also use <tt>do</tt> to inline the code belonging to <tt>msgBox</tt>, too:   If you create a new object you can add a code block with some statements that gets executed in the namespace of the new object. You can also use <tt>do</tt> to inline the code belonging to <tt>msgBox</tt>, too:
    
− <code ruby> + <syntaxhighlight lang="ruby">
  require 'Qt4'   require 'Qt4'



Neverendingo: Text replace - "" to ""

2011-06-29T20:38:50Z
Text replace - "<code bash>" to "<syntaxhighlight lang="bash">"

				
				
				
				
			
			← Older revision
			Revision as of 20:38, 29 June 2011
			
Line 57:
Line 57:
  Clicking the file opens it in your text editor, but on Linux we can also make it start the application. Look at the top of the improved Ruby application below. That is called a [http://en.wikipedia.org/wiki/Shebang_%28Unix%29 Shebang] line. After saving the file we need to tell Linux that the file is allowed to be executed by default with the shell command:   Clicking the file opens it in your text editor, but on Linux we can also make it start the application. Look at the top of the improved Ruby application below. That is called a [http://en.wikipedia.org/wiki/Shebang_%28Unix%29 Shebang] line. After saving the file we need to tell Linux that the file is allowed to be executed by default with the shell command:
    
− <code bash> + <syntaxhighlight lang="bash">
  chmod +x sayHello.rb   chmod +x sayHello.rb
  </code>   </code>



Dennis p: One dot too many
2010-02-03T17:54:36Z
One dot too many

				
				
				
				
			
			← Older revision
			Revision as of 17:54, 3 February 2010
			
Line 100:
Line 100:
  with the Ruby styled code   with the Ruby styled code
    
− <tt>text = "Hello World"</tt>. + <tt>text = "Hello World"</tt>
    
  Remember this as you need it to find the class method in the C++ documentation of Qt.   Remember this as you need it to find the class method in the C++ documentation of Qt.



Dennis p: improved writing style and removed spelling mistakes
2010-02-03T17:33:31Z
improved writing style and removed spelling mistakes

				
				
				
				
			
			← Older revision
			Revision as of 17:33, 3 February 2010
			
Line 19:
Line 19:
  == Interactive Implementation Using Qt 4 ==   == Interactive Implementation Using Qt 4 ==
    
− Open a shell and type in <tt>irb</tt> to start the interactive ruby shell. + Open a shell and type <tt>irb</tt> to start the interactive ruby shell.
  Now copy this short code example into the irb session.   Now copy this short code example into the irb session.
    
Line 31:
Line 31:
  </code>   </code>
    
− Before you start programming your Graphical User Interface (GUI) you have to <<tt>require</tt> the libraries, in this case <tt>Qt4</tt>, but <tt>korundum4</tt> would also do the job because the KDE libs automatically requires the Qt libs for you. + Before you start programming your Graphical User Interface (GUI) you have to <tt>require</tt> the libraries, in this case <tt>Qt4</tt>, but <tt>korundum4</tt> would also do the job because the KDE libs automatically requires the Qt libs for you.
    
  In the second line we create a new Qt Object <tt>a</tt> of <tt>Qt::Application</tt>. <tt>Qt</tt> is the Ruby module (namespace) and <tt>Application</tt> the name of the class in the module. In C++, the native language of Qt, you would write <tt>QApplication</tt>. Remember this as you will need it when you want to take a look at the Qt documentation, which assumes you use C++.   In the second line we create a new Qt Object <tt>a</tt> of <tt>Qt::Application</tt>. <tt>Qt</tt> is the Ruby module (namespace) and <tt>Application</tt> the name of the class in the module. In C++, the native language of Qt, you would write <tt>QApplication</tt>. Remember this as you will need it when you want to take a look at the Qt documentation, which assumes you use C++.
Line 49:
Line 49:
  The fifth line is required to make the created widget actually appear on the screen. Don't forget this line. Maybe you want to think of this as the starting point of your application.   The fifth line is required to make the created widget actually appear on the screen. Don't forget this line. Maybe you want to think of this as the starting point of your application.
    
− And finally the application gets started by <tt>a.exec</tt>. Now the GUI takes over and manages the control flow. Any other command after this line will be applied after the GUI was closed. + And finally the application gets started by <tt>a.exec</tt>. Now the GUI takes over and manages the control flow. Any other command after this line will be applied after the GUI has been closed by the user of the application.
    
  == Say Hello, Ruby ==   == Say Hello, Ruby ==
    
− In the next example we want our GUI to do something interactively. Because it is more complex you may want to save it in a file "sayHello.rb". + In the next example we want our GUI to do something interactive. Because it is more complex you may want to save it in a file "sayHello.rb".
  +  
  + Clicking the file opens it in your text editor, but on Linux we can also make it start the application. Look at the top of the improved Ruby application below. That is called a [http://en.wikipedia.org/wiki/Shebang_%28Unix%29 Shebang] line. After saving the file we need to tell Linux that the file is allowed to be executed by default with the shell command:
  +  
  + <code bash>
  + chmod +x sayHello.rb
  + </code>
  +  
  + After giving the file execution rights you can execute your program on the command line with <tt>./sayHello.rb</tt> or with a click on the icon in the file browser (Dolphin, Konqueror).
    
− If you are on a linux-based system, you can add on the top of the file a so called [http://en.wikipedia.org/wiki/Shebang_%28Unix%29 Shebang] line. After giving the file execution rights with <tt>chmod +x sayHello.rb</tt> by using the shell, you can execute your program with a click on the icon in the file browser or in the command line with <tt>./sayRuby.rb</tt>.  
    
  <code ruby>   <code ruby>
Line 85:
Line 92:
  </code>   </code>
    
− In the last example we connected the button with the existing slot <tt>:close</tt>. Now we want to create our own slot. We create a new class <tt>CustomApplication</tt> by inheriting from <tt>Qt::Application</tt> and add a slot <tt>:sayHello</tt>. It doesn't have any arguments. So we can use the shortcut instead of <tt>"sayHello()"</tt>. After that we define a method with the same name and number of arguments. In the method a message box is prepared which get shown to the user with <tt>exec()</tt>. To define the properties of the message box, the binding specific syntax is used, which allows you to replace <tt>setText( "Hello World" )</tt> with <tt>text = "Hello World"</tt>. Remember this as you need it to find the class method in the C++ documentation of Qt. + In the previous example we connected the button with the existing slot <tt>:close</tt>. Now, in the example above, we want to create our own slot. We create a new class <tt>CustomApplication</tt> by inheriting from <tt>Qt::Application</tt> and add a slot <tt>:sayHello</tt>. It doesn't have any arguments. So we can use the shortcut <tt>":sayHello"</tt> instead of <tt>":sayHello()"</tt>.  
  +  
  + After that we define a method with the same name and a number of arguments. In the method a message box is prepared which get shown to the user with <tt>exec()</tt>. To define the properties of the message box, the binding specific syntax is used, which allows you to replace the C++ styled code
  +  
  + <tt>setText( "Hello World" )</tt>
  +  
  + with the Ruby styled code
  +  
  + <tt>text = "Hello World"</tt>.
  +  
  + Remember this as you need it to find the class method in the C++ documentation of Qt.
    
  With <tt>Qt::Application.instance.quit</tt> the program gets closed.   With <tt>Qt::Application.instance.quit</tt> the program gets closed.
    
− The last lines are nearly the same as in the last example. We have to replace <tt>Qt::Application</tt> with our own class <tt>CustomApplication</tt> and change the in the slot to <tt>:sayHello</tt> in the connection command. + The last lines are nearly the same as in the last example. We have to replace <tt>Qt::Application</tt> with our own class <tt>CustomApplication</tt> and change the request to quit in the slot to <tt>:sayHello</tt> in the connection command.
    
    
Line 114:
Line 131:
  </code>   </code>
    
− The bindings offer you a special features, which allows you to define the actions for a given signal without having to create a slot. Just use the <tt>connect</tt> method of the Qt object which owns the signal you want to use. The <tt>connect</tt> expects you to give only one argument,the signal, followd by a code block (<tt>do ... end</tt>), which gets processed in the case the signal is triggered. This way of programming allows a very compact style. In this case you don't need to create a <tt>CustomApplication</tt>. + The bindings offer special features, allowing you to define the actions for a given signal without having to create a slot. Just use the <tt>connect</tt> method of the Qt object which owns the signal you want to use. The <tt>connect</tt> expects you to give only one argument, the signal, followed by a code block (<tt>do ... end</tt>), which gets processed in case the signal is triggered. This way of programming allows a very compact style. In this case you don't need to create a <tt>CustomApplication</tt>.
    
  == Say Hello, Ruby - an even shorter version ==   == Say Hello, Ruby - an even shorter version ==
Line 136:
Line 153:
  </code>   </code>
    
− If you create a new object, you can add a code block with some statements, that gets executed in the namespace of the new object. You can expand the usage on the <tt>msgBox</tt>, too. + If you create a new object you can add a code block with some statements that gets executed in the namespace of the new object. You can also use <tt>do</tt> to inline the code belonging to <tt>msgBox</tt>, too:
    
  <code ruby>   <code ruby>



Dennis p: Grammar check of 1.1
2010-02-03T11:48:00Z
Grammar check of 1.1

				
				
				
				
			
			← Older revision
			Revision as of 11:48, 3 February 2010
			
Line 11:
Line 11:
  * improve writing style and remove spelling mistakes|100%}}   * improve writing style and remove spelling mistakes|100%}}
    
− After all you should have a working ruby installation with KDE 4 bindings. + You should now have a working ruby installation with KDE 4 bindings.
    
− So lets try the a very minimalistic Qt 4 application to get a first impression. We don't start with KDE, because it would require some extra lines, that are not necessary when using Qt. + So let's try out a very minimalistic Qt 4 application to get a first impression. We don't start with KDE because that would require some extra lines which are not necessary when using Qt.
    
  = Hello Ruby =   = Hello Ruby =
Line 20:
Line 20:
    
  Open a shell and type in <tt>irb</tt> to start the interactive ruby shell.   Open a shell and type in <tt>irb</tt> to start the interactive ruby shell.
− Now copy the short code example into the irb session. + Now copy this short code example into the irb session.
    
  <code ruby>   <code ruby>
Line 31:
Line 31:
  </code>   </code>
    
− Before you starting you start programming your Graphical User Interface (GUI), you have to <<tt>require</tt> the libraries, in this case <tt>Qt4</tt>, but <tt>korundum4</tt> would also do the job, because the KDE libs automatically also requires the Qt libs for you. + Before you start programming your Graphical User Interface (GUI) you have to <<tt>require</tt> the libraries, in this case <tt>Qt4</tt>, but <tt>korundum4</tt> would also do the job because the KDE libs automatically requires the Qt libs for you.
    
− In the second line we create a new Qt Object a of <tt>Qt::Application</tt>. <tt>Qt</tt> is the Ruby module (namespace) and <tt>Application</tt> the name of the class in the module. In C++, the native language of Qt, you would write <tt>QApplication</tt>. Remember this as you will need it, if you want to take a look in the Qt documentation. + In the second line we create a new Qt Object <tt>a</tt> of <tt>Qt::Application</tt>. <tt>Qt</tt> is the Ruby module (namespace) and <tt>Application</tt> the name of the class in the module. In C++, the native language of Qt, you would write <tt>QApplication</tt>. Remember this as you will need it when you want to take a look at the Qt documentation, which assumes you use C++.
    
− Another object w of <tt>Qt::PushButton</tt> is created in the third line. <tt>"Hello Ruby"</tt> is the first (and only) argument of the Constructor. If you check the Qt documentation, you would find out, that this is the caption of the button. Ruby would also allow you to write it with brackets. + Another object <tt>w</tt> of <tt>Qt::PushButton</tt> is created in the third line. <tt>"Hello Ruby"</tt> is the first (and only) argument of the Constructor. If you check the Qt documentation, you would find out, that this is the caption of the button. Ruby would also allow you to write it with brackets.
    
  <code ruby>   <code ruby>
Line 43:
Line 43:
  The small <tt>w</tt> means widget. All graphical elements in Qt are called widgets.   The small <tt>w</tt> means widget. All graphical elements in Qt are called widgets.
    
− The fourth line is probably the most complicated one. The ruby class method <tt>connect</tt> of the object <tt>Object</tt> of the module <tt>Qt</tt> is used to bind the user action button-clicked with the action application-close. The signals and slots is a special concept of Qt. You can get a [http://en.wikipedia.org/wiki/Signals_and_slots short overview] and other ressources on Wikipedia. + The fourth line is probably the most complicated one. The ruby class method <tt>connect</tt> of the object <tt>Object</tt> of the module <tt>Qt</tt> is used to bind the user action button-clicked with the action application-close. Signals and slots is a special concept of Qt. You can get a [http://en.wikipedia.org/wiki/Signals_and_slots short overview], and find other resources, on Wikipedia.
    
  The C++ equivalent you will find in the Qt documentation to <tt>:clicked</tt> would be <tt>"clicked()"</tt>, a signal without an argument. In the case of no arguments you can always use a ruby symbol.   The C++ equivalent you will find in the Qt documentation to <tt>:clicked</tt> would be <tt>"clicked()"</tt>, a signal without an argument. In the case of no arguments you can always use a ruby symbol.
    
− The fifth line let the created widget show. Don't forget this line. Maybe you want to think of a starting point of your application. + The fifth line is required to make the created widget actually appear on the screen. Don't forget this line. Maybe you want to think of this as the starting point of your application.
    
− At last the application gets started by <tt>a.exec</tt>. Now the GUI takes over and manages the control flow. Any other command after this line will be applied after the GUI was closed. + And finally the application gets started by <tt>a.exec</tt>. Now the GUI takes over and manages the control flow. Any other command after this line will be applied after the GUI was closed.
    
  == Say Hello, Ruby ==   == Say Hello, Ruby ==



Robert Riemann: changed code snippets
2010-01-21T17:17:34Z
changed code snippets

				
				
				
				
			
			← Older revision
			Revision as of 17:17, 21 January 2010
			
Line 7:
Line 7:
    
  {{Box|Status Of Writing|   {{Box|Status Of Writing|
− [[Image:Action_pen.svg|noframe|left|40px]]{{Progress bar|0}}|100%}} + [[Image:Action_pen.svg|noframe|left|40px]]{{Progress bar|80}}
  + TODO:
  + * improve writing style and remove spelling mistakes|100%}}
    
  After all you should have a working ruby installation with KDE 4 bindings.   After all you should have a working ruby installation with KDE 4 bindings.
Line 69:
Line 71:
       msgBox.text = "Hello World"        msgBox.text = "Hello World"
       msgBox.icon = Qt::MessageBox::Information        msgBox.icon = Qt::MessageBox::Information
−     msgBox.standardButtons = Qt::MessageBox::Ok  
       val = msgBox.exec()        val = msgBox.exec()
                 
Line 88:
Line 89:
  With <tt>Qt::Application.instance.quit</tt> the program gets closed.   With <tt>Qt::Application.instance.quit</tt> the program gets closed.
    
− The last lines are nearly the same as in the last example. We have to replace <tt>Qt::Application</tt> with our own class <tt>CustomApplication</tt> and change the slot to <tt>:sayHello</tt>. + The last lines are nearly the same as in the last example. We have to replace <tt>Qt::Application</tt> with our own class <tt>CustomApplication</tt> and change the in the slot to <tt>:sayHello</tt> in the connection command.
  +  
  +  
  + == Say Hello, Ruby - the short version ==
    
  <code ruby>   <code ruby>
  + #!/usr/bin/ruby
  + #file: sayHello.rb
  + 
  require 'Qt4'   require 'Qt4'
    
  a = Qt::Application.new ARGV   a = Qt::Application.new ARGV
− w = Qt::PushButton.new( "Hello Ruby" ) + w = Qt::PushButton.new( "Say Hello, Ruby" )
− w.connect( SIGNAL :clicked ) do + w.connect( SIGNAL( :clicked ) ) do
−      puts "Do something else" +   msgBox = Qt::MessageBox.new
  +   msgBox.text = "Hello World"
  +   msgBox.icon = Qt::MessageBox::Information
  +   val = msgBox.exec()
  +   
  +   Qt::Application.instance.quit
  + end
  + w.show
  + a.exec
  + </code>
  +  
  + The bindings offer you a special features, which allows you to define the actions for a given signal without having to create a slot. Just use the <tt>connect</tt> method of the Qt object which owns the signal you want to use. The <tt>connect</tt> expects you to give only one argument,the signal, followd by a code block (<tt>do ... end</tt>), which gets processed in the case the signal is triggered. This way of programming allows a very compact style. In this case you don't need to create a <tt>CustomApplication</tt>.
  +  
  + == Say Hello, Ruby - an even shorter version ==
  +  
  + <code ruby>
  + require 'Qt4'
  +  
  + a = Qt::Application.new ARGV
  + w = Qt::PushButton.new( "Hello Ruby" ) do
  +   self.connect( SIGNAL :clicked ) do  
  +      msgBox = Qt::MessageBox.new
  +     msgBox.text = "Hello World"
  +     msgBox.icon = Qt::MessageBox::Information
  +     val = msgBox.exec()
  +     
       Qt::Application.instance.quit        Qt::Application.instance.quit
  +   end
  end   end
  w.show   w.show
  a.exec   a.exec
  </code>   </code>
  + 
  + If you create a new object, you can add a code block with some statements, that gets executed in the namespace of the new object. You can expand the usage on the <tt>msgBox</tt>, too.
    
  <code ruby>   <code ruby>
Line 108:
Line 143:
  a = Qt::Application.new ARGV   a = Qt::Application.new ARGV
  w = Qt::PushButton.new( "Hello Ruby" ) do   w = Qt::PushButton.new( "Hello Ruby" ) do
−    connect( SIGNAL :clicked ) do +    self.connect( SIGNAL :clicked ) do  
−      puts "Do something else" +      msgBox = Qt::MessageBox.new do
  +       self.text = "Hello World"
  +       self.icon = Qt::MessageBox::Information
  +     end
  +     val = msgBox.exec()    
       Qt::Application.instance.quit        Qt::Application.instance.quit
     end      end



Robert Riemann: explain second code example
2010-01-21T16:21:35Z
explain second code example

				
				
				
				
			
			← Older revision
			Revision as of 16:21, 21 January 2010
			
Line 57:
Line 57:
  <code ruby>   <code ruby>
  #!/usr/bin/ruby   #!/usr/bin/ruby
− # file: sayHello.rb + #file: sayHello.rb
    
  require 'Qt4'   require 'Qt4'
Line 66:
Line 66:
    
     def sayHello      def sayHello
−      puts "Hello World" +      msgBox = Qt::MessageBox.new
  +     msgBox.text = "Hello World"
  +     msgBox.icon = Qt::MessageBox::Information
  +     msgBox.standardButtons = Qt::MessageBox::Ok
  +     val = msgBox.exec()
  +     
       Qt::Application.instance.quit        Qt::Application.instance.quit
     end      end
Line 78:
Line 83:
  a.exec   a.exec
  </code>   </code>
  + 
  + In the last example we connected the button with the existing slot <tt>:close</tt>. Now we want to create our own slot. We create a new class <tt>CustomApplication</tt> by inheriting from <tt>Qt::Application</tt> and add a slot <tt>:sayHello</tt>. It doesn't have any arguments. So we can use the shortcut instead of <tt>"sayHello()"</tt>. After that we define a method with the same name and number of arguments. In the method a message box is prepared which get shown to the user with <tt>exec()</tt>. To define the properties of the message box, the binding specific syntax is used, which allows you to replace <tt>setText( "Hello World" )</tt> with <tt>text = "Hello World"</tt>. Remember this as you need it to find the class method in the C++ documentation of Qt.
  + 
  + With <tt>Qt::Application.instance.quit</tt> the program gets closed.
  + 
  + The last lines are nearly the same as in the last example. We have to replace <tt>Qt::Application</tt> with our own class <tt>CustomApplication</tt> and change the slot to <tt>:sayHello</tt>.
    
  <code ruby>   <code ruby>



Robert Riemann: add explanations
2010-01-20T20:03:43Z
add explanations

				
				
				
				
			
			← Older revision
			Revision as of 20:03, 20 January 2010
			
Line 51:
Line 51:
  == Say Hello, Ruby ==   == Say Hello, Ruby ==
    
  + In the next example we want our GUI to do something interactively. Because it is more complex you may want to save it in a file "sayHello.rb".
  + 
  + If you are on a linux-based system, you can add on the top of the file a so called [http://en.wikipedia.org/wiki/Shebang_%28Unix%29 Shebang] line. After giving the file execution rights with <tt>chmod +x sayHello.rb</tt> by using the shell, you can execute your program with a click on the icon in the file browser or in the command line with <tt>./sayRuby.rb</tt>.
    
  <code ruby>   <code ruby>
  #!/usr/bin/ruby   #!/usr/bin/ruby
  + # file: sayHello.rb
    
  require 'Qt4'   require 'Qt4'
Line 59:
Line 63:
  class CustomApplication < Qt::Application   class CustomApplication < Qt::Application
    
−    slots :doSomething +    slots :sayHello
    
−    def doSomething +    def sayHello
−      puts "Do something else" +      puts "Hello World"
       Qt::Application.instance.quit        Qt::Application.instance.quit
     end      end
Line 69:
Line 73:
    
  a = CustomApplication.new ARGV   a = CustomApplication.new ARGV
− w = Qt::PushButton.new( "Hello Ruby" ) + w = Qt::PushButton.new( "Say Hello, Ruby" )
− Qt::Object.connect( w, SIGNAL( :clicked ), a, SLOT( :doSomething ) ) + Qt::Object.connect( w, SIGNAL( :clicked ), a, SLOT( :sayHello ) )
  w.show   w.show
  a.exec   a.exec



Robert Riemann: explain hello ruby program
2010-01-20T19:54:50Z
explain hello ruby program

				
				
				
				
			
			← Older revision
			Revision as of 19:54, 20 January 2010
			
Line 2:
Line 2:
  series=Ruby|   series=Ruby|
  name=Ruby-Qt/KDE Book|   name=Ruby-Qt/KDE Book|
− pre=[[Development/Languages/Ruby/Ruby-Qt/KDE Book/Installation/Installation on Linux|Installation on Linux]], [[Development/Languages/Ruby/Ruby-Qt/KDE Book/Installation/Installation on Mac OS|Installation on Mac OS]] or [[Development/Languages/Ruby/Ruby-Qt/KDE Book/Installation/Installation on Windows|Installation on Windows]] + pre=[[Development/Languages/Ruby/Ruby-Qt/KDE Book/Installation/Installation on Linux|Installation on Linux]], [[Development/Languages/Ruby/Ruby-Qt/KDE Book/Installation/Installation on Mac OS|Installation on Mac OS]] or [[Development/Languages/Ruby/Ruby-Qt/KDE Book/Installation/Installation on Windows|Installation on Windows]]|
  + reading=[http://en.wikipedia.org/wiki/Signals_and_slots Signals and Slots-Concept]
  }}   }}
    
Line 10:
Line 11:
  After all you should have a working ruby installation with KDE 4 bindings.   After all you should have a working ruby installation with KDE 4 bindings.
    
− So lets try the a very minimalistic KDE 4 application to get a first impression. + So lets try the a very minimalistic Qt 4 application to get a first impression. We don't start with KDE, because it would require some extra lines, that are not necessary when using Qt.
    
− = Interactive Hello Ruby = + = Hello Ruby =
    
− == Implementation Using Qt 4 == + == Interactive Implementation Using Qt 4 ==
  +  
  + Open a shell and type in <tt>irb</tt> to start the interactive ruby shell.
  + Now copy the short code example into the irb session.
    
  <code ruby>   <code ruby>
  require 'Qt4'   require 'Qt4'
−  
  a = Qt::Application.new ARGV   a = Qt::Application.new ARGV
− w = Qt::PushButton.new( "Hello Ruby" ) + w = Qt::PushButton.new "Hello Ruby"
  Qt::Object.connect( w, SIGNAL( :clicked ), a, SLOT( :quit ) )   Qt::Object.connect( w, SIGNAL( :clicked ), a, SLOT( :quit ) )
  w.show   w.show
Line 26:
Line 29:
  </code>   </code>
    
  + Before you starting you start programming your Graphical User Interface (GUI), you have to <<tt>require</tt> the libraries, in this case <tt>Qt4</tt>, but <tt>korundum4</tt> would also do the job, because the KDE libs automatically also requires the Qt libs for you.
  + 
  + In the second line we create a new Qt Object a of <tt>Qt::Application</tt>. <tt>Qt</tt> is the Ruby module (namespace) and <tt>Application</tt> the name of the class in the module. In C++, the native language of Qt, you would write <tt>QApplication</tt>. Remember this as you will need it, if you want to take a look in the Qt documentation.
  + 
  + Another object w of <tt>Qt::PushButton</tt> is created in the third line. <tt>"Hello Ruby"</tt> is the first (and only) argument of the Constructor. If you check the Qt documentation, you would find out, that this is the caption of the button. Ruby would also allow you to write it with brackets.
    
  <code ruby>   <code ruby>
  + w = Qt::PushButton.new( "Hello Ruby" )
  + </code>
  + 
  + The small <tt>w</tt> means widget. All graphical elements in Qt are called widgets.
  + 
  + The fourth line is probably the most complicated one. The ruby class method <tt>connect</tt> of the object <tt>Object</tt> of the module <tt>Qt</tt> is used to bind the user action button-clicked with the action application-close. The signals and slots is a special concept of Qt. You can get a [http://en.wikipedia.org/wiki/Signals_and_slots short overview] and other ressources on Wikipedia.
  + 
  + The C++ equivalent you will find in the Qt documentation to <tt>:clicked</tt> would be <tt>"clicked()"</tt>, a signal without an argument. In the case of no arguments you can always use a ruby symbol.
  + 
  + The fifth line let the created widget show. Don't forget this line. Maybe you want to think of a starting point of your application.
  + 
  + At last the application gets started by <tt>a.exec</tt>. Now the GUI takes over and manages the control flow. Any other command after this line will be applied after the GUI was closed.
  + 
  + == Say Hello, Ruby ==
  + 
  + 
  + <code ruby>
  + #!/usr/bin/ruby
  + 
  require 'Qt4'   require 'Qt4'

@@ Line 29: / Line 29: @@
 w.show
 a.exec
-</code>
+</syntaxhighlight>
 Before you start programming your Graphical User Interface (GUI) you have to <tt>require</tt> the libraries, in this case <tt>Qt4</tt>, but <tt>korundum4</tt> would also do the job because the KDE libs automatically requires the Qt libs for you.
@@ Line 39: / Line 39: @@
 <syntaxhighlight lang="ruby">
 w = Qt::PushButton.new( "Hello Ruby" )
-</code>
+</syntaxhighlight>
 The small <tt>w</tt> means widget. All graphical elements in Qt are called widgets.
@@ Line 59: / Line 59: @@
 <syntaxhighlight lang="bash">
 chmod +x sayHello.rb
-</code>
+</syntaxhighlight>
 After giving the file execution rights you can execute your program on the command line with <tt>./sayHello.rb</tt> or with a click on the icon in the file browser (Dolphin, Konqueror).
@@ Line 90: / Line 90: @@
 w.show
 a.exec
-</code>
+</syntaxhighlight>
 In the previous example we connected the button with the existing slot <tt>:close</tt>. Now, in the example above, we want to create our own slot. We create a new class <tt>CustomApplication</tt> by inheriting from <tt>Qt::Application</tt> and add a slot <tt>:sayHello</tt>. It doesn't have any arguments. So we can use the shortcut <tt>":sayHello"</tt> instead of <tt>":sayHello()"</tt>.
@@ Line 129: / Line 129: @@
 w.show
 a.exec
-</code>
+</syntaxhighlight>
 The bindings offer special features, allowing you to define the actions for a given signal without having to create a slot. Just use the <tt>connect</tt> method of the Qt object which owns the signal you want to use. The <tt>connect</tt> expects you to give only one argument, the signal, followed by a code block (<tt>do ... end</tt>), which gets processed in case the signal is triggered. This way of programming allows a very compact style. In this case you don't need to create a <tt>CustomApplication</tt>.
@@ Line 151: / Line 151: @@
 w.show
 a.exec
-</code>
+</syntaxhighlight>
 If you create a new object you can add a code block with some statements that gets executed in the namespace of the new object. You can also use <tt>do</tt> to inline the code belonging to <tt>msgBox</tt>, too:
@@ Line 171: / Line 171: @@
 w.show
 a.exec
-</code>
+</syntaxhighlight>