KDE TechBase - User contributions [en]

Development/Tutorials/KWin/Scripting/API

2011-12-15T11:02:17Z

Vmax0770: Finished

= workspace[singleton] =
== Events ==
'''workspace.currentDesktopChanged'''
*Emitted when the user switches from a virtual desktop to another.
**'''old_desk {integer}''': The number of the virtual desktop the user switched from.

'''workspace.desktopPresenceChanged'''
*Emitted whenever a client is moved across virtual desktops. The client's previous desktop is available through the old_desk parameter, whereas the current desktop can be fetched using moved_client.desktop
**'''moved_client {client}''': The client which was moved from desktop old_desk to the new one
**'''old_desk {integer}''': The previous desktop on which the client was present

'''workspace.clientAdded'''
*Emitted whenever a new client is added to the workspace. This generally occurs when a new window is opened which includes dialog boxes, windows etc. However, it is NOT emitted for unmanaged clients like the Alt+Tab switcher.
**'''added_client {client}''': The client which was added.

'''workspace.clientManaging'''
*Emitted whenever a client is being managed by the KWin subsystem. The difference between workspace.clientManaging and workspace.clientAdded is that clientManaging is emitted BEFORE clientAdded. Also, if KWin is restarted with a list of clients C, then the clientManaging event will be emitted for every client in C, but clientAdded will not.
**'''managing_client {client}''': The client which is being managed.

'''workspace.clientMinimized'''
*Emitted whenever a client is minimized.
**'''minimized_client {client}''': The client which was minimized.

'''workspace.clientMaximizeSet'''
*Emitted whenever a client is maximized in a particular orientation. The orientation i.e. the rectangular direction in which the client was specified to occupy the entire available space is specified by the two parameters horizontally and vertically. If both are true, the client was maximized fully i.e. asked to occupy the entire workspace are available.
**'''maximized_client {client}''': The client which was maximized (in a certain orientation).
**'''horizontally {boolean}''': (true) if the client was maximized horizontally, (false) otherwise.
**'''vertically {boolean}''': (true) if the client was maximized vertically, (false) otherwise.

'''workspace.killWindowCalled'''
*Emitted whenever the user requests a Kill Window [generally using the Ctrl+Esc combination]. The parameter killwindow_client is not completely safe and may return kill windows out of order of invocation. This is just a fancy function, avoid using. Instead, use workspace.clientAdded and filter for incoming Kill Windows.
**'''killwindow_client {client}''': The client handle to the kill window that was called.

'''workspace.clientActivated'''
*Emitted whenever a client is given focus or 'activated'.
**'''activated_client {client}''': The client which was activated (or received focus).

'''workspace.clientFullScreenSet'''
*Emitted whenever a client is set to full screen or unset. The fss_set parameter can be used to determine whether the client was set or unset.
**'''fss_set {boolean}''': (true) if the client was switched to full screen mode, (false) if it was switched from full screen mode.
**'''fss_client {client}''': The client which was set/unset to fullscreen.

'''workspace.clientUnminimized'''
*Emitted whenever a client is Unminimized (or restored).
**'''unm_client {client}''': The client which was unminimzed.

== Methods ==
'''workspace.getAllClients[ret: Array(client)]'''

'''workspace.getAllClients(desktop_no {integer})'''
*Gets all clients on the virtual desktop desktop_no. If no desktop number is specified then it fetches all the clients. To specifically isolate clients which are on 'All desktops', set the desktop_no parameter to -1.
*'''desktop_no {integer}''': The desktop number belonging to which the clients are to be fetched.

'''workspace.dimensions[ret: qsize]'''

'''workspace.dimensions()'''
*Returns the dimensions of the workspace in pixels.

'''workspace.desktopGridSize[ret: qsize]'''

'''workspace.desktopGridSize()'''
*Returns the desktop size in grid units. In essence, it returns the order of a rectangular matrix, where each element is a virtual desktop and the rows and columns specify the number of virtual desktops and the way of arrangement.

'''workspace.activeClient[ret: client]'''

'''workspace.activeClient()'''
*Returns the client which currently has focus.

'''workspace.clientGroups[ret: Array(clientgroup)]'''

'''workspace.clientGroups()'''
*Returns an array of all the ClientGroups from the current workspace.

== Properties ==
'''workspace.currentDesktop [ret: integer] [GO]'''
*Returns the current desktop number of the workspace.

= toplevel[floating] =
== Methods ==
'''toplevel.x[ret: integer]'''

'''toplevel.x()'''
*Returns the x co-ordinate of the toplevel client (or the client).

'''toplevel.y[ret: integer]'''

'''toplevel.y()'''
*Returns the y co-ordinate of the toplevel client (or the client).

'''toplevel.width[ret: integer]'''

'''toplevel.width()'''
*Returns the width of the toplevel client (or the client).

'''toplevel.height[ret: integer]'''

'''toplevel.height()'''
*Returns the height of the toplevel client (or the client).

'''toplevel.size[ret: qsize]'''

'''toplevel.size()'''
*Returns the size of the toplevel client (or the client).

'''toplevel.pos[ret: qpoint]'''

'''toplevel.pos()'''
*Returns the position of the toplevel client (or the client).

'''toplevel.opacity[ret: decimal]'''

