Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2013/oss paa

2013-10-30T17:52:56Z

Pyadav: /* Filter */

'''Expertiza OSS Project –E809 (TreeDisplay)'''

__TOC__
== Introduction ==
The [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza] project has a collapsible tree view structure to facilitate traversal through all learning objects. The problem statement is to redesign the underlying structure and include efficient search, filter and sort mechanism in the tree view structure. The tree is composed of different folders namely Assignments, Courses, Questionnaires and their subfolders respectively.

==Existing Design==
Currently the folders structure is displayed as a tree. The structure of the tree is as follows -

: • Questionnaire

:: o Review

:: o Metareview

:: o Author Feedback

:: o Teammate Review

:: o Survey

:: o Global Survey

:: o Course Evaluation

: • Courses

:: o Course

:::  assignment

: • Assignments

The whole set of Courses, Assignments and Questionnaires are displayed on screen in a collapsible tree view upon login. Items may be expanded and collapsed. There is no functionality to search/filter results.
The sort functionality has been provided which sorts the tree structure with important metrics such as creation date, name and directory in ascending as well as descending order.
We also have the option to view either the public and private items or the private items only.

'''[[File:ExistingUI.jpg]]'''

Fig.1 Existing UI which implements display of nodes and a sort utility

==Project Requirement==
The tree display can be inefficient given many objects (courses, etc.). We are supposed to design the underlying structure at the model level to efficiently retrieve organized data.

We are also required to redesign the view to enable users to filter/search and sort by important metrics such as creation date, name (alphabetical) and relationship (e.g. filter all assignments by a course).

The interface should be kept modular in the code to increase extensibility for future metrics. We have to keep the controller as ‘skinny’ as possible, leaving the model to perform computational logic.

==Implementation==
We have introduced two new features - search and filter.
To implement the search/filter, we have decided to use the same tree display which is efficient and simple to show the current data.

'''[[File:newUI.jpg]]'''

Fig.2 Above is the new UI which includes search and filter functionality

===Search===
This functionality searches for a keyword among 3 categories courses/assignment/questionnaire. It is implemented using substring search. All the entries whose substring matches with the search string are returned. Based on the input the user can view the filtered results in any of the 3 categories.

'''[[File:sample1.jpg]]'''

Fig.3 A sample output of searching “demo” in assignments.

===Filter===
There are 2 main relationships in the tree structure. These are as follows -

: 1. A course can have many assignments.

: 2. An assignment can have many questionnaires.

If the user selects one of the two fields and enters the course/assignment name, then he can see a list of all the elements which are related to that course/assignment.

'''[[File:sample2.jpg]]'''

Fig.4 Sample output which shows the result of filtering assignments by course “CourseTest1”

===Compatibility with existing features===
A user can search all assignments for a respective course, and also search for all questionnaires related to one assignment, Also a search can be performed on all the nodes. We preserve the sort feature across the implementation which means that the user can sort the filtered/search results also. The user can also view the public and private items or the private items only for the filtered/search results.

'''[[File:sample3.jpg]]'''

Fig.5 Sample output which shows the same result of searching “demo” in assignments but sorted in descending order.

==Design==
===View===
Since the tree display is the best way to show the folder structure and to maximize code reuse, we choose the same display style for search results. We add search and filter boxes to input the search/filter keyword on the main page and output the result on the same page. We also add the reset button to reset the filter/search and display all the results again.
All the above changes are done in -
''' \view \tree_display\_page_header.html.erb '''

===Controller===
We modify the existing list function in the tree_display_controller.rb as it is responsible for all the inputs on the tree display page. We also add a new function filter in the file which parses the input string given by the user and converts it into a meaningful string depending on what user wants to filter. Filter is called by list function and the filter/search string is placed into a global variable, so that future operations can make use of the previous search.
'''tree_display_controller.rb '''

===Model===
We have made changes to the following models to search/filter for the keyword in corresponding nodes.-

'''questionnaire_node.rb '''
'''assignment_node.rb '''
'''course_node.rb '''
'''node.rb '''
'''folder_node.rb '''

All the models have the same logic to parse the input search string and accordingly find the nodes in the model objects. The design is extensible and controller is left skinny which just does the parsing of input string and calls a generic model function. The summary is given below

The view takes the string and passes to controller

'''User -> input string -> Controller. '''

Controller does the parsing and calls a generic function which iterates over folders.

'''Controller -> search string -> Models(Iterator) '''
'''Iterator -> Controller -> View(display) '''

Model returns the required nodes and controller handles them to view. The code which has been put in all model objects is generic. The same code can be used with future nodes or new folders when they are added in future.

The controller code remains generic and it only needs to include a new case which specifies the new filter. This way we can extend the same controller and model code later for future searches. By adding the code in this manner, we have introduced maximum cohesion as all search/filter functionality always uses the same code.

== External Links ==

:1. [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza]

