KDE TechBase - User contributions [en]

Development/Languages/Ruby

2010-08-18T18:55:56Z

Robert Riemann: repair quiloader script

{{Template:I18n/Language Navigation Bar|Development/Languages/Ruby}}
[[Image:ruby.png]]

Very complete bindings to both the KDE API and the Qt APIs. The Korundum package includes both a QtRuby Qt-only binding along with the full combined Qt/KDE one. The QtRuby package contains just Qt bindings with no dependencies on KDE.

[http://rubyforge.org/projects/korundum/ Korundum/QtRuby - Ruby-KDE/Qt bindings]

The book [http://www.pragmaticprogrammer.com/titles/ctrubyqt/ Rapid GUI Development with QtRuby] (for Qt version 3.x) is available.

Being [http://developer.kde.org/language-bindings/smoke/index.html Smoke-based] bindings means that they offer full access to most KDE 4.x and Qt 4.x classes.

= QtRuby =
Hello world example:
<code ruby>
#!/usr/bin/ruby -w
require 'Qt4'
a = Qt::Application.new(ARGV)
hello = Qt::PushButton.new("Hello World!")
hello.resize(100, 30)
hello.show
a.exec
</code>

Hello Qt example in a more 'Rubyish' way:

<code ruby>
require 'Qt4'

Qt::Application.new(ARGV) do
Qt::Widget.new do

self.window_title = 'Hello QtRuby v1.0'
resize(200, 100)

button = Qt::PushButton.new('Quit') do
connect(SIGNAL :clicked) { Qt::Application.instance.quit }
end

label = Qt::Label.new('<big>Hello Qt in the Ruby way!</big>')

self.layout = Qt::VBoxLayout.new do
add_widget(label, 0, Qt::AlignCenter)
add_widget(button, 0, Qt::AlignRight)
end

show
end

exec
end
</code>

= Current api coverage overview =

== Available calls ==
You can call all Qt public and protected methods, and all friend methods such as bitBlt() etc
== Virtual methods ==

All virtual methods can be overridden, not just event handlers
== Properties ==
'foobar = 5' is a synonym for 'setFooBar(5)'

==Use either CamelCase or lowercase with underscore naming==

Any underscores in method names are removed, and the following character is capitalised. For example, you can use either of these two forms to call the same method:

<code ruby>
create_standard_status_bar_action()
createStandardStatusBarAction()
</code>

==Operator overloading==
The full range of Qt operator methods is available, for example:

<code ruby>
p1 = Qt::Point.new(5,5) => (5, 5)
p2 = Qt::Point.new(20,20) => (20, 20)
p1 + p2 => (25, 25)
</code>

==Declare signals and slots==
Signals and slots are declared as list of strings like this:

<code ruby>
slots 'setColor(QColor)', 'slotLoad(const QString&)'..
signals 'clicked()'..
</code>

For slots and signals without arguments you can use Ruby symbols:

<code ruby>
slots :slotLoad
signals :clicked
</code>

Currently C++ type signatures must be used, a future version of QtRuby will allow ruby type signatures instead. (see the section on emitting Ruby Classes)

Connect slots and signals like this:

<code ruby>
Qt::Object.connect( @colormenu, SIGNAL( "activated(int)" ),
self, SLOT( "slotColorMenu(int)" ) )
</code>

There is also two another possibilities:

<code ruby>
connect(:mysig, mytarget, :mymethod))
connect(SIGNAL('mysignal(int)'), mytarget, :mymethod))
</code>

Or you can connect signal to a block:

<code ruby>
quit_button.connect(SIGNAL :clicked) { $qApp.quit }
</code>

And emit signals like this:

<code ruby>
emit colorChanged( black )
</code>

==Emitting Ruby Classes==
Ruby classes can be emitted by embedding them inside a QVariant, and emitting the QVariant.

The following code provides a method called to_variant that can be used to easily convert objects to Variants
<code ruby>
class Qt::RubyVariant < Qt::Variant
def initialize(value)
super()
@value = value
end

attr_accessor :value
end

class Object
def to_variant
Qt::RubyVariant.new self
end
end
</code>

Note: as of KDE 4.5 you can simply use
<code ruby>
variant = Qt::Variant.fromValue(my_ruby_object)
</code>
to create a QVariant that contains your ruby object. To get it back, you just call Qt::Variant#value as usual.

This can be used as follows
<code ruby>
class MyObject < Qt::Object
signals "mySignal(QVariant)"
def doEmit
# since KDE 4.5:
# emit mySignal(Qt::Variant.fromValue(ruby_object))
emit mySignal(ruby_object.to_variant)
end

slots "mySlot(QVariant)"
def mySlot(variant)
ruby_object = variant.value
end
end
</code>

=== Alternate way to emit Ruby Classes ===
You can also try to emit a ruby class by emitting it's object_id (either as an Integer or a QVariant), and use ObjectSpace._id2ref to get the object back.

<code ruby>
class Object
def to_variant
Qt::Variant.new object_id
end
end

class Qt::Variant
def to_object
ObjectSpace._id2ref to_int
end
end
</code>

==Constructors==
You can call constructors in the conventional style:

<code ruby>
quit = Qt::PushButton.new("Quit", self, "quit")
</code>

Or you can pass a block if you prefer:

<code ruby>
w = MyWidget.new { setCaption("foobar") }
</code>

The block will be called in the context of the newly created instance.

Ordinary arguments can be provided as well as a block at the end:

<code ruby>
w = MyWidget.new(nil) { setCaption("foobar") }
</code>

They are run in the context of the new instance.

And there's more! You can also pass an arg to the block, and it will be run in the context of the arg:

<code ruby>
w = MyWidget.new { |theWidget| theWidget.setCaption "foobar" }
</code>

==Garbage Collection==
When a ruby instance is garbage collected, the underlying C++ instance will only be deleted if it isn't 'owned' by a parent object. Normally this will 'just work', but there are occasions when you need to delete the C++ ahead of garbage collection, and whether or not it has a parent. Use the dispose(), isDisposed() and disposed? methods like this:

<code ruby>
item2.dispose
if item2.disposed?
puts "item2 is disposed"
end
</code>

==C++ 'int*' and 'int&' argument types==
Ruby passes numeric values by value, and so they can't be changed when passed to a method. The Qt::Integer class provides a mutable numeric type which does get updated when passed as an argument. For example, this C++ method 'findByFileContent()':

<code ruby>
# static Ptr findByFileContent( const QString &fileName,
# int *accuracy=0 );

acc = Qt::Integer.new(0)
fc = KDE::MimeType.findByFileContent("mimetype.rb", acc)
</code>

It supports the arithmetic operators, and so expressions such as 'acc + 3' will work.

==C++ 'bool*' and 'bool&' argument types==
There is a similar problem for bool arg types, and the mutable Qt::Boolean class can be used like this:

<code ruby>
# QFont getFont(bool * ok, const QFont&initial,
# QWidget* parent = 0, const char *name = 0);

ok = Qt::Boolean.new
font = Qt::FontDialog.getFont(ok,
Qt::Font.new("Helvetica [Cronyx]", 10),
self)
if !ok.nil?
# font is set to the font the user selected
else
# the user canceled the dialog
end
</code>

Use 'nil?' to test the value returned in the Boolean

==C++ (const )(unsigned )char* argument types==
In some cases Qt/KDE object "takes ownership" over Ruby String passed as char* argument type. Programmer needs to make sure that Ruby String is not being garbage collected or changed for the time it's being used by Qt/KDE object. It is also quite possible that Qt/KDE object will change and eventually free it(memory used internally by Ruby String to store its data). Be very careful when you call this kind of methods and make sure that there is no overloaded version witch accepts QString or QByteArray first!

==C++ unsigned char* functions==

Very few functions (as QImage::bits()) return a uchar* to directly manipulate data. These functions are not supported in Ruby and will throw an ArgumentError. More information on the [http://lists.kde.org/?l=kde-bindings&m=122899325331866&w=2 mail list].

==Debugging==
If a method call can't be matched in the Smoke library giving a 'method_missing' error, first check that you are passing correct class instance that is properly initialized (with super method called in constructors of custom Qt classes descendants). You can also turn on debugging to trace the matching process:

<code ruby>
a = Qt::Application.new(ARGV)
Qt.debug_level = Qt::DebugLevel::High
a.loadLibrary("foo") # Non existent method
</code>

Will give the following output:

classname == QApplication
:: method == loadLibrary$
-> methodIds == []
candidate list:
Possible prototypes:
static QWidget* QApplication::widgetAt(int, int, bool)
...

Here, the list of candidate methods 'methodIds' is empty

Another debugging mechanism allows various trace 'channels' to be switched on.

You can trace virtual method callbacks:

<code ruby>
Qt::Internal::setDebug(Qt::QtDebugChannel::QTDB_VIRTUAL)
</code>

Or trace QtRuby garbage collection:

<code ruby>
Qt::Internal::setDebug(Qt::QtDebugChannel::QTDB_GC)
</code>

==String i18n==

QtRuby supports $KCODE values of 'u', 'e' and 's' or the corresponding '-K' options from the command line. Qt Designer .ui files have UTF-8 strings so if you use any 8 bit UTF-8 characters, you will need to set $KCODE='u' or use the -Ku command line option.

=Other capabilities and offerings=

==Qt Designer==
A 'rbuic4' tool is included in qtruby/tools/rbuic to compile .ui files into ruby code. As described above, Qt Designer uses UTF-8. In addition to the options in the original uic C++ utility an '-x' flag has been added. This will generate a top level stub in the code:

<code bash>
$ rbuic mainform.ui -x -o mainform.rb
</code>

Will add this to the end of the generated code:

<code ruby>
if $0 == __FILE__
a = Qt::Application.new(ARGV)
w = MainForm.new
w.show
a.exec
end
</code>

Then you can test the example code straight away:

$ ruby mainform.rb

Use the '-kde' option to require the 'korundum4' extension rather than the 'Qt4' one. If the '-x' option is used in conjunction, it generates a KDE top level. For example:

<code bash>
$ rbuic4 -x -kde knotifywidgetbase.ui -o knotifywidgetbase.rb
</code>

Will generate this top level code:

<code ruby>
if $0 == __FILE__
about = KDE::AboutData.new("knotifywidgetbase",
"KNotifyWidgetBase", "0.1")
KDE::CmdLineArgs.init(ARGV, about)
a = KDE::Application.new()
w = KNotifyWidgetBase.new
w.show
a.exec
end
</code>

==Loading .ui files at runtime with Qt::UILoader==
{{improve|Remove example that does not work}}

You can load a Qt Designer .ui file at runtime with the 'quiloader' extension, for example:

require 'Qt4'
require 'quiloader'

a = Qt::Application.new(ARGV)
if ARGV.length == 0
exit
end

if ARGV.length == 2
QUI::WidgetFactory.loadImages ARGV[0]
w = QUI::WidgetFactory.create ARGV[1]
if w.nil?
exit
end
w.show()
a.connect(a, SIGNAL('lastWindowClosed()'), a, SLOT('quit()'))
a.exec()
end

With new version API changed a little.

require 'Qt4'
require 'qtuitools'

a = Qt::Application.new(ARGV)
if ARGV.length == 0
exit
end

if ARGV.length == 1
file = Qt::File.new(ARGV[0])
file.open(Qt::File::ReadOnly)

loader = Qt::UiLoader.new
window = loader.load(file, nil)
file.close

if (window.nil?)
print "Error. Window is nil.\n"
exit
end
window.show
a.connect(a, SIGNAL('lastWindowClosed()'), a, SLOT('quit()'))
a.exec
end

==API reference==

Use the bin/rbqtapi tool to discover which methods are available in the QtRuby api. This command:

<code bash>
$ rbqtapi Qt::TextEdit
</code>

Will list all the methods in the Qt::TextEdit class

<code bash>
$ rbqtapi -rsetCaption
</code>

Lists all methods whose names contain the string 'setCaption'

==Example programs==

The best way to start programming QtRuby is to look at some existing code and start messing with it.. The are various samples under qtrubyexamples and korundum/examples.

==Writing Unit Tests==
Using Ruby allows you the power to leverage testing frameworks such as RSpec in order to unit and integration test your classes.

Most classes such as Models can be easily tested via the APIs they expose. Below is a small extract with some interesting tests from the mingle_mover project (http://github.com/gja/mingle_mover). The class being tested is a TableModel

Note how we create a stub to pass to QAbstractTableModel::data, which accepts a QModelIndex as an argument.

<code ruby>
describe CardModel do
it "Should Implement QAbstractTableModel" do
CardModel.ancestors.should include Qt::AbstractTableModel
end

it "Should Not Be Editable" do
@model.data(mock_index(1,2), Qt::EditRole).should_not be_valid
@model.headerData(nil, nil, Qt::EditRole).should_not be_valid

flags = @model.flags(nil)
flags.should have_flag Qt::ItemIsEnabled
flags.should have_flag Qt::ItemIsSelectable
flags.should_not have_flag Qt::ItemIsEditable
end

it "Should not return any vertical headers" do
@model.headerData(1, Qt::Vertical).should_not be_valid
end

it "Should color a row according to the status" do
@model.data(mock_index(1,2), Qt::ForegroundRole).value.color.should == Qt::Color.new(Qt::red)
@model.data(mock_index(0,2), Qt::ForegroundRole).value.color.should == Qt::Color.new(Qt::green)
@model.data(mock_index(0,0), Qt::ForegroundRole).should_not be_valid
end

def mock_index(row, col)
stub(:row => row, :column => col)
end

def have_flag(flag)
return simple_matcher("A flag that matches " + flag.to_s) { |given| (given & flag) != 0 }
end
end
</code>

=== Testing Out Signals and Slots ===
Below is a simple class which can be used to test out a class via the signals it emits:

<code ruby>
class RubySignalSpy < Qt::Object
def self.create(*args, &block)
Class.new(self).new(*args, &block)
end

def count(name)
@calls[name].size
end

def params(name, invocation = 0)
@calls[name][invocation]
end

def method_missing(name, *args, &block)
@calls[name.to_sym] << args
exec_action_for(name, args)
end

def responds_to?(name)
true
end

private
def initialize
@calls = {}
def @calls.[](index)
super || self[index] = []
end
@actions = {}
super
end

def mocked_slots(*names, &block)
slots *names
names.each { |name| @actions[name] = block }
end

def exec_action_for(name, args)
@actions[name].call(self, args) if @actions[name]
end

def slots(*args)
self.class.slots(*args)
end
end
</code>

<code ruby>
it "Should be able to emit a signal when called" do
reciever = RubySignalSpy.create do
slots "recieved(int, int)" # Explicitly name slots with parameters
mocked_slot :some_other_slot do |spy, params| # Pass a block to be executed when called
end # You must call mocked_slot with a symbol
end

class ClassWeAreTesting < Qt::Object
signals "sending(int, int)"
def broadcast
emit sending(4, 2)
end
end

sender = ClassWeAreTesting.new

Qt::Object.connect(sender, SIGNAL("sending(int, int)"), reciever, SLOT("recieved(int, int)"))
sender.broadcast
reciever.count(:recieved).should == 1 # Get count of calls
reciever.params(:recieved, 0).should == [4, 2] # Get the parameters of nth invocation
end
</code>

=== Testing UI Classes ===
It is much more difficult to test UI classes. In most cases, you will need to instantiate a QApplication so that you can create your widgets.

Some rudimentary tests can be written by simulating clicks are various locations. Watch this space as more tests get written
<code ruby>
describe SomeTableView do
before(:all) do
@app = Qt::Application.new(ARGV)
@view = SomeTableView.new
end

it "Should accept a mouse click on second row"
@row2 = @view.rowViewportPosition 1
@view.mousePressEvent(Qt::MouseEvent.new(Qt::Event::MouseButtonPress, Qt::Point.new(0,@row2), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier))
# Assert something here, such as that a signal has been emitted
end

after(:all) do
@app.dispose!
end
end
</code>

=KDE Specific Infomation=
Instead of <code ruby>require 'Qt4'</code>, use<code ruby>require 'korundum4'</code> for KDE programs.

The KDE K* classes such as KApplication are renamed as KDE::Application. The other KDE classes are in the KParts::, KIO:: or DOM:: namespaces, with the same names as their C++ counterparts.

Use the 'rbkdeapi' script to introspect the Korundum api from the command line. For example:

<code bash>
$ rbkdeapi KDE::Action
</code>

Will list all the methods in the KDE::Action class. There are currently (as at KDE 3.3 beta 2) 977 classes/30841 methods in the Smoke library runtime, so the coverage of the Qt/KDE api is pretty complete.

=Build dependencies=

* ruby 1.8 or greater (svn trunk works with 1.9.1)
* cmake 2.6 or greater
* Qt 4.0 or greater
* KDE 4.1 or greater (for korundum)

=Tutorials=
There is a ruby translation of [http://developer.kde.org/language-bindings/ruby/tutorial/tutorial.html Qt Tutorial #1], and the corresponding ruby code is in qtruby/rubylib/tutorial/t1 to t14.

And a Qt4 version of the same tutorial translated to Ruby by Darshan Ishaya [[Development/Tutorials/Qt4_Ruby_Tutorial|Qt4 Ruby Tutorial]]

[http://developer.kde.org/language-bindings/ruby/tutorial2/tutorial2.html Qt Tutorial #2], a Charting Application with ruby code in qtruby/rubylib/examples/qt-examples/chart.

The Qt Designer [http://developer.kde.org/language-bindings/ruby/colortooltutorial/designer-manual-3.html Color Tool Tutorial], with ruby code in qtruby/rubylib/designer/examples/colortool.

Paul Lutus has written a tutorial on how to get started with [http://www.arachnoid.com/ruby/RubyGUIProject/index.html Ruby GUI programming with Qt]

For KDE, there is a ruby translation of this [http://developer.kde.org/language-bindings/ruby/kde3tutorial/index.html KDE 3.0 tutorial] originally written for C++ by Antonio Larrosa Jiménez. The sources are in korundum/rubylib/tutorials/p1 to p9.

The book [http://www.pragmaticprogrammer.com/titles/ctrubyqt/ Rapid GUI Development with QtRuby] is now available.

There is also an approach to create an [[/Ruby-Qt/KDE Book|Ruby-Qt/KDE Book]] under a free license. The content will be created in this wiki. The book made with latex will be derived from the content in the wiki. Any Questions? Contact [[User:SaLOUt|me]]!

=Download=
You can obtain recent SVN snapshots on the Rubyforge [http://rubyforge.org/projects/korundum/ QtRuby/Korundum site].

=More help=
There are two IRC channels (<tt><nowiki>#qtruby</nowiki></tt> and <tt><nowiki>#kde-ruby</nowiki></tt>) in [http://www.freenode.net FreeNode]. If you prefer e-mail, you can use the [http://mail.kde.org/mailman/listinfo/kde-bindings kde-bindings mailing-list] (low traffic) or ask in the [http://www.ruby-lang.org/en/20020104.html ruby-talk] mailing list (you may use the [http://www.ruby-forum.com/ Ruby Forum] gateway to post in ruby-talk from web).

=More information=
A series of articles on ruby QT (inspired by the work done for the [http://dradis.nomejortu.com dradis] project):
* [http://weblog.nomejortu.com/x-windows/ruby-workshop-the-way-of-the-qt-samurai ruby workshop: the way of the Qt samurai]
* [http://weblog.nomejortu.com/x-windows/ruby-qt-model-view-controller ruby Qt: model / view / controller]
* [http://weblog.nomejortu.com/x-windows/ruby-qt-menu-bar-status-bar-and-resources ruby Qt: menu bar, status bar and resources]
* [http://weblog.nomejortu.com/x-windows/ruby-qt-custom-widget-example ruby Qt custom widget example]
* [http://weblog.nomejortu.com/x-windows/ruby-qttreewidget-example ruby Qt::TreeWidget example]
* [http://www.ruby-forum.com/topic/189346#new Very usefull link how to create your first Qt window dialog]

[[Category:Ruby]]

Development/Tutorials/Plasma/Ruby/Writing DataEngines

2010-07-10T18:01:34Z

Robert Riemann: inital post: 2 important links

This is work in progress. For the inpatient two usefull links:

* http://www.kdedevelopers.org/node/3779 (might be outdated)
* examples in svn: <br /> http://websvn.kde.org/trunk/KDE/kdeexamples/plasma/ruby/dataengines/

Development/Tutorials/Plasma

2010-07-10T17:56:24Z

Robert Riemann: add link How to write your own Plasma DataEngine using Ruby

{{Template:I18n/Language Navigation Bar|Development/Tutorials/Plasma}}

== Plasma Programming with C++ ==

;[[Development/Tutorials/Plasma/GettingStarted|Getting Started With Plasmoids]]
:''Creating your first plasmoid in C++ with SVG background, icon and text''

;[[Development/Tutorials/Plasma/DataEngines|Writing a DataEngine]]
:''DataEngines provide a standardized interface to various data sources for visualizations to use. Learn what a DataEngine is and how to write one of your own.''

;[http://www.kdedevelopers.org/node/3247 Video tutorial]
:''Video and slides from a presentation on libplasma (link to Slides below)''

;[http://mirror.linux.org.au/pub/linux.conf.au/2008/slides/296-coolplasma.odp Link To Slides For The Above Video]
:''Slides For The Presentation Creating User Interfaces With Plasma by Aaron Seigo''

;[[Development/Tutorials/Plasma/UsingExtenders|How to use extenders in your Plasmoid]]
:''A simple example that shows how to use extenders in a Plasmoid.''

;[[Development/Tutorials/Plasma/AbstractRunner|Creating Runners]]
:''Runners are plugins that provide action-based search functionality in the Plasma workspace "run command" dialog. These plugins can be used by any application that links again libplasma.''

;[[Development/Tutorials/Plasma/WallpaperHelloWorld|Wallpaper Tutorial 1]]
:''This tutorial shows you how to make a simple Hello World plasma wallpaper plugin.''

;[http://www.linux-magazine.com/w3/issue/114/036-040_plasma.pdf Creating Plasmoids]
:''May 2010 article from Linux Magazine''

;[http://www.ibm.com/developerworks/linux/library/l-kde-plasmoids/index.html Create Plasmoids using KDevelop]
:''Article explaining the structure of Plasma and how to create a Plasmoid''

== Plasma Programming with JavaScript ==

Plasma has built-in JavaScript (also known as ECMAScript, and often referred to as QtScript in the context of Qt) scripting support without requiring any external dependencies.

=== Plasmoids ===

;[[Development/Tutorials/Plasma/JavaScript/GettingStarted|Getting Started]]
:''Creating and running your first plasmoid in JavaScript''

;[[Development/Tutorials/Plasma/JavaScript/DataEngine|Getting Data]]
:''How to retreive data from a data engine''

;[[Development/Tutorials/Plasma/JavaScript/NowPlaying|Now Playing]]
:''Slightly more advanced data engine usage: displaying what's currently playing''

;[[Development/Tutorials/Plasma/JavaScript/SystemMonitor|System Monitor]]
:''How to access systemmonitor data engine''

;[[Development/Tutorials/Plasma/JavaScript/CheatSheet|Cheat Sheet]]
:''A cheat sheet, rather than a tutorial, of things to remember and watch out for when developing JavaScript plasmoids''

;[[Development/Tutorials/Plasma/JavaScript/API|API Reference]]
:''The Simplified JavaScript Plasmoid API. Useful for referencing what is available in the runtime and as a study aid for the tutorials above.''

=== Other Applications Of Javascript ===
;[[KDE_System_Administration/PlasmaDestkopScripting|Scripting Plasma Shells]]
:The KDE Plasma Desktop and Netbook provide means to manage the desktop shell (desktop, panels, widget) via scripts written in JavaScript. This article describes how to take advantage of this feature set as well as documents the full API. This is primarily a system administration tool, but may also be of interest to power users.

;[[Development/Tutorials/Plasma/JavaScript/Animations]]
:''How to write Animations using Javascript for use in Plasma applications''

;[[Development/Tutorials/Plasma/ComicPlugin|Creating Comic Plugins]]
:''This guide shows you how to create a comic plugin for the comic plasmoid.''

== Plasma Programming with Python ==

;[[Development/Tutorials/Plasma/Python/GettingStarted|Getting Started]]
:''Creating and running your first plasmoid in Python''

;[[Development/Tutorials/Plasma/Python/Using widgets|Using widgets]]
:''Introduction to using Plasma widgets''

;[[Development/Tutorials/Plasma/Python/Using DataEngines|Using DataEngines]]
:''How to use DataEngines from a plasmoid''

;[[Development/Tutorials/Plasma/Python/Writing DataEngines|Writing DataEngines]]
:''How to write your own Plasma DataEngine''

;[[Development/Tutorials/Plasma/PythonPlasmoid|Writing a Plasmoid in Python]]
:''Writing a simple battery graph in python''

== Plasma Programming with Ruby ==
;[[Development/Tutorials/Plasma/Ruby/GettingStarted|Getting Started]]
:''Creating and running your first plasmoid in Ruby''

;[[Development/Tutorials/Plasma/Ruby/Using widgets|Using widgets]]
:''Introduction to using Plasma widgets''

;[[Development/Tutorials/Plasma/Ruby/SimplePasteApplet|Writing a simple paste applet]]
:''A tutorial explaining how to set up a plasmoid, create a simple paste applet using widgets and add Plasma features seen elsewhere. Complete with tips for those who have never programmed before.''

;[[Development/Tutorials/Plasma/Ruby/Writing DataEngines|Writing DataEngines]]
:''How to write your own Plasma DataEngine using Ruby''

;[[Development/Tutorials/Plasma/Ruby/Blinker|Use SVG artwork in the simplest way possible]]
:''Follow a fellow student as he asks around about SVG usage and explains why the code examples work. This is a wiki so feel free to add your own insights until this tutorial can be considered complete.''

== Plasma Programming with Web Technologies (HTML/JS/CSS etc) ==
;[[Development/Tutorials/Plasma/Web/GettingStarted|Getting Started]]
:''Creating and running your first plasmoid in HTML''

== Theme development ==

;[[Development/Tutorials/Plasma/Theme|Creating a Plasma Theme]]
:''Guide to creating your first Plasma theme''

== Resources ==

* [[Projects/Plasma|Projects: Plasma]]
* [http://api.kde.org/4.x-api/kdelibs-apidocs/plasma/html/index.html Plasma api documentation]
* [http://techbase.kde.org/Projects/Plasma/Eclipse_Integration Plasma Eclipse Integration]
* The [https://mail.kde.org/mailman/listinfo/plasma-devel plasma-devel mailing list] and #plasma on IRC (irc.freenode.org).

Development/Languages/Ruby

2010-02-19T15:48:24Z

Robert Riemann: add new forms for connect

{{Template:I18n/Language Navigation Bar|Development/Languages/Ruby}}
[[Image:ruby.png]]

Very complete bindings to both the KDE API and the Qt APIs. The Korundum package includes both a QtRuby Qt-only binding along with the full combined Qt/KDE one. The QtRuby package contains just Qt bindings with no dependencies on KDE.

[http://rubyforge.org/projects/korundum/ Korundum/QtRuby - Ruby-KDE/Qt bindings]

The book [http://www.pragmaticprogrammer.com/titles/ctrubyqt/ Rapid GUI Development with QtRuby] (for Qt version 3.x) is available.

Being [http://developer.kde.org/language-bindings/smoke/index.html Smoke-based] bindings means that they offer full access to most KDE 4.x and Qt 4.x classes.

= QtRuby =
Hello world example:
<code ruby>
#!/usr/bin/ruby -w
require 'Qt4'
a = Qt::Application.new(ARGV)
hello = Qt::PushButton.new("Hello World!")
hello.resize(100, 30)
hello.show
a.exec
</code>

Hello Qt example in a more 'Rubyish' way:

<code ruby>
require 'Qt4'

Qt::Application.new(ARGV) do
Qt::Widget.new do

self.window_title = 'Hello QtRuby v1.0'
resize(200, 100)

button = Qt::PushButton.new('Quit') do
connect(SIGNAL :clicked) { Qt::Application.instance.quit }
end

label = Qt::Label.new('<big>Hello Qt in the Ruby way!</big>')

self.layout = Qt::VBoxLayout.new do
add_widget(label, 0, Qt::AlignCenter)
add_widget(button, 0, Qt::AlignRight)
end

show
end

exec
end
</code>

= Current api coverage overview =

== Available calls ==
You can call all Qt public and protected methods, and all friend methods such as bitBlt() etc
== Virtual methods ==

All virtual methods can be overridden, not just event handlers
== Properties ==
'foobar = 5' is a synonym for 'setFooBar(5)'

==Use either CamelCase or lowercase with underscore naming==

Any underscores in method names are removed, and the following character is capitalised. For example, you can use either of these two forms to call the same method:

<code ruby>
create_standard_status_bar_action()
createStandardStatusBarAction()
</code>

==Operator overloading==
The full range of Qt operator methods is available, for example:

<code ruby>
p1 = Qt::Point.new(5,5) => (5, 5)
p2 = Qt::Point.new(20,20) => (20, 20)
p1 + p2 => (25, 25)
</code>

==Declare signals and slots==
Signals and slots are declared as list of strings like this:

<code ruby>
slots 'setColor(QColor)', 'slotLoad(const QString&)'..
signals 'clicked()'..
</code>

For slots and signals without arguments you can use Ruby symbols:

<code ruby>
slots :slotLoad
signals :clicked
</code>

Currently C++ type signatures must be used, a future version of QtRuby will allow ruby type signatures instead.

Connect slots and signals like this:

<code ruby>
Qt::Object.connect( @colormenu, SIGNAL( "activated(int)" ),
self, SLOT( "slotColorMenu(int)" ) )
</code>

There is also two another possibilities:

<code ruby>
connect(:mysig, mytarget, :mymethod))
connect(SIGNAL('mysignal(int)'), mytarget, :mymethod))
</code>

Or you can connect signal to a block:

<code ruby>
quit_button.connect(SIGNAL :clicked) { $qApp.quit }
</code>

And emit signals like this:

<code ruby>
emit colorChanged( black )
</code>

==Constructors==
You can call constructors in the conventional style:

<code ruby>
quit = Qt::PushButton.new("Quit", self, "quit")
</code>

Or you can pass a block if you prefer:

<code ruby>
w = MyWidget.new { setCaption("foobar") }
</code>

The block will be called in the context of the newly created instance.

Ordinary arguments can be provided as well as a block at the end:

<code ruby>
w = MyWidget.new(nil) { setCaption("foobar") }
</code>

They are run in the context of the new instance.

And there's more! You can also pass an arg to the block, and it will be run in the context of the arg:

<code ruby>
w = MyWidget.new { |theWidget| theWidget.setCaption "foobar" }
</code>

==Garbage Collection==
When a ruby instance is garbage collected, the underlying C++ instance will only be deleted if it isn't 'owned' by a parent object. Normally this will 'just work', but there are occasions when you need to delete the C++ ahead of garbage collection, and whether or not it has a parent. Use the dispose(), isDisposed() and disposed? methods like this:

<code ruby>
item2.dispose
if item2.disposed?
puts "item2 is disposed"
end
</code>

==C++ 'int*' and 'int&' argument types==
Ruby passes numeric values by value, and so they can't be changed when passed to a method. The Qt::Integer class provides a mutable numeric type which does get updated when passed as an argument. For example, this C++ method 'findByFileContent()':

<code ruby>
# static Ptr findByFileContent( const QString &fileName,
# int *accuracy=0 );

acc = Qt::Integer.new(0)
fc = KDE::MimeType.findByFileContent("mimetype.rb", acc)
</code>

It supports the arithmetic operators, and so expressions such as 'acc + 3' will work.

==C++ 'bool*' and 'bool&' argument types==
There is a similar problem for bool arg types, and the mutable Qt::Boolean class can be used like this:

<code ruby>
# QFont getFont(bool * ok, const QFont&initial,
# QWidget* parent = 0, const char *name = 0);

ok = Qt::Boolean.new
font = Qt::FontDialog.getFont(ok,
Qt::Font.new("Helvetica [Cronyx]", 10),
self)
if !ok.nil?
# font is set to the font the user selected
else
# the user canceled the dialog
end
</code>

Use 'nil?' to test the value returned in the Boolean

==C++ (const )(unsigned )char* argument types==
In some cases Qt/KDE object "takes ownership" over Ruby String passed as char* argument type. Programmer needs to make sure that Ruby String is not being garbage collected or changed for the time it's being used by Qt/KDE object. It is also quite possible that Qt/KDE object will change and eventually free it(memory used internally by Ruby String to store its data). Be very careful when you call this kind of methods and make sure that there is no overloaded version witch accepts QString or QByteArray first!

==C++ unsigned char* functions==

Very few functions (as QImage::bits()) return a uchar* to directly manipulate data. These functions are not supported in Ruby and will throw an ArgumentError. More information on the [http://lists.kde.org/?l=kde-bindings&m=122899325331866&w=2 mail list].

==Debugging==
If a method call can't be matched in the Smoke library giving a 'method_missing' error, first check that you are passing correct class instance that is properly initialized (with super method called in constructors of custom Qt classes descendants). You can also turn on debugging to trace the matching process:

<code ruby>
a = Qt::Application.new(ARGV)
Qt.debug_level = Qt::DebugLevel::High
a.loadLibrary("foo") # Non existent method
</code>

Will give the following output:

classname == QApplication
:: method == loadLibrary$
-> methodIds == []
candidate list:
Possible prototypes:
static QWidget* QApplication::widgetAt(int, int, bool)
...

Here, the list of candidate methods 'methodIds' is empty

Another debugging mechanism allows various trace 'channels' to be switched on.

You can trace virtual method callbacks:

<code ruby>
Qt::Internal::setDebug(Qt::QtDebugChannel::QTDB_VIRTUAL)
</code>

Or trace QtRuby garbage collection:

<code ruby>
Qt::Internal::setDebug(Qt::QtDebugChannel::QTDB_GC)
</code>

==String i18n==

QtRuby supports $KCODE values of 'u', 'e' and 's' or the corresponding '-K' options from the command line. Qt Designer .ui files have UTF-8 strings so if you use any 8 bit UTF-8 characters, you will need to set $KCODE='u' or use the -Ku command line option.

=Other capabilities and offerings=

==Qt Designer==
A 'rbuic4' tool is included in qtruby/tools/rbuic to compile .ui files into ruby code. As described above, Qt Designer uses UTF-8. In addition to the options in the original uic C++ utility an '-x' flag has been added. This will generate a top level stub in the code:

<code bash>
$ rbuic mainform.ui -x -o mainform.rb
</code>

Will add this to the end of the generated code:

<code ruby>
if $0 == __FILE__
a = Qt::Application.new(ARGV)
w = MainForm.new
w.show
a.exec
end
</code>

Then you can test the example code straight away:

$ ruby mainform.rb

Use the '-kde' option to require the 'korundum4' extension rather than the 'Qt4' one. If the '-x' option is used in conjunction, it generates a KDE top level. For example:

<code bash>
$ rbuic4 -x -kde knotifywidgetbase.ui -o knotifywidgetbase.rb
</code>

Will generate this top level code:

<code ruby>
if $0 == __FILE__
about = KDE::AboutData.new("knotifywidgetbase",
"KNotifyWidgetBase", "0.1")
KDE::CmdLineArgs.init(ARGV, about)
a = KDE::Application.new()
w = KNotifyWidgetBase.new
w.show
a.exec
end
</code>

==Loading .ui files at runtime with Qt::UILoader==
{{improve|Remove example that does not work}}

You can load a Qt Designer .ui file at runtime with the 'quiloader' extension, for example:

require 'Qt4'
require 'quiloader'

a = Qt::Application.new(ARGV)
if ARGV.length == 0
exit
end

if ARGV.length == 2
QUI::WidgetFactory.loadImages ARGV[0]
w = QUI::WidgetFactory.create ARGV[1]
if w.nil?
exit
end
w.show()
a.connect(a, SIGNAL('lastWindowClosed()'), a, SLOT('quit()'))
a.exec()
end

With new version API changed a little.

require 'Qt4'
require 'qtuitools'

a = Qt::Application.new(ARGV)
if ARGV.length == 0
exit
end

if ARGV.length == 1
file = Qt::File.new(ARGV[1])
file.open(Qt::File::ReadOnly)

loader = Qt::UiLoader.new
window = loader.load(file, nil)
file.close

if (window.nil?)
print "Error. Window is nil.\n"
exit
end
window.show
a.connect(a, SIGNAL('lastWindowClosed()'), a, SLOT('quit()'))
a.exec
end

==API reference==

Use the bin/rbqtapi tool to discover which methods are available in the QtRuby api. This command:

<code bash>
$ rbqtapi Qt::TextEdit
</code>

Will list all the methods in the Qt::TextEdit class

<code bash>
$ rbqtapi -rsetCaption
</code>

Lists all methods whose names contain the string 'setCaption'

==Example programs==

The best way to start programming QtRuby is to look at some existing code and start messing with it.. The are various samples under qtrubyexamples and korundum/examples.

=KDE Specific Infomation=
Instead of <code ruby>require 'Qt4'</code>, use<code ruby>require 'korundum4'</code> for KDE programs.

The KDE K* classes such as KApplication are renamed as KDE::Application. The other KDE classes are in the KParts::, KIO:: or DOM:: namespaces, with the same names as their C++ counterparts.

Use the 'rbkdeapi' script to introspect the Korundum api from the command line. For example:

<code bash>
$ rbkdeapi KDE::Action
</code>

Will list all the methods in the KDE::Action class. There are currently (as at KDE 3.3 beta 2) 977 classes/30841 methods in the Smoke library runtime, so the coverage of the Qt/KDE api is pretty complete.

=Build dependencies=

* ruby 1.8 or greater (svn trunk works with 1.9.1)
* cmake 2.6 or greater
* Qt 4.0 or greater
* KDE 4.1 or greater (for korundum)

=Tutorials=
There is a ruby translation of [http://developer.kde.org/language-bindings/ruby/tutorial/tutorial.html Qt Tutorial #1], and the corresponding ruby code is in qtruby/rubylib/tutorial/t1 to t14.

And a Qt4 version of the same tutorial translated to Ruby by Darshan Ishaya [[Development/Tutorials/Qt4_Ruby_Tutorial|Qt4 Ruby Tutorial]]

[http://developer.kde.org/language-bindings/ruby/tutorial2/tutorial2.html Qt Tutorial #2], a Charting Application with ruby code in qtruby/rubylib/examples/qt-examples/chart.

The Qt Designer [http://developer.kde.org/language-bindings/ruby/colortooltutorial/designer-manual-3.html Color Tool Tutorial], with ruby code in qtruby/rubylib/designer/examples/colortool.

Paul Lutus has written a tutorial on how to get started with [http://www.arachnoid.com/ruby/RubyGUIProject/index.html Ruby GUI programming with Qt]

For KDE, there is a ruby translation of this [http://developer.kde.org/language-bindings/ruby/kde3tutorial/index.html KDE 3.0 tutorial] originally written for C++ by Antonio Larrosa Jiménez. The sources are in korundum/rubylib/tutorials/p1 to p9.

The book [http://www.pragmaticprogrammer.com/titles/ctrubyqt/ Rapid GUI Development with QtRuby] is now available.

There is also an approach to create an [[/Ruby-Qt/KDE Book|Ruby-Qt/KDE Book]] under a free license. The content will be created in this wiki. The book made with latex will be derived from the content in the wiki. Any Questions? Contact [[User:SaLOUt|me]]!

=Download=
You can obtain recent SVN snapshots on the Rubyforge [http://rubyforge.org/projects/korundum/ QtRuby/Korundum site].

=More help=
There are two IRC channels (<tt><nowiki>#qtruby</nowiki></tt> and <tt><nowiki>#kde-ruby</nowiki></tt>) in [http://www.freenode.net FreeNode]. If you prefer e-mail, you can use the [http://mail.kde.org/mailman/listinfo/kde-bindings kde-bindings mailing-list] (low traffic) or ask in the [http://www.ruby-lang.org/en/20020104.html ruby-talk] mailing list (you may use the [http://www.ruby-forum.com/ Ruby Forum] gateway to post in ruby-talk from web).

=More information=
A series of articles on ruby QT (inspired by the work done for the [http://dradis.nomejortu.com dradis] project):
* [http://weblog.nomejortu.com/x-windows/ruby-workshop-the-way-of-the-qt-samurai ruby workshop: the way of the Qt samurai]
* [http://weblog.nomejortu.com/x-windows/ruby-qt-model-view-controller ruby Qt: model / view / controller]
* [http://weblog.nomejortu.com/x-windows/ruby-qt-menu-bar-status-bar-and-resources ruby Qt: menu bar, status bar and resources]
* [http://weblog.nomejortu.com/x-windows/ruby-qt-custom-widget-example ruby Qt custom widget example]
* [http://weblog.nomejortu.com/x-windows/ruby-qttreewidget-example ruby Qt::TreeWidget example]
* [http://www.ruby-forum.com/topic/189346#new Very usefull link how to create your first Qt window dialog]

[[Category:Ruby]]

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

2010-01-21T17:17:34Z

Robert Riemann: changed code snippets

{{TutorialBrowser|
series=Ruby|
name=Ruby-Qt/KDE Book|
pre=[[Development/Languages/Ruby/Ruby-Qt/KDE Book/Installation/Installation on Linux|Installation on Linux]], [[Development/Languages/Ruby/Ruby-Qt/KDE Book/Installation/Installation on Mac OS|Installation on Mac OS]] or [[Development/Languages/Ruby/Ruby-Qt/KDE Book/Installation/Installation on Windows|Installation on Windows]]|
reading=[http://en.wikipedia.org/wiki/Signals_and_slots Signals and Slots-Concept]
}}

{{Box|Status Of Writing|
[[Image:Action_pen.svg|noframe|left|40px]]{{Progress bar|80}}
TODO:
* improve writing style and remove spelling mistakes|100%}}

After all you should have a working ruby installation with KDE 4 bindings.

So lets try the a very minimalistic Qt 4 application to get a first impression. We don't start with KDE, because it would require some extra lines, that are not necessary when using Qt.

= Hello Ruby =

== Interactive Implementation Using Qt 4 ==

Open a shell and type in <tt>irb</tt> to start the interactive ruby shell.
Now copy the short code example into the irb session.

<code ruby>
require 'Qt4'
a = Qt::Application.new ARGV
w = Qt::PushButton.new "Hello Ruby"
Qt::Object.connect( w, SIGNAL( :clicked ), a, SLOT( :quit ) )
w.show
a.exec
</code>

Before you starting you start programming your Graphical User Interface (GUI), you have to <<tt>require</tt> the libraries, in this case <tt>Qt4</tt>, but <tt>korundum4</tt> would also do the job, because the KDE libs automatically also requires the Qt libs for you.

In the second line we create a new Qt Object a of <tt>Qt::Application</tt>. <tt>Qt</tt> is the Ruby module (namespace) and <tt>Application</tt> the name of the class in the module. In C++, the native language of Qt, you would write <tt>QApplication</tt>. Remember this as you will need it, if you want to take a look in the Qt documentation.

Another object w of <tt>Qt::PushButton</tt> is created in the third line. <tt>"Hello Ruby"</tt> is the first (and only) argument of the Constructor. If you check the Qt documentation, you would find out, that this is the caption of the button. Ruby would also allow you to write it with brackets.

<code ruby>
w = Qt::PushButton.new( "Hello Ruby" )
</code>

The small <tt>w</tt> means widget. All graphical elements in Qt are called widgets.

The fourth line is probably the most complicated one. The ruby class method <tt>connect</tt> of the object <tt>Object</tt> of the module <tt>Qt</tt> is used to bind the user action button-clicked with the action application-close. The signals and slots is a special concept of Qt. You can get a [http://en.wikipedia.org/wiki/Signals_and_slots short overview] and other ressources on Wikipedia.

The C++ equivalent you will find in the Qt documentation to <tt>:clicked</tt> would be <tt>"clicked()"</tt>, a signal without an argument. In the case of no arguments you can always use a ruby symbol.

The fifth line let the created widget show. Don't forget this line. Maybe you want to think of a starting point of your application.

At last the application gets started by <tt>a.exec</tt>. Now the GUI takes over and manages the control flow. Any other command after this line will be applied after the GUI was closed.

== Say Hello, Ruby ==

In the next example we want our GUI to do something interactively. Because it is more complex you may want to save it in a file "sayHello.rb".

If you are on a linux-based system, you can add on the top of the file a so called [http://en.wikipedia.org/wiki/Shebang_%28Unix%29 Shebang] line. After giving the file execution rights with <tt>chmod +x sayHello.rb</tt> by using the shell, you can execute your program with a click on the icon in the file browser or in the command line with <tt>./sayRuby.rb</tt>.

<code ruby>
#!/usr/bin/ruby
#file: sayHello.rb

require 'Qt4'

class CustomApplication < Qt::Application

slots :sayHello

def sayHello
msgBox = Qt::MessageBox.new
msgBox.text = "Hello World"
msgBox.icon = Qt::MessageBox::Information
val = msgBox.exec()

Qt::Application.instance.quit
end

end

a = CustomApplication.new ARGV
w = Qt::PushButton.new( "Say Hello, Ruby" )
Qt::Object.connect( w, SIGNAL( :clicked ), a, SLOT( :sayHello ) )
w.show
a.exec
</code>

In the last example we connected the button with the existing slot <tt>:close</tt>. Now we want to create our own slot. We create a new class <tt>CustomApplication</tt> by inheriting from <tt>Qt::Application</tt> and add a slot <tt>:sayHello</tt>. It doesn't have any arguments. So we can use the shortcut instead of <tt>"sayHello()"</tt>. After that we define a method with the same name and number of arguments. In the method a message box is prepared which get shown to the user with <tt>exec()</tt>. To define the properties of the message box, the binding specific syntax is used, which allows you to replace <tt>setText( "Hello World" )</tt> with <tt>text = "Hello World"</tt>. Remember this as you need it to find the class method in the C++ documentation of Qt.

With <tt>Qt::Application.instance.quit</tt> the program gets closed.

The last lines are nearly the same as in the last example. We have to replace <tt>Qt::Application</tt> with our own class <tt>CustomApplication</tt> and change the in the slot to <tt>:sayHello</tt> in the connection command.

== Say Hello, Ruby - the short version ==

<code ruby>
#!/usr/bin/ruby
#file: sayHello.rb

require 'Qt4'

a = Qt::Application.new ARGV
w = Qt::PushButton.new( "Say Hello, Ruby" )
w.connect( SIGNAL( :clicked ) ) do
msgBox = Qt::MessageBox.new
msgBox.text = "Hello World"
msgBox.icon = Qt::MessageBox::Information
val = msgBox.exec()

Qt::Application.instance.quit
end
w.show
a.exec
</code>

The bindings offer you a special features, which allows you to define the actions for a given signal without having to create a slot. Just use the <tt>connect</tt> method of the Qt object which owns the signal you want to use. The <tt>connect</tt> expects you to give only one argument,the signal, followd by a code block (<tt>do ... end</tt>), which gets processed in the case the signal is triggered. This way of programming allows a very compact style. In this case you don't need to create a <tt>CustomApplication</tt>.

== Say Hello, Ruby - an even shorter version ==

<code ruby>
require 'Qt4'

a = Qt::Application.new ARGV
w = Qt::PushButton.new( "Hello Ruby" ) do
self.connect( SIGNAL :clicked ) do
msgBox = Qt::MessageBox.new
msgBox.text = "Hello World"
msgBox.icon = Qt::MessageBox::Information
val = msgBox.exec()

Qt::Application.instance.quit
end
end
w.show
a.exec
</code>

If you create a new object, you can add a code block with some statements, that gets executed in the namespace of the new object. You can expand the usage on the <tt>msgBox</tt>, too.

<code ruby>
require 'Qt4'

a = Qt::Application.new ARGV
w = Qt::PushButton.new( "Hello Ruby" ) do
self.connect( SIGNAL :clicked ) do
msgBox = Qt::MessageBox.new do
self.text = "Hello World"
self.icon = Qt::MessageBox::Information
end
val = msgBox.exec()
Qt::Application.instance.quit
end
end
w.show
a.exec
</code>

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

2010-01-21T16:21:35Z

Robert Riemann: explain second code example

{{TutorialBrowser|
series=Ruby|
name=Ruby-Qt/KDE Book|
pre=[[Development/Languages/Ruby/Ruby-Qt/KDE Book/Installation/Installation on Linux|Installation on Linux]], [[Development/Languages/Ruby/Ruby-Qt/KDE Book/Installation/Installation on Mac OS|Installation on Mac OS]] or [[Development/Languages/Ruby/Ruby-Qt/KDE Book/Installation/Installation on Windows|Installation on Windows]]|
reading=[http://en.wikipedia.org/wiki/Signals_and_slots Signals and Slots-Concept]
}}

{{Box|Status Of Writing|
[[Image:Action_pen.svg|noframe|left|40px]]{{Progress bar|0}}|100%}}

After all you should have a working ruby installation with KDE 4 bindings.

So lets try the a very minimalistic Qt 4 application to get a first impression. We don't start with KDE, because it would require some extra lines, that are not necessary when using Qt.

= Hello Ruby =

== Interactive Implementation Using Qt 4 ==

Open a shell and type in <tt>irb</tt> to start the interactive ruby shell.
Now copy the short code example into the irb session.

<code ruby>
require 'Qt4'
a = Qt::Application.new ARGV
w = Qt::PushButton.new "Hello Ruby"
Qt::Object.connect( w, SIGNAL( :clicked ), a, SLOT( :quit ) )
w.show
a.exec
</code>

Before you starting you start programming your Graphical User Interface (GUI), you have to <<tt>require</tt> the libraries, in this case <tt>Qt4</tt>, but <tt>korundum4</tt> would also do the job, because the KDE libs automatically also requires the Qt libs for you.

In the second line we create a new Qt Object a of <tt>Qt::Application</tt>. <tt>Qt</tt> is the Ruby module (namespace) and <tt>Application</tt> the name of the class in the module. In C++, the native language of Qt, you would write <tt>QApplication</tt>. Remember this as you will need it, if you want to take a look in the Qt documentation.

Another object w of <tt>Qt::PushButton</tt> is created in the third line. <tt>"Hello Ruby"</tt> is the first (and only) argument of the Constructor. If you check the Qt documentation, you would find out, that this is the caption of the button. Ruby would also allow you to write it with brackets.

<code ruby>
w = Qt::PushButton.new( "Hello Ruby" )
</code>

The small <tt>w</tt> means widget. All graphical elements in Qt are called widgets.

The fourth line is probably the most complicated one. The ruby class method <tt>connect</tt> of the object <tt>Object</tt> of the module <tt>Qt</tt> is used to bind the user action button-clicked with the action application-close. The signals and slots is a special concept of Qt. You can get a [http://en.wikipedia.org/wiki/Signals_and_slots short overview] and other ressources on Wikipedia.

The C++ equivalent you will find in the Qt documentation to <tt>:clicked</tt> would be <tt>"clicked()"</tt>, a signal without an argument. In the case of no arguments you can always use a ruby symbol.

The fifth line let the created widget show. Don't forget this line. Maybe you want to think of a starting point of your application.

At last the application gets started by <tt>a.exec</tt>. Now the GUI takes over and manages the control flow. Any other command after this line will be applied after the GUI was closed.

== Say Hello, Ruby ==

In the next example we want our GUI to do something interactively. Because it is more complex you may want to save it in a file "sayHello.rb".

If you are on a linux-based system, you can add on the top of the file a so called [http://en.wikipedia.org/wiki/Shebang_%28Unix%29 Shebang] line. After giving the file execution rights with <tt>chmod +x sayHello.rb</tt> by using the shell, you can execute your program with a click on the icon in the file browser or in the command line with <tt>./sayRuby.rb</tt>.

<code ruby>
#!/usr/bin/ruby
#file: sayHello.rb

require 'Qt4'

class CustomApplication < Qt::Application

slots :sayHello

def sayHello
msgBox = Qt::MessageBox.new
msgBox.text = "Hello World"
msgBox.icon = Qt::MessageBox::Information
msgBox.standardButtons = Qt::MessageBox::Ok
val = msgBox.exec()

Qt::Application.instance.quit
end

end

a = CustomApplication.new ARGV
w = Qt::PushButton.new( "Say Hello, Ruby" )
Qt::Object.connect( w, SIGNAL( :clicked ), a, SLOT( :sayHello ) )
w.show
a.exec
</code>

In the last example we connected the button with the existing slot <tt>:close</tt>. Now we want to create our own slot. We create a new class <tt>CustomApplication</tt> by inheriting from <tt>Qt::Application</tt> and add a slot <tt>:sayHello</tt>. It doesn't have any arguments. So we can use the shortcut instead of <tt>"sayHello()"</tt>. After that we define a method with the same name and number of arguments. In the method a message box is prepared which get shown to the user with <tt>exec()</tt>. To define the properties of the message box, the binding specific syntax is used, which allows you to replace <tt>setText( "Hello World" )</tt> with <tt>text = "Hello World"</tt>. Remember this as you need it to find the class method in the C++ documentation of Qt.

With <tt>Qt::Application.instance.quit</tt> the program gets closed.

The last lines are nearly the same as in the last example. We have to replace <tt>Qt::Application</tt> with our own class <tt>CustomApplication</tt> and change the slot to <tt>:sayHello</tt>.

<code ruby>
require 'Qt4'

a = Qt::Application.new ARGV
w = Qt::PushButton.new( "Hello Ruby" )
w.connect( SIGNAL :clicked ) do
puts "Do something else"
Qt::Application.instance.quit
end
w.show
a.exec
</code>

<code ruby>
require 'Qt4'

a = Qt::Application.new ARGV
w = Qt::PushButton.new( "Hello Ruby" ) do
connect( SIGNAL :clicked ) do
puts "Do something else"
Qt::Application.instance.quit
end
end
w.show
a.exec
</code>

Development/Languages/Ruby/Ruby-Qt/KDE Book

2010-01-21T15:13:10Z

Robert Riemann: add link ruby editors

{{TutorialBrowser|
series=Ruby|
name=Ruby-Qt/KDE Book|
pre=basic level of ruby skills
}}

{{Box|Status Of Writing|
[[Image:Action_pen.svg|noframe|left|40px]]{{Progress bar|2}}|100%}}

= About Ruby Bindings =
Through the engagement of only a few guys the project [http://rubyforge.org/projects/korundum/ Korundum] on [http://rubyforge.org Rubyforge] was raised,
which allowed to use the famous [http://en.wikipedia.org/wiki/Qt_(toolkit) Qt toolkit] within the [[http://ruby-lang.org ruby language]]. The bindings were were ported to allow the use of Qt4 and KDE4. After years of development this
bindings can be considered as stable for production usage.
<ref name="kdebindings_stable01">Richard Dale: [http://www.kdedevelopers.org/node/4146 KDE Bindings in KDE 4.5]. In: his [http://www.kdedevelopers.org/blog/89 blog] (January 2010).</ref>

= Future Plans =
After creating a minimum of content the wiki pages will be copied into a
book made with [http://en.wikipedia.org/wiki/LaTeX LaTeX] for people prefering
to work with a printed version of this set of tutorials. Afterwards the book
should be synchronized with the wiki maybe every half year.

= Installation =

== Installation Of Ruby ==

;[[/Installation/Installation of Ruby|Installation of Ruby]]
:''setup ruby itself for end-user and developers''

== Installation Of Bindings ==

;[[/Installation/Installation on Linux|Installation on Linux]]
:''setup ruby bindings for end-user and developers on [http://en.wikipedia.org/wiki/Linux Linux]-based systems''

;[[/Installation/Installation on Mac OS|Installation on Mac OS]]
:''setup ruby bindings for end-user and developers on Apple [http://en.wikipedia.org/wiki/Mac_OS Mac OS]''

;[[/Installation/Installation on Windows|Installation on Windows]]
:''setup ruby bindings for end-user and developers on Microsoft [http://en.wikipedia.org/wiki/Windows Windows]''

= The Ruby Language =

== Introduction ==

Before starting into Ruby-KDE hacking you may want to refresh your Ruby.
Or do you meet Ruby for the first time? Take a look on these sites:

;http://ruby-lang.org
:''Official Ruby Homepage with a lot of information''

;[http://mislav.uniqpath.com/poignant-guide/ Why's (Poignant) Guide to Ruby]
:''Very famous ruby guide in comic style''

;http://tryruby.org/
:'' Test Ruby right in your browser''

;http://ruby-doc.org
:''a lot of ruby documentation with usefull links''

;http://en.wikibooks.org/wiki/Ruby_Programming
:''Ruby Programming from Wikibooks''

== Usefull Tools ==

;http://pastie.org
:''Share Ruby code with friends (i.e. in IRC)''

;http://refactormycode.com
:''Share usefull code snippets in different languages and learn from other people''

;http://vim-ruby.rubyforge.org
:''Improve the [http://www.vim.org Vim] editor with intelligent Ruby code completion features''

;[http://en.wikibooks.org/wiki/Ruby_Programming/Ruby_editors Ruby Editors]
:''List from the Ruby Programming Wikibook''

= First Steps =

;[[Development/Languages/Ruby/Ruby-Qt/KDE Book/First Steps/Hello World|Hello World]]
:''Start with some simple ruby programs using Qt''

= References =
<references/>
[[Category:KDE4]]
[[Category:Ruby]]

Development/Languages/Ruby/Ruby-Qt/KDE Book

2010-01-21T12:21:55Z

Robert Riemann: add links

{{TutorialBrowser|
series=Ruby|
name=Ruby-Qt/KDE Book|
pre=basic level of ruby skills
}}

{{Box|Status Of Writing|
[[Image:Action_pen.svg|noframe|left|40px]]{{Progress bar|2}}|100%}}

= About Ruby Bindings =
Through the engagement of only a few guys the project [http://rubyforge.org/projects/korundum/ Korundum] on [http://rubyforge.org Rubyforge] was raised,
which allowed to use the famous [http://en.wikipedia.org/wiki/Qt_(toolkit) Qt toolkit] within the [[http://ruby-lang.org ruby language]]. The bindings were were ported to allow the use of Qt4 and KDE4. After years of development this
bindings can be considered as stable for production usage.
<ref name="kdebindings_stable01">Richard Dale: [http://www.kdedevelopers.org/node/4146 KDE Bindings in KDE 4.5]. In: his [http://www.kdedevelopers.org/blog/89 blog] (January 2010).</ref>

= Future Plans =
After creating a minimum of content the wiki pages will be copied into a
book made with [http://en.wikipedia.org/wiki/LaTeX LaTeX] for people prefering
to work with a printed version of this set of tutorials. Afterwards the book
should be synchronized with the wiki maybe every half year.

= Installation =

== Installation Of Ruby ==

;[[/Installation/Installation of Ruby|Installation of Ruby]]
:''setup ruby itself for end-user and developers''

== Installation Of Bindings ==

;[[/Installation/Installation on Linux|Installation on Linux]]
:''setup ruby bindings for end-user and developers on [http://en.wikipedia.org/wiki/Linux Linux]-based systems''

;[[/Installation/Installation on Mac OS|Installation on Mac OS]]
:''setup ruby bindings for end-user and developers on Apple [http://en.wikipedia.org/wiki/Mac_OS Mac OS]''

;[[/Installation/Installation on Windows|Installation on Windows]]
:''setup ruby bindings for end-user and developers on Microsoft [http://en.wikipedia.org/wiki/Windows Windows]''

= The Ruby Language =

== Introduction ==

Before starting into Ruby-KDE hacking you may want to refresh your Ruby.
Or do you meet Ruby for the first time? Take a look on these sites:

;http://ruby-lang.org
:''Official Ruby Homepage with a lot of information''

;[http://mislav.uniqpath.com/poignant-guide/ Why's (Poignant) Guide to Ruby]
:''Very famous ruby guide in comic style''

;http://tryruby.org/
:'' Test Ruby right in your browser''

;http://ruby-doc.org
:''a lot of ruby documentation with usefull links''

;http://en.wikibooks.org/wiki/Ruby_Programming
:''Ruby Programming from Wikibooks''

== Usefull Tools ==

;http://pastie.org
:''Share Ruby code with friends (i.e. in IRC)''

;http://refactormycode.com
:''Share usefull code snippets in different languages and learn from other people''

;http://vim-ruby.rubyforge.org
:''Improve the [http://www.vim.org Vim] editor with intelligent Ruby code completion features''

= First Steps =

;[[Development/Languages/Ruby/Ruby-Qt/KDE Book/First Steps/Hello World|Hello World]]
:''Start with some simple ruby programs using Qt''

= References =
<references/>
[[Category:KDE4]]
[[Category:Ruby]]

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

2010-01-20T20:03:43Z

Robert Riemann: add explanations

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

2010-01-20T19:54:50Z

Robert Riemann: explain hello ruby program

Development/Languages/Ruby/Ruby-Qt/KDE Book

2010-01-20T19:16:30Z

Robert Riemann: add wikibook link ruby programming

{{Template:I18n/Language Navigation Bar|Development/Languages/Ruby/Ruby-Qt/KDE_Book}}

{{TutorialBrowser|
series=Ruby|
name=Ruby-Qt/KDE Book|
pre=basic level of ruby skills
}}

{{Box|Status Of Writing|
[[Image:Action_pen.svg|noframe|left|40px]]{{Progress bar|2}}|100%}}

= About Ruby Bindings =
Through the engagement of only a few guys the project [http://rubyforge.org/projects/korundum/ Korundum] on [http://rubyforge.org Rubyforge] was raised,
which allowed to use the famous [http://en.wikipedia.org/wiki/Qt_(toolkit) Qt toolkit] within the [[http://ruby-lang.org ruby language]]. The bindings were were ported to allow the use of Qt4 and KDE4. After years of development this
bindings can be considered as stable for production usage.
<ref name="kdebindings_stable01">Richard Dale: [http://www.kdedevelopers.org/node/4146 KDE Bindings in KDE 4.5]. In: his [http://www.kdedevelopers.org/blog/89 blog] (January 2010).</ref>

= Future Plans =
After creating a minimum of content the wiki pages will be copied into a
book made with [http://en.wikipedia.org/wiki/LaTeX LaTeX] for people prefering
to work with a printed version of this set of tutorials. Afterwards the book
should be synchronized with the wiki maybe every half year.

= Installation =

== Installation Of Ruby ==

;[[/Installation/Installation of Ruby|Installation of Ruby]]
:''setup ruby itself for end-user and developers''

== Installation Of Bindings ==

;[[/Installation/Installation on Linux|Installation on Linux]]
:''setup ruby bindings for end-user and developers on [http://en.wikipedia.org/wiki/Linux Linux]-based systems''

;[[/Installation/Installation on Mac OS|Installation on Mac OS]]
:''setup ruby bindings for end-user and developers on Apple [http://en.wikipedia.org/wiki/Mac_OS Mac OS]''

;[[/Installation/Installation on Windows|Installation on Windows]]
:''setup ruby bindings for end-user and developers on Microsoft [http://en.wikipedia.org/wiki/Windows Windows]''

= Introduction To Ruby Language =

Before starting into Ruby-KDE hacking you may want to refresh your Ruby.
Or do you meet Ruby for the first time? Take a look on these sites:

;http://ruby-lang.org
:''Official Ruby Homepage with a lot of information''

;[http://mislav.uniqpath.com/poignant-guide/ Why's (Poignant) Guide to Ruby]
:''Very famous ruby guide in comic style''

;http://tryruby.org/
:'' Test Ruby right in your browser''

;http://ruby-doc.org/
:''a lot of ruby documentation with usefull links''

;http://en.wikibooks.org/wiki/Ruby_Programming
:''Ruby Programming from Wikibooks''

= First Steps =

;[[Development/Languages/Ruby/Ruby-Qt/KDE Book/First Steps/Hello World|Hello World]]
:''Start with some simple ruby programs using Qt''

= References =
<references/>
[[Category:KDE4]]
[[Category:Ruby]]

Development/Languages/Ruby/Ruby-Qt/KDE Book

2010-01-20T00:07:00Z

Robert Riemann: add some ruby learning links

{{Template:I18n/Language Navigation Bar|Development/Languages/Ruby/Ruby-Qt/KDE_Book}}

{{TutorialBrowser|
series=Ruby|
name=Ruby-Qt/KDE Book|
pre=basic level of ruby skills
}}

{{Box|Status Of Writing|
[[Image:Action_pen.svg|noframe|left|40px]]{{Progress bar|2}}|100%}}

= About Ruby Bindings =
Through the engagement of only a few guys the project [http://rubyforge.org/projects/korundum/ Korundum] on [http://rubyforge.org Rubyforge] was raised,
which allowed to use the famous [http://en.wikipedia.org/wiki/Qt_(toolkit) Qt toolkit] within the [[http://ruby-lang.org ruby language]]. The bindings were were ported to allow the use of Qt4 and KDE4. After years of development this
bindings can be considered as stable for production usage.
<ref name="kdebindings_stable01">Richard Dale: [http://www.kdedevelopers.org/node/4146 KDE Bindings in KDE 4.5]. In: his [http://www.kdedevelopers.org/blog/89 blog] (January 2010).</ref>

= Future Plans =
After creating a minimum of content the wiki pages will be copied into a
book made with [http://en.wikipedia.org/wiki/LaTeX LaTeX] for people prefering
to work with a printed version of this set of tutorials. Afterwards the book
should be synchronized with the wiki maybe every half year.

= Installation =

== Installation Of Ruby ==

;[[/Installation/Installation of Ruby|Installation of Ruby]]
:''setup ruby itself for end-user and developers''

== Installation Of Bindings ==

;[[/Installation/Installation on Linux|Installation on Linux]]
:''setup ruby bindings for end-user and developers on [http://en.wikipedia.org/wiki/Linux Linux]-based systems''

;[[/Installation/Installation on Mac OS|Installation on Mac OS]]
:''setup ruby bindings for end-user and developers on Apple [http://en.wikipedia.org/wiki/Mac_OS Mac OS]''

;[[/Installation/Installation on Windows|Installation on Windows]]
:''setup ruby bindings for end-user and developers on Microsoft [http://en.wikipedia.org/wiki/Windows Windows]''

= Introduction To Ruby Language =

Before starting into Ruby-KDE hacking you may want to refresh your Ruby.
Or do you meet Ruby for the first time? Take a look on these sites:

;http://ruby-lang.org
:''Official Ruby Homepage with a lot of information''

;[http://mislav.uniqpath.com/poignant-guide/ Why's (Poignant) Guide to Ruby]
:''Very famous ruby guide in comic style''

;http://tryruby.org/
:'' Test Ruby right in your browser''

;http://ruby-doc.org/
:''a lot of ruby documentation with usefull links''

= First Steps =

;[[Development/Languages/Ruby/Ruby-Qt/KDE Book/First Steps/Hello World|Hello World]]
:''Start with some simple ruby programs using Qt''

= References =
<references/>
[[Category:KDE4]]
[[Category:Ruby]]

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

2010-01-19T23:02:18Z

Robert Riemann: insert code examples, code works

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

2010-01-19T22:36:26Z

Robert Riemann: add some code

Development/Languages/Ruby/Ruby-Qt/KDE Book/Installation/Installation on Linux

2010-01-19T22:05:32Z

Robert Riemann: add next step and a note for gnome users

{{TutorialBrowser|
series=Ruby|
name=Ruby-Qt/KDE Book|
pre=[[Development/Languages/Ruby/Ruby-Qt/KDE Book/Installation/Installation of Ruby|Installation of Ruby]]|
next=[[Development/Languages/Ruby/Ruby-Qt/KDE Book/First Steps/Hello World|Hello World]]
}}

{{Box|Status Of Writing|
[[Image:Action_pen.svg|noframe|left|40px]]{{Progress bar|30}}|100%}}

In comparison to the installation process on [[Development/Languages/Ruby/Ruby-Qt/KDE Book/Installation/Installation on Windows|Microsoft Windows]] or [[Development/Languages/Ruby/Ruby-Qt/KDE Book/Installation/Installation on Mac OS|Apple Mac OS]] you have to deal with the fact, that there are a lot of different Linux-based operating systems. So there are also different ways to setup your environment for kdebindings.

After [[Development/Languages/Ruby/Ruby-Qt/KDE Book/Installation/Installation of Ruby|installing and testing your Ruby installation]], you you should check before starting to install something if your [http://en.wikipedia.org/wiki/Linux_distribution Linux distribution] has the bindings preinstalled.

= Test Bindings Installation =

Maybe the Qt/KDE bindings are already installed. For a quick check, enter <tt>irb</tt> in a shell to start the interactive ruby shell. Try to load the bindings.

<code ruby>
require "Qt4"
=> true
require "korundum4"
=> true
</code>

You can load bindings for KDE 4 (korundum4) or only Qt 4 by a <tt>require</tt>. Later you won't need to load Qt 4 first when using KDE 4, because on requiring KDE 4 everything needed is loaded automatically.

If you got it so far you seem to have a working environment.

= Installation =

There is always the possibility to install the bindings from source code, but it is recommended to use the existing binary packages.

== Installation On Linux-based Systems ==

After [[Development/Languages/Ruby/Ruby-Qt/KDE Book/Installation/Installation of Ruby|installing Ruby]] you should know how to use your package manager.

Install the package "ruby-kde4" or something like that. Be aware, that there maybe exist a package "ruby-kde", which probably contain the old version of the bindings with KDE 3. Consider furthermore, that you will need a lot of KDE dependencies, if you are working on a GNOME desktop environment.

== Installation On Mac OS ==

TODO

== Installation On Windows ==

TODO

Development/Languages/Ruby/Ruby-Qt/KDE Book/Installation/Installation of Ruby

2010-01-19T21:46:36Z

Robert Riemann: add installation: general, openSUSE, ubuntu

{{TutorialBrowser|
series=Ruby|
name=Ruby-Qt/KDE Book|
next=[[Development/Languages/Ruby/Ruby-Qt/KDE Book/Installation/Installation on Linux|Installation on Linux]], [[Development/Languages/Ruby/Ruby-Qt/KDE Book/Installation/Installation on Mac OS|Installation on Mac OS]] or [[Development/Languages/Ruby/Ruby-Qt/KDE Book/Installation/Installation on Windows|Installation on Windows]]
}}

{{Box|Status Of Writing|
[[Image:Action_pen.svg|noframe|left|40px]]{{Progress bar|10}}|100%}}

Before you can use the Qt/KDE bindings with Ruby, you have to install Ruby itself.
On the most linux-based systems, ruby should be installed already. So just check before installing it, if it is installed already. On Windows and Mac OS it isn't most likely preinstalled.

= Test Installation Of Ruby =

Start a shell and try to get the version of your ruby installation. In the case of a working ruby installation you get something like this.

<code bash>
> ruby -v
ruby 1.8.7 (2008-08-11 patchlevel 72) [x86_64-linux]
</code>

In any other case you can proceed to install ruby and check afterwards the installation again.

= Installation Of Ruby =

General information are also provided by the [http://www.ruby-lang.org/ official ruby site] on their [http://www.ruby-lang.org/en/downloads/ download page].

== Installation On Linux-based Systems ==

The most linux packages delivers already configured binary packages of ruby that can be installed by the package manager of your distribution. This way is recommended. The installation from source code is possible, but not preferred, because the automatic installation of the bindings requires the binary package of ruby. The installation of ruby by source code should be not complicated, but installing the bindings manually requires advanced knowledge in different development tools.

;Generic Installation
:Start you favorite distribution specific package manager and add a the package "ruby". There may be some additional packages like "ruby-devel", "ruby-doc", etc. Maybe you want to install them to.

;Installation on [http://opensuse.org openSUSE]
:Start YaST, open the module called something like "add/delete Software", change to Installation Patterns and activate "Ruby Development". Install the chosen packages.

;Installation on [http://www.ubuntu.com/ Ubuntu]
:Follow the [https://help.ubuntu.com/community/SoftwareManagement specific ubuntu help] to install the ruby package.

== Installation On Mac OS ==

TODO

== Installation On Windows ==

TODO

Development/Languages/Ruby/Ruby-Qt/KDE Book

2010-01-19T21:11:33Z

Robert Riemann:

{{Template:I18n/Language Navigation Bar|Development/Languages/Ruby/Ruby-Qt/KDE_Book}}

{{TutorialBrowser|
series=Ruby|
name=Ruby-Qt/KDE Book|
pre=basic level of ruby skills
}}

{{Box|Status Of Writing|
[[Image:Action_pen.svg|noframe|left|40px]]{{Progress bar|2}}|100%}}

= About Ruby Bindings =
Through the engagement of only a few guys the project [http://rubyforge.org/projects/korundum/ Korundum] on [http://rubyforge.org Rubyforge] was raised,
which allowed to use the famous [http://en.wikipedia.org/wiki/Qt_(toolkit) Qt toolkit] within the [[http://ruby-lang.org ruby language]]. The bindings were were ported to allow the use of Qt4 and KDE4. After years of development this
bindings can be considered as stable for production usage.
<ref name="kdebindings_stable01">Richard Dale: [http://www.kdedevelopers.org/node/4146 KDE Bindings in KDE 4.5]. In: his [http://www.kdedevelopers.org/blog/89 blog] (January 2010).</ref>

= Future Plans =
After creating a minimum of content the wiki pages will be copied into a
book made with [http://en.wikipedia.org/wiki/LaTeX LaTeX] for people prefering
to work with a printed version of this set of tutorials. Afterwards the book
should be synchronized with the wiki maybe every half year.

= Installation =

== Installation Of Ruby ==

;[[/Installation/Installation of Ruby|Installation of Ruby]]
:''setup ruby itself for end-user and developers''

== Installation Of Bindings ==

;[[/Installation/Installation on Linux|Installation on Linux]]
:''setup ruby bindings for end-user and developers on [http://en.wikipedia.org/wiki/Linux Linux]-based systems''

;[[/Installation/Installation on Mac OS|Installation on Mac OS]]
:''setup ruby bindings for end-user and developers on Apple [http://en.wikipedia.org/wiki/Mac_OS Mac OS]''

;[[/Installation/Installation on Windows|Installation on Windows]]
:''setup ruby bindings for end-user and developers on Microsoft [http://en.wikipedia.org/wiki/Windows Windows]''

= Introduction To Ruby Language =
Welcome Text
;[[/Ruby|Ruby]]
:''description''

= References =
<references/>
[[Category:KDE4]]
[[Category:Ruby]]

Development/Languages/Ruby/Ruby-Qt/KDE Book/Installation/Installation on Linux

2010-01-19T21:07:30Z

Robert Riemann: Created page with '{{Box|Status Of Writing| 40px{{Progress bar|10}}|100%}} In comparison to the installation process on [[Development/Languages/Ruby/Ruby-Qt/K...'

{{Box|Status Of Writing|
[[Image:Action_pen.svg|noframe|left|40px]]{{Progress bar|10}}|100%}}

In comparison to the installation process on [[Development/Languages/Ruby/Ruby-Qt/KDE Book/Installation/Installation on Windows|Microsoft Windows]] or [[Development/Languages/Ruby/Ruby-Qt/KDE Book/Installation/Installation on Mac OS|Apple Mac OS]] you have to deal with the fact, that there are a lot of different Linux-based operating systems. So there are also different ways to setup your environment for kdebindings.

First you should check before starting to install something if your [http://en.wikipedia.org/wiki/Linux_distribution Linux distribution] has ruby and/or the bindings preinstalled.

= Test Installation =

Start a shell on your Linux system and type and try to get the version of your ruby installation. In the case of a working ruby installation you get something like this.

<code bash>
> ruby -v
ruby 1.8.7 (2008-08-11 patchlevel 72) [x86_64-linux]
</code>

Maybe the Qt/KDE bindings are installed, too. For a quick check, enter <tt>irb</tt> in a shell to start the interactive ruby-shell. Try to load the bindings.

<code ruby>
require "Qt4"
=> true
require "korundum4"
=> true
</code>

You can load bindings for KDE4 (korundum4) or only Qt4 by a <tt>require</tt>. Later you won't need to load Qt4 first when using KDE4, because on requiring KDE4 everything needed is loaded automatically.

If you got it so far you seems to have a working environment.

= Installation =

== Installation of ruby ==

If you haven't ruby installed, you have two different ways to get it.

# using the distribution package manager to install ruby automatically
# install ruby manually from source.

I recommend the first way.

Development/Languages/Ruby/Ruby-Qt/KDE Book

2010-01-19T19:07:36Z

Robert Riemann:

{{Template:I18n/Language Navigation Bar|Development/Languages/Ruby/Ruby-Qt/KDE_Book}}

{{TutorialBrowser|
series=Ruby|
name=Ruby-Qt/KDE Book|
pre=basic level of ruby skills
}}

{{note|This book is work in progress. Don't hesitate to contribute!}}

== About Ruby Bindings ==
Through the engagement of only a few guys the project [http://rubyforge.org/projects/korundum/ Korundum] on [http://rubyforge.org Rubyforge] was raised,
which allowed to use the famous [http://en.wikipedia.org/wiki/Qt_(toolkit) Qt toolkit] within the [[http://ruby-lang.org ruby language]]. The bindings were were ported to allow the use of Qt4 and KDE4. After years of development this
bindings can be considered as stable for production usage.
<ref name="kdebindings_stable01">Richard Dale: [http://www.kdedevelopers.org/node/4146 KDE Bindings in KDE 4.5]. In: his [http://www.kdedevelopers.org/blog/89 blog] (January 2010).</ref>

== Future Plans ==
After creating a minimum of content the wiki pages will be copied into a
book made with [http://en.wikipedia.org/wiki/LaTeX LaTeX] for people prefering
to work with a printed version of this set of tutorials. Afterwards the book
should be synchronized with the wiki maybe every half year.

== Installation ==

;[[/Installation/Installation on Linux|Installation on Linux]]
:''setup ruby bindings for end-user and developers on [http://en.wikipedia.org/wiki/Linux Linux]-based systems''

;[[/Installation/Installation on Mac OS|Installation on Mac OS]]
:''setup ruby bindings for end-user and developers on Apple [http://en.wikipedia.org/wiki/Mac_OS Mac OS]''

;[[/Installation/Installation on Windows|Installation on Windows]]
:''setup ruby bindings for end-user and developers on Microsoft [http://en.wikipedia.org/wiki/Windows Windows]''

== Introduction To Ruby Language ==
Welcome Text
;[[/Ruby|Ruby]]
:''description''

== References ==
<references/>
[[Category:KDE4]]
[[Category:Ruby]]

Development/Languages/Ruby/Ruby-Qt/KDE Book

2010-01-19T19:05:27Z

Robert Riemann: add future plans and links to installation on ...

{{Template:I18n/Language Navigation Bar|Development/Languages/Ruby/Ruby-Qt/KDE_Book}}

{{TutorialBrowser|
series=Ruby|
name=Ruby-Qt/KDE Book|
pre=basic level of ruby skills
}}

{{note|This book is work in progress. Don't hesitate to contribute!}}

== About Ruby Bindings ==
Through the engagement of only a few guys the project [http://rubyforge.org/projects/korundum/ Korundum] on [http://rubyforge.org Rubyforge] was raised,
which allowed to use the famous [http://en.wikipedia.org/wiki/Qt_(toolkit) Qt toolkit] within the [[http://ruby-lang.org ruby language]]. The bindings were were ported to allow the use of Qt4 and KDE4. After years of development this
bindings can be considered as stable for production usage.
<ref name="kdebindings_stable01">Richard Dale: [http://www.kdedevelopers.org/node/4146 KDE Bindings in KDE 4.5]. In: his [http://www.kdedevelopers.org/blog/89 blog] (January 2010).</ref>

== Future Plans ==
After creating a minimum of content the wiki pages will be copied into a
book made with [http://en.wikipedia.org/wiki/LaTeX LaTeX] for people prefering
to work with a printed version of this set of tutorials. Afterwards the book
should be synchronized with the wiki maybe every half year.

== Installation ==
Installation on [http://en.wikipedia.org/wiki/Linux Linux]
;[[/Installation/Installation on Linux|Installation on Linux]]
:''setup ruby bindings for end-user and developers on linux-based systems''

Installation on [http://en.wikipedia.org/wiki/Mac_OS Mac OS]
;[[/Installation/Installation on Mac OS|Installation on Mac OS]]
:''setup ruby bindings for end-user and developers on Apple Mac OS''

Installation on [http://en.wikipedia.org/wiki/Windows Windows]
;[[/Installation/Installation on Windows|Installation on Windows]]
:''setup ruby bindings for end-user and developers on Microsoft Windows''

== Introduction To Ruby Language ==
Welcome Text
;[[/Ruby|Ruby]]
:''description''

== References ==
<references/>
[[Category:KDE4]]
[[Category:Ruby]]

Development/Languages/Ruby/Ruby-Qt/KDE Book

2010-01-19T18:55:55Z

Robert Riemann:

{{Template:I18n/Language Navigation Bar|Development/Languages/Ruby/Ruby-Qt/KDE_Book}}

{{TutorialBrowser|
series=Ruby|
name=Ruby-Qt/KDE Book|
pre=basic level of ruby skills
}}

{{note|This book is work in progress. Don't hesitate to contribute!}}

== About Ruby Bindings ==
Through the engagement of only a few guys the project [http://rubyforge.org/projects/korundum/ Korundum] on [http://rubyforge.org Rubyforge] was raised,
which allowed to use the famous [http://en.wikipedia.org/wiki/Qt_(toolkit) Qt toolkit] within the [[http://ruby-lang.org ruby language]]. The bindings were were ported to allow the use of Qt4 and KDE4. After years of development this
bindings can be considered as stable for production usage.
<ref name="kdebindings_stable01">Richard Dale: [http://www.kdedevelopers.org/node/4146 KDE Bindings in KDE 4.5]. In: his [http://www.kdedevelopers.org/blog/89 blog] (January 2010).</ref>

== Future Plans ==
plans

== Installation ==

== Introduction To Ruby Language ==
Welcome Text
;[[/Ruby|Ruby]]
:''description''

== References ==
<references/>
[[Category:KDE4]]
[[Category:Ruby]]

Development/Languages/Ruby/Ruby-Qt/KDE Book

2010-01-19T18:45:58Z

Robert Riemann: about ruby bindings

{{Template:I18n/Language Navigation Bar|Development/Languages/Ruby/Ruby-Qt/KDE_Book}}

{{TutorialBrowser|
series=Ruby|
name=Ruby-Qt/KDE Book|
pre=basic level of ruby skills
}}

{{note|This book is work in progress. Don't hesitate to contribute!}}

== About Ruby Bindings ==
Through the engagement of only a few guys the project [http://rubyforge.org/projects/korundum/ Korundum] on [http://rubyforge.org Rubyforge] was raised,
which allowed to use the famous [http://en.wikipedia.org/wiki/Qt_(toolkit) Qt toolkit] within the [[http://ruby-lang.org ruby language]]. The bindings were were ported to allow the use of Qt4 and KDE4. After years of development this
bindings can be considered as stable for production usage.
<ref name="kdebindings_stable01">Richard Dale: [http://www.kdedevelopers.org/node/4146 KDE Bindings in KDE 4.5]., In: his [[http://www.kdedevelopers.org/blog/89 blog]] (January 2010).</ref>

== Future Plans ==
plans

== Installation ==

== Introduction To Ruby Language ==
Welcome Text
;[[/Ruby|Ruby]]
:''description''

[[Category:KDE4]]
[[Category:Ruby]]

Development/Tutorials

2010-01-19T18:17:56Z

Robert Riemann: added ruby-qt/kde book to Ruby section

{{Template:I18n/Language Navigation Bar|Development/Tutorials}}

Tutorials are the fastest way of finding out what KDE will do for you, and how to do it. Here is a list of currently available tutorials '''for KDE4'''. Material for KDE3 and KDE2 is available on the bottom of this page.

== Introduction To KDE 4 Programming ==
Are you interested in writing applications with KDE 4? This tutorial series is aimed at those completely new to KDE programming.
;[[Development/Tutorials/First program|Hello World]]
:''A preliminary introduction to the very basics of KDE4 programming''

;[[Development/Tutorials/Using KXmlGuiWindow|Creating the Main Window]]
:''This tutorial shows you the magic of an application's most important thing: The main window.''

;[[Development/Tutorials/Using KActions|Using KActions]]
:''How to add actions to the menus and toolbars.''

;[[Development/Tutorials/Saving and loading|Saving and Loading]]
:''Introduces the KIO library while adding loading and saving support to our application.''

;[[Development/Tutorials/KCmdLineArgs|Command line arguments]]
:''Adds the ability to specify which file to open from the command line to our text editor.''

== Basics ==
;[[Development/Tutorials/KDE4 Porting Guide|Porting Your Application]]
:''Help Porting Applications from Qt3/KDE3 to Qt4/KDE4''

;[[Development/Tutorials/CMake|Introduction to CMake]]
:''How to use the CMake build system used by KDE4.''

;[[Development/Tutorials/Common Programming Mistakes|Common Programming Mistakes]]
:''Various common mistakes made while developing Qt and KDE applications and how to avoid them.''

;[[Development/Tutorials/Using Qt Designer|Using Qt Designer to build user interfaces]]
:''How to create UI files with designer, and how to integrate them into a KDE program.''

;[[Development/Tutorials/Creating Libraries|Creating Libraries to share code]]
:''How to add the library to the buildsystem and how to prepare the source code.''

;[[Development/Tutorials/Session_Management|Session Management]]
:''Make your application aware of X sessions''

== Testing And Debugging ==

;[[Development/Tutorials/Debugging|Debugging your application]]
:''Tips, tools and techniques to apply when debugging your KDE application''

;[[Development/Tutorials/Unittests|Writing Unittests for Qt4 and KDE4 with QTestLib]] ([http://developer.kde.org/documentation/tutorials/writingunittests/writingunittests.html Original link])
:''Tutorial by [mailto:bradh@frogmouth.net Brad Hards] that describes how to write unit tests using the QTestLib framework. It is presented as an example based tutorial, and is still under development.''

;[[Development/Tutorials/Code_Checking|Semi-automatic ways to detect code errors]]
:''Techniques you can use to detect errors in KDE code''

== Managing Configuration Data With KConfig ==
;[[Development/Tutorials/KConfig|Introduction To KConfig]]
:''An overview of the KConfig classes and how to use them in your application code''

;[[Development/Tutorials/Using KConfig XT|Using KConfig XT]]
:''Tutorial on how to efficiently use the KConfig XT framework.''

;[[Development/Tutorials/Updating KConfig Files|Updating KConfig Files]]
:''Tutorial on how to write an update script to keep changes in your application's config file format in sync with the user's already existing config file''

== Services: Applications and Plugins ==
;[[Development/Tutorials/Services/Introduction|Introduction to the Services Framework]]
:''An overview of the services framework in KDE and what it provides the application developer. Covers the system configuration cache (SyCoCa), the source data files and what the indexed information can be used for.''

;[[Development/Tutorials/Services/Traders|Finding Services Using Trader Queries]]
:''How to find services, such as plugins or mimetypes, that are indexed in the SyCoCa using Trader Query Syntax''

;[[Development/Tutorials/Services/Plugins|Creating and Loading Plugins Using KService]]
:''Learn how to define custom plugin types, find installed plugins (including 3rd party plugins) and load them in an easy and portable fashion using KService.''

== Localization ==
See also [[Localization|Localization portal]].

;[[Development/Tutorials/Localization/Unicode|Introduction To Unicode]]
:''An introduction to what Unicode is as well as how to handle Unicode data in KDE applications.''

; [[Development/Tutorials/Localization/i18n|Writing Applications With Localization In Mind]]
:''This tutorial covers what localization is, why it's important and how to ensure your application is ready to be localized. A must read for all application developers.''

; [[Development/Tutorials/Localization/i18n Mistakes|Avoiding Common Localization Pitfalls]]
:''There are several common mistakes that prevent applications from being properly localized. Find out what they are and how to easily avoid them in this tutorial.''

; [[Development/Tutorials/Localization/Building KDE's l10n Module|Building KDE's Localization Module]]
:''Building and installing language support from KDE's localization (l10n) module is a good idea for those working on applications in the main KDE repository. Doing so will allow you to test your application in another language and spot problem areas. Learn how to do just that in this tutorial.''

; [[Development/Tutorials/Localization/i18n Build Systems|Incorporating i18n Into the Build System]]
:''Once your application is ready to be localized, the next step is to ensure that translation files are built automatically and kept up to date. This tutorial covers the necessary CMakeFiles.txt additions as well the process of distributing the resulting message catalogs with your application.''

; [[Development/Tutorials/Localization/i18n Challenges|Common i18n Challenges and Solutions]]
:''This tutorial covers challenges that you may eventually run into such as translating handbooks and other data that exists outside of the source code, merging and handling obsolete .po files, dealing with freezes, coding in languages other than English and creating independent releases of or moving applications between KDE modules.''

; [[Development/Tutorials/Localization/i18n_Semantics|Semantic Markup of Messages]]
:''To ensure consistent presentation and more meaningful representations of messages in applications, semantic markup can be applied to messages marked for translation using the KUIT system. This tutorial describes how this system works.''

; [[Development/Tutorials/Localization/i18n Krazy|Automated i18n Code Checking]]
:''The Krazy code checker scans KDE's code and reports common i18n mistakes.''

== Documentation ==

;[[Development/Tutorials/API_Documentation|API Documentation]]
:''This tutorial explains how to document your APIs properly.''

;[[Development/Tutorials/Man_Pages|Man Pages]]
:''Writing and Generating Reference Manual Pages.''

== Application Automation and Scripting ==

=== D-Bus ===
; [[Development/Tutorials/D-Bus/Introduction|Introduction to D-Bus]]
:''A straight-forward introduction to the core concepts in D-Bus from an application developer's perspective, this tutorial covers what D-Bus is and how it can be used by applications.''
; [[Development/Tutorials/D-Bus/Accessing Interfaces|Accessing D-Bus Interfaces]]
:''A step-by-step guide to calling D-Bus methods and connecting to D-Bus signals using QtDBus.''
; [[Development/Tutorials/D-Bus/Intermediate_D-Bus|Intermediate D-Bus]]
:''Tips to make use of QtDBus when faced with problematic real-world interfaces.''
; [[Development/Tutorials/D-Bus/Creating Interfaces|Creating D-Bus Interfaces]]
:''Learn how to expose functionality in your application by creating and using custom D-Bus interfaces. Covers generating the XML descriptions, instantiating interfaces at run time and setting up the build system with CMake.''
; [[Development/Tutorials/D-Bus/Autostart Services|D-Bus Autostart Services]]
:''Turn your application into a D-Bus autostart service with this tutorial. This D-Bus feature, also known as "D-Bus service activation", will ensure that even when your application isn't running that D-Bus calls made to it will work by relying on the D-Bus daemon itself to start your app if and when needed.''
; [[Development/Tutorials/Porting_to_D-Bus|Porting from DCOP to D-Bus]]
: ''Port your applications from DCOP to D-Bus with this handy guide.''

=== Konqueror ===
; [[Development/Tutorials/Creating Konqueror Service Menus|Creating Konqueror Service Menus]]
:''This tutorial shows you how to create mimetype-specific actions in Konqueror's context menu (aka "servicemenus").''

=== Kross ===
; [[Development/Tutorials/Kross/Introduction|Introduction to Kross]]
:''An introduction to the Kross Scripting Framework.''

; [[Development/Tutorials/Kross/Hello_World|Hello World]]
:''A first application with working kross code.''

; [[Development/Tutorials/Kross/Call_Functions_in_Kross|Calling Functions in Kross]]
:''Simple demonstration of calling scripting functions''

; [[Development/Tutorials/Kross/Connecting_Signals_and_slots_in_Kross|Connecting Signals and Slots in Kross]]
:''Simple demonstration of connecting object signals with script slots''

; [[Development/Tutorials/Kross/Scripts-as-Plugins|Scripts as Plugins with Kross]]
:''This tutorial provides a step-by-step introduction how to integrate scripts as plugins into a KDE application.''

; [[Development/Tutorials/Kross/Script-Actions|Placing script actions in your application menus ]]
:''Simple demonstration on how to extend you application menus to execute script files.''

{{:KOffice/Plugin Tutorials}}

=== SuperKaramba ===
; [[Development/Tutorials/SuperKaramba|SuperKaramba Tutorial]]
:''This tutorial provides an overview of SuperKaramba, theme files and scripting with Python, Ruby and JavaScript.''

=== System Activity ===

: [[Development/Tutorials/SystemActivity/Scripting|Writing script actions for the process's context menu]]
:''This tutorial shows how to add a context menu action to show custom information about a process.

== Plugins and KParts ==

; [[Development/Tutorials/Writing kontact plugins|Writing kontact plugins]]:''Kontact plugins are KParts. This tutorial describes how you can write one.''

; [[Development/Tutorials/Using KParts|Using KParts]]:''Learn how to load a KPart into an application window.''

; [[Development/Tutorials/Writing Qt Designer Plugins|Writing Qt Designer Plugins]]:''Add your widgets to Qt Designer and thus make them usable in UI files.''

== Search and Metadata ==

=== Strigi ===

; [[Development/Tutorials/Writing file analyzers|Writing file analyzers]]
:''File analyzers extract data from files to display in the file dialogs and file managers. The data gathered this way is also used to search for files. KDE4 allows the use of multiple analyzers per file type. This tutorial describes how you can write new analyzers.''

=== [http://nepomuk.kde.org Nepomuk] ===

; [[Development/Tutorials/Metadata/Nepomuk/Quickstart|Nepomuk Quickstart]]
:''How to use Nepomuk resources in a quick and painless way without much fuss.''

; [[Development/Tutorials/Metadata/Nepomuk/RDFIntroduction|RDF and Ontologies in Nepomuk]]
:''An introduction to RDF and the usage of ontologies in Nepomuk.''

; [[Development/Tutorials/Metadata/Nepomuk/DataLayout|Data Layout in Nepomuk]]
:''An overview of which and how data is stored in Nepomuk.''

; [[Development/Tutorials/Metadata/Nepomuk/Resources|Handling Resources with Nepomuk]]
:''Nepomuk is the KDE library which provides easy access to metadata in the Nepomuk system. Learn how to make your application create and read metadata using the Nepomuk system.''

; [[Development/Tutorials/Metadata/Nepomuk/ResourceGenerator|Using the Nepomuk Resource Generator]]
:''Nepomuk includes a resource generator which creates convenience classes for handling metadata.''

; [[Development/Tutorials/Metadata/Nepomuk/NepomukQuery|Using the Nepomuk Query API]]
:''Starting with KDE 4.4 Nepomuk provides a desktop query API.''

; [[Development/Tutorials/Metadata/Nepomuk/AdvancedQueries|Advanced Queries]]
:''The real power of Nepomuk can only be exposed when performing fancy queries on the data repository. This tutorial provides an introduction to semantic and full text queries in Nepomuk.''

; [[Development/Tutorials/Metadata/Nepomuk/NepomukServer|The Nepomuk Server and the Architecture of the Nepomuk subsystem]]
:''The Nepomuk Server hosts the main Nepomuk data repository and can be accessed directly via a Soprano API.''

; [[Development/Tutorials/Metadata/Nepomuk/NepomukServices|Nepomuk Services]]
:''The Nepomuk Server manages a set of Nepomuk services.''
:* [[Development/Tutorials/Metadata/Nepomuk/StorageService|Storage Service]] ''The probably most important service hosts the Nepomuk data repository using [http://soprano.sourceforge.net Soprano].''
:* [[Development/Tutorials/Metadata/Nepomuk/OntologyLoaderService|Ontology Loader]] ''Makes sure installed ontologies such as RDF, RDFS, NRL, or Xesam are loaded into the storage repository.''
:* [[Development/Tutorials/Metadata/Nepomuk/FileWatchService|File Watch Service]] ''Monitors the file system for changes and updates the file resource paths and URIs in Nepomuk.''
:* [[Development/Tutorials/Metadata/Nepomuk/StrigiService|Strigi Service]] ''Controls Strigi, the file indexing tool which extracts metadata from files and stores it into the storage repository.''
:* [[Development/Tutorials/Metadata/Nepomuk/QueryService|Query Service]] ''Provides persistant query folders.''

; [[Development/Tutorials/Metadata/Nepomuk/TipsAndTricks|Nepomuk Tips and Tricks]]
:''A set of tips and tricks for development with Nepomuk and Soprano. This is a must-read if you intend to use Nepomuk in your application or hack on it directly.''

== Hardware Awareness (Solid) ==

;[[Development/Tutorials/Solid_Tutorials|Introduction to Solid]]
:''An introduction to using the Solid hardware discovery and interaction system in KDE applications.''

;[[Development/Tutorials/Solid_Network_Tutorial|Accessing Network Information]]
:''How to use the Solid system to get information about the network''

== Privileged Applications (PolicyKit) ==
; [[Development/Tutorials/PolicyKit/Introduction|Introduction to PolicyKit]]
:''A straight-forward introduction to what PolicyKit is, and how it can be useful for your next application requiring super-user privileges or user authentication''
; [[Development/Tutorials/PolicyKit/Helper_HowTo|Using the caller-helper model to perform actions as root]]
:''This tutorial will teach you how to get your application to perform some actions as root in a completely safe and easy manner, if the user is authorized to, by using PolicyKit and the caller-helper technique''
; [[Development/Tutorials/PolicyKit/KCM_HowTo|Getting root privileges in KCM Modules]]
:''This tutorial will teach you how to create KCModules able to save settings as root''

== Multimedia (Phonon) ==

;[[Development/Tutorials/Phonon/Introduction|Phonon]]
:''How to start with the multimedia API''

:''How to compile and use Phonon and its GStreamer backend on Linux using Qt 4.3.x''
::''This article gives you a quick brief of how you can use checkout, compile Phonon and its GStreamer backend on GNU/Linux with just Qt 4.3.x. Towards the end, the article also describes how a developer can make use of Phonon to create simple audio and video players. You can read the article [http://www.vcreatelogic.com/oss/docs/CompilingPhononOnLinux.pdf here]. You can download the editable OpenDocumentText file from [http://www.prashanthudupa.com/phonon/CompilingPhononOnLinux.odt here].''

== Plasma ==

See [[Development/Tutorials/Plasma|Plasma tutorials]].

== Communication (Decibel) ==

;[[Development/Tutorials/Decibel/GettingStarted|Getting started with Decibel]]
:''This tutorial describes how to set up Decibel.''

;[[Development/Tutorials/Decibel/Handling_TextChannels|Handling TextChannels]]
:''This tutorial introduces the basics of handling incoming TextChannels by guiding you through building a simple text chat application.''

== Personal Information Management (Akonadi) ==

;[[Development/Tutorials/Akonadi/Application|Using Akonadi in Applications]]
:''Displaying and modifying data provided by Akonadi''

;[[Development/Tutorials/Akonadi/Resources|Developing Akonadi Resources]]
:''Akonadi Resources are agent programs which transport PIM data between Akonadi and a backend (files, servers, etc)''

;[[Development/Tutorials/Akonadi/SerializerPlugin|Using custom data types with Akonadi]]
:''Akonadi can handle arbitrary data as item payloads through the use of a plugin based serialization framework''

== Kate / Kwrite ==

;[[Development/Tutorials/Kate/KTextEditor Plugins|Getting started with KTextEditor plugins]]
:''Creating your first KTextEditor plugin''

;[[Development/Tutorials/Kate/KTextEditor_Plugins_Advanced|Developing a plugin with configuration dialog]]
:''Adding a configuration dialog to the Time & Date example''

;[[Development/Tutorials/Kate/KTextEditor_Example|A small Editor]]
:''Create a small application using KTextEditor''

== KDevelop ==

;[[Development/KDevelop-PG-Qt_Introduction|KDevelop-PG-Qt Introduction]]
:''Information on the KDevelop parser generator, useful for language plugins.''

==Printing==

;[[Development/Tutorials/Printing Hello World|Hello World]]
:''Introduction to the KDE printing system''

;[[Development/Tutorials/Printing Print Dialog|Print Dialog]]
:''Using the KDE print dialog''

== kioslaves ==
* [[Development/Tutorials/KIO Slaves/Using KIO Slaves in your Program|Using kioslaves in your Program]]
* [[Development/Tutorials/KIO Slaves/Hello World|Creating a Hello-World kioslave]]

== Collaboration ==

=== Open Collaboration Services (libattica) ===

;[[Development/Tutorials/Collaboration/Attica/Introduction|Introduction to Attica]]
:''In this tutorial a simple widget showing information about a Person on the server is created.''

=== Get Hot New Stuff ===
;[[Development/Tutorials/Collaboration/HotNewStuff/Introduction|Get Hot New Stuff 3]]
:''How to use KHotNewStuff3 in your application.''

;[[Development/Tutorials/K Hot New Stuff2|Introduction to Get Hot New Stuff 2]]
:''A short tutorial about how to use KHotNewStuff2 in your application. Deprecated, use version 3''

*old links for KNS1 content:

;[[Development/Tutorials/Introduction to Get Hot New Stuff|Introduction to Get Hot New Stuff]]
:''An introduction to the developer-friendly network update system that allows KDE applications to fetch new application data at runtime in a user friendly manner.''

;[[Development/Tutorials/KNewStuffSecure|KNewStuff Secure]] ([http://developer.kde.org/documentation/tutorials/knewstuffsecure/index.html Original Link])
:''Tutorial showing how to share resources in a secured way (KDE 3.4 and later).'' By András Mantia <amantia@kde.org>.

== Goya ==
; [[Development/Tutorials/Introduction to Goya usage|Introduction to Goya usage]]
:''An introduction for the Goya subsystem usage, which allows you to easily add widgets to your itemviews and connect their signals to your code, as they were real widgets.''

; [[Development/Tutorials/Introduction to Goya usage 2|Introduction to Goya usage (part 2)]]
:''The second part of the tutorial, with a slightly more complex example than the first part.''

== Other programming languages ==

=== Python ===

;[http://www.learningpython.com/2008/09/20/an-introduction-to-pyqt/ An Introduction to PyQt]
:''Starting off''

;[http://lateral.netmanagers.com.ar/stories/BBS47.html PyQt by Example]
:''Another introduction to PyQt''

;[[Development/Languages/Python/PyKDE_WebKit_Tutorial|PyKDE WebKit Tutorial]]
:''A simple web browser application in PyKDE''

;[[Development/Tutorials/Python introduction to signals and slots|101 Introduction to signals and slots]]
:''A simple introduction to Qt's signal and slot architecture.''

;[[Development/Languages/Python/PyKDE_DBus_Tutorial|PyKDE DBus Tutorial]]
:''An introduction to DBus communication using PyKDE''

=== Ruby ===

;[http://developer.kde.org/language-bindings/ruby/kde3tutorial/index.html KDE Ruby Korundum tutorial]
:''A ruby version of Antonio Larrosa Jiménez's KDE tutorial by Richard Dale. See the [http://developer.kde.org/language-bindings/ruby/index.html Ruby Developers Corner] for Qt tutorials and other info.''

;[[Development/Tutorials/Qt4_Ruby_Tutorial|Qt4 Ruby Tutorial]]
:''Nokia's fabulous introductory tutorial to Qt, translated to Ruby.''

;[[Development/Tutorials/Plasma/RubyApplet|Creating a Plasma Widget in Ruby]]
:''Tutorial that shows how to create your first Plasma Applet using the Ruby language.''

;[[Development/Tutorials/Developing_Qt4_Applications_using_Qt_Designer_and_Ruby_on_Kubuntu|Developing Qt4 Applications using Qt Designer and Ruby on Kubuntu]]
:''Tutorial that shows how to design a simple User Interface in Qt Designer and then use the resulting widget in a Qt Ruby application we build from scratch.''

;[[Development/Languages/Ruby/Ruby-Qt/KDE_Book|Ruby-Qt/KDE Book]]
:''There is also an approach to create an Ruby-Qt/KDE Book under a free license. The content will be created in this wiki.''

=== Shell ===

;[[Development/Tutorials/Shell_Scripting_with_KDE_Dialogs|Shell Scripting with KDE dialogs]] ([http://developer.kde.org/documentation/tutorials/kdialog/t1.html Original Link])
:''Tutorial by [mailto:bradh@frogmouth.net Brad Hards] that describes how to use KDE dialogs in shell scripts with kdialog. It is presented as an example based tutorial.''

== Graphics Programming ==

;[[Development/Tutorials/Graphics/Performance|QPainter Perfomance]]
:''Hints on avoiding common mistakes leading to poor performance when using QPainter''

== Using the KDE Games Libraries ==
;[[Development/Tutorials/Games/KStandardGameAction| KStandardGameAction]]
:''Using libkdegames to make your game fit the kdegames standard''
;[[Development/Tutorials/Games/Highscores| Highscores]]
:''Implementing a simple highscore table into your game''
;[[Development/Tutorials/Games/Theme Selector| Theme Selector]]
:''Using the libkdegames theme selection dialog''
;[[Development/Tutorials/Games/Palapeli Patterns| Palapeli Slicers]]
:''Creating a slicer plugin for Palapeli''

=== KGLEngine ===
;[[Development/Tutorials/Games/kglengine/kglengine-simpleBox| installation and your first KGLItem]]
:''start your first kglengine application''
;[[Development/Tutorials/Games/KGLEngine2d| kglpong]]
:''Now use our knowledge to make a pong''

=== KALEngine ===
;[[Development/Tutorials/Games/KALEngine| Play hello word sound]]
:''Using KALEngine for games sound development using openAL''
;[[Development/Tutorials/Games/KALEngine-music| Play music]]
:''Using KALEngine to play music in a stream''

== Using the KDE PIM Libraries ==
;[[Development/Tutorials/PIM/ical| iCalendar functionality]]
:''Using kcal to manage iCalendar files''

== Other tutorials ==

=== 2D Plotting (KPlotWidget) ===
;[[Development/Tutorials/KPlotWidget|Using the KDE data-plotting widget]]
:''This tutorial introduces KPlotWidget, which is used for 2-D data plotting. It includes information on simple usage of the widget (including adding and modifying data sets, and customizing the plot axes and labels), and advanced customization (including extending the widget through sub-classing).''

=== Spelling and Grammar Checking (Sonnet) ===
;[[Development/Tutorials/Sonnet/SonnetTutorial|Adding spell-checking or grammar-checking to KDE applications]]
:''This tutorial introduces Sonnet and how one may use it to add language correction to your KDE application. Sonnet's auxiliary features shall be described in a separate tutorial.''

=== Pixmap cache (KPixmapCache) ===
;[[Development/Tutorials/KPixmapCache|Using the KDE pixmap cache]]
:''This tutorial shows how to use KPixmapCache to cache e.g. pixmaps generated from SVGs or some data.''

=== Using MarbleWidget (Marble) ===
;[[Development/Tutorials/MarbleWidget|Using MarbleWidget]]
:''This short tutorial describes how to use the MarbleWidget in your project''

=== Using local SCM for KDE development ===
;[[Development/Tutorials/Git|Using Git to develop for KDE]]
:''This tutorial shows how to use Git to develop for KDE''

=== Kwin effect tutorial (blog) ===
;[http://blog.martin-graesslin.com/blog/?p=258 blog by Martin Graesslin]
:''This tutorial guides you through the development of a simple KWin effect''

=== Implementing KSysGuard sensors and adding them ===
;[[Development/Tutorials/Sensors]]
:''This tutorial shows how to write and KSysGuard sensor and connect it to the systray.''
Runners
== KDE2 and KDE3 Materials ==

;[[Development/Tutorials/KDE3|KDE3 Tutorials]]
:''These tutorials cover topics related to KDE3.''

;[[Development/Tutorials/KDE2|KDE2 Tutorials]]
:''These tutorials cover topics related to KDE2.''

[[Category:KDE4]]

User:Robert Riemann/Drafts/Build qtruby

2009-07-30T11:30:14Z

Robert Riemann:

{{Template:I18n/Language Navigation Bar|User:Robert_Riemann/Drafts/Build_qtruby}}
{{improve}}

== Get Sources ==

Before starting, the recent sources have to be downloaded.
The following command will download some important cmake files and, of course, the kdebindings.

svn co svn://anonsvn.kde.org/home/kde/trunk/KDE/kdebindings
svn co svn://anonsvn.kde.org/home/kde/trunk/KDE/kdelibs/cmake/modules

== Preparation ==

Now all files (not folders) from ./modules have to be placed in ./kdebindings/cmake/modules

You will find in ./kdebindings a file called CMakeLists.txt.qtruby - copy that file to CMakeLists.txt. You will overwrite a file to do it, but that doesn't matters.

== Building ==

Now create a directory build next to kdebindings. You will find the following commands in the beginning of the CMakeLists.txt.qtruby file.

I copied the cmake command from there, but deleted the lines DRUBY_EXECUTABLE and DRUBY_INCLUDE_PATH

To get the qtruby build with ruby v1.9 I have had to make sure that the command which ruby finds the right file version. Maybe you need to create a symbolic link or modify your PATH variable.

Perhaps there is also a simpler way.

Sometimes it is necessary to install some devel packages additionally to meet the dependencies.

With opensuse it can be done with:

su # become root
zypper in libqimageblitz-devel libkde4-devel #i install packages

When cmake quits without errors you can proceed with make and make install.

[[Category:Ruby]]

User:Robert Riemann/Drafts/Build qtruby

2009-07-28T20:39:38Z

Robert Riemann:

{{Template:I18n/Language Navigation Bar|Development/Tutorials}}
{{improve}}

== Get Sources ==

Before starting, the recent sources have to be downloaded.
The following command will download some important cmake files and, of course, the kdebindings.

svn co svn://anonsvn.kde.org/home/kde/trunk/KDE/kdebindings
svn co svn://anonsvn.kde.org/home/kde/trunk/KDE/kdelibs/cmake/modules

== Preparation ==

Now all files (not folders) from ./modules have to be placed in ./kdebindings/cmake/modules

You will find in ./kdebindings a file called CMakeLists.txt.qtruby - copy that file to CMakeLists.txt. You will overwrite a file to do it, but that doesn't matters.

== Building ==

Now create a directory build next to kdebindings. You will find the following commands in the beginning of the CMakeLists.txt.qtruby file.

I copied the cmake command from there, but deleted the lines DRUBY_EXECUTABLE and DRUBY_INCLUDE_PATH

To get the qtruby build with ruby v1.9 I have had to make sure that the command which ruby finds the right file version. Maybe you need to create a symbolic link or modify your PATH variable.

Perhaps there is also a simpler way.

Sometimes it is necessary to install some devel packages additionally to meet the dependencies.

With opensuse it can be done with:

su # become root
zypper in libqimageblitz-devel libkde4-devel #i install packages

When cmake quits without errors you can proceed with make and make install.

[[Category:Ruby]]

User:Robert Riemann/Drafts/Build qtruby

2009-07-27T14:55:34Z

Robert Riemann: draft for a subpage to Ruby