'''toplevel.opacity()'''
*Returns the opacity (or 1 - transperency) of the toplevel client (or the client).

'''toplevel.hasAlpha[ret: bool]'''

'''toplevel.hasAlpha()'''
*Returns (true) if the client can be made translucent i.e. opacity can be set to values other than 0 or 1, (false) otherwise. NOTE: If compositing is OFF, then clients may still show that translucency is possible, but translucency is not possible without compositing being ON.

'''toplevel.setOpacity'''

'''toplevel.setOpacity(opacity_v {decimal})'''
*Sets the opacity of the client to opacity_v or sets transperency to (1 - opacity_v). NOTE: If compositing is OFF, this function has no effect for any values between 0 and 1 (exclusive).

'''setOpacity(opacity_v {decimal})'''
*opacity_v {decimal}: The opacity to be set (on a scale of 0-1).

= client[floating] =
== Events ==
'''client.clientMoved'''
*Emitted whenever the client is moved or it's geometry changed. This includes when a client is resized.

'''client.minimized'''
*Emitted whenever a client is minimized. Equivalent to workspace.clientMinimized, but for a specific client. Use wherever possible instead of workspace.clientMinimzed to improve performance.

'''client.maximizeSet'''
*Emitted when the client is maximized in a particular orientation. The orientation i.e. the rectangular direction in which the client was specified to occupy the entire available space is specified by the two parameters horizontally and vertically. If both are true, the client was maximized fully i.e. asked to occupy the entire workspace are available. Equivalent to workspace.clientMaximizeSet, but for a specific client. Use wherever possible instead of workspace.clientMaximizeSet to improve performance.
**'''horizontally {boolean}''': (true) if the client was maximized horizontally, (false) otherwise.
**'''vertically {boolean}''': (true) if the client was maximized vertically, (false) otherwise.

'''client.activated'''
*Emitted whenever the client is activated (or gets focus). Equivalent to workspace.clientActivated but for a specific client. Use wherever possible instead of workspace.clientActivated to improve performance.

'''client.unminimized'''
*Emitted whenever the given client is unminimized. Equivalent of workspace.clientUnminimzed but for a specific client. Use wherever possible instead of workspace.clientUnminimized to improve performance.

'''client.fullScreenSet'''
*Emitted whenever the client's fullscreen mode is toggled. fss_set specifies whether the client was set to or from fullscreen mode.
**'''fss_set {boolean}''': (true) if the client was set to full screen mode, (false) if the client was set from full screen mode.

== Methods ==
'''client.caption[ret: string]'''

'''client.caption()'''
*Returns the caption of the caption (or the title) of the window.

'''client.close'''

'''client.close()'''
*Closes the given client using killClient.

'''client.move[variable parameter styles]'''

'''client.move(location {qpoint}, emitjs {boolean})'''

'''client.move(x {integer}, y {integer}, emitjs {boolean})'''
*Moves the client to the specified location keeping the height and width of the client same.
**'''location {qpoint}''': The (x, y) point to where the top left corner of the client must be moved to keeping the current height and width same.
**'''emitjs {boolean}''': EmitJS value (defaults to true).
**'''x {integer}''': The x co-ordinate value of the point to where the top left corner of the client must be moved to keeping the current height and width same.
**'''y {integer}''': The y co-ordinate value of the point to where the top left corner of the client must be moved to keeping the current height and width same.

'''client.resize[variable parameter styles]'''

'''client.resize(size {qsize}, emitJS {boolean})'''

'''client.resize(w {integer}, h {integer}, emitJS {boolean})'''
*Resizes the client to the specified size without changing its position.
**'''size {qsize}''': The size to which the client is to be resized.
**'''emitJS {boolean}''': EmitJS value (defaults to true).
**'''w {integer}''': New width for the client.
**'''h {integer}''': New height for the client.
**'''emitJS {boolean}''': EmitJS value (defaults to true).

'''client.setGeometry[variable parameter styles]'''

'''client.setGeometry(geometry {qrect}, emitJS {boolean})'''

'''client.setGeometry(x {integer}, y {integer}, w {integer}, h {integer})'''
*Sets the geometry of the client i.e. sets is size and location according to the provided parameters.
**'''geometry {qrect}''': The new geometry which is to be set for the client.
**'''emitJS {boolean}''': EmitJS value (defaults to true).
**'''x {integer}''': The x co-ordinate of the new geometry.
**'''y {integer}''': The y co-ordinate of the new geometry.
**'''w {integer}''': The width of the new geometry.
**'''h {integer}''': The height of the new geometry.

'''client.getWindowInfo[ret: windowinfo]'''

'''client.getWindowInfo()'''
*Returns a windowinfo object which can be used to get further information about the client. Wherever possible, directly use the client properties than calling for a windowinfo object. NOTE: The windowinfo object is a 'snapshot' object and hence the data provided by it is not modified when the properties of the client are changed.

'''client.isTransient[ret: boolean]'''

'''client.isTransient()'''
*Returns (true) is 'client' is transient, (false) otherwise.

'''client.isTransientFor[ret: client]'''

'''client.isTransientFor()'''
*If the given client is transient, returns it's parent client, otherwise returns an undefined scriptvalue.

'''client.activate'''
'''client.activate()'''
*Attempt to activate (focus) the client. By attempt, it means that focus stealing prevention still is activated and the rules for activation are in place. Hence, the client actually may nor may not be activated.