:2. [http://152.46.20.83:3000/ VCL Link]

:3. [https://github.com/prateeky1407/expertiza Git repository]

:4. [https://docs.google.com/a/ncsu.edu/document/d/1Z0xjFZu-Zy-xm73YyUVUgFCtfWgRwhN1rZuThoyF-U0/edit Steps to setup Expertiza]

CSC/ECE 517 Fall 2013/oss paa

2013-10-30T17:52:23Z

Pyadav:

'''Expertiza OSS Project –E809 (TreeDisplay)'''

__TOC__
== Introduction ==
The [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza] project has a collapsible tree view structure to facilitate traversal through all learning objects. The problem statement is to redesign the underlying structure and include efficient search, filter and sort mechanism in the tree view structure. The tree is composed of different folders namely Assignments, Courses, Questionnaires and their subfolders respectively.

==Existing Design==
Currently the folders structure is displayed as a tree. The structure of the tree is as follows -

: • Questionnaire

:: o Review

:: o Metareview

:: o Author Feedback

:: o Teammate Review

:: o Survey

:: o Global Survey

:: o Course Evaluation

: • Courses

:: o Course

:::  assignment

: • Assignments

The whole set of Courses, Assignments and Questionnaires are displayed on screen in a collapsible tree view upon login. Items may be expanded and collapsed. There is no functionality to search/filter results.
The sort functionality has been provided which sorts the tree structure with important metrics such as creation date, name and directory in ascending as well as descending order.
We also have the option to view either the public and private items or the private items only.

'''[[File:ExistingUI.jpg]]'''

Fig.1 Existing UI which implements display of nodes and a sort utility

==Project Requirement==
The tree display can be inefficient given many objects (courses, etc.). We are supposed to design the underlying structure at the model level to efficiently retrieve organized data.

We are also required to redesign the view to enable users to filter/search and sort by important metrics such as creation date, name (alphabetical) and relationship (e.g. filter all assignments by a course).

The interface should be kept modular in the code to increase extensibility for future metrics. We have to keep the controller as ‘skinny’ as possible, leaving the model to perform computational logic.

==Implementation==
We have introduced two new features - search and filter.
To implement the search/filter, we have decided to use the same tree display which is efficient and simple to show the current data.

'''[[File:newUI.jpg]]'''

Fig.2 Above is the new UI which includes search and filter functionality

===Search===
This functionality searches for a keyword among 3 categories courses/assignment/questionnaire. It is implemented using substring search. All the entries whose substring matches with the search string are returned. Based on the input the user can view the filtered results in any of the 3 categories.

'''[[File:sample1.jpg]]'''

Fig.3 A sample output of searching “demo” in assignments.

===Filter===
There are 2 main relationships in the tree structure. These are as follows -

: 1. A course can have many assignments.

: 2. An assignment can have many questionnaires.

If the user selects one of the two fields and enters the course/assignment name, Then he can see a list of all the elements which are related to that course/assignment.

'''[[File:sample2.jpg]]'''

Fig.4 Sample output which shows the result of filtering assignments by course “CourseTest1”

===Compatibility with existing features===
A user can search all assignments for a respective course, and also search for all questionnaires related to one assignment, Also a search can be performed on all the nodes. We preserve the sort feature across the implementation which means that the user can sort the filtered/search results also. The user can also view the public and private items or the private items only for the filtered/search results.

'''[[File:sample3.jpg]]'''

Fig.5 Sample output which shows the same result of searching “demo” in assignments but sorted in descending order.

==Design==
===View===
Since the tree display is the best way to show the folder structure and to maximize code reuse, we choose the same display style for search results. We add search and filter boxes to input the search/filter keyword on the main page and output the result on the same page. We also add the reset button to reset the filter/search and display all the results again.
All the above changes are done in -
''' \view \tree_display\_page_header.html.erb '''

===Controller===
We modify the existing list function in the tree_display_controller.rb as it is responsible for all the inputs on the tree display page. We also add a new function filter in the file which parses the input string given by the user and converts it into a meaningful string depending on what user wants to filter. Filter is called by list function and the filter/search string is placed into a global variable, so that future operations can make use of the previous search.
'''tree_display_controller.rb '''

===Model===
We have made changes to the following models to search/filter for the keyword in corresponding nodes.-

'''questionnaire_node.rb '''
'''assignment_node.rb '''
'''course_node.rb '''
'''node.rb '''
'''folder_node.rb '''

All the models have the same logic to parse the input search string and accordingly find the nodes in the model objects. The design is extensible and controller is left skinny which just does the parsing of input string and calls a generic model function. The summary is given below

The view takes the string and passes to controller

'''User -> input string -> Controller. '''

Controller does the parsing and calls a generic function which iterates over folders.

'''Controller -> search string -> Models(Iterator) '''
'''Iterator -> Controller -> View(display) '''

Model returns the required nodes and controller handles them to view. The code which has been put in all model objects is generic. The same code can be used with future nodes or new folders when they are added in future.

The controller code remains generic and it only needs to include a new case which specifies the new filter. This way we can extend the same controller and model code later for future searches. By adding the code in this manner, we have introduced maximum cohesion as all search/filter functionality always uses the same code.

== External Links ==

:1. [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza]

:2. [http://152.46.20.83:3000/ VCL Link]

:3. [https://github.com/prateeky1407/expertiza Git repository]

:4. [https://docs.google.com/a/ncsu.edu/document/d/1Z0xjFZu-Zy-xm73YyUVUgFCtfWgRwhN1rZuThoyF-U0/edit Steps to setup Expertiza]

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-19T01:36:09Z

Pyadav: /* Shoes */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver.<ref name=one >http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules</ref> Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.<ref name=two>http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)</ref>
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 300, :height => 200 do
para "Hello World!!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application.It starts up a Shoes app window. This is the starting place for making a Shoes program. The parameters passed to it are the width and height of the window in pixels.Inside the block,we can fill the window with various Shoes elements.It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."<ref>http://ruby.about.com/od/shoes/ss/shoes1_2.htm</ref><ref>http://shoesrb.com/manual/App.html</ref>

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.<ref name=two />

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries:
** [http://en.wikipedia.org/wiki/Cairo_(graphics) Cairo ]– for device independent API using vector graphics
** [http://en.wikipedia.org/wiki/Pango Pango] – for full-function rendering of text
** Ruby – for programming
*Shoes is one of a kind,with its very own layout mechanisms “stack” and “flow”.<ref name=six >http://pragtob.wordpress.com/2013/07/17/shoes-4-a-progress-report/</ref>

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.The default backend implementation uses JRuby + SWT, but there also is a proof of concept backend in Qt.<ref name=six />
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to Shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.<ref name=six />

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.<ref name=eight >http://www.fxruby.org/</ref>
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.<ref>https://code.google.com/p/fox-toolkit/</ref>
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.

==Advantages==

* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics<ref>http://rubydoc.info/github/larskanis/fxruby/1.6/</ref>

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==

FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.

The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.<ref name=one />

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface. <ref>http://www.tutorialspoint.com/ruby/ruby_tk_guide.htm</ref>
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>

:Line by line walkthrough

<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.

<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk we can create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In this program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.

<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.

<pre>
Tk.mainloop
</pre>
:Finally, we call main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.<ref>http://en.wikipedia.org/wiki/Qt_%28framework%29</ref>

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture.<ref>http://lists.qt.nokia.com/public/qt5-feedback/2011-October/001622.html</ref> Qt5 brings significant improvements to the speed and ease of developing user interfaces.<ref>http://blog.qt.digia.com/blog/2011/05/09/thoughts-about-qt-5/</ref> Here is a code snippet to create a Hello world window using QtRuby.

<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough

<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.

<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments

<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.

<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).

<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.

<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==

*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==

*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing.<ref name=seven >http://ruby.about.com/od/gui/a/wxwidgets.htm</ref> There are several benefits of using WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator.<ref name=seven />It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-

<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>

: line by line walkthrough

<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.

<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp

<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. the third parameter of the Wx::Frame constructor is the text to display in the title bar. The string "Application" will be displayed in the title bar of our window, as well as in the task bar. After creating a widget, you must call show on it or it won't be shown.

<pre>
app = MyApp.new
app.main_loop
</pre>
:This simply creates an instance of MyApp, then calls the method main_loop on it which ends when you click the close button.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==

*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface. <ref>http://en.wikipedia.org/wiki/GTK</ref>
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>

:Line by line walk trough

<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==

The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==

*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
<references />

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-19T01:35:40Z

Pyadav: /* Shoes */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver.<ref name=one >http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules</ref> Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.<ref name=two>http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit) shoes</ref>
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 300, :height => 200 do
para "Hello World!!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application.It starts up a Shoes app window. This is the starting place for making a Shoes program. The parameters passed to it are the width and height of the window in pixels.Inside the block,we can fill the window with various Shoes elements.It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."<ref>http://ruby.about.com/od/shoes/ss/shoes1_2.htm</ref><ref>http://shoesrb.com/manual/App.html</ref>

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.<ref name=two />

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries:
** [http://en.wikipedia.org/wiki/Cairo_(graphics) Cairo ]– for device independent API using vector graphics
** [http://en.wikipedia.org/wiki/Pango Pango] – for full-function rendering of text
** Ruby – for programming
*Shoes is one of a kind,with its very own layout mechanisms “stack” and “flow”.<ref name=six >http://pragtob.wordpress.com/2013/07/17/shoes-4-a-progress-report/</ref>

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.The default backend implementation uses JRuby + SWT, but there also is a proof of concept backend in Qt.<ref name=six />
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to Shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.<ref name=six />

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.<ref name=eight >http://www.fxruby.org/</ref>
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.<ref>https://code.google.com/p/fox-toolkit/</ref>
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.

==Advantages==

* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics<ref>http://rubydoc.info/github/larskanis/fxruby/1.6/</ref>

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==

FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.

The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.<ref name=one />

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface. <ref>http://www.tutorialspoint.com/ruby/ruby_tk_guide.htm</ref>
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>

:Line by line walkthrough

<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.

<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk we can create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In this program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.

<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.

<pre>
Tk.mainloop
</pre>
:Finally, we call main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.<ref>http://en.wikipedia.org/wiki/Qt_%28framework%29</ref>

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture.<ref>http://lists.qt.nokia.com/public/qt5-feedback/2011-October/001622.html</ref> Qt5 brings significant improvements to the speed and ease of developing user interfaces.<ref>http://blog.qt.digia.com/blog/2011/05/09/thoughts-about-qt-5/</ref> Here is a code snippet to create a Hello world window using QtRuby.

<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough

<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.

<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments

<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.

<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).

<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.

<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==

*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==

*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing.<ref name=seven >http://ruby.about.com/od/gui/a/wxwidgets.htm</ref> There are several benefits of using WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator.<ref name=seven />It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-

<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>

: line by line walkthrough

<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.

<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp

<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. the third parameter of the Wx::Frame constructor is the text to display in the title bar. The string "Application" will be displayed in the title bar of our window, as well as in the task bar. After creating a widget, you must call show on it or it won't be shown.

<pre>
app = MyApp.new
app.main_loop
</pre>
:This simply creates an instance of MyApp, then calls the method main_loop on it which ends when you click the close button.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==

*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface. <ref>http://en.wikipedia.org/wiki/GTK</ref>
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>

:Line by line walk trough

<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==

The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==

*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
<references />

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-19T00:55:00Z

Pyadav: /* Cool Features */

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-19T00:50:50Z

Pyadav: /* ffi-tk */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver.<ref name=one >http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules</ref> Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.<ref name=two>http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)</ref>
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 300, :height => 200 do
para "Hello World!!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application.It starts up a Shoes app window. This is the starting place for making a Shoes program. The parameters passed to it are the width and height of the window in pixels.Inside the block,we can fill the window with various Shoes elements.It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."<ref>http://ruby.about.com/od/shoes/ss/shoes1_2.htm</ref><ref>http://shoesrb.com/manual/App.html</ref>

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.<ref name=two />

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries<ref>http://rubydoc.info/gems/shoes/frames</ref>:
** [http://en.wikipedia.org/wiki/Cairo_(graphics) Cairo ]– for device independent API using vector graphics
** [http://en.wikipedia.org/wiki/Pango Pango] – for full-function rendering of text
** Ruby – for programming
*Shoes is one of a kind,with its very own layout mechanisms “stack” and “flow”.<ref name=six >http://pragtob.wordpress.com/2013/07/17/shoes-4-a-progress-report/</ref>

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.The default backend implementation uses JRuby + SWT, but there also is a proof of concept backend in Qt.<ref name=six />
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to Shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.<ref name=six />

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.<ref name=eight >http://www.fxruby.org/</ref>
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.<ref>https://code.google.com/p/fox-toolkit/</ref>
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.

==Advantages==

* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics<ref>http://rubydoc.info/github/larskanis/fxruby/1.6/</ref>

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==

FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.

The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.<ref name=one />

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface. <ref>http://www.tutorialspoint.com/ruby/ruby_tk_guide.htm</ref>
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>

:Line by line walkthrough

<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.

<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk we can create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In this program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.

<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.

<pre>
Tk.mainloop
</pre>
:Finally, we call main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.<ref>http://en.wikipedia.org/wiki/Qt_%28framework%29</ref>

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture.<ref>http://lists.qt.nokia.com/public/qt5-feedback/2011-October/001622.html</ref> Qt5 brings significant improvements to the speed and ease of developing user interfaces.<ref>http://blog.qt.digia.com/blog/2011/05/09/thoughts-about-qt-5/</ref> Here is a code snippet to create a Hello world window using QtRuby.

<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough

<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.

<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments

<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.

<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).

<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.

<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==

*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==

*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing.<ref name=seven >http://ruby.about.com/od/gui/a/wxwidgets.htm</ref> There are several benefits of using WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator.<ref name=seven />It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-

<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>

: line by line walkthrough

<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.

<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp

<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. the third parameter of the Wx::Frame constructor is the text to display in the title bar. The string "Application" will be displayed in the title bar of our window, as well as in the task bar. After creating a widget, you must call show on it or it won't be shown.

<pre>
app = MyApp.new
app.main_loop
</pre>
:This simply creates an instance of MyApp, then calls the method main_loop on it which ends when you click the close button.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==

*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface. <ref>http://en.wikipedia.org/wiki/GTK</ref>
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>

:Line by line walk trough

<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==

The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==

*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
<references />

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-19T00:50:07Z

Pyadav:

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver.<ref name=one >http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules</ref> Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.<ref name=two>http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)</ref>
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 300, :height => 200 do
para "Hello World!!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application.It starts up a Shoes app window. This is the starting place for making a Shoes program. The parameters passed to it are the width and height of the window in pixels.Inside the block,we can fill the window with various Shoes elements.It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."<ref>http://ruby.about.com/od/shoes/ss/shoes1_2.htm</ref><ref>http://shoesrb.com/manual/App.html</ref>

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.<ref name=two />

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries<ref>http://rubydoc.info/gems/shoes/frames</ref>:
** [http://en.wikipedia.org/wiki/Cairo_(graphics) Cairo ]– for device independent API using vector graphics
** [http://en.wikipedia.org/wiki/Pango Pango] – for full-function rendering of text
** Ruby – for programming
*Shoes is one of a kind,with its very own layout mechanisms “stack” and “flow”.<ref name=six >http://pragtob.wordpress.com/2013/07/17/shoes-4-a-progress-report/</ref>

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.The default backend implementation uses JRuby + SWT, but there also is a proof of concept backend in Qt.<ref name=six />
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to Shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.<ref name=six />

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.<ref name=eight >http://www.fxruby.org/</ref>
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.<ref>https://code.google.com/p/fox-toolkit/</ref>
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.

==Advantages==

* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics<ref>http://rubydoc.info/github/larskanis/fxruby/1.6/</ref>

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==

FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.

The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.<ref>http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules/Tk</ref>

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface. <ref>http://www.tutorialspoint.com/ruby/ruby_tk_guide.htm</ref>
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>

:Line by line walkthrough

<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.

<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk we can create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In this program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.

<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.

<pre>
Tk.mainloop
</pre>
:Finally, we call main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.<ref>http://en.wikipedia.org/wiki/Qt_%28framework%29</ref>

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture.<ref>http://lists.qt.nokia.com/public/qt5-feedback/2011-October/001622.html</ref> Qt5 brings significant improvements to the speed and ease of developing user interfaces.<ref>http://blog.qt.digia.com/blog/2011/05/09/thoughts-about-qt-5/</ref> Here is a code snippet to create a Hello world window using QtRuby.

<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough

<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.

<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments

<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.

<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).

<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.

<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==

*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==

*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing.<ref name=seven >http://ruby.about.com/od/gui/a/wxwidgets.htm</ref> There are several benefits of using WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator.<ref name=seven />It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-

<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>

: line by line walkthrough

<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.

<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp

<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. the third parameter of the Wx::Frame constructor is the text to display in the title bar. The string "Application" will be displayed in the title bar of our window, as well as in the task bar. After creating a widget, you must call show on it or it won't be shown.

<pre>
app = MyApp.new
app.main_loop
</pre>
:This simply creates an instance of MyApp, then calls the method main_loop on it which ends when you click the close button.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==

*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface. <ref>http://en.wikipedia.org/wiki/GTK</ref>
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>

:Line by line walk trough

<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==

The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==

*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
<references />

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-19T00:49:43Z

Pyadav: /* ffi-tk */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver.<ref>http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules</ref> Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.<ref name=two>http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)</ref>
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 300, :height => 200 do
para "Hello World!!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application.It starts up a Shoes app window. This is the starting place for making a Shoes program. The parameters passed to it are the width and height of the window in pixels.Inside the block,we can fill the window with various Shoes elements.It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."<ref>http://ruby.about.com/od/shoes/ss/shoes1_2.htm</ref><ref>http://shoesrb.com/manual/App.html</ref>

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.<ref name=two />

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries<ref>http://rubydoc.info/gems/shoes/frames</ref>:
** [http://en.wikipedia.org/wiki/Cairo_(graphics) Cairo ]– for device independent API using vector graphics
** [http://en.wikipedia.org/wiki/Pango Pango] – for full-function rendering of text
** Ruby – for programming
*Shoes is one of a kind,with its very own layout mechanisms “stack” and “flow”.<ref name=six >http://pragtob.wordpress.com/2013/07/17/shoes-4-a-progress-report/</ref>

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.The default backend implementation uses JRuby + SWT, but there also is a proof of concept backend in Qt.<ref name=six />
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to Shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.<ref name=six />

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.<ref name=eight >http://www.fxruby.org/</ref>
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.<ref>https://code.google.com/p/fox-toolkit/</ref>
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.

==Advantages==

* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics<ref>http://rubydoc.info/github/larskanis/fxruby/1.6/</ref>

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==

FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.

The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.<ref>http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules/Tk</ref>

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface. <ref>http://www.tutorialspoint.com/ruby/ruby_tk_guide.htm</ref>
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>

:Line by line walkthrough

<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.

<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk we can create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In this program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.

<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.

<pre>
Tk.mainloop
</pre>
:Finally, we call main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.<ref>http://en.wikipedia.org/wiki/Qt_%28framework%29</ref>

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture.<ref>http://lists.qt.nokia.com/public/qt5-feedback/2011-October/001622.html</ref> Qt5 brings significant improvements to the speed and ease of developing user interfaces.<ref>http://blog.qt.digia.com/blog/2011/05/09/thoughts-about-qt-5/</ref> Here is a code snippet to create a Hello world window using QtRuby.

<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough

<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.

<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments

<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.

<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).

<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.

<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==

*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==

*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing.<ref name=seven >http://ruby.about.com/od/gui/a/wxwidgets.htm</ref> There are several benefits of using WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator.<ref name=seven />It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-

<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>

: line by line walkthrough

<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.

<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp

<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. the third parameter of the Wx::Frame constructor is the text to display in the title bar. The string "Application" will be displayed in the title bar of our window, as well as in the task bar. After creating a widget, you must call show on it or it won't be shown.

<pre>
app = MyApp.new
app.main_loop
</pre>
:This simply creates an instance of MyApp, then calls the method main_loop on it which ends when you click the close button.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==

*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface. <ref>http://en.wikipedia.org/wiki/GTK</ref>
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>

:Line by line walk trough

<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==

The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==

*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
<references />

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-19T00:48:58Z

Pyadav: /* Shoes 4 */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver.<ref>http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules</ref> Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.<ref name=two>http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)</ref>
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 300, :height => 200 do
para "Hello World!!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application.It starts up a Shoes app window. This is the starting place for making a Shoes program. The parameters passed to it are the width and height of the window in pixels.Inside the block,we can fill the window with various Shoes elements.It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."<ref>http://ruby.about.com/od/shoes/ss/shoes1_2.htm</ref><ref>http://shoesrb.com/manual/App.html</ref>

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.<ref name=two />

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries<ref>http://rubydoc.info/gems/shoes/frames</ref>:
** [http://en.wikipedia.org/wiki/Cairo_(graphics) Cairo ]– for device independent API using vector graphics
** [http://en.wikipedia.org/wiki/Pango Pango] – for full-function rendering of text
** Ruby – for programming
*Shoes is one of a kind,with its very own layout mechanisms “stack” and “flow”.<ref name=six >http://pragtob.wordpress.com/2013/07/17/shoes-4-a-progress-report/</ref>

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.The default backend implementation uses JRuby + SWT, but there also is a proof of concept backend in Qt.<ref name=six />
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to Shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.<ref name=six />

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.<ref name=eight >http://www.fxruby.org/</ref>
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.<ref>https://code.google.com/p/fox-toolkit/</ref>
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.

==Advantages==

* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics<ref>http://rubydoc.info/github/larskanis/fxruby/1.6/</ref>

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==

FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.

The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.<ref>http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules/Tk</ref>

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface. <ref>http://www.tutorialspoint.com/ruby/ruby_tk_guide.htm</ref>
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>

:Line by line walkthrough

<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.

<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk we can create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In this program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.

<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.

<pre>
Tk.mainloop
</pre>
:Finally, we call main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.<ref>http://en.wikipedia.org/wiki/Qt_%28framework%29</ref>

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture.<ref>http://lists.qt.nokia.com/public/qt5-feedback/2011-October/001622.html</ref> Qt5 brings significant improvements to the speed and ease of developing user interfaces.<ref>http://blog.qt.digia.com/blog/2011/05/09/thoughts-about-qt-5/</ref> Here is a code snippet to create a Hello world window using QtRuby.

<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough

<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.

<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments

<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.

<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).

<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.

<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==

*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==

*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing.<ref name=seven >http://ruby.about.com/od/gui/a/wxwidgets.htm</ref> There are several benefits of using WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator.<ref name=seven />It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-

<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>

: line by line walkthrough

<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.

<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp

<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. the third parameter of the Wx::Frame constructor is the text to display in the title bar. The string "Application" will be displayed in the title bar of our window, as well as in the task bar. After creating a widget, you must call show on it or it won't be shown.

<pre>
app = MyApp.new
app.main_loop
</pre>
:This simply creates an instance of MyApp, then calls the method main_loop on it which ends when you click the close button.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==

*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface. <ref>http://en.wikipedia.org/wiki/GTK</ref>
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>

:Line by line walk trough

<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==

The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==

*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
<references />

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-19T00:47:45Z

Pyadav: /* GTK+ */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver.<ref>http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules</ref> Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.<ref name=two>http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)</ref>
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 300, :height => 200 do
para "Hello World!!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application.It starts up a Shoes app window. This is the starting place for making a Shoes program. The parameters passed to it are the width and height of the window in pixels.Inside the block,we can fill the window with various Shoes elements.It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."<ref>http://ruby.about.com/od/shoes/ss/shoes1_2.htm</ref><ref>http://shoesrb.com/manual/App.html</ref>

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.<ref name=two />

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries<ref>http://rubydoc.info/gems/shoes/frames</ref>:
** [http://en.wikipedia.org/wiki/Cairo_(graphics) Cairo ]– for device independent API using vector graphics
** [http://en.wikipedia.org/wiki/Pango Pango] – for full-function rendering of text
** Ruby – for programming
*Shoes is one of a kind,with its very own layout mechanisms “stack” and “flow”.<ref name=six >http://pragtob.wordpress.com/2013/07/17/shoes-4-a-progress-report/</ref>

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.The default backend implementation uses JRuby + SWT, but there also is a proof of concept backend in Qt.<ref>http://pragtob.wordpress.com/2013/07/17/shoes-4-a-progress-report/</ref>
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to Shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.<ref name=six />

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.<ref name=eight >http://www.fxruby.org/</ref>
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.<ref>https://code.google.com/p/fox-toolkit/</ref>
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.

==Advantages==

* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics<ref>http://rubydoc.info/github/larskanis/fxruby/1.6/</ref>

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==

FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.

The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.<ref>http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules/Tk</ref>

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface. <ref>http://www.tutorialspoint.com/ruby/ruby_tk_guide.htm</ref>
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>

:Line by line walkthrough

<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.

<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk we can create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In this program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.

<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.

<pre>
Tk.mainloop
</pre>
:Finally, we call main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.<ref>http://en.wikipedia.org/wiki/Qt_%28framework%29</ref>

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture.<ref>http://lists.qt.nokia.com/public/qt5-feedback/2011-October/001622.html</ref> Qt5 brings significant improvements to the speed and ease of developing user interfaces.<ref>http://blog.qt.digia.com/blog/2011/05/09/thoughts-about-qt-5/</ref> Here is a code snippet to create a Hello world window using QtRuby.

<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough

<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.

<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments

<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.

<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).

<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.

<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==

*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==

*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing.<ref name=seven >http://ruby.about.com/od/gui/a/wxwidgets.htm</ref> There are several benefits of using WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator.<ref name=seven />It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-

<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>

: line by line walkthrough

<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.

<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp

<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. the third parameter of the Wx::Frame constructor is the text to display in the title bar. The string "Application" will be displayed in the title bar of our window, as well as in the task bar. After creating a widget, you must call show on it or it won't be shown.

<pre>
app = MyApp.new
app.main_loop
</pre>
:This simply creates an instance of MyApp, then calls the method main_loop on it which ends when you click the close button.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==

*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface. <ref>http://en.wikipedia.org/wiki/GTK</ref>
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>

:Line by line walk trough

<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==

The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==

*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
<references />

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-19T00:47:09Z

Pyadav: /* FxRuby */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver.<ref>http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules</ref> Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.<ref name=two>http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)</ref>
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 300, :height => 200 do
para "Hello World!!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application.It starts up a Shoes app window. This is the starting place for making a Shoes program. The parameters passed to it are the width and height of the window in pixels.Inside the block,we can fill the window with various Shoes elements.It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."<ref>http://ruby.about.com/od/shoes/ss/shoes1_2.htm</ref><ref>http://shoesrb.com/manual/App.html</ref>

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.<ref name=two />

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries<ref>http://rubydoc.info/gems/shoes/frames</ref>:
** [http://en.wikipedia.org/wiki/Cairo_(graphics) Cairo ]– for device independent API using vector graphics
** [http://en.wikipedia.org/wiki/Pango Pango] – for full-function rendering of text
** Ruby – for programming
*Shoes is one of a kind,with its very own layout mechanisms “stack” and “flow”.<ref name=six >http://pragtob.wordpress.com/2013/07/17/shoes-4-a-progress-report/</ref>

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.The default backend implementation uses JRuby + SWT, but there also is a proof of concept backend in Qt.<ref>http://pragtob.wordpress.com/2013/07/17/shoes-4-a-progress-report/</ref>
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to Shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.<ref name=six />

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.<ref name=eight >http://www.fxruby.org/</ref>
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.<ref>https://code.google.com/p/fox-toolkit/</ref>
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.

==Advantages==

* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics<ref>http://rubydoc.info/github/larskanis/fxruby/1.6/</ref>

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==

FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.

The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.<ref>http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules/Tk</ref>

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface. <ref>http://www.tutorialspoint.com/ruby/ruby_tk_guide.htm</ref>
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>

:Line by line walkthrough

<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.

<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk we can create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In this program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.

<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.

<pre>
Tk.mainloop
</pre>
:Finally, we call main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.<ref>http://en.wikipedia.org/wiki/Qt_%28framework%29</ref>

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture.<ref>http://lists.qt.nokia.com/public/qt5-feedback/2011-October/001622.html</ref> Qt5 brings significant improvements to the speed and ease of developing user interfaces.<ref>http://blog.qt.digia.com/blog/2011/05/09/thoughts-about-qt-5/</ref> Here is a code snippet to create a Hello world window using QtRuby.

<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough

<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.

<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments

<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.

<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).

<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.

<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==

*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==

*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing.<ref name=seven >http://ruby.about.com/od/gui/a/wxwidgets.htm</ref> There are several benefits of using WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator.<ref name=seven />It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-

<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>

: line by line walkthrough

<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.

<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp

<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. the third parameter of the Wx::Frame constructor is the text to display in the title bar. The string "Application" will be displayed in the title bar of our window, as well as in the task bar. After creating a widget, you must call show on it or it won't be shown.

<pre>
app = MyApp.new
app.main_loop
</pre>
:This simply creates an instance of MyApp, then calls the method main_loop on it which ends when you click the close button.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==

*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface. <ref>http://en.wikipedia.org/wiki/GTK</ref>
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>
<ref>http://ruby-gnome.sourceforge.net/programming/hello.html</ref>

:Line by line walk trough

<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==

The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==

*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
<references />

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-19T00:46:39Z

Pyadav: /* FxRuby */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver.<ref>http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules</ref> Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.<ref name=two>http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)</ref>
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 300, :height => 200 do
para "Hello World!!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application.It starts up a Shoes app window. This is the starting place for making a Shoes program. The parameters passed to it are the width and height of the window in pixels.Inside the block,we can fill the window with various Shoes elements.It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."<ref>http://ruby.about.com/od/shoes/ss/shoes1_2.htm</ref><ref>http://shoesrb.com/manual/App.html</ref>

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.<ref name=two />

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries<ref>http://rubydoc.info/gems/shoes/frames</ref>:
** [http://en.wikipedia.org/wiki/Cairo_(graphics) Cairo ]– for device independent API using vector graphics
** [http://en.wikipedia.org/wiki/Pango Pango] – for full-function rendering of text
** Ruby – for programming
*Shoes is one of a kind,with its very own layout mechanisms “stack” and “flow”.<ref name=six >http://pragtob.wordpress.com/2013/07/17/shoes-4-a-progress-report/</ref>

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.The default backend implementation uses JRuby + SWT, but there also is a proof of concept backend in Qt.<ref>http://pragtob.wordpress.com/2013/07/17/shoes-4-a-progress-report/</ref>
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to Shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.<ref name=six />

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.<ref = eight >http://www.fxruby.org/</ref>
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.<ref>https://code.google.com/p/fox-toolkit/</ref>
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.

==Advantages==

* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics<ref>http://rubydoc.info/github/larskanis/fxruby/1.6/</ref>

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==

FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.

The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.<ref>http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules/Tk</ref>

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface. <ref>http://www.tutorialspoint.com/ruby/ruby_tk_guide.htm</ref>
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>

:Line by line walkthrough

<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.

<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk we can create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In this program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.

<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.

<pre>
Tk.mainloop
</pre>
:Finally, we call main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.<ref>http://en.wikipedia.org/wiki/Qt_%28framework%29</ref>

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture.<ref>http://lists.qt.nokia.com/public/qt5-feedback/2011-October/001622.html</ref> Qt5 brings significant improvements to the speed and ease of developing user interfaces.<ref>http://blog.qt.digia.com/blog/2011/05/09/thoughts-about-qt-5/</ref> Here is a code snippet to create a Hello world window using QtRuby.

<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough

<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.

<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments

<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.

<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).

<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.

<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==

*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==

*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing.<ref name=seven >http://ruby.about.com/od/gui/a/wxwidgets.htm</ref> There are several benefits of using WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator.<ref name=seven />It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-

<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>

: line by line walkthrough

<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.

<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp

<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. the third parameter of the Wx::Frame constructor is the text to display in the title bar. The string "Application" will be displayed in the title bar of our window, as well as in the task bar. After creating a widget, you must call show on it or it won't be shown.

<pre>
app = MyApp.new
app.main_loop
</pre>
:This simply creates an instance of MyApp, then calls the method main_loop on it which ends when you click the close button.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==

*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface. <ref>http://en.wikipedia.org/wiki/GTK</ref>
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>
<ref>http://ruby-gnome.sourceforge.net/programming/hello.html</ref>

:Line by line walk trough

<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==

The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==

*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
<references />

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-19T00:44:47Z

Pyadav: /* wxRuby */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver.<ref>http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules</ref> Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.<ref name=two>http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)</ref>
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 300, :height => 200 do
para "Hello World!!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application.It starts up a Shoes app window. This is the starting place for making a Shoes program. The parameters passed to it are the width and height of the window in pixels.Inside the block,we can fill the window with various Shoes elements.It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."<ref>http://ruby.about.com/od/shoes/ss/shoes1_2.htm</ref><ref>http://shoesrb.com/manual/App.html</ref>

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.<ref name=two />

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries<ref>http://rubydoc.info/gems/shoes/frames</ref>:
** [http://en.wikipedia.org/wiki/Cairo_(graphics) Cairo ]– for device independent API using vector graphics
** [http://en.wikipedia.org/wiki/Pango Pango] – for full-function rendering of text
** Ruby – for programming
*Shoes is one of a kind,with its very own layout mechanisms “stack” and “flow”.<ref name=six >http://pragtob.wordpress.com/2013/07/17/shoes-4-a-progress-report/</ref>

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.The default backend implementation uses JRuby + SWT, but there also is a proof of concept backend in Qt.<ref>http://pragtob.wordpress.com/2013/07/17/shoes-4-a-progress-report/</ref>
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to Shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.<ref name=six />

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.<ref>http://www.fxruby.org/</ref>
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.<ref>https://code.google.com/p/fox-toolkit/</ref>
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre><ref>http://www.fxruby.org/doc/tutorial1.html</ref>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.

==Advantages==

* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics<ref>http://rubydoc.info/github/larskanis/fxruby/1.6/</ref>

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==

FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.

The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.<ref>http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules/Tk</ref>

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface. <ref>http://www.tutorialspoint.com/ruby/ruby_tk_guide.htm</ref>
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>

:Line by line walkthrough

<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.

<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk we can create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In this program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.

<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.

<pre>
Tk.mainloop
</pre>
:Finally, we call main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.<ref>http://en.wikipedia.org/wiki/Qt_%28framework%29</ref>

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture.<ref>http://lists.qt.nokia.com/public/qt5-feedback/2011-October/001622.html</ref> Qt5 brings significant improvements to the speed and ease of developing user interfaces.<ref>http://blog.qt.digia.com/blog/2011/05/09/thoughts-about-qt-5/</ref> Here is a code snippet to create a Hello world window using QtRuby.

<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough

<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.

<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments

<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.

<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).

<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.

<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==

*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==

*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing.<ref name=seven >http://ruby.about.com/od/gui/a/wxwidgets.htm</ref> There are several benefits of using WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator.<ref name=seven />It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-

<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>

: line by line walkthrough

<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.

<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp

<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. the third parameter of the Wx::Frame constructor is the text to display in the title bar. The string "Application" will be displayed in the title bar of our window, as well as in the task bar. After creating a widget, you must call show on it or it won't be shown.

<pre>
app = MyApp.new
app.main_loop
</pre>
:This simply creates an instance of MyApp, then calls the method main_loop on it which ends when you click the close button.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==

*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface. <ref>http://en.wikipedia.org/wiki/GTK</ref>
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>
<ref>http://ruby-gnome.sourceforge.net/programming/hello.html</ref>

:Line by line walk trough

<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==

The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==

*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
<references />

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-19T00:42:58Z

Pyadav: /* Shoes 4 */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver.<ref>http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules</ref> Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.<ref name=two>http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)</ref>
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 300, :height => 200 do
para "Hello World!!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application.It starts up a Shoes app window. This is the starting place for making a Shoes program. The parameters passed to it are the width and height of the window in pixels.Inside the block,we can fill the window with various Shoes elements.It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."<ref>http://ruby.about.com/od/shoes/ss/shoes1_2.htm</ref><ref>http://shoesrb.com/manual/App.html</ref>

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.<ref name=two />

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries<ref>http://rubydoc.info/gems/shoes/frames</ref>:
** [http://en.wikipedia.org/wiki/Cairo_(graphics) Cairo ]– for device independent API using vector graphics
** [http://en.wikipedia.org/wiki/Pango Pango] – for full-function rendering of text
** Ruby – for programming
*Shoes is one of a kind,with its very own layout mechanisms “stack” and “flow”.<ref name=six >http://pragtob.wordpress.com/2013/07/17/shoes-4-a-progress-report/</ref>

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.The default backend implementation uses JRuby + SWT, but there also is a proof of concept backend in Qt.<ref>http://pragtob.wordpress.com/2013/07/17/shoes-4-a-progress-report/</ref>
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to Shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.<ref name=six />

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.<ref>http://www.fxruby.org/</ref>
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.<ref>https://code.google.com/p/fox-toolkit/</ref>
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre><ref>http://www.fxruby.org/doc/tutorial1.html</ref>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.

==Advantages==

* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics<ref>http://rubydoc.info/github/larskanis/fxruby/1.6/</ref>

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==

FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.

The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.<ref>http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules/Tk</ref>

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface. <ref>http://www.tutorialspoint.com/ruby/ruby_tk_guide.htm</ref>
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>

:Line by line walkthrough

<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.

<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk we can create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In this program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.

<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.

<pre>
Tk.mainloop
</pre>
:Finally, we call main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.<ref>http://en.wikipedia.org/wiki/Qt_%28framework%29</ref>

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture.<ref>http://lists.qt.nokia.com/public/qt5-feedback/2011-October/001622.html</ref> Qt5 brings significant improvements to the speed and ease of developing user interfaces.<ref>http://blog.qt.digia.com/blog/2011/05/09/thoughts-about-qt-5/</ref> Here is a code snippet to create a Hello world window using QtRuby.

<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough

<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.

<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments

<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.

<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).

<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.

<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==

*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==

*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing.<ref>http://ruby.about.com/od/gui/a/wxwidgets.htm</ref> There are several benefits of using WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator.<ref>http://ruby.about.com/od/gui/a/wxwidgets.htm</ref> It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-

<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>

: line by line walkthrough

<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.

<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp

<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. the third parameter of the Wx::Frame constructor is the text to display in the title bar. The string "Application" will be displayed in the title bar of our window, as well as in the task bar. After creating a widget, you must call show on it or it won't be shown.

<pre>
app = MyApp.new
app.main_loop
</pre>
:This simply creates an instance of MyApp, then calls the method main_loop on it which ends when you click the close button.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==

*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface. <ref>http://en.wikipedia.org/wiki/GTK</ref>
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>
<ref>http://ruby-gnome.sourceforge.net/programming/hello.html</ref>

:Line by line walk trough

<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==

The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==

*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
<references />

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-19T00:42:04Z

Pyadav: /* Cool Features */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver.<ref>http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules</ref> Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.<ref name=two>http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)</ref>
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 300, :height => 200 do
para "Hello World!!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application.It starts up a Shoes app window. This is the starting place for making a Shoes program. The parameters passed to it are the width and height of the window in pixels.Inside the block,we can fill the window with various Shoes elements.It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."<ref>http://ruby.about.com/od/shoes/ss/shoes1_2.htm</ref><ref>http://shoesrb.com/manual/App.html</ref>

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.<ref name=two />

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries<ref>http://rubydoc.info/gems/shoes/frames</ref>:
** [http://en.wikipedia.org/wiki/Cairo_(graphics) Cairo ]– for device independent API using vector graphics
** [http://en.wikipedia.org/wiki/Pango Pango] – for full-function rendering of text
** Ruby – for programming
*Shoes is one of a kind,with its very own layout mechanisms “stack” and “flow”.<ref name=six >http://pragtob.wordpress.com/2013/07/17/shoes-4-a-progress-report/</ref>

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.The default backend implementation uses JRuby + SWT, but there also is a proof of concept backend in Qt.<ref>http://pragtob.wordpress.com/2013/07/17/shoes-4-a-progress-report/</ref>
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to Shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.<ref>https://github.com/shoes/shoes</ref>

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.<ref>http://www.fxruby.org/</ref>
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.<ref>https://code.google.com/p/fox-toolkit/</ref>
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre><ref>http://www.fxruby.org/doc/tutorial1.html</ref>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.

==Advantages==

* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics<ref>http://rubydoc.info/github/larskanis/fxruby/1.6/</ref>

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==

FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.

The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.<ref>http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules/Tk</ref>

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface. <ref>http://www.tutorialspoint.com/ruby/ruby_tk_guide.htm</ref>
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>

:Line by line walkthrough

<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.

<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk we can create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In this program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.

<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.

<pre>
Tk.mainloop
</pre>
:Finally, we call main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.<ref>http://en.wikipedia.org/wiki/Qt_%28framework%29</ref>

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture.<ref>http://lists.qt.nokia.com/public/qt5-feedback/2011-October/001622.html</ref> Qt5 brings significant improvements to the speed and ease of developing user interfaces.<ref>http://blog.qt.digia.com/blog/2011/05/09/thoughts-about-qt-5/</ref> Here is a code snippet to create a Hello world window using QtRuby.

<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough

<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.

<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments

<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.

<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).

<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.

<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==

*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==

*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing.<ref>http://ruby.about.com/od/gui/a/wxwidgets.htm</ref> There are several benefits of using WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator.<ref>http://ruby.about.com/od/gui/a/wxwidgets.htm</ref> It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-

<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>

: line by line walkthrough

<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.

<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp

<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. the third parameter of the Wx::Frame constructor is the text to display in the title bar. The string "Application" will be displayed in the title bar of our window, as well as in the task bar. After creating a widget, you must call show on it or it won't be shown.

<pre>
app = MyApp.new
app.main_loop
</pre>
:This simply creates an instance of MyApp, then calls the method main_loop on it which ends when you click the close button.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==

*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface. <ref>http://en.wikipedia.org/wiki/GTK</ref>
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>
<ref>http://ruby-gnome.sourceforge.net/programming/hello.html</ref>

:Line by line walk trough

<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==

The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==

*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
<references />

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-19T00:41:09Z

Pyadav: /* Versions */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver.<ref>http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules</ref> Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.<ref name=two>http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)</ref>
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 300, :height => 200 do
para "Hello World!!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application.It starts up a Shoes app window. This is the starting place for making a Shoes program. The parameters passed to it are the width and height of the window in pixels.Inside the block,we can fill the window with various Shoes elements.It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."<ref>http://ruby.about.com/od/shoes/ss/shoes1_2.htm</ref><ref>http://shoesrb.com/manual/App.html</ref>

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.<ref name=two />

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries<ref>http://rubydoc.info/gems/shoes/frames</ref>:
** [http://en.wikipedia.org/wiki/Cairo_(graphics) Cairo ]– for device independent API using vector graphics
** [http://en.wikipedia.org/wiki/Pango Pango] – for full-function rendering of text
** Ruby – for programming
*Shoes is one of a kind,with its very own layout mechanisms “stack” and “flow”.<ref>http://pragtob.wordpress.com/2013/07/17/shoes-4-a-progress-report/</ref>

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.The default backend implementation uses JRuby + SWT, but there also is a proof of concept backend in Qt.<ref>http://pragtob.wordpress.com/2013/07/17/shoes-4-a-progress-report/</ref>
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to Shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.<ref>https://github.com/shoes/shoes</ref>

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.<ref>http://www.fxruby.org/</ref>
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.<ref>https://code.google.com/p/fox-toolkit/</ref>
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre><ref>http://www.fxruby.org/doc/tutorial1.html</ref>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.

==Advantages==

* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics<ref>http://rubydoc.info/github/larskanis/fxruby/1.6/</ref>

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==

FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.

The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.<ref>http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules/Tk</ref>

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface. <ref>http://www.tutorialspoint.com/ruby/ruby_tk_guide.htm</ref>
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>

:Line by line walkthrough

<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.

<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk we can create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In this program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.

<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.

<pre>
Tk.mainloop
</pre>
:Finally, we call main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.<ref>http://en.wikipedia.org/wiki/Qt_%28framework%29</ref>

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture.<ref>http://lists.qt.nokia.com/public/qt5-feedback/2011-October/001622.html</ref> Qt5 brings significant improvements to the speed and ease of developing user interfaces.<ref>http://blog.qt.digia.com/blog/2011/05/09/thoughts-about-qt-5/</ref> Here is a code snippet to create a Hello world window using QtRuby.

<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough

<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.

<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments

<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.

<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).

<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.

<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==

*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==

*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing.<ref>http://ruby.about.com/od/gui/a/wxwidgets.htm</ref> There are several benefits of using WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator.<ref>http://ruby.about.com/od/gui/a/wxwidgets.htm</ref> It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-

<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>

: line by line walkthrough

<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.

<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp

<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. the third parameter of the Wx::Frame constructor is the text to display in the title bar. The string "Application" will be displayed in the title bar of our window, as well as in the task bar. After creating a widget, you must call show on it or it won't be shown.

<pre>
app = MyApp.new
app.main_loop
</pre>
:This simply creates an instance of MyApp, then calls the method main_loop on it which ends when you click the close button.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==

*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface. <ref>http://en.wikipedia.org/wiki/GTK</ref>
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>
<ref>http://ruby-gnome.sourceforge.net/programming/hello.html</ref>

:Line by line walk trough

<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==

The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==

*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
<references />

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-19T00:40:17Z

Pyadav: /* Shoes */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver.<ref>http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules</ref> Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.<ref name=two>http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)</ref>
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 300, :height => 200 do
para "Hello World!!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application.It starts up a Shoes app window. This is the starting place for making a Shoes program. The parameters passed to it are the width and height of the window in pixels.Inside the block,we can fill the window with various Shoes elements.It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."<ref>http://ruby.about.com/od/shoes/ss/shoes1_2.htm</ref><ref>http://shoesrb.com/manual/App.html</ref>

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.<ref>http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)</ref>

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries<ref>http://rubydoc.info/gems/shoes/frames</ref>:
** [http://en.wikipedia.org/wiki/Cairo_(graphics) Cairo ]– for device independent API using vector graphics
** [http://en.wikipedia.org/wiki/Pango Pango] – for full-function rendering of text
** Ruby – for programming
*Shoes is one of a kind,with its very own layout mechanisms “stack” and “flow”.<ref>http://pragtob.wordpress.com/2013/07/17/shoes-4-a-progress-report/</ref>

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.The default backend implementation uses JRuby + SWT, but there also is a proof of concept backend in Qt.<ref>http://pragtob.wordpress.com/2013/07/17/shoes-4-a-progress-report/</ref>
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to Shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.<ref>https://github.com/shoes/shoes</ref>

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.<ref>http://www.fxruby.org/</ref>
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.<ref>https://code.google.com/p/fox-toolkit/</ref>
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre><ref>http://www.fxruby.org/doc/tutorial1.html</ref>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.

==Advantages==

* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics<ref>http://rubydoc.info/github/larskanis/fxruby/1.6/</ref>

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==

FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.

The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.<ref>http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules/Tk</ref>

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface. <ref>http://www.tutorialspoint.com/ruby/ruby_tk_guide.htm</ref>
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>

:Line by line walkthrough

<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.

<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk we can create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In this program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.

<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.

<pre>
Tk.mainloop
</pre>
:Finally, we call main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.<ref>http://en.wikipedia.org/wiki/Qt_%28framework%29</ref>

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture.<ref>http://lists.qt.nokia.com/public/qt5-feedback/2011-October/001622.html</ref> Qt5 brings significant improvements to the speed and ease of developing user interfaces.<ref>http://blog.qt.digia.com/blog/2011/05/09/thoughts-about-qt-5/</ref> Here is a code snippet to create a Hello world window using QtRuby.

<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough

<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.

<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments

<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.

<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).

<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.

<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==

*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==

*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing.<ref>http://ruby.about.com/od/gui/a/wxwidgets.htm</ref> There are several benefits of using WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator.<ref>http://ruby.about.com/od/gui/a/wxwidgets.htm</ref> It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-

<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>

: line by line walkthrough

<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.

<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp

<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. the third parameter of the Wx::Frame constructor is the text to display in the title bar. The string "Application" will be displayed in the title bar of our window, as well as in the task bar. After creating a widget, you must call show on it or it won't be shown.

<pre>
app = MyApp.new
app.main_loop
</pre>
:This simply creates an instance of MyApp, then calls the method main_loop on it which ends when you click the close button.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==

*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface. <ref>http://en.wikipedia.org/wiki/GTK</ref>
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>
<ref>http://ruby-gnome.sourceforge.net/programming/hello.html</ref>

:Line by line walk trough

<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==

The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==

*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
<references />

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-18T17:26:24Z

Pyadav: /* ffi-tk */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver.<ref>http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules</ref> Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.<ref>http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)</ref>
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 200, :height => 140 do
para "Hello World!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application. The parameters passed to it are the width and height of the window in pixels. It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries:
** Cairo – for drawing
** Pango – for text
** Ruby – for programming

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.
==Advantages==
* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==
FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.
The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.<ref>http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules/Tk</ref>

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface. <ref>http://www.tutorialspoint.com/ruby/ruby_tk_guide.htm</ref>
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>
:Line by line walkthrough
<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.
<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk we can create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In this program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.
<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.
<pre>
Tk.mainloop
</pre>
:Finally, we call main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.<ref>http://en.wikipedia.org/wiki/Qt_%28framework%29</ref>

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture.<ref>http://lists.qt.nokia.com/public/qt5-feedback/2011-October/001622.html</ref> Qt5 brings significant improvements to the speed and ease of developing user interfaces.<ref>http://blog.qt.digia.com/blog/2011/05/09/thoughts-about-qt-5/</ref> Here is a code snippet to create a Hello world window using QtRuby.
<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough
<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.
<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments
<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.
<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).
<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.
<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==
*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==
*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing.<ref>http://ruby.about.com/od/gui/a/wxwidgets.htm</ref> There are several benefits of using WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator.<ref>http://ruby.about.com/od/gui/a/wxwidgets.htm</ref> It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-
<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>
: line by line walkthrough
<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.
<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp
<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. the third parameter of the Wx::Frame constructor is the text to display in the title bar. The string "Application" will be displayed in the title bar of our window, as well as in the task bar. After creating a widget, you must call show on it or it won't be shown.
<pre>
app = MyApp.new
app.main_loop
</pre>
:This simply creates an instance of MyApp, then calls the method main_loop on it which ends when you click the close button.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==
*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface.
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>

:Line by line walktrough
<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==
The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==
*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
<references />

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-18T17:22:48Z

Pyadav: /* wxRuby */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver.<ref>http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules</ref> Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.<ref>http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)</ref>
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 200, :height => 140 do
para "Hello World!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application. The parameters passed to it are the width and height of the window in pixels. It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries:
** Cairo – for drawing
** Pango – for text
** Ruby – for programming

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.
==Advantages==
* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==
FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.
The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.<ref>http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules/Tk</ref>

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface. <ref>http://www.tutorialspoint.com/ruby/ruby_tk_guide.htm</ref>
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>
:Line by line walkthrough
<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.
<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk you create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In our program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.
<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.
<pre>
Tk.mainloop
</pre>
:Finally, we pack the root frame and enter the main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.<ref>http://en.wikipedia.org/wiki/Qt_%28framework%29</ref>

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture.<ref>http://lists.qt.nokia.com/public/qt5-feedback/2011-October/001622.html</ref> Qt5 brings significant improvements to the speed and ease of developing user interfaces.<ref>http://blog.qt.digia.com/blog/2011/05/09/thoughts-about-qt-5/</ref> Here is a code snippet to create a Hello world window using QtRuby.
<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough
<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.
<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments
<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.
<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).
<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.
<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==
*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==
*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing.<ref>http://ruby.about.com/od/gui/a/wxwidgets.htm</ref> There are several benefits of using WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator.<ref>http://ruby.about.com/od/gui/a/wxwidgets.htm</ref> It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-
<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>
: line by line walkthrough
<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.
<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp
<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. the third parameter of the Wx::Frame constructor is the text to display in the title bar. The string "Application" will be displayed in the title bar of our window, as well as in the task bar. After creating a widget, you must call show on it or it won't be shown.
<pre>
app = MyApp.new
app.main_loop
</pre>
:This simply creates an instance of MyApp, then calls the method main_loop on it which ends when you click the close button.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==
*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface.
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>

:Line by line walktrough
<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==
The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==
*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
<references />

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-18T17:21:55Z

Pyadav: /* wxRuby */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver.<ref>http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules</ref> Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.<ref>[http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)]</ref>
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 200, :height => 140 do
para "Hello World!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application. The parameters passed to it are the width and height of the window in pixels. It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries:
** Cairo – for drawing
** Pango – for text
** Ruby – for programming

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.
==Advantages==
* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==
FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.
The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.<ref>http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules/Tk</ref>

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface. <ref>http://www.tutorialspoint.com/ruby/ruby_tk_guide.htm</ref>
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>
:Line by line walkthrough
<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.
<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk you create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In our program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.
<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.
<pre>
Tk.mainloop
</pre>
:Finally, we pack the root frame and enter the main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.<ref>http://en.wikipedia.org/wiki/Qt_%28framework%29</ref>

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture.<ref>http://lists.qt.nokia.com/public/qt5-feedback/2011-October/001622.html</ref> Qt5 brings significant improvements to the speed and ease of developing user interfaces.<ref>http://blog.qt.digia.com/blog/2011/05/09/thoughts-about-qt-5/</ref> Here is a code snippet to create a Hello world window using QtRuby.
<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough
<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.
<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments
<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.
<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).
<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.
<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==
*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==
*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing.<ref>http://ruby.about.com/od/gui/a/wxwidgets.htm</ref> There are several benefits of using WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator.<ref>http://ruby.about.com/od/gui/a/wxwidgets.htm</ref> It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-
<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>
: line by line walkthrough
<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.
<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp
<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. the third parameter of the Wx::Frame constructor is the text to display in the title :bar. The string "Application" will be displayed in the title bar of our window, as well as in the task bar. After creating a widget, you must call show on it or it won't be shown.
<pre>
app = MyApp.new
app.main_loop
</pre>
:This simply creates an instance of MyApp, then calls the method main_loop on it which ends when you click the close button.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==
*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface.
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>