'''client.setCaption'''

'''client.setCaption(caption_string {string})'''
*Sets the caption for the specified client to caption_string.
**'''caption_string {string}''': The caption to be set for the specified.

'''client.unminimize'''

'''client.unminimize()'''
*Unminimizes (or restores) the given client.

'''client.setFullScreen'''

'''client.setFullScreen( {fss_set})'''
*Sets the client to or from full screen mode.
**'''{fss_set}''': If (true), then the client is set to full screen or else, it is unset from fullscreen mode. If no parameter is provided, it toggles the full screen state.

'''client.isShade[ret: boolean]'''

'''client.isShade()'''
*Returns (true) of the client is shaded, (false) otherwise.

'''client.isShadeable[ret: boolean]'''

'''client.isShadeable()'''
*Returns (true) of the client is shadeable (can be shaded), (false) otherwise.

'''client.isMinimized[ret: boolean]'''

'''client.isMinimized()'''
*Returns (true) of the client is minimized, (false) otherwise.

'''client.isMinimizable[ret: boolean]'''

'''client.isMinimizable()'''
*Returns (true) of the client can be minimized, (false) otherwise.

'''client.isMaximizable[ret: boolean]'''

'''client.isMaximizable()'''
*Returns (true) of the client can be mazimized, (false) otherwise.

'''client.isResizable[ret: boolean]'''

'''client.isResizable()'''
*Returns (true) of the client can be resized (changable size), (false) otherwise.

'''client.isMovable[ret: boolean]'''

'''client.isMovable()'''
*Returns (true) of the client can be moved (non-fixed location), (false) otherwise.

'''client.isMovableAcrossScreens[ret: boolean]'''

'''client.isMovableAcrossScreens()'''
*Returns (true) of the client can be moved across screens (only valid in a multiple monitor setup), (false) otherwise.

'''client.isCloseable[ret: boolean]'''

'''client.isCloseable()'''
*Returns (true) of the client can be closed by user action (or any other action other than the system or the application itself), (false) otherwise.

'''client.isFullScreen[ret: boolean]'''

'''client.isFullScreen()'''
*Returns (true) of the client is in fullscreen mode, (false) otherwise.

'''client.isFullScreenable[ret: boolean]'''

'''client.isFullScreenable()'''
*Returns (true) of the client can be set to fullscreen mode, (false) otherwise.

'''client.clientGroup[ret: clientgroup]'''

'''client.clientGroup()'''
*Returns the client group the client belongs to. If it belongs to no client, it returns an undefined script value.

'''client.desktop[ret: integer]'''

'''client.desktop()'''
*Returns the desktop number that the client is on. If it is on all desktops, it returns -1.

= clientgroup[instantiable] =
== Methods ==

'''clientgroup.ClientGroup[constructor]'''

'''clientgroup.ClientGroup(seed_client {client})'''
*Creates a new clientgroup object. A clientgroup in essence refers to a group of tabbed clients and an object refers to a specific group of such tabbed clients. It returns a clientgroup object which can be then manipulated using the various accessor functions.
**'''seed_client {client}''': The client to be added to the newly formed clientgroup. This is a mandatory argument for the creation of a new clientgroup object.

'''clientgroup.add'''

'''clientgroup.add(new_client {client}, beforeClient {integer}, becomeVisible {boolean})'''
*Adds new_client to the clientgroup at the index specified by beforeClient and if becomeVisible is true, makes it visible.
**'''new_client {client}''': A client object to be added to the clientgroup.
**'''beforeClient {integer}''': An index as to where the client is to be added to the clientgroup. It is an optional argument and if not specified, it will be added at the last position in the clientgroup.
becomeVisible {boolean}: If (true), makes the added client visible.

'''clientgroup.remove[variable parameter styles]'''

'''clientgroup.remove(index {integer}, set_geom {qrect})'''

'''clientgroup.remove(rem_client {client}, set_geom {qrect})'''
*Removes the client from the clientgroup and then sets it's geometry according to set_geom. This parameter is optional.
**'''index {integer}''': The client index which is to be removed.
**'''set_geom {qrect}''': The geometry to be set after removeal. This parameter is optional.
**'''rem_client {client}''': The client which is to be removed.
**'''set_geom {qrect}''': The geometry to be set after removal.

'''clientgroup.clients[ret: Array(client)]'''

'''clientgroup.clients()'''
*Returns an array of all the member clients of the clientgroup.

'''clientgroup.contains[ret: boolean]'''

'''clientgroup.contains(needle_client {client})'''
*Returns (true) if needle_client is a member of the clientgroup, (false) otherwise.
**'''needle_client {client}''': The client to be searched for

'''clientgroup.indexOf[ret: integer]'''

'''clientgroup.indexOf(needle_client {client})'''
*Searches for needle_client in the clientgroup and returns the position at which it exists. If needle_client is not found, then it returns -1.
**'''needle_client {client}''': The client whose index is to be found

'''clientgroup.move[variable parameter styles]'''

'''clientgroup.move(index_a {integer}, index_b {integer})'''

'''clientgroup.move(move_client {integer}, index {integer})'''

'''clientgroup.move(move_client {integer}, before_client {integer})'''

'''clientgroup.move(index_a {integer}, before_client {integer})'''
*Move a client within the group. Accepts move(client, client), move(index, index), move(index, client), move(client, index). All calls except move(client, client) are eventually mapped to move(index, index) using indexOf(client)
**'''index_a {integer}''': The index of the client to be moved.
**'''index_b {integer}''': The index of the position to move the client to.
**'''move_client {integer}''': The client to be moved.
**'''index {integer}''': The index of the position to move the client to.
**'''move_client {integer}''': The client to be moved.
**'''before_client {integer}''': The client before which the client is to moved.
**'''index_a {integer}''': The index of the client to be moved.
**'''before_client {integer}''': The client before which the client is to moved.

'''clientgroup.removeAll'''

'''clientgroup.removeAll()'''
*Removes all the clients from the clientgroup i.e. completely disassembles the clientgroup into its proponents.

'''clientgroup.closeAll'''

'''clientgroup.closeAll()'''
*Closes all the clients presents in the clientgroup.

'''clientgroup.minSize[ret: qsize]'''

'''clientgroup.minSize()'''
*Returns the minimum size acceptable for the clientgroup computed from the minimum sizes of all its present members.

'''clientgroup.maxSize[ret: qsize]'''

'''clientgroup.maxSize()'''
*Returns the maximum size acceptable for the clientgroup computed from the minimum sizes of all its present members.

= windowinfo[floating] =
== Properties ==
'''windowinfo.isValid [ret: boolean] [GO]'''
*Returns (true) if the client is valid, (false) otherwise.

'''windowinfo.visibleName [ret: string] [GO]'''
*Returns the visible name of the client.

'''windowinfo.isMinimized [ret: boolean] [GO]'''
*Returns (true) if client is minimized. Redundant with client.isMinimized. For client, the subclass property is called, not the toplevel one.

'''windowinfo.state [ret: integer] [GO]'''
*Returns an integeral state for the client. Prefer other methods like isShaded, isFullScreenSet etc. over this.

'''windowinfo.windowRole [ret: string] [GO]'''
*Returns the window role of the toplevel client.

'''windowinfo.windowClassClass [ret: string] [GO]'''
*Returns the windowclass class of the client.

'''windowinfo.windowClassName [ret: string] [GO]'''
*Returns the windowclass name of the client.

= config[singleton] =
== Methods ==

'''config.exists'''

'''config.exists(config_key {string})'''
*Searches for config_key in the configuration array and returns (true) if a corresponding value exists, (false) otherwise.
**'''config_key {string}''': The configuration key to be seeked.

'''config.get[variable parameter styles]'''

'''config.get()'''

'''config.get(key1, key2 ... keyN {string})'''

'''config.get(key {string})'''

'''config.get(keyArray {Array(string)}, showNonAssoc {boolean})'''
*If called without parameters, returns an associative array in the format ["key" : "value"] of all available key value pairs. If only a single key is requested for (passing 1 string parameter), then the corresponding value is returned and NOT an array. If multiple keys are provided as multiple arguments, an associative array is returned. If multiple keys (or a single) key is provided as an Array, then an associative array is present (if showNonAssoc is false or it is not specified), otherwise returns an integer indexed array.
**'''key1, key2 ... keyN {string}''': A list of keys to search the values for.
**'''key {string}''': The key to search the value for.
**'''keyArray {Array(string)}''': An array of keys to search the corresponding values for.
**'''showNonAssoc {boolean}''': If (true) causes the function to return an integer-indexed array, otherwise returns an associative array in the form ["key" : "value"]. This parameter is optional, defaults to false

== Properties ==
'''config.loaded [ret: boolean] [GO]'''
*Returns (true) if a configuration file was found and loaded, (false) otherwise.

Thread:Talk:Development/Tutorials/KWin/Scripting/Copyright/reply

2011-12-15T10:26:58Z

Vmax0770: Reply to Copyright

I think, yes, because it's a Google Code-In task (http://www.google-melange.com/gci/task/view/google/gci2011/7127225). If you need, I can contact the author.

Development/Tutorials/KWin/Scripting/API

2011-12-14T23:19:34Z

Vmax0770: /* unfinished */

Development/Tutorials/KWin/Scripting

2011-12-14T23:13:31Z

Vmax0770: Adapted from http://rohanprabhu.com/?p=116

= KWin Scripting Tutorial =

== The KWin script loading procedure ==

When KWin loads it looks in a folder for scripts it should run. This folder is given by: ''$KDEHOME/share/apps/kwin/scripts/''. Let’s call this directory ''KWINSCRIPTS'' for now.

Now, here is how KWin loads the scripts:

*Locate the ''$KWINSCRIPTS'' directory.
*Make a list of all the files in the ''$KWINSCRIPTS'' directory. For a file to be recognized and executed as a script, it must meet the following conditions:
**It must have one of the following extensions: ''.kwinscript'', ''.kws'' or ''.kwinqs''
**It must have the executable flag set.
*For every file with name as ''scriptfile.kwinscript'', ''scriptfile.kwinqs'' or ''scriptfile.kws'', a configuration file ''scriptfile.kwscfg'' is loaded as its configuration file and all its keys and values are loaded.
*All files recognized as scripts are executed one after the other.