:Line by line walktrough
<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==
The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==
*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
<references />

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-18T17:19:18Z

Pyadav: /* wxRuby */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver.<ref>[http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules]</ref> Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.<ref>[http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)]</ref>
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 200, :height => 140 do
para "Hello World!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application. The parameters passed to it are the width and height of the window in pixels. It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries:
** Cairo – for drawing
** Pango – for text
** Ruby – for programming

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.
==Advantages==
* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==
FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.
The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.<ref>http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules/Tk</ref>

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface. <ref>http://www.tutorialspoint.com/ruby/ruby_tk_guide.htm</ref>
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>
:Line by line walkthrough
<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.
<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk you create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In our program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.
<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.
<pre>
Tk.mainloop
</pre>
:Finally, we pack the root frame and enter the main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.<ref>http://en.wikipedia.org/wiki/Qt_%28framework%29</ref>

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture.<ref>http://lists.qt.nokia.com/public/qt5-feedback/2011-October/001622.html</ref> Qt5 brings significant improvements to the speed and ease of developing user interfaces.<ref>http://blog.qt.digia.com/blog/2011/05/09/thoughts-about-qt-5/</ref> Here is a code snippet to create a Hello world window using QtRuby.
<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough
<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.
<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments
<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.
<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).
<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.
<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==
*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==
*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing.<ref>http://ruby.about.com/od/gui/a/wxwidgets.htm</ref> There are several benefits of using WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator.<ref>http://ruby.about.com/od/gui/a/wxwidgets.htm</ref> It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-
<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>
: line by line walkthrough
<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.
<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp
<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. the third parameter of the Wx::Frame constructor is the text to display in the title :bar. The string "Application" will be displayed in the title bar of our window, as well as in the task bar.
<pre>
app = MyApp.new
app.main_loop
</pre>
:Finally, after creating a widget, you must call show on it or it won't be shown. Though you may want to wait to do this for some things (such as popup windows), since this is a simple single-widget application, doing this in the on_init :method is appropriate.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==
*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface.
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>

:Line by line walktrough
<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==
The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==
*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
<references />

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-18T17:18:16Z

Pyadav: /* wxRuby */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver.<ref>[http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules]</ref> Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.<ref>[http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)]</ref>
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 200, :height => 140 do
para "Hello World!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application. The parameters passed to it are the width and height of the window in pixels. It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries:
** Cairo – for drawing
** Pango – for text
** Ruby – for programming

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.
==Advantages==
* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==
FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.
The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.<ref>http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules/Tk</ref>

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface. <ref>http://www.tutorialspoint.com/ruby/ruby_tk_guide.htm</ref>
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>
:Line by line walkthrough
<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.
<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk you create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In our program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.
<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.
<pre>
Tk.mainloop
</pre>
:Finally, we pack the root frame and enter the main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.<ref>http://en.wikipedia.org/wiki/Qt_%28framework%29</ref>

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture.<ref>http://lists.qt.nokia.com/public/qt5-feedback/2011-October/001622.html</ref> Qt5 brings significant improvements to the speed and ease of developing user interfaces.<ref>http://blog.qt.digia.com/blog/2011/05/09/thoughts-about-qt-5/</ref> Here is a code snippet to create a Hello world window using QtRuby.
<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough
<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.
<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments
<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.
<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).
<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.
<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==
*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==
*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing.<ref>http://ruby.about.com/od/gui/a/wxwidgets.htm</ref> There are several benefits of using WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator.<ref>http://ruby.about.com/od/gui/a/wxwidgets.htm</ref> It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-
<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>
: line by line walkthrough
<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.
<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp
<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. the third parameter of the Wx::Frame constructor is the text to display in the title :bar. The string "Application" will be displayed in the title bar of our window, as well as in the task bar.
<pre>
app = MyApp.new
app.main_loop
</pre>
:Finally, after creating a widget, you must call show on it or it won't be shown. Though you may want to wait to do this :for some things (such as popup windows), since this is a simple single-widget application, doing this in the on_init :method is appropriate.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==
*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface.
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>

:Line by line walktrough
<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==
The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==
*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
<references />

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-18T17:17:42Z

Pyadav: /* wxRuby */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver.<ref>[http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules]</ref> Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.<ref>[http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)]</ref>
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 200, :height => 140 do
para "Hello World!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application. The parameters passed to it are the width and height of the window in pixels. It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries:
** Cairo – for drawing
** Pango – for text
** Ruby – for programming

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.
==Advantages==
* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==
FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.
The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.<ref>http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules/Tk</ref>

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface. <ref>http://www.tutorialspoint.com/ruby/ruby_tk_guide.htm</ref>
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>
:Line by line walkthrough
<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.
<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk you create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In our program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.
<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.
<pre>
Tk.mainloop
</pre>
:Finally, we pack the root frame and enter the main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.<ref>http://en.wikipedia.org/wiki/Qt_%28framework%29</ref>

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture.<ref>http://lists.qt.nokia.com/public/qt5-feedback/2011-October/001622.html</ref> Qt5 brings significant improvements to the speed and ease of developing user interfaces.<ref>http://blog.qt.digia.com/blog/2011/05/09/thoughts-about-qt-5/</ref> Here is a code snippet to create a Hello world window using QtRuby.
<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough
<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.
<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments
<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.
<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).
<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.
<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==
*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==
*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing.<ref>http://ruby.about.com/od/gui/a/wxwidgets.htm</ref> There are several benefits of using WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator.<ref>http://ruby.about.com/od/gui/a/wxwidgets.htm</ref> It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-
<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>
: line by line walkthrough
<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.
<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp
<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets.
the third parameter of the Wx::Frame constructor is the text to display in the title :bar. The string "Application" will be displayed in the title bar of our window, as well as in the task bar.
<pre>
app = MyApp.new
app.main_loop
</pre>
:Finally, after creating a widget, you must call show on it or it won't be shown. Though you may want to wait to do this :for some things (such as popup windows), since this is a simple single-widget application, doing this in the on_init :method is appropriate.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==
*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface.
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>

:Line by line walktrough
<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==
The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==
*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
<references />

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-18T17:15:43Z

Pyadav: /* wxRuby */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver.<ref>[http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules]</ref> Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.<ref>[http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)]</ref>
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 200, :height => 140 do
para "Hello World!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application. The parameters passed to it are the width and height of the window in pixels. It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries:
** Cairo – for drawing
** Pango – for text
** Ruby – for programming

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.
==Advantages==
* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==
FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.
The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.<ref>http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules/Tk</ref>

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface. <ref>http://www.tutorialspoint.com/ruby/ruby_tk_guide.htm</ref>
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>
:Line by line walkthrough
<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.
<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk you create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In our program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.
<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.
<pre>
Tk.mainloop
</pre>
:Finally, we pack the root frame and enter the main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.<ref>http://en.wikipedia.org/wiki/Qt_%28framework%29</ref>

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture.<ref>http://lists.qt.nokia.com/public/qt5-feedback/2011-October/001622.html</ref> Qt5 brings significant improvements to the speed and ease of developing user interfaces.<ref>http://blog.qt.digia.com/blog/2011/05/09/thoughts-about-qt-5/</ref> Here is a code snippet to create a Hello world window using QtRuby.
<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough
<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.
<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments
<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.
<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).
<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.
<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==
*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==
*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing.<ref>http://ruby.about.com/od/gui/a/wxwidgets.htm</ref> There are several benefits of using WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator.<ref>http://ruby.about.com/od/gui/a/wxwidgets.htm</ref> It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-
<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>
: line by line walkthrough
<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.
<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp
<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. Though since :we're not putting any other widgets in it, we're simply using it to display an empty window.
:the third parameter of the Wx::Frame constructor (not necessarily all constructors) is the text to display in the title :bar. Our rather non-descriptive string "Application" will be displayed in the title bar of our window, as well as in the :task bar.
<pre>
app = MyApp.new
app.main_loop
</pre>
:Finally, after creating a widget, you must call show on it or it won't be shown. Though you may want to wait to do this :for some things (such as popup windows), since this is a simple single-widget application, doing this in the on_init :method is appropriate.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==
*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface.
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>