In this tutorial, configuration files and it’s loading is not covered. Details about configuring your KWin scripts are available [http://rohanprabhu.com/?p=85 here].

== Setting up your development environment ==

For the purposes of this tutorial, we’ll create a script file ''tutorial.kwinscript'' or anything you may prefer. Save it to the ''KWINSCRIPTS'' folder. Also, do set the executable bit for the scripting file using <code>chmod +x tutorial.kwinscript</code>. In the script ''tutorial.kwinscript'', enter the following code:

<syntaxhighlight lang="javascript">
print("Hello World");
</syntaxhighlight>

The phrase '''‘Hello World’''' may have become too old and repetitive, but we may break laws, we may break promises, but we never ever break tradition. So, Hello World it is. You may either have another account for KDE-development or you may be a KWin user having a single KDE installation. If you have a single KDE installation, I would suggest that you create another account for KDE-development, the details for which can be found [http://techbase.kde.org/Getting_Started/Build/KDE4.x here]. This is so because KWin scripting is still in development and some nasty scripts may cause a crash or some other similarly crippling behaviour. Whenever testing a script or changes to a script, use a terminal to reload kwin. The reason to do so is so that you can read the output from a script on the terminal. Any scripting errors are also reported to the stdout, so it is helpful if you run it within a terminal. To load KWin, open '''Konsole''' and just type in:
<code>kwin --replace &</code>

This will reload the scripts and execute them again. For your first script, let us follow these steps:

*First create a file in KWINSCRIPTS called ‘tutorial.kwinscript’.
*Edit ''tutorial.kwinscript'' and add the following line:

<syntaxhighlight lang="javascript">
print("Hello World");
</syntaxhighlight>

*Save the file, and set executable permissions on the file using <code>chmod +x tutorial.kwinscript</code>.
*Open up '''Konsole''' (or switch to the user account you develop on and then start up '''Konsole''') and type in the following line: <code>kwin --replace &</code>
*In the terminal, you should see the line '''‘Hello World’''' printed. If you see it, Congrats! You’ve just written and run your first KWin script.

Output from the terminal is pretty useful when it comes to debugging your script. Here is how my terminal looks after attaching an event which prints a line everytime a client is minimized alongwith its caption:

[[File:Kwintut1.png]]

This is the development environment you’ve setup and this is what we’ll be using for the rest of this tutorial. If KWin crashes, you can try moving your mouse over the '''Konsole''' window which launched KWin. This will most probably return focus to the window and then you can try entering <code>kwin --replace &</code> again. Since focusing is handled by the Window manager, when KWin crashes focus issues are common and you need a little bit of experience and luck at times. I suggest you read the KWin/HACKING file located [http://community.kde.org/KWin/Hacking here].

== KWin scripting basics ==

To follow this tutorial, you must have some idea about [http://en.wikipedia.org/wiki/ECMAScript ECMAScript] (or [http://en.wikipedia.org/wiki/JavaScript JavaScript]. A quick introduction can be found in the [http://techbase.kde.org/Development/Tutorials/Plasma#JavaScript Plasma scripting tutorial].

===Types===
In KWin scripting, there are three kinds of variables:

*Floating
*Singleton
*Instantiable

'''Instantiable''' objects are your regular objects, instances of which you can create using the <syntaxhighlight lang="javascript">var x = new X();</syntaxhighlight> syntax. Examples of instantiable objects would be ''QTimer'' and ''ClientGroup''.

'''Singletong''' objects are those objects who have only one instance of their type. For example, there is only one ''‘workspace’'' objects.

'''Floating''' objects, quite unique to the KWin scripting itself are objects that although have many instances, but none of them can be created. These can only be obtained as the return values of various methods.

===Events===
KWin scripting is completely ''event-driven''. Now there are quite a number of events within KWin scripting, and a lot more to be added. The thing to note here is that some events are availabe both system-wide and specific only. The previous sentence might seem a little confusing. Allow me to explain. Take the case of an event ''‘A client is minimized’''. KWin scripting provides two kinds of events:
*'''workspace.clientMinimized''' is emitted system-wide i.e. whenever any client is minimized throughout the workspace.
*'''myclient.minimized''' is specific to the object it is called from, in this case '''‘myclient’'''. It is emitted only and only when '''‘myclient’''' is minimized.

To handle events, one must simply use the <syntaxhighlight lang=javascript>object.event.connect()</syntaxhighlight> syntax. Let’s say, whenever I minimize a client, I want to print it’s caption. Here’s the code:

<syntaxhighlight lang=javascript>
workspace.clientMinimized.connect(function(client) {
print(client.caption());
});
</syntaxhighlight>

The '''print''' function prints to your terminal and is extremely useful for debugging. In the code snippet above, an anonymous function is connected to the event '''workspace.clientMinimized''', which is emitted whenever a client is minimized. The function which is called is passed as a parameter the client that was minimized. In case of the other event, no such parameter is passed, as we obviously know the specific client which is being called:

<syntaxhighlight lang=javascript>
myclient.minimized.connect(function() {
print("Minimize a client!!");
});
</syntaxhighlight>

To understand which parameters are passed to the event handlers (i.e. the functions we connect to), one can always refer the [[Development/Tutorials/KWin/Scripting/API]].

== Your first (useful) script ==

In this tutorial we will be creating a script based on a suggestion by Eike Hein. In Eike’s words: ''“A quick use case question: For many years I’ve desired the behavior of disabling keep-above on a window with keep-above enabled when it is maximized, and re-enabling keep-above when it is restored. Is that be possible with kwin scripting? It’ll need the ability to trigger methods on state changes and store information above a specific window across those state changes, I guess.”''

Other than the really function and useful script idea, what is really great about this is that it makes for a perfect tutorial example. I get to cover most of the important aspects of KWin scripting while at the same time creating something useful.

So let’s get on with it…

=== The basic outline ===
'''Design statement''': For every window that is set to '''‘Keep Above’''' others, the window should not be above all windows when it is maximized.

To do so, this is how we’ll proceed:
#Create an array of clients whose '''‘Keep Above’''' property is set.
#Whenever a script loads, make a list of all clients whose '''‘Keep Above’''' property is set and add it to the array.
#Whenever a client is maximized, if it’s ''''‘Keep Above’''' property is set, remove the '''‘Keep Above’''' property.
#Whenever a client is restored, if it is in the ‘array’, set it’s '''‘Keep Above’''' property.
#Whenever a new client is added, check and see if it needs to be added to the array (depending on whether it’s '''‘Keep Above’''' property is set or not).

==== The basic framework ====
So, for first steps, let us just create an array:
<syntaxhighlight lang=javascript>
var ka_clients = new Array();
</syntaxhighlight>
Now, we need to make a list of all available clients whose '''‘Keep Above’''' property is set. From the [[Development/Tutorials/KWin/Scripting/API|KWin API docs]] you can lookup the '''workspace.getAllClients()''' method:

[[File:Kwintut2.png]]

Allow me to present a small primer on how to read the KWin API docs. Here, the first line mentions the method, which is '''‘workspace.getAllClients’'''. The '''‘ret’''' specifies the type of value that will be returned by the method. Here, it says ''ret: Array(client)'', which means that an array of client objects will be returned. It takes one parameter '''desktop_no''', which specifies which desktop to fetch the clients from. The rest is clear from the description itself. So, to check all the clients whose '''‘Keep Above’''' property is set, we will use the following piece of code:

<syntaxhighlight lang=javascript>
var c = workspace.getAllClients();

for(var i=0; i<c.length; i++) {
if(c[i].keepAbove()) {
print(client.caption() + " (yes)");
}
}
</syntaxhighlight>

'''Explanation:'''
*First, it gets a list of all clients available from all the desktops and stores it in a variable '''‘c’'''.
*Then it loops over the entire array and checks for clients whose '''‘keepAbove’''' property is set. To do this, one can use the '''client.keepAbove''' method. It returns true if the given clients '''‘Keep Above’''' property is set.
*Then it simply prints the clients caption.

Here, every element of '''‘c’''' is an object of type '''‘client’'''. Every '''‘client’''' object represents a window. Here is how my terminal looks after writing this script:

[[File:Kwintut3.png]]

Now, what we need to do, is add every such client to the array '''ka_clients'''. So this is how our code will look:

<syntaxhighlight lang=javascript>
var ka_clients = new Array();
var c = workspace.getAllClients();

for(var i=0; i<c.length; i++) {
if(c[i].keepAbove()) {
ka_clients[ka_clients.length] = c[i];
}
}
</syntaxhighlight>

What '''ka_clients[ka_clients.length]''' does is append an element to that array.

==== Manage maximization for clients ====
Now that we have added it to an array, we need to make a provision that whenever the client is maximized, it’s '''‘Keep Above’''' property does not stay. So, we’ll modify the previous code a little:

<syntaxhighlight lang=javascript>
function manageKeepAbove(type) {
if((type.h == 1) && (type.v == 1)) {
this.setKeepAbove(0);
}
}

for(var i=0; i<c.length; i++) {
if(c[i].keepAbove()) {
ka_clients[ka_clients.length] = c[i];
ka_clients.onMaximizeSet.connect(c[i], manageKeepAbove);
}
}
</syntaxhighlight>

For all events, there are two ways to connect it:

<syntaxhighlight lang=javascript>
object.event.connect(h_function);
object.event.connect(f_this, h_function);
</syntaxhighlight>

In either case, '''h_function''' is called whenever the event occurs, but in the second case, the function’s '''‘this’''' object is set to '''f_this'''. We use the second way because as you can see, multiple clients connect to the same function. So whenever a function is called, how does it know which client it must handle? Hence, we must specify the object it must ‘act on’, or in the other words, it’s ‘this object’.

'''client.onMaximizeSet''' is an event whenever a client is maximized. There are two parameters while specifying a maximization: horizontal maximization and vertical maximization. The function is passed only one value which has two properties '''‘h’''' and '''‘v’'''. It specifies in which direction the client occupied the workspace dimension. We want the property to be triggered only when the client is maximized in both the directions. Note here that it is not necessary to write a function of our own in the global scope since we can use anonymous functions also. However, we are writing a function in the global scope so that we can even disconnect this slot later if needed.

Save and run this script and see if it works as one would expect it to.

==== Managing clients whose properties which are dynamically set ====
At this point however, if you set the '''‘Keep Above’''' property for a client, its property won’t be removed on maximization. This is because currently we are only covering the clients which are already present. To cover clients whose property is set after a script has been loaded, we’ll use the event '''workspace.clientSetKeepAbove'''. What we’ll do is, for every client whose '''‘Keep Above’''' property is changed, we’ll add it to the array if it is set, and we’ll remove it from the array if it is unset. This is how we’ll proceed:

<syntaxhighlight lang=javascript>
workspace.clientSetKeepAbove.connect(function(client, set) {
var found = ka_clients.indexOf(client);

if(set == 1) {
if(found == -1) {
ka_clients[ka_clients.length] = client;
client.maximizeSet.connect(client, manageKeepAbove);
}
} else if(set == 0) {
ka_clients.splice(found, 1);
client.maximizeSet.disconnect(manageKeepAbove);
}
});
</syntaxhighlight>

'''Explanation:'''
*In the event handler for '''workspace.clientSetKeepAbove''', we’ve used an anonymous function, as I mentioned was also possible previously. This is because we want this event handler to be alive throughout the execution of the script i.e. we don’t want to ever disconnect it. In such cases, anonymous functions can be used.
*Here, we simply check for a client. If its property was set, we add it to the array (if it isn’t already there) and it was unset, we remove it from the array (if it is there in the array).
*Also, whenever it is added to the array, we need to connect it’s '''maximizeSet''' event as we did previously.
*Do note that we also disconnect the function if the '''‘Keep Above’''' property was unset. To disconnect, we need to provide a function name. This is the reason why we wrote a named function in the global scope instead of an anonymous function.

One point to note there is that, the client object is merely a ''‘wrapper’'' for an actual '''Client''' object (in C++). So then how does the ‘==’ operator work for the same object that was wrapped separately (the == relation is used to lookup up a value using the '''Array.indexOf()''' method)? Even though the object they wrap is the same, shouldn’t their wrapper be different? The answer is no. A scripting object to a kwin scripting object follows a strict 1:1 relation. Just as a wrapper can be mapped to a client, a client can be mapped back to a unique wrapper. This is achieved using script caching, details for which are [http://rohanprabhu.com/?p=14 here]. This is why the ‘==’ and the ‘!=’ operator can be used safely to check if two variables actually wrap the same object or not.

==== Restoring it all ====

Now the last and most important part of it all. Whenver the client is restored, we must set it’s '''‘Keep Above’''' property if it was set earlier. To do this, we must simply extend our '''manageKeepAbove''' code to handle this scenario. In case the client is not maximized both vertically and horizontally, we check if the client is in our '''ka_clients''' arrray and if it is, we set its '''‘Keep Above’''' property, otherwise we don’t bother:

<syntaxhighlight lang=javascript>
function manageKeepAbove(type) {
if((type.h == 1) && (type.v == 1)) {
this.setKeepAbove(0);
} else {
if(ka_clients.indexOf(this)) {
this.setKeepAbove(1);
}
}
}
</syntaxhighlight>

In the end, our entire script looks like:

<syntaxhighlight lang=javascript>
var ka_clients = new Array();
var c = workspace.getAllClients();

workspace.clientSetKeepAbove.connect(function(client, set) {
var found = ka_clients.indexOf(client);

if(set == 1) {
if(found == -1) {
ka_clients[ka_clients.length] = client;
client.maximizeSet.connect(client, manageKeepAbove);
}
} else if(set == 0) {
ka_clients.splice(found, 1);
client.maximizeSet.disconnect(manageKeepAbove);
}
});

function manageKeepAbove(type) {
if((type.h == 1) && (type.v == 1)) {
this.setKeepAbove(0);
} else {
if(ka_clients.indexOf(this)) {
this.setKeepAbove(1);
}
}
}

for(var i=0; i<c.length; i++) {
if(c[i].keepAbove()) {
ka_clients[ka_clients.length] = c[i];
c[i].maximizeSet.connect(c[i], manageKeepAbove);
}
}
</syntaxhighlight>

Try out this script and check if it works according to your wishes. Before going, let me give you a small excercise. Although we’ve covered all the cases, we surely have left one. Whenever I launch a new window, what if its '''‘Keep Above’''' property is already set? We surely need to manage that also.. ''HINT:'' Use the '''workspace.clientAdded''' property.

File:Kwintut3.png

2011-12-14T23:00:00Z

Vmax0770:

File:Kwintut2.png

2011-12-14T22:56:17Z

Vmax0770:

Development/Tutorials

2011-12-14T21:59:32Z

Vmax0770: /* Application Automation and Scripting */

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

== Basics of 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]]
:''An 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.'' Based on the MainWindow tutorial.

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

;[[Development/Tutorials/SqLite|Using SqLite databases and QtSql]]
: integrated databases without the need for a database server

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

;[[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/Debugging Linker Errors|Debugging Linker Errors]]
:''How to understand and debug errors from the linker, at compile time.''

;[[Development/Tutorials/Using Qt Creator|Using Qt Creator to develop your KDE program]]
:''How to use Qt Creator as an [http://en.wikipedia.org/wiki/Integrated_development_environment IDE] to develop KDE programs''

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

;[[Development/Tutorial/Icons|Icons]]
:''Deliver your application with icons that are automatically installed to the right places''. Based on the [[Development/Tutorials/Using_KActions|Kaction Tutorial]].

;[[Development/Tutorials/Desktop_File|Desktop File]]
:''Let your application show up in the K menu and in application menus''. Based on the Icons Tutorial.

== 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.''

;Source Code
: http://gitweb.kde.org
: http://websvn.kde.org

== Accessibility ==

;[[Development/Tutorials/Accessibility|Accessibility]]
:''This tutorial will explain how to make your application accessible.''

;[[Development/Tutorials/Text-To-Speech|Text-To-Speech]]
:''How to utilize Jovie text-to-speech service in your application.''

== 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/CustomTypes|Using Custom Types with D-Bus]]: ''Learn how to use your own types in classes exported on D-Bus. Covers marhaling and unmarshaling of objects, the integration of custom types into XML descriptions and registering the custom types with the Qt Meta Object system.''
; [[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.''

; [[Development/Tutorials/Kross/ActionCollections|How to use an ActionCollection ]]
:''A small Tutorial on How to use Kross::ActionCollections.''
{{: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.

=== KWin ===
: [[Development/Tutorials/KWin/Scripting|KWin Scripting Tutorial]]
:''This tutorial shows how to write a useful script for KWin.

== Plugins and KParts ==

; [[Development/Tutorials/Using KParts|Using KParts]]:''A kPart is a plugin that you can just load into your application. For example, it is easy to integrate an editor (the katePart) or a console (the konsolePart) into your application's window.''

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

; [[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] ===

See [[Development/Tutorials/Metadata/Nepomuk|Nepomuk tutorials]].

== Hardware Awareness (Solid) ==

;[[Development/Tutorials/Solid/Introduction|Introduction to Solid]]
:''An introduction to the Solid effort in general and it library in particular.''

;[[Development/Tutorials/Solid/Device_Discovery|Listing Devices]]
:''How to use the Solid core library to discover the hardware and interact with the system.''

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

;[[Development/Tutorials/Solid/Device_Actions|Creating a Device Action]]
:''When your application is interested in registering actions with the system for removable hardware''

== Authorization and Privilege escalation (KAuth) ==
; [[Development/Tutorials/KAuth/KAuth_Basics|KAuth Basics]]
:''An overview of concepts and basic knowledge required to understand and use KAuth effectively''
; [[Development/Tutorials/KAuth/KAuth_Actions|Using KAuth actions in your application]]
:''How to execute KAuth actions in your application, and how to integrate them tightly into your UI''
; [[Development/Tutorials/KAuth/Helper_HowTo|Creating a KAuth helper to perform a privileged action]]
:''You will learn how to use KAuth's helpers and escalation facilities, and how to seamlessly make a privileged and non privileged portion of your application interact''
; [[Development/Tutorials/KAuth/KCM_HowTo|Creating a KCM requiring authorization upon saving]]
:''Learn how to use the high level KCModule API to create KCModules handling authorization, and its UI integration, on their own''

== 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].''

;[[Development/Tutorials/Phonon/Backends|Writing Backends]]
:''How to start creating a new backend for the multimedia API''

;Resources
:''Please have a look at the [http://api.kde.org/kdesupport-api/kdesupport-apidocs/phonon-git/html/ online documentation] for information on the Phonon API. If you prefer using Qt Assistant or Qt Creator you can also use our [http://mts.ms/phonon-4.4.2.qch offline documentation].''

== Plasma ==

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

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

;[[Development/AkonadiPorting|Porting Applications which use KResource API]]
:''Applications using KDE's now deprecated KResource APIs, e.g. KABC or KCal, need to be ported to use their Akonadi equivalents''

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

KDE mostly uses the [http://doc.qt.nokia.com/latest/printing.html Qt Printing infrastructure].

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

== 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 - Download]]
:''How to use KHotNewStuff3 in your application.''<br>

;[[Development/Tutorials/Collaboration/HotNewStuff/Updates|Get Hot New Stuff 3 - Checking for Updates]]
:''How to check if updates for installed stuff are available without showing the dialog/widget.''<br>

;[[Development/Tutorials/Collaboration/HotNewStuff/Upload|Get Hot New Stuff 3 - Upload]]
:''How to add an upload dialog to your application.''<br>

Old links for KNS2 and KNS1 content:<br>

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

;[[Development/Languages/Python/PyKDE_Knotify_Tutorial|PyKDE KNotify Tutorial]]
:''An introduction to Knotify (Notifications and KJobs) 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 [[Development/Languages/Ruby|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''

== 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/Git|Using Git to develop for KDE]]
:''Here you find 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

=== Porting an application from KSystemTrayIcon to KStatusNotifierItem ===
;[[Development/Tutorials/PortToKStatusNotifierItem]]
:''This tutorials shows how to port an application using KSystemTrayIcon to KStatusNotifierItem''

=== Using the KDE Wallet API for safe storage ===
;[[Development/Tutorials/KWallet]]
:"Brief introduction to the KWallet API which can be used for storing all kinds of sensitive information."

===How to edit a wiki with Libmediawiki ===
;[[Development/Tutorials/Libmediawiki]]
:''This tutorial present how to edit a wiki with Libmediawiki.''

== KDE2 and KDE3 Materials ==
;[[Development/Tutorials/KDE4 Porting Guide|Porting Your Application from KDE 3 to KDE 4]]
:''These tutorials cover topics related to the migration from KDE 3 to KDE 4.''

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