:Line by line walktrough
<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==
The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==
*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
<references />

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-18T17:12:16Z

Pyadav: /* QtRuby */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver.<ref>[http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules GUI Toolkit Modules]</ref> Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 200, :height => 140 do
para "Hello World!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application. The parameters passed to it are the width and height of the window in pixels. It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries:
** Cairo – for drawing
** Pango – for text
** Ruby – for programming

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.
==Advantages==
* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==
FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.
The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.<ref>http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules/Tk</ref>

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface. <ref>http://www.tutorialspoint.com/ruby/ruby_tk_guide.htm</ref>
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>
:Line by line walkthrough
<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.
<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk you create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In our program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.
<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.
<pre>
Tk.mainloop
</pre>
:Finally, we pack the root frame and enter the main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.<ref>http://en.wikipedia.org/wiki/Qt_%28framework%29</ref>

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture.<ref>http://lists.qt.nokia.com/public/qt5-feedback/2011-October/001622.html</ref> Qt5 brings significant improvements to the speed and ease of developing user interfaces.<ref>http://blog.qt.digia.com/blog/2011/05/09/thoughts-about-qt-5/</ref> Here is a code snippet to create a Hello world window using QtRuby.
<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough
<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.
<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments
<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.
<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).
<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.
<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==
*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==
*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing. So what is the benefit of a GUI toolkit that needs yet another GUI toolkit to run? There are several.
Benefits of WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator. It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-
<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>
: line by line walkthrough
<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.
<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp
<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. Though since :we're not putting any other widgets in it, we're simply using it to display an empty window.
:the third parameter of the Wx::Frame constructor (not necessarily all constructors) is the text to display in the title :bar. Our rather non-descriptive string "Application" will be displayed in the title bar of our window, as well as in the :task bar.
<pre>
app = MyApp.new
app.main_loop
</pre>
:Finally, after creating a widget, you must call show on it or it won't be shown. Though you may want to wait to do this :for some things (such as popup windows), since this is a simple single-widget application, doing this in the on_init :method is appropriate.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==
*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface.
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>

:Line by line walktrough
<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==
The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==
*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
<references />

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-18T17:10:23Z

Pyadav: /* QtRuby */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver.<ref>[http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules GUI Toolkit Modules]</ref> Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 200, :height => 140 do
para "Hello World!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application. The parameters passed to it are the width and height of the window in pixels. It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries:
** Cairo – for drawing
** Pango – for text
** Ruby – for programming

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.
==Advantages==
* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==
FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.
The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.<ref>http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules/Tk</ref>

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface. <ref>http://www.tutorialspoint.com/ruby/ruby_tk_guide.htm</ref>
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>
:Line by line walkthrough
<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.
<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk you create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In our program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.
<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.
<pre>
Tk.mainloop
</pre>
:Finally, we pack the root frame and enter the main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.<ref>http://en.wikipedia.org/wiki/Qt_%28framework%29</ref>

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture. Qt5 brings significant improvements to the speed and ease of developing user interfaces. Here is a code snippet to create a Hello world window using QtRuby.
<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough
<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.
<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments
<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.
<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).
<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.
<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==
*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==
*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing. So what is the benefit of a GUI toolkit that needs yet another GUI toolkit to run? There are several.
Benefits of WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator. It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-
<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>
: line by line walkthrough
<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.
<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp
<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. Though since :we're not putting any other widgets in it, we're simply using it to display an empty window.
:the third parameter of the Wx::Frame constructor (not necessarily all constructors) is the text to display in the title :bar. Our rather non-descriptive string "Application" will be displayed in the title bar of our window, as well as in the :task bar.
<pre>
app = MyApp.new
app.main_loop
</pre>
:Finally, after creating a widget, you must call show on it or it won't be shown. Though you may want to wait to do this :for some things (such as popup windows), since this is a simple single-widget application, doing this in the on_init :method is appropriate.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==
*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface.
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>

:Line by line walktrough
<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==
The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==
*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
<references />

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-18T17:08:03Z

Pyadav: /* ffi-tk */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver.<ref>[http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules GUI Toolkit Modules]</ref> Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 200, :height => 140 do
para "Hello World!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application. The parameters passed to it are the width and height of the window in pixels. It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries:
** Cairo – for drawing
** Pango – for text
** Ruby – for programming

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.
==Advantages==
* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==
FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.
The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.<ref>http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules/Tk</ref>

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface. <ref>http://www.tutorialspoint.com/ruby/ruby_tk_guide.htm</ref>
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>
:Line by line walkthrough
<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.
<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk you create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In our program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.
<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.
<pre>
Tk.mainloop
</pre>
:Finally, we pack the root frame and enter the main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture. Qt5 brings significant improvements to the speed and ease of developing user interfaces. Here is a code snippet to create a Hello world window using QtRuby.
<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough
<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.
<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments
<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.
<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).
<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.
<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==
*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==
*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing. So what is the benefit of a GUI toolkit that needs yet another GUI toolkit to run? There are several.
Benefits of WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator. It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-
<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>
: line by line walkthrough
<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.
<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp
<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. Though since :we're not putting any other widgets in it, we're simply using it to display an empty window.
:the third parameter of the Wx::Frame constructor (not necessarily all constructors) is the text to display in the title :bar. Our rather non-descriptive string "Application" will be displayed in the title bar of our window, as well as in the :task bar.
<pre>
app = MyApp.new
app.main_loop
</pre>
:Finally, after creating a widget, you must call show on it or it won't be shown. Though you may want to wait to do this :for some things (such as popup windows), since this is a simple single-widget application, doing this in the on_init :method is appropriate.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==
*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface.
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>

:Line by line walktrough
<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==
The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==
*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
<references />

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-18T17:06:47Z

Pyadav: /* ffi-tk */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver. Ruby bindings are available for several widget toolkits. Commonly used tools are described below.<ref>[http://en.wikipedia.org/wiki/Ruby Ruby]</ref>

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 200, :height => 140 do
para "Hello World!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application. The parameters passed to it are the width and height of the window in pixels. It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries:
** Cairo – for drawing
** Pango – for text
** Ruby – for programming

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.
==Advantages==
* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==
FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.
The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.<ref>http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules/Tk</ref>

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface. <ref>http://www.tutorialspoint.com/ruby/ruby_tk_guide.htm</ref>
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>
:Line by Line Walkthrough
<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.
<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk you create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In our program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.
<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.
<pre>
Tk.mainloop
</pre>
:Finally, we pack the root frame and enter the main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture. Qt5 brings significant improvements to the speed and ease of developing user interfaces. Here is a code snippet to create a Hello world window using QtRuby.
<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough
<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.
<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments
<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.
<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).
<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.
<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==
*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==
*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing. So what is the benefit of a GUI toolkit that needs yet another GUI toolkit to run? There are several.
Benefits of WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator. It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-
<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>
: line by line walkthrough
<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.
<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp
<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. Though since :we're not putting any other widgets in it, we're simply using it to display an empty window.
:the third parameter of the Wx::Frame constructor (not necessarily all constructors) is the text to display in the title :bar. Our rather non-descriptive string "Application" will be displayed in the title bar of our window, as well as in the :task bar.
<pre>
app = MyApp.new
app.main_loop
</pre>
:Finally, after creating a widget, you must call show on it or it won't be shown. Though you may want to wait to do this :for some things (such as popup windows), since this is a simple single-widget application, doing this in the on_init :method is appropriate.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==
*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface.
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>

:Line by line walktrough
<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==
The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==
*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
<references />

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-18T17:05:31Z

Pyadav: /* ffi-tk */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver. Ruby bindings are available for several widget toolkits. Commonly used tools are described below.<ref>[http://en.wikipedia.org/wiki/Ruby Ruby]</ref>

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 200, :height => 140 do
para "Hello World!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application. The parameters passed to it are the width and height of the window in pixels. It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries:
** Cairo – for drawing
** Pango – for text
** Ruby – for programming

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.
==Advantages==
* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==
FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.
The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface. <ref>http://www.tutorialspoint.com/ruby/ruby_tk_guide.htm</ref>
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>
:Line by Line Walkthrough
<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.
<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk you create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In our program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.
<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.
<pre>
Tk.mainloop
</pre>
:Finally, we pack the root frame and enter the main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture. Qt5 brings significant improvements to the speed and ease of developing user interfaces. Here is a code snippet to create a Hello world window using QtRuby.
<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough
<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.
<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments
<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.
<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).
<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.
<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==
*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==
*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing. So what is the benefit of a GUI toolkit that needs yet another GUI toolkit to run? There are several.
Benefits of WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator. It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-
<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>
: line by line walkthrough
<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.
<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp
<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. Though since :we're not putting any other widgets in it, we're simply using it to display an empty window.
:the third parameter of the Wx::Frame constructor (not necessarily all constructors) is the text to display in the title :bar. Our rather non-descriptive string "Application" will be displayed in the title bar of our window, as well as in the :task bar.
<pre>
app = MyApp.new
app.main_loop
</pre>
:Finally, after creating a widget, you must call show on it or it won't be shown. Though you may want to wait to do this :for some things (such as popup windows), since this is a simple single-widget application, doing this in the on_init :method is appropriate.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==
*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface.
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>

:Line by line walktrough
<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==
The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==
*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
<references />

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-17T22:35:56Z

Pyadav: /* GTK+ */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver. Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 200, :height => 140 do
para "Hello World!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application. The parameters passed to it are the width and height of the window in pixels. It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries:
** Cairo – for drawing
** Pango – for text
** Ruby – for programming

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.
==Advantages==
* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==
FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.
The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface.
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>
:Line by Line Walkthrough
<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.
<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk you create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In our program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.
<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.
<pre>
Tk.mainloop
</pre>
:Finally, we pack the root frame and enter the main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture. Qt5 brings significant improvements to the speed and ease of developing user interfaces. Here is a code snippet to create a Hello world window using QtRuby.
<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough
<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.
<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments
<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.
<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).
<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.
<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==
*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==
*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing. So what is the benefit of a GUI toolkit that needs yet another GUI toolkit to run? There are several.
Benefits of WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator. It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-
<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>
: line by line walkthrough
<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.
<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp
<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. Though since :we're not putting any other widgets in it, we're simply using it to display an empty window.
:the third parameter of the Wx::Frame constructor (not necessarily all constructors) is the text to display in the title :bar. Our rather non-descriptive string "Application" will be displayed in the title bar of our window, as well as in the :task bar.
<pre>
app = MyApp.new
app.main_loop
</pre>
:Finally, after creating a widget, you must call show on it or it won't be shown. Though you may want to wait to do this :for some things (such as popup windows), since this is a simple single-widget application, doing this in the on_init :method is appropriate.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==
*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface.
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>

:Line by line walktrough
<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==
The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==
*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
# http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules
# http://wonko.com/post/a_brief_comparison_of_cross-platform_gui_toolkits_from_rubys_per
# http://en.wikipedia.org/wiki/QtRuby
# http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)
# http://rubydoc.info/gems/shoes/frames
# http://www.fxruby.org/
# http://www.darshancomputing.com/qt4-qtruby-tutorial/chapter_01
# http://ruby.about.com/od/gui/qt/wxrubyworld.htm
# http://rubylearning.com/satishtalim/ruby_tk_tutorial.html

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-17T22:35:41Z

Pyadav: /* wxRuby */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver. Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 200, :height => 140 do
para "Hello World!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application. The parameters passed to it are the width and height of the window in pixels. It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries:
** Cairo – for drawing
** Pango – for text
** Ruby – for programming

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.
==Advantages==
* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==
FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.
The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface.
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>
:Line by Line Walkthrough
<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.
<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk you create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In our program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.
<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.
<pre>
Tk.mainloop
</pre>
:Finally, we pack the root frame and enter the main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture. Qt5 brings significant improvements to the speed and ease of developing user interfaces. Here is a code snippet to create a Hello world window using QtRuby.
<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough
<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.
<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments
<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.
<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).
<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.
<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==
*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==
*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing. So what is the benefit of a GUI toolkit that needs yet another GUI toolkit to run? There are several.
Benefits of WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator. It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-
<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>
: line by line walkthrough
<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.
<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp
<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. Though since :we're not putting any other widgets in it, we're simply using it to display an empty window.
:the third parameter of the Wx::Frame constructor (not necessarily all constructors) is the text to display in the title :bar. Our rather non-descriptive string "Application" will be displayed in the title bar of our window, as well as in the :task bar.
<pre>
app = MyApp.new
app.main_loop
</pre>
:Finally, after creating a widget, you must call show on it or it won't be shown. Though you may want to wait to do this :for some things (such as popup windows), since this is a simple single-widget application, doing this in the on_init :method is appropriate.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==
*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface.
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>

:Line by line walktrough
<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==
The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==
*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
# http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules
# http://wonko.com/post/a_brief_comparison_of_cross-platform_gui_toolkits_from_rubys_per
# http://en.wikipedia.org/wiki/QtRuby
# http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)
# http://rubydoc.info/gems/shoes/frames
# http://www.fxruby.org/
# http://www.darshancomputing.com/qt4-qtruby-tutorial/chapter_01
# http://ruby.about.com/od/gui/qt/wxrubyworld.htm
# http://rubylearning.com/satishtalim/ruby_tk_tutorial.html

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-17T22:35:28Z

Pyadav: /* QtRuby */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver. Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 200, :height => 140 do
para "Hello World!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application. The parameters passed to it are the width and height of the window in pixels. It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries:
** Cairo – for drawing
** Pango – for text
** Ruby – for programming

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.
==Advantages==
* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==
FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.
The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface.
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>
:Line by Line Walkthrough
<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.
<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk you create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In our program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.
<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.
<pre>
Tk.mainloop
</pre>
:Finally, we pack the root frame and enter the main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture. Qt5 brings significant improvements to the speed and ease of developing user interfaces. Here is a code snippet to create a Hello world window using QtRuby.
<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough
<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.
<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments
<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.
<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).
<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.
<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==
*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==
*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing. So what is the benefit of a GUI toolkit that needs yet another GUI toolkit to run? There are several.
Benefits of WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator. It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-
<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>
: line by line walkthrough
<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.
<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp
<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. Though since :we're not putting any other widgets in it, we're simply using it to display an empty window.
:the third parameter of the Wx::Frame constructor (not necessarily all constructors) is the text to display in the title :bar. Our rather non-descriptive string "Application" will be displayed in the title bar of our window, as well as in the :task bar.
<pre>
app = MyApp.new
app.main_loop
</pre>
:Finally, after creating a widget, you must call show on it or it won't be shown. Though you may want to wait to do this :for some things (such as popup windows), since this is a simple single-widget application, doing this in the on_init :method is appropriate.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==
*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface.
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>

:Line by line walktrough
<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==
The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==
*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
# http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules
# http://wonko.com/post/a_brief_comparison_of_cross-platform_gui_toolkits_from_rubys_per
# http://en.wikipedia.org/wiki/QtRuby
# http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)
# http://rubydoc.info/gems/shoes/frames
# http://www.fxruby.org/
# http://www.darshancomputing.com/qt4-qtruby-tutorial/chapter_01
# http://ruby.about.com/od/gui/qt/wxrubyworld.htm
# http://rubylearning.com/satishtalim/ruby_tk_tutorial.html

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-17T22:35:13Z

Pyadav: /* ffi-tk */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver. Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 200, :height => 140 do
para "Hello World!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application. The parameters passed to it are the width and height of the window in pixels. It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries:
** Cairo – for drawing
** Pango – for text
** Ruby – for programming

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.
==Advantages==
* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==
FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.
The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface.
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>
:Line by Line Walkthrough
<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.
<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk you create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In our program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.
<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.
<pre>
Tk.mainloop
</pre>
:Finally, we pack the root frame and enter the main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture. Qt5 brings significant improvements to the speed and ease of developing user interfaces. Here is a code snippet to create a Hello world window using QtRuby.
<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough
<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.
<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments
<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.
<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).
<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.
<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==
*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==
*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing. So what is the benefit of a GUI toolkit that needs yet another GUI toolkit to run? There are several.
Benefits of WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator. It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-
<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>
: line by line walkthrough
<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.
<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp
<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. Though since :we're not putting any other widgets in it, we're simply using it to display an empty window.
:the third parameter of the Wx::Frame constructor (not necessarily all constructors) is the text to display in the title :bar. Our rather non-descriptive string "Application" will be displayed in the title bar of our window, as well as in the :task bar.
<pre>
app = MyApp.new
app.main_loop
</pre>
:Finally, after creating a widget, you must call show on it or it won't be shown. Though you may want to wait to do this :for some things (such as popup windows), since this is a simple single-widget application, doing this in the on_init :method is appropriate.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==
*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface.
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>

:Line by line walktrough
<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==
The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==
*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
# http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules
# http://wonko.com/post/a_brief_comparison_of_cross-platform_gui_toolkits_from_rubys_per
# http://en.wikipedia.org/wiki/QtRuby
# http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)
# http://rubydoc.info/gems/shoes/frames
# http://www.fxruby.org/
# http://www.darshancomputing.com/qt4-qtruby-tutorial/chapter_01
# http://ruby.about.com/od/gui/qt/wxrubyworld.htm
# http://rubylearning.com/satishtalim/ruby_tk_tutorial.html

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-17T22:34:47Z

Pyadav: /* FxRuby */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver. Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 200, :height => 140 do
para "Hello World!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application. The parameters passed to it are the width and height of the window in pixels. It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries:
** Cairo – for drawing
** Pango – for text
** Ruby – for programming

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.
==Advantages==
* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==
FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.
The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface.
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>
:Line by Line Walkthrough
<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.
<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk you create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In our program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.
<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.
<pre>
Tk.mainloop
</pre>
:Finally, we pack the root frame and enter the main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture. Qt5 brings significant improvements to the speed and ease of developing user interfaces. Here is a code snippet to create a Hello world window using QtRuby.
<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough
<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.
<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments
<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.
<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).
<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.
<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==
*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==
*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing. So what is the benefit of a GUI toolkit that needs yet another GUI toolkit to run? There are several.
Benefits of WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator. It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-
<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>
: line by line walkthrough
<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.
<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp
<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. Though since :we're not putting any other widgets in it, we're simply using it to display an empty window.
:the third parameter of the Wx::Frame constructor (not necessarily all constructors) is the text to display in the title :bar. Our rather non-descriptive string "Application" will be displayed in the title bar of our window, as well as in the :task bar.
<pre>
app = MyApp.new
app.main_loop
</pre>
:Finally, after creating a widget, you must call show on it or it won't be shown. Though you may want to wait to do this :for some things (such as popup windows), since this is a simple single-widget application, doing this in the on_init :method is appropriate.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==
*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface.
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>

:Line by line walktrough
<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==
The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==
*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
# http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules
# http://wonko.com/post/a_brief_comparison_of_cross-platform_gui_toolkits_from_rubys_per
# http://en.wikipedia.org/wiki/QtRuby
# http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)
# http://rubydoc.info/gems/shoes/frames
# http://www.fxruby.org/
# http://www.darshancomputing.com/qt4-qtruby-tutorial/chapter_01
# http://ruby.about.com/od/gui/qt/wxrubyworld.htm
# http://rubylearning.com/satishtalim/ruby_tk_tutorial.html

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-17T22:34:13Z

Pyadav: /* GTK+ */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver. Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 200, :height => 140 do
para "Hello World!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application. The parameters passed to it are the width and height of the window in pixels. It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries:
** Cairo – for drawing
** Pango – for text
** Ruby – for programming

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.
==Advantages==
* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==
FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.
The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface.
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>
:Line by Line Walkthrough
<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.
<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk you create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In our program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.
<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.
<pre>
Tk.mainloop
</pre>
:Finally, we pack the root frame and enter the main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture. Qt5 brings significant improvements to the speed and ease of developing user interfaces. Here is a code snippet to create a Hello world window using QtRuby.
<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough
<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.
<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments
<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.
<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).
<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.
<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==
*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==
*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing. So what is the benefit of a GUI toolkit that needs yet another GUI toolkit to run? There are several.
Benefits of WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator. It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-
<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>
: line by line walkthrough
<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.
<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp
<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. Though since :we're not putting any other widgets in it, we're simply using it to display an empty window.
:the third parameter of the Wx::Frame constructor (not necessarily all constructors) is the text to display in the title :bar. Our rather non-descriptive string "Application" will be displayed in the title bar of our window, as well as in the :task bar.
<pre>
app = MyApp.new
app.main_loop
</pre>
:Finally, after creating a widget, you must call show on it or it won't be shown. Though you may want to wait to do this :for some things (such as popup windows), since this is a simple single-widget application, doing this in the on_init :method is appropriate.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==
*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface.
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>

:Line by line walktrough
<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==
The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==
*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
# http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules
# http://wonko.com/post/a_brief_comparison_of_cross-platform_gui_toolkits_from_rubys_per
# http://en.wikipedia.org/wiki/QtRuby
# http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)
# http://rubydoc.info/gems/shoes/frames
# http://www.fxruby.org/
# http://www.darshancomputing.com/qt4-qtruby-tutorial/chapter_01
# http://ruby.about.com/od/gui/qt/wxrubyworld.htm
# http://rubylearning.com/satishtalim/ruby_tk_tutorial.html

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-17T22:33:55Z

Pyadav: /* wxRuby */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver. Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 200, :height => 140 do
para "Hello World!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application. The parameters passed to it are the width and height of the window in pixels. It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries:
** Cairo – for drawing
** Pango – for text
** Ruby – for programming

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.
==Advantages==
* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==
FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.
The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface.
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>
:Line by Line Walkthrough
<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.
<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk you create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In our program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.
<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.
<pre>
Tk.mainloop
</pre>
:Finally, we pack the root frame and enter the main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture. Qt5 brings significant improvements to the speed and ease of developing user interfaces. Here is a code snippet to create a Hello world window using QtRuby.
<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough
<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.
<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments
<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.
<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).
<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.
<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==
*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==
*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing. So what is the benefit of a GUI toolkit that needs yet another GUI toolkit to run? There are several.
Benefits of WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator. It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-
<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>
: line by line walkthrough
<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.
<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp
<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. Though since :we're not putting any other widgets in it, we're simply using it to display an empty window.
:the third parameter of the Wx::Frame constructor (not necessarily all constructors) is the text to display in the title :bar. Our rather non-descriptive string "Application" will be displayed in the title bar of our window, as well as in the :task bar.
<pre>
app = MyApp.new
app.main_loop
</pre>
:Finally, after creating a widget, you must call show on it or it won't be shown. Though you may want to wait to do this :for some things (such as popup windows), since this is a simple single-widget application, doing this in the on_init :method is appropriate.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==
*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface.
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>

:Line by line walktrough
<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==
The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==
*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
# http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules
# http://wonko.com/post/a_brief_comparison_of_cross-platform_gui_toolkits_from_rubys_per
# http://en.wikipedia.org/wiki/QtRuby
# http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)
# http://rubydoc.info/gems/shoes/frames
# http://www.fxruby.org/
# http://www.darshancomputing.com/qt4-qtruby-tutorial/chapter_01
# http://ruby.about.com/od/gui/qt/wxrubyworld.htm
# http://rubylearning.com/satishtalim/ruby_tk_tutorial.html

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-17T22:33:43Z

Pyadav: /* QtRuby */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver. Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 200, :height => 140 do
para "Hello World!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application. The parameters passed to it are the width and height of the window in pixels. It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries:
** Cairo – for drawing
** Pango – for text
** Ruby – for programming

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.
==Advantages==
* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==
FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.
The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface.
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>
:Line by Line Walkthrough
<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.
<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk you create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In our program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.
<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.
<pre>
Tk.mainloop
</pre>
:Finally, we pack the root frame and enter the main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture. Qt5 brings significant improvements to the speed and ease of developing user interfaces. Here is a code snippet to create a Hello world window using QtRuby.
<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough
<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.
<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments
<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.
<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).
<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.
<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==
*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==
*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing. So what is the benefit of a GUI toolkit that needs yet another GUI toolkit to run? There are several.
Benefits of WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator. It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-
<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>
: line by line walkthrough
<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.
<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp
<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. Though since :we're not putting any other widgets in it, we're simply using it to display an empty window.
:the third parameter of the Wx::Frame constructor (not necessarily all constructors) is the text to display in the title :bar. Our rather non-descriptive string "Application" will be displayed in the title bar of our window, as well as in the :task bar.
<pre>
app = MyApp.new
app.main_loop
</pre>
:Finally, after creating a widget, you must call show on it or it won't be shown. Though you may want to wait to do this :for some things (such as popup windows), since this is a simple single-widget application, doing this in the on_init :method is appropriate.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==
*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface.
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>

:Line by line walktrough
<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==
The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==
*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
# http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules
# http://wonko.com/post/a_brief_comparison_of_cross-platform_gui_toolkits_from_rubys_per
# http://en.wikipedia.org/wiki/QtRuby
# http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)
# http://rubydoc.info/gems/shoes/frames
# http://www.fxruby.org/
# http://www.darshancomputing.com/qt4-qtruby-tutorial/chapter_01
# http://ruby.about.com/od/gui/qt/wxrubyworld.htm
# http://rubylearning.com/satishtalim/ruby_tk_tutorial.html

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-17T22:33:24Z

Pyadav: /* ffi-tk */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver. Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 200, :height => 140 do
para "Hello World!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application. The parameters passed to it are the width and height of the window in pixels. It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries:
** Cairo – for drawing
** Pango – for text
** Ruby – for programming

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.
==Advantages==
* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==
FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.
The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface.
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>
:Line by Line Walkthrough
<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.
<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk you create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In our program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.
<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.
<pre>
Tk.mainloop
</pre>
:Finally, we pack the root frame and enter the main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture. Qt5 brings significant improvements to the speed and ease of developing user interfaces. Here is a code snippet to create a Hello world window using QtRuby.
<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough
<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.
<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments
<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.
<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).
<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.
<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==
*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==
*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing. So what is the benefit of a GUI toolkit that needs yet another GUI toolkit to run? There are several.
Benefits of WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator. It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-
<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>
: line by line walkthrough
<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.
<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp
<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. Though since :we're not putting any other widgets in it, we're simply using it to display an empty window.
:the third parameter of the Wx::Frame constructor (not necessarily all constructors) is the text to display in the title :bar. Our rather non-descriptive string "Application" will be displayed in the title bar of our window, as well as in the :task bar.
<pre>
app = MyApp.new
app.main_loop
</pre>
:Finally, after creating a widget, you must call show on it or it won't be shown. Though you may want to wait to do this :for some things (such as popup windows), since this is a simple single-widget application, doing this in the on_init :method is appropriate.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==
*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface.
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>

:Line by line walktrough
<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==
The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==
*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
# http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules
# http://wonko.com/post/a_brief_comparison_of_cross-platform_gui_toolkits_from_rubys_per
# http://en.wikipedia.org/wiki/QtRuby
# http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)
# http://rubydoc.info/gems/shoes/frames
# http://www.fxruby.org/
# http://www.darshancomputing.com/qt4-qtruby-tutorial/chapter_01
# http://ruby.about.com/od/gui/qt/wxrubyworld.htm
# http://rubylearning.com/satishtalim/ruby_tk_tutorial.html

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-17T22:32:43Z

Pyadav:

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver. Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 200, :height => 140 do
para "Hello World!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application. The parameters passed to it are the width and height of the window in pixels. It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries:
** Cairo – for drawing
** Pango – for text
** Ruby – for programming

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.
==Advantages==
* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==
FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.
The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface.
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>
:Line by Line Walkthrough
<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.
<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk you create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In our program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.
<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.
<pre>
Tk.mainloop
</pre>
:Finally, we pack the root frame and enter the main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture. Qt5 brings significant improvements to the speed and ease of developing user interfaces. Here is a code snippet to create a Hello world window using QtRuby.
<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough
<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.
<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments
<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.
<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).
<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.
<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==
*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==
*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing. So what is the benefit of a GUI toolkit that needs yet another GUI toolkit to run? There are several.
Benefits of WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator. It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-
<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>
: line by line walkthrough
<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.
<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp
<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. Though since :we're not putting any other widgets in it, we're simply using it to display an empty window.
:the third parameter of the Wx::Frame constructor (not necessarily all constructors) is the text to display in the title :bar. Our rather non-descriptive string "Application" will be displayed in the title bar of our window, as well as in the :task bar.
<pre>
app = MyApp.new
app.main_loop
</pre>
:Finally, after creating a widget, you must call show on it or it won't be shown. Though you may want to wait to do this :for some things (such as popup windows), since this is a simple single-widget application, doing this in the on_init :method is appropriate.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==
*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface.
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>

:Line by line walktrough
<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==
The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==
*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
# http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules
# http://wonko.com/post/a_brief_comparison_of_cross-platform_gui_toolkits_from_rubys_per
# http://en.wikipedia.org/wiki/QtRuby
# http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)
# http://rubydoc.info/gems/shoes/frames
# http://www.fxruby.org/
# http://www.darshancomputing.com/qt4-qtruby-tutorial/chapter_01
# http://ruby.about.com/od/gui/qt/wxrubyworld.htm
# http://rubylearning.com/satishtalim/ruby_tk_tutorial.html

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-17T22:30:51Z

Pyadav: /* GTK+ */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver. Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window. This is intended to be run from Shoes itself, as is common with Shoes programs.

<pre>
Shoes.app :width => 200, :height => 140 do
para "Hello World!"
end
</pre>
:The Shoes.app method call encapsulates the entire Shoes application. The parameters passed to it are the width and height of the window in pixels. It contains all the things needed inside of the application window. In this case, a para (or "paragraph") displays the text "Hello World."

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries:
** Cairo – for drawing
** Pango – for text
** Ruby – for programming

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as [http://en.wikipedia.org/wiki/OpenGL OpenGL] widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>
:Every FXRuby program begins by creating an FXApp instance.The FXApp instance has a lot of responsibilities in an FXRuby application. One of the most frequent ways you'll use it is to start the application's main event loop.

<pre>
theMainWindow = FXMainWindow.new(theApp, "Hello")
</pre>
:The next step is to create an FXMainWindow instance to serve as the application's main window.It similar to TkRoot window in tk. Here, we pass theApp as the first argument to FXMainWindow.new to associate the new FXMainWindow instance with this FXApp. The second argument to FXMainWindow.new is a string that will be used for the main window's title.

<pre>
theApp.create
</pre>
:So far, we have instantiated the client-side objects. Unlike most other toolkits, FOX makes a distinction between client-side data and server-side. In order to create the server-side objects associated with the already-constructed client-side objects, we call FXApp#create.

<pre>
theMainWindow.show
</pre>
:By default, all windows in FXRuby programs are invisible, so we need to call our main window's show instance method.

<pre>
theApp.run
</pre>
:The last step is to start the program's main loop by calling theApp's run instance method.
==Advantages==
* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==
FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.
The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface.
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>
:Line by Line Walkthrough
<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.
<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk you create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In our program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.
<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.
<pre>
Tk.mainloop
</pre>
:Finally, we pack the root frame and enter the main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture. Qt5 brings significant improvements to the speed and ease of developing user interfaces. Here is a code snippet to create a Hello world window using QtRuby.
<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough
<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.
<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments
<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.
<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).
<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.
<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==
*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==
*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing. So what is the benefit of a GUI toolkit that needs yet another GUI toolkit to run? There are several.
Benefits of WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator. It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-
<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>
: line by line walkthrough
<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.
<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp
<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. Though since :we're not putting any other widgets in it, we're simply using it to display an empty window.
:the third parameter of the Wx::Frame constructor (not necessarily all constructors) is the text to display in the title :bar. Our rather non-descriptive string "Application" will be displayed in the title bar of our window, as well as in the :task bar.
<pre>
app = MyApp.new
app.main_loop
</pre>
:Finally, after creating a widget, you must call show on it or it won't be shown. Though you may want to wait to do this :for some things (such as popup windows), since this is a simple single-widget application, doing this in the on_init :method is appropriate.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==
*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface.
Here is a sample program using Ruby/GTK -

<pre>
require 'gtk'

window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
button = Gtk::Button.new('Hello World')
button.signal_connect('clicked') {
print "Hello World\n"
}

window.add button
button.show
window.show
Gtk.main
</pre>

:Line by line walktrough
<pre>
require 'gtk'
</pre>
:Mandatory line for all scripts which use ruby/gtk to include gtk.

<pre>
window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
</pre>
:Creates a new Gtk::Window, which is a toplevel window that can contain other widgets. Nearly always, the type of the window should beGtk::Window::TOPLEVEL. The new method creates the widget but it is not yet shown on the screen.

<pre>
button = Gtk::Button.new('Hello World')
</pre>
:Creates a widget button labeled 'Hello World'.

<pre>
button.signal_connect('clicked') {
print "Hello World\n"
</pre>
:Gtk uses signals and callbacks mechanism. Some signals are peculiar to specific widgets .e.g. `clicked' to buttons and others are common among all kinds of widgets e.g. `destroy' . Here, when a button is clicked with the pointer, `clicked' signal is emitted. When a signal is emitted, callbacks (i.e. signal handlers) associated with the signal are called.

<pre>
window.add button
</pre>
:Some widgets can contain other widgets. Such widgets are called `container widgets'. Above expression places the button on the toplevel window which is a kind of container widget.

<pre>
button.show
window.show
</pre>
:Shows each widget. Widgets need to be shown explicitly by calling show method.

<pre>
Gtk.main
</pre>
:Gtk is an event-driven toolkit. Like all GUI toolkits, GTK+ uses an event-driven programming model. When the user is doing nothing, GTK+ waits in the main loop for the input. When an action occurs, GTK calls appropriate event handler and processes the event. Once the event is processed, the control returns to the mail loop.

==Advantages==
The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==
*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
# http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules
# http://wonko.com/post/a_brief_comparison_of_cross-platform_gui_toolkits_from_rubys_per
# http://en.wikipedia.org/wiki/QtRuby
# http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)
# http://rubydoc.info/gems/shoes/frames
# http://www.fxruby.org/
# http://www.darshancomputing.com/qt4-qtruby-tutorial/chapter_01
# http://ruby.about.com/od/gui/qt/wxrubyworld.htm
# http://rubylearning.com/satishtalim/ruby_tk_tutorial.html

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-17T22:20:03Z

Pyadav: /* GTK+ */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver. Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries:
** Cairo – for drawing
** Pango – for text
** Ruby – for programming

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp.
FOX is a C++ based Toolkit for developing Graphical User Interfaces easily and effectively. It offers a wide, and growing, collection of Controls, and provides state of the art facilities such as drag and drop, selection, as well as OpenGL widgets for 3D graphical manipulation. FOX uses a number of techniques to speed up drawing and spatial layout of the GUI. Memory is conserved by allowing programmers to create and destroy GUI elements on the fly.
The example below is a simple "Hello World" program. It will display the message "Hello World" in a window.

<pre>
require 'fox16'
include Fox
theApp = FXApp.new
theMainWindow = FXMainWindow.new(theApp, "Hello")
theApp.create
theMainWindow.show
theApp.run
</pre>

:Line by line walk through

<pre>
require 'fox16'
</pre>
:All of the code associated with the FXRuby extension is provided by the fox16 gem.Hence, require ‘fox 16’is a mandatory statement.

<pre>
include Fox
</pre>
:Since all of the FXRuby classes are defined under the Fox module,we add an include Foxstatement so that all of the names in the Fox module are "included" into the global namespace.

<pre>
theApp = FXApp.new
</pre>

==Advantages==
* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Cool Features==
FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.
The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface.
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>
:Line by Line Walkthrough
<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.
<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk you create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In our program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.
<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.
<pre>
Tk.mainloop
</pre>
:Finally, we pack the root frame and enter the main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture. Qt5 brings significant improvements to the speed and ease of developing user interfaces. Here is a code snippet to create a Hello world window using QtRuby.
<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough
<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.
<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments
<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.
<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).
<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.
<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==
*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==
*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing. So what is the benefit of a GUI toolkit that needs yet another GUI toolkit to run? There are several.
Benefits of WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator. It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-
<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>
: line by line walkthrough
<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.
<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp
<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. Though since :we're not putting any other widgets in it, we're simply using it to display an empty window.
:the third parameter of the Wx::Frame constructor (not necessarily all constructors) is the text to display in the title :bar. Our rather non-descriptive string "Application" will be displayed in the title bar of our window, as well as in the :task bar.
<pre>
app = MyApp.new
app.main_loop
</pre>
:Finally, after creating a widget, you must call show on it or it won't be shown. Though you may want to wait to do this :for some things (such as popup windows), since this is a simple single-widget application, doing this in the on_init :method is appropriate.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==
*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the [http://en.wikipedia.org/wiki/GIMP GIMP] (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface.

==Advantages==
The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==
*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
# http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules
# http://wonko.com/post/a_brief_comparison_of_cross-platform_gui_toolkits_from_rubys_per
# http://en.wikipedia.org/wiki/QtRuby
# http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)
# http://rubydoc.info/gems/shoes/frames
# http://www.fxruby.org/
# http://www.darshancomputing.com/qt4-qtruby-tutorial/chapter_01
# http://ruby.about.com/od/gui/qt/wxrubyworld.htm
# http://rubylearning.com/satishtalim/ruby_tk_tutorial.html

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-17T22:18:00Z

Pyadav: /* QtRuby */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver. Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries:
** Cairo – for drawing
** Pango – for text
** Ruby – for programming

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp. FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Advantages==
* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.
The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface.
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>
:Line by Line Walkthrough
<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.
<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk you create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In our program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.
<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.
<pre>
Tk.mainloop
</pre>
:Finally, we pack the root frame and enter the main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture. Qt5 brings significant improvements to the speed and ease of developing user interfaces. Here is a code snippet to create a Hello world window using QtRuby.
<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough
<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.
<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments
<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.
<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).
<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.
<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==
*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==
*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing. So what is the benefit of a GUI toolkit that needs yet another GUI toolkit to run? There are several.
Benefits of WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator. It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-
<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>
: line by line walkthrough
<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.
<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp
<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. Though since :we're not putting any other widgets in it, we're simply using it to display an empty window.
:the third parameter of the Wx::Frame constructor (not necessarily all constructors) is the text to display in the title :bar. Our rather non-descriptive string "Application" will be displayed in the title bar of our window, as well as in the :task bar.
<pre>
app = MyApp.new
app.main_loop
</pre>
:Finally, after creating a widget, you must call show on it or it won't be shown. Though you may want to wait to do this :for some things (such as popup windows), since this is a simple single-widget application, doing this in the on_init :method is appropriate.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==
*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the GIMP (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface.

==Advantages==
The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==
*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
# http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules
# http://wonko.com/post/a_brief_comparison_of_cross-platform_gui_toolkits_from_rubys_per
# http://en.wikipedia.org/wiki/QtRuby
# http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)
# http://rubydoc.info/gems/shoes/frames
# http://www.fxruby.org/
# http://www.darshancomputing.com/qt4-qtruby-tutorial/chapter_01
# http://ruby.about.com/od/gui/qt/wxrubyworld.htm
# http://rubylearning.com/satishtalim/ruby_tk_tutorial.html

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-17T22:17:31Z

Pyadav: /* wxRuby */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver. Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries:
** Cairo – for drawing
** Pango – for text
** Ruby – for programming

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp. FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Advantages==
* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.
The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface.
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>
:Line by Line Walkthrough
<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.
<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk you create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In our program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.
<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.
<pre>
Tk.mainloop
</pre>
:Finally, we pack the root frame and enter the main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture. Qt5 brings significant improvements to the speed and ease of developing user interfaces. Here is a code snippet to create a Hello world window.
<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough
<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.
<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments
<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.
<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).
<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.
<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==
*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==
*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing. So what is the benefit of a GUI toolkit that needs yet another GUI toolkit to run? There are several.
Benefits of WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator. It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly.
Here is sample Hello World program using wxRuby-
<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>
: line by line walkthrough
<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.
<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp
<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. Though since :we're not putting any other widgets in it, we're simply using it to display an empty window.
:the third parameter of the Wx::Frame constructor (not necessarily all constructors) is the text to display in the title :bar. Our rather non-descriptive string "Application" will be displayed in the title bar of our window, as well as in the :task bar.
<pre>
app = MyApp.new
app.main_loop
</pre>
:Finally, after creating a widget, you must call show on it or it won't be shown. Though you may want to wait to do this :for some things (such as popup windows), since this is a simple single-widget application, doing this in the on_init :method is appropriate.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==
*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the GIMP (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface.

==Advantages==
The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==
*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
# http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules
# http://wonko.com/post/a_brief_comparison_of_cross-platform_gui_toolkits_from_rubys_per
# http://en.wikipedia.org/wiki/QtRuby
# http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)
# http://rubydoc.info/gems/shoes/frames
# http://www.fxruby.org/
# http://www.darshancomputing.com/qt4-qtruby-tutorial/chapter_01
# http://ruby.about.com/od/gui/qt/wxrubyworld.htm
# http://rubylearning.com/satishtalim/ruby_tk_tutorial.html

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-17T22:16:25Z

Pyadav: /* wxRuby */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver. Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries:
** Cairo – for drawing
** Pango – for text
** Ruby – for programming

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp. FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Advantages==
* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.
The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface.
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>
:Line by Line Walkthrough
<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.
<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk you create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In our program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.
<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.
<pre>
Tk.mainloop
</pre>
:Finally, we pack the root frame and enter the main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture. Qt5 brings significant improvements to the speed and ease of developing user interfaces. Here is a code snippet to create a Hello world window.
<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough
<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.
<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments
<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.
<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).
<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.
<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==
*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==
*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing. So what is the benefit of a GUI toolkit that needs yet another GUI toolkit to run? There are several.
Benefits of WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and [http://en.wikipedia.org/wiki/Cocoa_%28API%29 Cocoa] on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator. It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly. Here is sample Hello World program-
<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>
: line by line walkthrough
<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.
<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp
<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. Though since :we're not putting any other widgets in it, we're simply using it to display an empty window.
:the third parameter of the Wx::Frame constructor (not necessarily all constructors) is the text to display in the title :bar. Our rather non-descriptive string "Application" will be displayed in the title bar of our window, as well as in the :task bar.
<pre>
app = MyApp.new
app.main_loop
</pre>
:Finally, after creating a widget, you must call show on it or it won't be shown. Though you may want to wait to do this :for some things (such as popup windows), since this is a simple single-widget application, doing this in the on_init :method is appropriate.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==
*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the GIMP (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface.

==Advantages==
The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==
*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
# http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules
# http://wonko.com/post/a_brief_comparison_of_cross-platform_gui_toolkits_from_rubys_per
# http://en.wikipedia.org/wiki/QtRuby
# http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)
# http://rubydoc.info/gems/shoes/frames
# http://www.fxruby.org/
# http://www.darshancomputing.com/qt4-qtruby-tutorial/chapter_01
# http://ruby.about.com/od/gui/qt/wxrubyworld.htm
# http://rubylearning.com/satishtalim/ruby_tk_tutorial.html

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-17T22:11:00Z

Pyadav: /* QtRuby */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver. Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries:
** Cairo – for drawing
** Pango – for text
** Ruby – for programming

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp. FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Advantages==
* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.
The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface.
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>
:Line by Line Walkthrough
<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.
<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk you create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In our program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.
<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.
<pre>
Tk.mainloop
</pre>
:Finally, we pack the root frame and enter the main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, [http://en.wikipedia.org/wiki/QML QML] and [http://en.wikipedia.org/wiki/JavaScript JavaScript] playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture. Qt5 brings significant improvements to the speed and ease of developing user interfaces. Here is a code snippet to create a Hello world window.
<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough
<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.
<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments
<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.
<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).
<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.
<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==
*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==
*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing. So what is the benefit of a GUI toolkit that needs yet another GUI toolkit to run? There are several.
Benefits of WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and Cocoa on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator. It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly. Here is sample Hello World program-
<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>
: line by line walkthrough
<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.
<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp
<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. Though since :we're not putting any other widgets in it, we're simply using it to display an empty window.
:the third parameter of the Wx::Frame constructor (not necessarily all constructors) is the text to display in the title :bar. Our rather non-descriptive string "Application" will be displayed in the title bar of our window, as well as in the :task bar.
<pre>
app = MyApp.new
app.main_loop
</pre>
:Finally, after creating a widget, you must call show on it or it won't be shown. Though you may want to wait to do this :for some things (such as popup windows), since this is a simple single-widget application, doing this in the on_init :method is appropriate.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==
*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the GIMP (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface.

==Advantages==
The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==
*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
# http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules
# http://wonko.com/post/a_brief_comparison_of_cross-platform_gui_toolkits_from_rubys_per
# http://en.wikipedia.org/wiki/QtRuby
# http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)
# http://rubydoc.info/gems/shoes/frames
# http://www.fxruby.org/
# http://www.darshancomputing.com/qt4-qtruby-tutorial/chapter_01
# http://ruby.about.com/od/gui/qt/wxrubyworld.htm
# http://rubylearning.com/satishtalim/ruby_tk_tutorial.html

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-17T22:08:21Z

Pyadav: /* ffi-tk */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver. Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries:
** Cairo – for drawing
** Pango – for text
** Ruby – for programming

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp. FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Advantages==
* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is [http://en.wikipedia.org/wiki/Tk_%28framework%29 Tk]. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.
The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface.
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>
:Line by Line Walkthrough
<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.
<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk you create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In our program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.
<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.
<pre>
Tk.mainloop
</pre>
:Finally, we pack the root frame and enter the main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, QML and JavaScript playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture. Qt5 brings significant improvements to the speed and ease of developing user interfaces. Here is a code snippet to create a Hello world window.
<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough
<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.
<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments
<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.
<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).
<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.
<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==
*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==
*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing. So what is the benefit of a GUI toolkit that needs yet another GUI toolkit to run? There are several.
Benefits of WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and Cocoa on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator. It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly. Here is sample Hello World program-
<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>
: line by line walkthrough
<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.
<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp
<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. Though since :we're not putting any other widgets in it, we're simply using it to display an empty window.
:the third parameter of the Wx::Frame constructor (not necessarily all constructors) is the text to display in the title :bar. Our rather non-descriptive string "Application" will be displayed in the title bar of our window, as well as in the :task bar.
<pre>
app = MyApp.new
app.main_loop
</pre>
:Finally, after creating a widget, you must call show on it or it won't be shown. Though you may want to wait to do this :for some things (such as popup windows), since this is a simple single-widget application, doing this in the on_init :method is appropriate.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==
*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the GIMP (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface.

==Advantages==
The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==
*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
# http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules
# http://wonko.com/post/a_brief_comparison_of_cross-platform_gui_toolkits_from_rubys_per
# http://en.wikipedia.org/wiki/QtRuby
# http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)
# http://rubydoc.info/gems/shoes/frames
# http://www.fxruby.org/
# http://www.darshancomputing.com/qt4-qtruby-tutorial/chapter_01
# http://ruby.about.com/od/gui/qt/wxrubyworld.htm
# http://rubylearning.com/satishtalim/ruby_tk_tutorial.html

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-17T22:07:46Z

Pyadav: /* ffi-tk */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver. Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries:
** Cairo – for drawing
** Pango – for text
** Ruby – for programming

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp. FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Advantages==
* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
The standard graphical user interface (GUI) for Ruby is Tk. Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.
The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface.
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>
:Line by Line Walkthrough
<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.
<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk you create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In our program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.
<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.
<pre>
Tk.mainloop
</pre>
:Finally, we pack the root frame and enter the main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, QML and JavaScript playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture. Qt5 brings significant improvements to the speed and ease of developing user interfaces. Here is a code snippet to create a Hello world window.
<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough
<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.
<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments
<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.
<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).
<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.
<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==
*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==
*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing. So what is the benefit of a GUI toolkit that needs yet another GUI toolkit to run? There are several.
Benefits of WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and Cocoa on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator. It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly. Here is sample Hello World program-
<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>
: line by line walkthrough
<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.
<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp
<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. Though since :we're not putting any other widgets in it, we're simply using it to display an empty window.
:the third parameter of the Wx::Frame constructor (not necessarily all constructors) is the text to display in the title :bar. Our rather non-descriptive string "Application" will be displayed in the title bar of our window, as well as in the :task bar.
<pre>
app = MyApp.new
app.main_loop
</pre>
:Finally, after creating a widget, you must call show on it or it won't be shown. Though you may want to wait to do this :for some things (such as popup windows), since this is a simple single-widget application, doing this in the on_init :method is appropriate.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==
*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the GIMP (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface.

==Advantages==
The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==
*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
# http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules
# http://wonko.com/post/a_brief_comparison_of_cross-platform_gui_toolkits_from_rubys_per
# http://en.wikipedia.org/wiki/QtRuby
# http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)
# http://rubydoc.info/gems/shoes/frames
# http://www.fxruby.org/
# http://www.darshancomputing.com/qt4-qtruby-tutorial/chapter_01
# http://ruby.about.com/od/gui/qt/wxrubyworld.htm
# http://rubylearning.com/satishtalim/ruby_tk_tutorial.html

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-17T22:05:13Z

Pyadav: /* ffi-tk */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver. Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries:
** Cairo – for drawing
** Pango – for text
** Ruby – for programming

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp. FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Advantages==
* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.
The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface.
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>
:Line by Line Walkthrough
<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.
<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk you create widgets and then bind code blocks to them. When something happens (like the user clicking a widget), Tk runs the appropriate code block. In our program, we use the title and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.
<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the label.
<pre>
Tk.mainloop
</pre>
:Finally, we pack the root frame and enter the main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, QML and JavaScript playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture. Qt5 brings significant improvements to the speed and ease of developing user interfaces. Here is a code snippet to create a Hello world window.
<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough
<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.
<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments
<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.
<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).
<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.
<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==
*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==
*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing. So what is the benefit of a GUI toolkit that needs yet another GUI toolkit to run? There are several.
Benefits of WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and Cocoa on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator. It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly. Here is sample Hello World program-
<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>
: line by line walkthrough
<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.
<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp
<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. Though since :we're not putting any other widgets in it, we're simply using it to display an empty window.
:the third parameter of the Wx::Frame constructor (not necessarily all constructors) is the text to display in the title :bar. Our rather non-descriptive string "Application" will be displayed in the title bar of our window, as well as in the :task bar.
<pre>
app = MyApp.new
app.main_loop
</pre>
:Finally, after creating a widget, you must call show on it or it won't be shown. Though you may want to wait to do this :for some things (such as popup windows), since this is a simple single-widget application, doing this in the on_init :method is appropriate.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==
*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the GIMP (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface.

==Advantages==
The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==
*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
# http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules
# http://wonko.com/post/a_brief_comparison_of_cross-platform_gui_toolkits_from_rubys_per
# http://en.wikipedia.org/wiki/QtRuby
# http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)
# http://rubydoc.info/gems/shoes/frames
# http://www.fxruby.org/
# http://www.darshancomputing.com/qt4-qtruby-tutorial/chapter_01
# http://ruby.about.com/od/gui/qt/wxrubyworld.htm
# http://rubylearning.com/satishtalim/ruby_tk_tutorial.html

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-17T22:03:21Z

Pyadav: /* References */

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver. Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries:
** Cairo – for drawing
** Pango – for text
** Ruby – for programming

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp. FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Advantages==
* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.
The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface.
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>
:Line by Line Walkthrough
<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.
<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk you create widgets and then bind code blocks to them. When :something happens (like the user clicking a widget), Tk runs the appropriate code block. In our program, we use the title :and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.
<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the :label.
<pre>
Tk.mainloop
</pre>
:Finally, we pack the root frame and enter the main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, QML and JavaScript playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture. Qt5 brings significant improvements to the speed and ease of developing user interfaces. Here is a code snippet to create a Hello world window.
<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough
<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.
<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments
<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.
<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).
<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.
<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==
*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==
*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing. So what is the benefit of a GUI toolkit that needs yet another GUI toolkit to run? There are several.
Benefits of WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and Cocoa on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator. It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly. Here is sample Hello World program-
<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>
: line by line walkthrough
<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.
<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp
<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. Though since :we're not putting any other widgets in it, we're simply using it to display an empty window.
:the third parameter of the Wx::Frame constructor (not necessarily all constructors) is the text to display in the title :bar. Our rather non-descriptive string "Application" will be displayed in the title bar of our window, as well as in the :task bar.
<pre>
app = MyApp.new
app.main_loop
</pre>
:Finally, after creating a widget, you must call show on it or it won't be shown. Though you may want to wait to do this :for some things (such as popup windows), since this is a simple single-widget application, doing this in the on_init :method is appropriate.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==
*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the GIMP (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface.

==Advantages==
The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==
*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
# http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules
# http://wonko.com/post/a_brief_comparison_of_cross-platform_gui_toolkits_from_rubys_per
# http://en.wikipedia.org/wiki/QtRuby
# http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)
# http://rubydoc.info/gems/shoes/frames
# http://www.fxruby.org/
# http://www.darshancomputing.com/qt4-qtruby-tutorial/chapter_01
# http://ruby.about.com/od/gui/qt/wxrubyworld.htm
# http://rubylearning.com/satishtalim/ruby_tk_tutorial.html

CSC/ECE 517 Fall 2013/ch1 1w17 pk

2013-09-17T22:01:44Z

Pyadav:

GUI programming tools for [http://en.wikipedia.org/wiki/Ruby Ruby] are a set of widgets used for designing RUBY applications with [http://en.wikipedia.org/wiki/Graphical_user_interface graphical user interfaces] (GUIs). Each widget facilitates a specific user-computer interaction, and appears as a visible part of the computer's GUI. Widget toolkits can be either native or cross platform. Ruby GUI toolkits are typically 3rd party GUI platforms that are wrapped by a Ruby driver. Ruby bindings are available for several widget toolkits. Commonly used tools are described below.

=Shoes=
Shoes is the best little [http://en.wikipedia.org/wiki/Domain-specific_language DSL] for cross-platform GUI programming in RUBY. This GUI toolkit feels like real Ruby, rather than just another C++ library wrapper. It was originally written by a guy named [http://en.wikipedia.org/wiki/Why_the_lucky_stiff _why], and is now maintained by others. Currently, it is the most widely used GUI toolkit for RUBY.

==Versions==
{| class="wikitable"
|-
! Version !! Name !! Release
|-
| Version1 || Curious || _why release
|-
| Version2 || Raisins || _why release
|-
| Version3 || Policeman ||Post_why release
|}

Version 3 is the current stable release. It was released on August 19, 2013; 3 years ago.

==Advantages==

* Simplicity- It is designed to make applications as easy as possible.
* It has control at a lower level
* Makes GUI development fun.
* Simple Interface
* Very good graphics

==Cool Features==

* The unique thing about Shoes is that it gives very few controls, but one can build a wide range of different pages that are immediately accessible.
* To save a bit of work, Shoes relies on a few libraries:
** Cairo – for drawing
** Pango – for text
** Ruby – for programming

==Disadvantages==

* It tries to support many platforms. Hence, it is a bit rough at the edges.
* Current version is a place holder until Shoes is properly gemified.
* Many common robust widgets are not available

==Shoes 4==
The upcoming version of shoes is Shoes 4.
Due to various issues like compilation/release and stability with the current shoes implementation, development moved on to shoes4. Shoes4 is a complete all Ruby rewrite of shoes, using the Ruby bindings to the windowing libraries, rather than the C ones. It's goal is to be as close to 100% backwards compatible as it can get.

=FxRuby=
FxRuby is a toolkit for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for RUBY applications. It is based on the [http://en.wikipedia.org/wiki/Fox_toolkit FOX Toolkit], a popular open source C++ library developed by Jeroen van der Zijp. FXRuby has the advantages of both Ruby and C++. An application developer can write the code in ruby programming language which is [http://en.wikipedia.org/wiki/Dynamic_programming_language dynamic], [http://en.wikipedia.org/wiki/Reflection_(computer_science) reflective] and [http://en.wikipedia.org/wiki/Object-oriented_programming_language object-oriented] while simultaneously take advantage of the performance and functionality of the highly optimized C++ toolkit.

==Advantages==
* FXRuby supports everything of FOX, that is useful in Ruby:
# MDI/SDI application window layouts
# Floating toolbars
# Rich set of controls (tables, imagelists, menus, canvas, …)
# Flexible layout management
# Image read/write support in many formats
# Embedded [http://en.wikipedia.org/wiki/OpenGL OpenGL] graphics

* Relatively flat learning curve- very consistent naming, widget creation parameters, and so on.
* It is not a wrapper around some other toolkit. Hence, one can actually override the way a widget works by sub classing and re-implementing behavior and how it is drawn.
* Consistent vision- It is written with a consistent vision of how things should fit together.

==Disadvantages==

* Missing support for some kind of RichText (which [http://en.wikipedia.org/wiki/Qt_(framework) Qt] and [http://en.wikipedia.org/wiki/GTK%2B GTK+] today provide)
* Internationalization and Localization are still being worked on.
* Non-native look and feel. It looks like Windows XP even on a Mac or in Windows 7
* Binary gems are available for Windows, OS X, and Ubuntu Linux but for other platforms, installing the gem requires you to compile native code.

=ffi-tk=
Of Ruby GUI bindings, the Tk binding is the oldest; it is widely available and still more or less the default toolkit for GUI programming with Ruby.Tk provides a number of (GUI) widgets commonly needed to develop desktop applications such as button, menu, canvas, text, frame, label, etc. Tk has been ported to run on most flavors of Linux, Mac OS, Unix, and Microsoft Windows. Tk was designed to be extended, and a wide range of extensions are available that offer new widgets or other capabilities.
The "look and feel" of the Tk application depends on the version of the Tk library Ruby interpreter is linked against:
*Tk 8.4 and below is notorious for its “ugly” look. The widgets have the outdated Motif look and feel, and, on Unix-based systems, bitmap fonts are used.
*Tk 8.5 and above look more modern. It is shipped with the Tile theming engine, and widgets now look native to the hosting platform. On Unix-based systems outline fonts are now used.

Tk applications follow a widget hierarchy where any number of widgets may be placed within another widget, and those widgets within another widget, ad infinitum. The main widget in a Tk program is referred to as the root widget and can be created by making a new instance of the TkRoot class.
*Most Tk-based applications follow the same cycle: create the widgets, place them in the interface, and finally, bind the events associated with each widget to a method.
*There are three geometry managers place, grid and pack that are responsible for controlling the size and location of each of the widgets in the interface.
Here is a sample Hello World program-

<pre>
require 'tk'

root = TkRoot.new { title "Hello, World!" }
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
</pre>
:Line by Line Walkthrough
<pre>
require 'tk'
</pre>
:In the program, we load the tk extension module.
<pre>
root = TkRoot.new { title "Hello, World!" }
</pre>
:we create a root-level frame using TkRoot.new. With Tk you create widgets and then bind code blocks to them. When :something happens (like the user clicking a widget), Tk runs the appropriate code block. In our program, we use the title :and minsize instance methods (of module Tk::Wm) in the code block to TkRoot.new.
<pre>
TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
</pre>
:Here, we make a TkLabel widget (representing a label) as a child of the root frame, setting several options for the :label.
<pre>
Tk.mainloop
</pre>
:Finally, we pack the root frame and enter the main GUI event loop.

=QtRuby=
QtRuby is a binding of the application framework [http://en.wikipedia.org/wiki/Qt_(framework) Qt] for the programming language Ruby. Qt is a cross-platform application framework that is widely used for developing application software with a graphical user interface (GUI) and also used for developing non-GUI programs such as command-line tools and consoles for servers.

Qt uses standard C++ but makes extensive use of a special [http://en.wikipedia.org/wiki/Code_generator code generator] (called the Meta Object Compiler, or moc) together with several macros to enrich the language. Qt can also be used in several other programming languages via language bindings. It runs on the major desktop platforms and some of the mobile platforms. It has extensive internationalization support. Non-GUI features include [http://en.wikipedia.org/wiki/SQL SQL] database access, [http://en.wikipedia.org/wiki/XML XML] parsing, thread management, network support, and a unified cross-platform [http://en.wikipedia.org/wiki/Application_programming_interface application programming interface] (API) for file handling.

Qt5 is the new version which marks a major change in the platform, with hardware-accelerated graphics, QML and JavaScript playing a major role. The traditional C++-only QWidgets continue to be supported, but do not benefit from the performance improvements available through the new architecture. Qt5 brings significant improvements to the speed and ease of developing user interfaces. Here is a code snippet to create a Hello world window.
<pre>
require 'Qt4'
app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()
app.exec()
</pre>

:Line by Line Walkthrough
<pre>
require 'Qt4'
</pre>
:This line loads the QtRuby extension.
<pre>
app = Qt::Application.new(ARGV)
</pre>
:app is this program's Qt::Application instance. It is created here. We pass ARGV to the Qt::Application constructor so that it can process certain standard command-line arguments
<pre>
hello = Qt::PushButton.new('Hello World!')
</pre>
:Here, after the Qt::Application, comes the first window-system code: A push button is created.
:The button is set up to display the text "Hello world!". Because we don't specify a parent window (as second argument to :the Qt::PushButton constructor), the button will be a window of its own, with its own window frame and title bar.
<pre>
hello.resize(100, 30)
</pre>
:The button is set up to be 100 pixels wide and 30 pixels high (excluding the window frame, which is provided by the :windowing system).
<pre>
hello.show()
</pre>
:A widget is never visible when you create it. You must call Qt::Widget::show() to make it visible.
<pre>
app.exec()
</pre>
This is where our program passes control to Qt.

==Advantages==
*It supports Linux and other flavors of Unix, as well as Mac OS X and Microsoft Windows.
*The main advantage to Qt is that it has exactly the same look on Windows and OSX. This is not true for FXRuby nor Gtk2.

==Disadvantages==
*While a gem is available for the Windows installation, only source code is available for other platforms.

=wxRuby=
wxRuby is a binding for the cross-platform [http://en.wikipedia.org/wiki/Wxwidgets wxWidgets] C++ GUI toolkit, which lets you create native-looking desktop applications. It is available for installation as a gem.

WxWidgets is a C++ GUI toolkit that can be used to write GUI (graphical user interface) applications. In this way, it's not unlike GTK, Qt or TK. However, it does differ from these toolkits in one major way: WxWidgets doesn't actually implement the toolkit at all, it uses another toolkit to do the actual drawing. So what is the benefit of a GUI toolkit that needs yet another GUI toolkit to run? There are several.
Benefits of WxWidgets
*WxWidgets is cross platform. applications can be ported to different operating systems with as little as a recompile.
*WxWidgets is consistent and gives a native look and feel. WxWidgets uses the native toolkits on each OS (GTK on Linux, Win32 controls on Windows and Cocoa on OS X), so the application blends in everywhere.

So WxWidgets is kind of a middleman or a translator. It will sit between the program and the native GUI toolkit and allow us to create widgets, as well as passing any messages received (mouse clicks, etc) up to the program. It can also be thought of as a simplifier. Some GUI toolkits are very cumbersome and difficult to work with. Even if we don't need the cross-platform features, or care about the consistency, look and feel, writing programs with WxWidgets can be easier than using the native GUI toolkit directly. Here is sample Hello World program-
<pre>
require 'rubygems'
require 'wx'

class MyApp < Wx::App
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
end

app = MyApp.new
app.main_loop
</pre>
: line by line walkthrough
<pre>
require 'wx'
</pre>
:To load the WxRuby library, require the 'wx' module. From this point on, all the WxRuby classes will be available in the :Wx module.
<pre>
class MyApp < Wx::App
</pre>
:Every WxRuby application is contained in a class inherited from the Wx::App class. this test class uses the name MyApp
<pre>
def on_init
@frame = Wx::Frame.new( nil, -1, "Application" )
@frame.show
end
</pre>
:In this example, we're creating a single widget, a Wx::Frame. A Frame is a widget that holds other widgets. Though since :we're not putting any other widgets in it, we're simply using it to display an empty window.
:the third parameter of the Wx::Frame constructor (not necessarily all constructors) is the text to display in the title :bar. Our rather non-descriptive string "Application" will be displayed in the title bar of our window, as well as in the :task bar.
<pre>
app = MyApp.new
app.main_loop
</pre>
:Finally, after creating a widget, you must call show on it or it won't be shown. Though you may want to wait to do this :for some things (such as popup windows), since this is a simple single-widget application, doing this in the on_init :method is appropriate.

==Advantages==

*Cross platform
*Large support community
*Excellent support for all major platforms

==Disadvantages==
*The API is very C++-oriented
*It has no documentation aside from auto-generated class and function list.

=GTK+=
The GTK is a library for creating graphical user interfaces in C programming language. The GTK library is also called the GIMP (GNU Image Manipulation Program) Toolkit. GIMP is an image retouching and editing tool. Originally, the library was created while developing the GIMP image manipulation program. Since then, the GTK became one of the most popular toolkits under Linux and BSD Unix. Today, most of the GUI software in the open source world is created in Qt or in GTK. Language bindings exist for Ruby, C++, Python, Perl, Java, and other programming languages.
Ruby/GTK is an extension library to use [http://en.wikipedia.org/wiki/GTK%2B GTK+] in Ruby. There are many applications using GTK+. Especially, Desktop Environment [http://en.wikipedia.org/wiki/GNOME GNOME] adopt GTK+ as interface.

==Advantages==
The API bindings provided by Ruby-GNOME2 are excellent as well, and mostly do things in the Ruby Way.
The Ruby-GNOME2 project also provides excellent documentation and tutorials.

==Disadvantages==
*Windows support isn’t bad, and even uses native widgets in many places under Windows XP, but it requires a hefty set of runtime libraries.
*Unix support is excellent with the sad exception of Mac OS X. It’s possible to run GTK+ apps in OS X using the X Windowing System, but this means the app looks inconsistent and ugly compared to the rest of the OS X interface.

=References=
# http://en.wikibooks.org/wiki/Ruby_Programming/GUI_Toolkit_Modules
# http://wonko.com/post/a_brief_comparison_of_cross-platform_gui_toolkits_from_rubys_per
# http://en.wikipedia.org/wiki/QtRuby
# http://en.wikipedia.org/wiki/Shoes_(GUI_toolkit)
# http://rubydoc.info/gems/shoes/frames
# http://www.fxruby.org/
# http://www.darshancomputing.com/qt4-qtruby-tutorial/chapter_01
# http://ruby.about.com/od/gui/qt/wxrubyworld.htm