KDE TechBase - User contributions [en]

Development/Tutorials/Plasma/QML/API

2013-02-06T00:57:49Z

Hefee: /* Signals */ adding sample

= Introduction to the Plasmoid QML Declarative API =

This document provides an overview/reference of the Declarative QML API for Plasmoids. It isn't a full binding to all of Qt or KDE's libraries, but a focused set of bindings designed to make writing Plasmoids fast and easy, while remaining powerful.

The API in this documentation covers the API of the Plasma specific QML components, so only the Declarative part of the API.

The QML ScriptEngine is based upon the Plasma JavaScript engine, making the API of the JavaScript part identical to the one of the JavaScript plasmoids engine.
To see the api of the global ''Plasmoid'' object, see the [http://techbase.kde.org/Development/Tutorials/Plasma/JavaScript/API#The_Global_plasmoid_Object JavaScript API] documentation.
(TODO: the JavaScript api page should probably be copied and stripped down the imperative bits not present there, it would make it harder to update tough)
The most important API for using graphical widgets is the [http://api.kde.org/4.x-api/plasma-qml-apidocs/ Plasma QtComponents API]

== What Is a Declarative Plasmoid? ==

To denote that this Plasmoid is a Declarative widget, ensure that in the metadata.desktop file there is this line:

X-Plasma-API=declarativeappletscript

What follows is a description of the Plasma declarative classes instantiable from QML.

== fetching data from the plasmoid package ==

If you have a file in your plasmoid package under contents, let's say an image, you can access it with the plasmapackage url protocol:

<syntaxhighlight lang="javascript">
Image {
source: "plasmapackage:/images/foo.png"
}
</syntaxhighlight>

The above code will load in the Image component the file foo.png located in contents/images of your plasmoid package.

<syntaxhighlight lang="javascript">
import "plasmapackage:/code/foo.js" as Foo
</syntaxhighlight>

Similarly, the above code will import a javascript file from the folder contents/code of your plasmoid package.

= Properties exported from the main QML item =
The root qml item can export some properties to influence its behavior:
* '''property int minimumWidth''': the plasmoid won't ever become narrower then that, size in pixels.
* '''property int minimumHeight''': minum height of the plasmoid, size in pixels.
* '''property Component compactRepresentation''': if the plasmoid is a popupapplet, the component in compactRepresentation will be used instead of the icon and will always be collapsed, regardless if it's in a panel or not.

= Main Plasma QML Classes =

== Data Engines ==
While it's possible to fetch data from a Plasma DataEngine in the same way as the [http://techbase.kde.org/Development/Tutorials/Plasma/JavaScript/API#DataEngine JavaScript API], it is preferrable to use the following declarative classes:

=== DataSource ===
DataSource is a receiver for a dataEngine and can be declared inside QML:

<syntaxhighlight lang="javascript">
import org.kde.plasma.core 0.1 as PlasmaCore

PlasmaCore.DataSource {
id: dataSource
engine: "time"
connectedSources: ["Local"]
interval: 500
}
</syntaxhighlight>

==== Properties ====
It has the following properties:
* bool '''valid''' (read only): true when the DataSource is successfully connected to a data engine
* int '''interval''': interval of polling of the dataengine, if 0 (default value, so no need to specify if you don't need it) no polling will be executed
* string '''engine''': the plugin name of the dataengine to load, e.g. "nowplaying", etc.
* Array(string) '''connectedSources''': all the sources of the dataengine we are connected to (and whose data will appear in the '''data''' property)
* Array(string) '''sources''' (read only): all the sources available from the dataengine
* variant map '''data''' (read only): It's the most important property, it's a map of all the data available from the dataengine: its structure will be as follows:
** each key of the map will be a source name, in '''connectedSources'''
** each value will be a variant hash, so an hash with strings as keys and any variant as value
** example: dataSource.data["Local"]["Time"] indicates the '''Time''' key of the dataengine source called "Local"
* string '''sourceFilter''' it's a regular expression. If the DataSource is connected to more than one source, only inserts data from sources matching this filter expression in the model. If we want to have a source watch all sources beginning with say "name:", the required regexp would be sourceFilter: "name:.*"

==== Signals ====
It has the following signals:

Note that javascript/qml applies the 'on' prefix to signals. So the actual signal name in C++ which is e.g. '''newData'''(...) becomes '''onNewData'''(...).

* '''onNewData'''(String sourceName, Plasma::DataEngine::Data data) the local vairables are named to '''sourceName''' and '''data'''
* '''onSourceAdded'''(String source)
* '''onSourceRemoved'''(String source)
* '''onSourceConnected'''(String source)
* '''onSourceDisconnected'''(String source)
* '''onIntervalChanged'''()
* '''onEngineChanged'''()
* '''onDataChanged'''()
* '''onConnectedSourcesChanged'''()
* '''onSourcesChanged'''()

You normaly wants to use '''onNewData''' (that is the aquivalent to '''dataUpdated''' in other languages). Here is sample with the time dataengine:

<syntaxhighlight lang="javascript">
import QtQuick 1.0
import org.kde.plasma.core 0.1 as PlasmaCore

Item {
PlasmaCore.DataSource {
id: dataSource
engine: "time"
connectedSources: ["Local","UTC"]
interval: 500

onNewData:{
if(sourceName== "Local"){
local.text = data.Time
}
else if(sourceName== "UTC"){
label_utc.text = data.Timezone
}
}

}
Grid{
columns: 2
spacing: 5
Text{text: dataSource.data.Local.Timezone}
Text {
id: local
text: "XX:XX:XX"
}
Text{id: label_utc; text: "XXXX"}
Text {
id: utc
text: dataSource.data.UTC.Time
}
}
}
</syntaxhighlight>

You see two different approches to get to the data:

* One is to act on ''onNewData''
* Use the ''data'' parameter from dataSource

==== Methods ====
It has the following methods:
* StringList keysForSource(String source): lists all the keys corresponding to a certain source: for instance in the "time" dataengine, for the "Local" source, keys will be:
** "Timezone Continent"
** "Offset"
** "Timezone"
** "Time"
** "Date"
** "Timezone City"
* Service serviceForSource(String source): returns a Plasma service that corresponds a given source: see the section about services for how to use it.
* void connectSource(String source): adds to '''connectedSources''' the new source
* void disconnectSource(String source): removes that source from '''connectedSources'''

=== Service ===
Due to their imperative nature, Plasma Services are not instantiated as QML classes, but rather created out of a '''DataSource''' with the method '''serviceForSource''' and used in the JavaScript portions of the QML files.
This following example is a simplified version from the Now Playing QML widget in the kdeexamples git repository:

<syntaxhighlight lang="javascript">
var service = dataSource.serviceForSource(activeSource)
var operation = service.operationDescription("seek")
operation.seconds = 10

var job = service.startOperationCall(operation)
</syntaxhighlight>
Here dataSource is the id of a DataSource object, and activeSource is a source contained in one of its '''connectedSources'''.
The service provides an operation called "seek", with a parameter called "seconds", that can be written on it as a property of a JavaScript object.

=== ServiceJob ===
It is necessary to monitor the result of a Service operation, it's possible to connect to the '''finished''' signal provided by the job return paramenter of the '''startOperationCall''' service method.
The '''finished''' signal has the same job as parameter, from which is possible to check the variant '''result''' property, to check the result.

<syntaxhighlight lang="javascript">

var service = messagesDataSource.serviceForSource(src)
var operation = "auth";

function result(job) {
statusItem.authorizationStatus = job.result;
print("ServiceJob result: " + job.result + " op: " + job.operationName);
}

var operation = service.operationDescription(operation);
operation.user = userName;
operation.password = password;
var serviceJob = service.startOperationCall(operation);
serviceJob.finished.connect(result);

</syntaxhighlight>

=== DataModel ===
Some data engines return as their data something that can be interpreted as a list of items, rather than simple key/value pairs.
QML provides some item views such as '''ListView''', '''GridView''' and '''Repeater'''.
The '''DataModel''' QML object can provide, based on a DataSource a model suitable for those QML item views.

It has the following properties:
* DataSource '''dataSource''': the id of an existing (and connected) DataSource
* String '''sourceFilter''': it's a regular expression. If the DataSource is connected to more than one source, only inserts data from sources matching this filter expression in the model. To, for example, have a source watch all sources beginning with say "name:", the required regexp would be sourceFilter: "name:.*"
* String '''keyRoleFilter''': it's a regular expression. Only data with keys that match this filter expression will be inserted in the model. If you need all data inserted in the mode, you must explicitly request it using the regular expression ".*"
* int '''count''' (read only): how many items are in the model

Example:

<syntaxhighlight lang="javascript">
ListView {
model: PlasmaCore.DataModel {
dataSource: microblogSource
keyRoleFilter: "[\\d]*"
}
delegate: Text {
text: title
}
}
</syntaxhighlight>

In the example, ''microblogSource'' is the id of a DataSource, and inserts in the model only entries that have a number as the key name (matched with [\\d]*, in this case tweets ids)

Each item in the model will have the form of a variant hash: all the keys of the hash will be registered as model role names, in the example, "title" is a role of the model containing a string (also reachable with model["title"]).

A special reserved role will always be present: '''"DataEngineSource"''': it will contain the name of the data engine source that gave origin to this item. Therefore, if you want merely the string of the current source that the model is at...do model["DataEngineSource"].

Note that view.currentItem holds the item currently selected. However, due to (http://bugreports.qt.nokia.com/browse/QTBUG-16347) this does not work in PathView. A workaround is to make your own.

=== SortFilterModel ===
SortFilterModel is a proxy model for easy sorting and/or filtering of the items in a DataModel (or any other QAbstractItemModel subclass that has been registered in QML with setContextProperty from a C++ application)
Properties:
* model '''sourceModel'''
* String '''filterRegExp'''
* String '''filterRole'''
* String '''sortRole'''
* Qt::SortOrder '''sortOrder'''
* int '''count''' (read only)

This is an example from the feed widget:
<syntaxhighlight lang="javascript">
model: PlasmaCore.SortFilterModel {
id: postTitleFilter
filterRole: "title"
sortRole: "time"
sortOrder: "DescendingOrder"
filterRegExp: toolbarFrame.searchQuery
sourceModel: PlasmaCore.SortFilterModel {
id: feedCategoryFilter
filterRole: "feed_url"
sourceModel: PlasmaCore.DataModel {
dataSource: feedSource
keyRoleFilter: "items"
}
}
}
</syntaxhighlight>

== Popup Applet ==
So you want your QML applet to be a popup applet, like the device notifier (an icon in the panel shows and expands the applet)?

Why, that's easy.

To change your plasmoid from being a regular boring one, in your '''metadata.desktop''', simply change this following line:

<syntaxhighlight lang="ini">
ServiceTypes=Plasma/Applet
</syntaxhighlight>

To:

<syntaxhighlight lang="ini">
ServiceTypes=Plasma/Applet,Plasma/PopupApplet
</syntaxhighlight>

Then in the main QML item's Component.onCompleted, do:

<syntaxhighlight lang="javascript">
plasmoid.popupIcon = "konqueror"
</syntaxhighlight>

If you want to use other elements instead of an icon when collapsed in a panel, use the '''compactRepresentation''' property in the root Item.

== Plasma Themes ==

=== Theme ===
This class instantiable from QML provides access to the Plasma Theme colors and other facilities such as fonts.
From KDE 4.8 a Theme instance is always present given the org.kde.plasma.core plugin was imported, is not necessary to create it by hand.
It has the following properties:
* String '''themeName''' (read only)
* bool '''windowTranslucentEnabled''' (read only)
* Url '''homepage''' (read only)
* bool '''useGlobalSettings''' (read only)
* QString '''wallpaperPath''' (read only)
* color '''textColor''' (read only)
* color '''highlightColor''' (read only)
* color '''backgroundColor''' (read only)
* color '''buttonTextColor''' (read only)
* color '''buttonBackgroundColor''' (read only)
* color '''linkColor''' (read only)
* color '''visitedLinkColor''' (read only)
* color '''visitedLinkColor''' (read only)
* color '''buttonHoverColor''' (read only)
* color '''buttonFocusColor''' (read only)
* color '''viewTextColor''' (read only)
* color '''viewBackgroundColor''' (read only)
* color '''viewHoverColor''' (read only)
* color '''viewFocusColor''' (read only)
* String '''styleSheet''' (read only)
* Font '''defaultFont''' (read only)
* Font '''desktopFont''' (read only)
* Font '''smallestFont''' (read only)

Each Font element has the following properties:
* bool bold
* Capitalization '''capitalization''' (MixedCase, AllUppercase, AllLowercase, SmallCaps, Capitalize) (read only)
* String '''family''' (read only)
* bool '''italic''' (read only)
* real '''letterSpacing''' (read only)
* int '''pixelSize''' (read only)
* real '''pointSize''' (read only)
* bool '''strikeout''' (read only)
* bool '''underline''' (read only)
* Weight '''weight''' (Light, Normal, DemiBold, Bold, Black) (read only)
* real '''wordSpacing''' (read only)
* size '''mSize''' the size, width and height of an uppercase "M" in this font (read only)

Theme is also used to control icon sizes, with the property '''iconSize'''. it is an Object, that has the following properties:
* int '''desktop''': size of icons suited for the workspace
* int '''toolbar''': icons to be put in a ToolBar component
* int '''small''': smallest size for still "readable" icons
* int '''dialog''': icons to be put in popup dialogs

=== Svg ===
Declaring a Svg element instantiates a Plasma Svg instance. This class doesn't draw anything. For drawing, SvgItem is used.
Properties:
* QSize '''size'''
* bool '''multipleImages'''
* String '''imagePath''' can be anything in the '''desktoptheme/''' folder. For more information on what is available, see [http://techbase.kde.org/Projects/Plasma/Theme#Current_Theme_Elements Plasma Theme Elements]. Make sure to strip the final extension from this string, so you should for example use <code>"dialogs/background"</code> to get the standard background.
* bool '''usingRenderingCache'''

Methods:
* QPixmap pixmap(QString elementID)
* void resize(qreal width, qreal height)
* void resize(): resets the image to its default dimension
* QSize elementSize(QString elementId)
* QRectF elementRect(QString elementId)
* bool hasElement(QString elementId)
* bool isValid(): true if valid svg file

=== FrameSvg ===
Declaring a FrameSvg element instantiates a Plasma FrameSvg instance. This class doesn't draw anything. For drawing, FrameSvgItem is used.
This is to be used when you need informations about the framesvg, such as hasElementPrefix().

Properties:
* All properties from Svg
* EnabledBorders '''enabledBorders''': flag combination of:
** NoBorder
** TopBorder
** BottomBorder
** LeftBorder
** RightBorder

Methods:
* All methods from Svg
* void setImagePath(QString path)
* void resizeFrame(QSize size)
* QSize frameSize()
* qreal marginSize(Plasma::MarginEdge edge)
* void getMargins(qreal left, qreal top, qreal right, qreal bottom): parameters are output, they get set with the margins from the FrameSvg
* QRectF contentsRect(): the rectangle of the center element, taking the margins into account.
* void setElementPrefix(QString prefix)
* bool hasElementPrefix(const QString prefix)
* QString prefix()
* void setCacheAllRenderedFrames(bool cache)
* bool cacheAllRenderedFrames()
* void clearCache()
* QPixmap framePixmap()

Sample Code:
<syntaxhighlight lang="javascript">
PlasmaCore.FrameSvg {
id: myFrameSvg
imagePath: "widgets/button"
prefix: "pressed"
}
</syntaxhighlight>

=== SvgItem ===
It's a graphical element that will actually paint a Svg instance.
Properties:
* String '''elementId''': what element to render. If null, the whole svg will be rendered
* Svg '''svg''': instance of the Svg class mentioned above
* QSizeF '''naturalSize''' (read only): default size of the Svg
* bool '''smooth''': paint with antialias (default false)

Sample Code:

<syntaxhighlight lang="javascript">
PlasmaCore.SvgItem {
id: mySvgItem
anchors {
top: parent.top
left: parent.left
}

width: 300
height: 3

svg: mySvg
elementId: "horizontal-line"
}
</syntaxhighlight>

=== FrameSvgItem ===
It's a graphical element that paints a Plasma::FrameSvg, so a rectangular image composed by 9 elements contained in a Svg file, useful for things like buttons and frames.

Flags
* EnabledBorders: combination of TopBorder | BottomBorder | LeftBorder | RightBorder, NoBorder if no border of the frame is enabled

Properties:
* String '''imagePath''': path of the file relative to the Plasma Theme, for instance "widgets/background"
* String '''prefix''': a FrameSvg can contain multiple frames, for instance a button contains "normal", "raised" and "pressed"
* Margins '''margins''' (read only): the margins of the frame, see documentation below
* EnabledBorders '''enabledBorders''': what borders are enabled

==== Margins ====
Properties:
* real '''left''' (read only)
* real '''top''' (read only)
* real '''right''' (read only)
* real '''bottom''' (read only)

Sample Code:

<syntaxhighlight lang="javascript">
PlasmaCore.FrameSvgItem {
id: myFrameSvgItem
anchors.fill: parent
imagePath: "translucent/dialogs/background"
}
</syntaxhighlight>

== Top Level windows ==

=== Dialog ===
Dialog instantiates a Plasma::Dialog, it will be a Plasma themed top level window that can contain any QML component.

Properties:
* Item '''mainItem''': the Item contained in the Dialog, it can be any QML Item instance
* bool '''visible''': if the window (not the mainItem) is visible
* int '''x''': x position of the window in screen coordinates
* int '''y''': y position of the window in screen coordinates
* int '''width''' (read only): total width of the dialog, including margins
* int '''height''' (read only): total height of the dialog, including margins.
* int '''windowFlags''': Qt window flags of the Dialog
* Margins '''margins''' (read only): margins of the Dialog

{{Note|The width and height will scale with size of the main item within this Dialog component.}}

<syntaxhighlight lang="javascript">
import QtQuick 1.1
import org.kde.plasma.core 0.1 as PlasmaCore

Item {
PlasmaCore.Dialog {
visible: true
mainItem: Item {
width: 500
height: 500

Text {
anchors.centerIn: parent
color: "red"
text: qsTr("text")
}
}
}
}
</syntaxhighlight>

Methods:
* QPoint popupPosition(Item item, Qt::Alignment alignment=Qt::AlignLeft): the suggested position for the Dialog if it has to be correctly placed as popup of the QML item passed as parameter.
* void setAttribute(Qt::WindowAttribute attribute, bool on): set an attribute for the dialog window

==== Margins ====
Properties:
* real '''left''' (read only)
* real '''top''' (read only)
* real '''right''' (read only)
* real '''bottom''' (read only)

=== ToolTip ===
Declaring a ToolTip instance makes it possible to use Plasma tooltips with any QML item.

Properties:
* Item '''target''': the QML item we want to show a tooltip of
* String '''mainText'''
* String '''subText'''
* String '''image''': freedesktop compliant icon name as image of the tooltip

== Containments ==
A Plasma Containment manages the position and manipulation of Plasmoids. The declarative containment is responsible for layout of applets and can provide custom applet handles. The containment should listen to the plasmoid.immutability property. In order to lay out applets in your containment, you can use the AppletContainer class to access geometry information of applets.
Actions such as configure and close are available through plasmoid.actions.
You can access the plasmoid global property from containments in the same way as from declarative and javascript plasmoids. If the plasmoid is a Containment, you can get a list of actions for it. If you want to provide background rendering in your Containment yourself, read the applet.backgroundHints property and after that set applet.backgroundHints to 0 to tell the Applet that is should not render the background.

=== AppletContainer ===
The AppletContainer class provides access to the geometry and status of Plasmoids in this Containment.
Properties:
* ''Item'' '''applet''': The applet item, this property allows you to track destruction of the actual applet and update your layout.
** ''int'' '''backgroundHints''': Should the Applet be rendered on top of a background frame? 0 for no background, 1 for default background, 2 for translucent background
* ''int'' '''minimumWidth''': The minimum width of the applet
* ''int'' '''minimumHeight''': The minimum height of the applet
* ''int'' '''maximumWidth''': The maximum width of the applet
* ''int'' '''maximumHeight''': The maximum height of the applet
* ''int'' '''preferredWidth''': The preferred height of the applet
* ''int'' '''preferredHeight''': The preferred height of the applet
* ''enum'' '''status''': The status of the applet, one in the enum
** '''UnknownStatus''': The status is unknown
** '''PassiveStatus''': The applet is passive
** '''ActiveStatus''': The applet is active
** '''NeedsAttentionStatus''': The applet asks for attention
** '''AcceptingInputStatus''': The applet is accepting input

They can be imported in your code with:
<syntaxhighlight lang="javascript">
import org.kde.plasma.containments 0.1 as PlasmaContainments
</syntaxhighlight>

AppletContainer is only available for Plasma/Containment packages, and only if they are loaded as containment. AppletContainer is new in 4.10.

=== ToolBox ===
The ToolBox is only available through the plasmoid object, through plasmoid.toolBox(). The ToolBox is rendered as a separate item on top of the scene covering the entire containment. It is loaded from the "org.kde.toolbox" Plasma Package, if the package is not found, no ToolBox will be loaded.
The ToolBox provides a listmodel of actions that can be rendered using Repeaters or ListViews. The ''actions'' list property contains actions from the Corona and Containments. Examples for these actions are showing the add widget or activities interface, lock and unlock. The actions in the list change dynamically whenever the widgets are locked or unlocked.
Actions such as lock screen and leave can be implemented using the powermanagement dataengine's services for these functions.

ToolBox provides access to the following properties:
* ''Array(QAction)'' '''actions''': A list of actions provided by the Containment. These actions' most interesting properties are:
** ''QIcon'' '''icon''': The icon belonging to this action.
** ''String'' '''text''': The icon belonging to this action.
** '''trigger()''': Call trigger from your action delegate to trigger the action.

<syntaxhighlight lang="javascript">
import org.kde.plasma.containments 0.1 as PlasmaContainments
</syntaxhighlight>

ToolBox is only available for Containments and new in 4.10.

= Plasma QtComponents (4.8) =
Plasma components documentation online at [http://api.kde.org/4.x-api/plasma-qml-apidocs/ api.kde.org]

=QtExtraComponents=
The QtExtraComponents make some very convenient Qt classes usable from within QML.

They can be imported in your code with:
<syntaxhighlight lang="javascript">
import org.kde.qtextracomponents 0.1
</syntaxhighlight>

==QPixmapItem==
This one wraps around a QPixmap class and allows you to send a QPixmap directly to QPixmapItem.

Properties:
* QPixmap '''pixmap''': The QPixmap object.
* bool '''smooth''': Set to true to render smooth.
* int '''nativeWidth''': (verification needed) The QPixmap width
* int '''nativeHeight''': (verification needed) The QPixmap height
* FillMode '''fillMode''': see below

==QImageItem==
This one wraps around a QImage class and allows you to send a QImage directly to QImageItem.

Properties:
* QImage '''image''': The QImage object.
* bool '''smooth''': Set to true to render smooth.
* int '''nativeWidth''': (verification needed) The QImage width
* int '''nativeHeight''': (verification needed) The QImage height
* FillMode '''fillMode''': see below

==FillMode==
Both QPixmapItem and QImageItem expose a FillMode enum. This enum defines how the image is going to be used to fill the item.

For QPixmapItem, possible values are:

* QPixmapItem.Stretch: the image is scaled to fit
* QPixmapItem.PreserveAspectFit: the image is scaled uniformly to fit without cropping
* QPixmapItem.PreserveAspectCrop: the image is scaled uniformly to fill, cropping if necessary
* QPixmapItem.Tile: the image is duplicated horizontally and vertically
* QPixmapItem.TileVertically: the image is stretched horizontally and tiled vertically
* QPixmapItem.TileHorizontally :e image is stretched vertically and tiled horizontally

QImageItem defines the same values, you just need to replace QPixmapItem with QImageItem.

==QIconItem==
This one wraps around a QPixmap class and allows you to send a QIcon directly to QIconItem.

Properties:
* QIcon/QString '''icon''': If you provide a QIcon it uses that directly. If you provide a string it uses a KIcon internally!
* bool '''smooth''': Set to true to render smooth.
* int '''implicitWidth''': Default width of as set in SystemSettings->Applications Appearance->Icons
* int '''implicitHeight''': Default height of as set in SystemSettings->Applications Appearance->Icons
* State '''state''': Icon state (DefaultState, ActiveState, DisabledState)

Development/Tutorials/Plasma/QML/GettingStarted

2013-02-06T00:36:01Z

Hefee: adding documentation to Row and Column

== Abstract ==

Writing a plasma applet in QML is very easy, in fact, with KDE 4.6 and Qt 4.7 it just works.

== QML Basics ==

It is recommended that you have read through the [http://qt-project.org/doc/qt-4.8/qtquick.html Qt QML Tutorials], as there are quite a few and they are explained thoroughly. There is also a list of all [http://qt-project.org/doc/qt-4.8/qdeclarativeelements.html standard QML elements].

Essentially, most of the content is the same. The exceptions to be noted are how data is gathered...since we use Data Engines, it is a bit different. Text color and font should be made to use PlasmaCore.Theme.

See the [https://projects.kde.org/projects/kde/kdeexamples/repository KDE Examples] repository for more KDE-related helpful resources. Also of use (which use QML and Plasma) are: [https://projects.kde.org/projects/playground/base/plasma-mobile/repository Plasma Mobile], [https://projects.kde.org/projects/playground/base/declarative-plasmoids/repository Declarative Plasmoids (playground)], for WIP ports of C++ originals

=== Root Item ===

The root item can be anything that inherits QGraphicsItem. For example, in this case it is QGraphicsWidget which is a plasmoid. It can also simply be an Item. I also noticed that PathView does not respond to mouse inputs automatically (so flicking doesn't work). Probably because events are being intercepted. So take note, it'll have to be e.g. an Item, for that case.

=== Layouts ===

==== Row and Column ====
Coloums and Rows are very easy way to grouping items and is very simular to the "normal layout management" with [http://doc.qt.digia.com/stable/qhboxlayout.html QHBoxLayout] and [http://doc.qt.digia.com/stable/qvboxlayout.html QVBoxLayout]. In QML these are named:

* Column arranges its children in a column
* Row arranges its children in a row
* Grid arranges its children in a grid
* Flow arranges its children like words on a page

They have a special property '''spacing'''(int) to define the distance in pixels between two children.

For furture help please look at [http://qt-project.org/doc/qt-4.8/qml-positioners.html Using QML Positioner and Repeater Items from qt-project.org]

Some example:
<syntaxhighlight lang="javascript">
import QtQuick 1.0
import org.kde.plasma.core 0.1 as PlasmaCore

Item {
Column{
spacing: 10
Row {
spacing: 5
Text{text: 'Local'}
Text {
id: local
text: "XX:XX:XX"
}
}
Row {
spacing: 5
Text{text: 'UTC'}
Text {
id: utc
text: "XX:XX:XX"
}
}
}
}
</syntaxhighlight>
==== Anchors ====
Anchor layouts offer a nice way of grouping UI elements nicely together. The idea is that you connect edges or corners of one element to the edge or corner of another widget. Available anchors are:
* left
* horizontalCenter
* right
* top
* verticalCenter
* baseline, and bottom.

Some examples:
<syntaxhighlight lang="javascript">
import QtQuick 1.0
import org.kde.plasma.core 0.1 as PlasmaCore

Item {
width: 200
height: 300

Text {
id: first
text: i18n("1st line")
anchors {
top: parent.top;
left: parent.left;
right: parent.right;
}
}
Text {
id: second
text: i18n("2nd line")
anchors {
top: first.bottom;
left: parent.left;
right: parent.right;
bottom: parent.bottom;
}
}
}
</syntaxhighlight>

Keep in mind, that you can only use elements that are a parent or a sibling.

Here a WRONG example ('first'' and ''second'' are no siblings ):

<syntaxhighlight lang="javascript">
Text {
id: first
text: i18n("1st line")
}
Item{
id: breakIt
Text {
id: second
text: i18n("2nd line")
anchors {
top: first.bottom;
}
}
}
</syntaxhighlight>
Plasmoidviewer you show you folloing explanation:

file:///XXXX/contents/ui/main.qml:69:9: QML Text: Cannot anchor to an item that isn't a parent or sibling.

More examples you will find on the [http://qt-project.org/doc/qt-4.8/qml-anchor-layout.html Anchor-based Layout in QML from the qt-project.org].

=== Buttons ===

=== Animations ===

== Package Structure ==

You create a .desktop file and the .qml file. They have to be in the usual plasma package structure:

* plasmoid-qml/metadata.desktop
* plasmoid-qml/contents/ui/main.qml

=== <tt>metadata.desktop</tt> ===
<syntaxhighlight lang="ini">
[Desktop Entry]
Name=Hello QML
Comment=A hello world widget in QML
Icon=chronometer

X-Plasma-API=declarativeappletscript
X-Plasma-MainScript=ui/main.qml
X-Plasma-DefaultSize=200,100

X-KDE-PluginInfo-Author=Frederik Gladhorn
X-KDE-PluginInfo-Email=gladhorn@kde.org
X-KDE-PluginInfo-Website=http://plasma.kde.org/
X-KDE-PluginInfo-Category=Examples
X-KDE-PluginInfo-Name=org.kde.hello-qml
X-KDE-PluginInfo-Version=0.0

X-KDE-PluginInfo-Depends=
X-KDE-PluginInfo-License=GPL
X-KDE-PluginInfo-EnabledByDefault=true
X-KDE-ServiceTypes=Plasma/Applet
Type=Service
</syntaxhighlight>

The line below indicates the default size of the plasmoid. The applet's starting size will be this, when added to a scene:

<syntaxhighlight lang="ini">
X-Plasma-DefaultSize=200,100
</syntaxhighlight>

=== <tt>main.qml</tt> ===
<syntaxhighlight lang="javascript">
import QtQuick 1.0

Text {
text: "Hello world!";
}
</syntaxhighlight>

== Installing ==
You can install your plasmoid, though obviously this is just temporary. CMake, below, is recommended:
<syntaxhighlight lang="bash">
plasmapkg --install plasmoid-qml
</syntaxhighlight>

=== Installation through CMake ===
In your CMakeLists.txt:

<syntaxhighlight lang="cmake">
project(helloqml)

find_package(KDE4 REQUIRED)

include(KDE4Defaults)

install(DIRECTORY package/
DESTINATION ${DATA_INSTALL_DIR}/plasma/plasmoids/org.kde.plasma.applet.myapplet)

install(FILES package/metadata.desktop
DESTINATION ${SERVICES_INSTALL_DIR} RENAME plasma-applet-myapplet.desktop)
</syntaxhighlight>

Your directory structure should now be as follows:

<syntaxhighlight lang="bash">
myproject/CMakeLists.txt
myproject/package/
myproject/package/metadata.desktop
myproject/package/contents/
myproject/package/contents/ui/
myproject/package/contents/ui/helloworld.qml
</syntaxhighlight>

(if you have a configuration file (.ui file) to load the right-click 'plasmoid settings' menu, then your structure will also have myproject/package/contents/config/config.ui, or so)

== plasmoidviewer ==
You can run it in plasmoidviewer as usual:
plasmoidviewer plasmoid-qml

== qmlviewer ==
It's possible to use Plasma specific imports in qml files loaded by qmlviewer:

qmlviewer -I /usr/lib/kde4/imports/ plasmoid-qml/contents/qml/main.qml

Where the -I is the path to the plasma plugin for qml. Try to look for the path of
/usr/lib/kde4/imports/org/kde/plasma/graphicswidgets/libgraphicswidgetsbindingsplugin.so
and use everything up to org of that path.

Hovewer it's '''strongly discouraged''' to use qmlviewer to develop plasmoids, because '''some features won't be available there, like the following''':
* localization with i18n()
* access to the global ''plasmoid'' object
* device specific qml files imported with plasmapackage:// urls
* bindings for qicons, KJobs, services and KConfig
* retrieving data from a DataEngine

Therefore, it is recommended to simply use '''plasmoidviewer'''

= Features only available in Plasma widgets =
In order to have a better integration with the KDE platform and to reach an higher degree of expressivity, the stock features of QML have been expanded with the following features, that strictly follow the Plasmoid JavaScript API:

== Minimum size ==
if the root object of the plasmoid has the properties minimumWidth and minimumHeight, they will be used as the minimum size for the plasmoid. If they will change during the plasmoid execution, the plasmoid minimum size will be updated accordingly.
<syntaxhighlight lang="javascript">
import QtQuick 1.0

Text {
property int minimumWidth: paintedWidth
property int minimumHeight: paintedHeight
text: "Hello world!";
}
</syntaxhighlight>

In the above example, the minimum size is bound to the paintedWidth/paintedHeight properties of the Text element, ensuring there will always be enough room for the whole text to be displayed.

== Plasmoid object ==
Every QML plasmoid will have an object called ''plasmoid'', that will give access to the configuration, the formfactor, immutability and so on. It offers the same api as the object with the same name in the Javascript API.

For specific info on this, see [http://techbase.kde.org/Development/Tutorials/Plasma/JavaScript/API-PlasmoidObject Javascript API-Plasmoid Object]

== Localization ==
It is possible to localize strings with the usual i18n(), i18nc(), i18np() global functions.

== Extra types ==
Some extra types are available from withing JavaScript, namely

* KConfigGroup: it's an object with its config keys readable and writable as properties
* QIcon: can be constructed with QIcon("fdo name") such as QIcon("konqueror")
* KJob
* Plasma Service api

= Plasma specific imports =
To use some Plasma specific features and to take advantage of them in order for your applet to become a true Plasma applet, it is necessary to use some particular QML imports. See [http://techbase.kde.org/Development/Tutorials/Plasma/QML/API Plasma QML API].

== Extra Qt features ==
org.kde.qtextraimports
To use, do:

<syntaxhighlight lang="javascript">
import org.kde.qtextracomponents 0.1 as QtExtraComponents
</syntaxhighlight>

* QPixmapItem
* QImageItem
* QIconItem

== Plasma Widgets in QML ==
To use standard plasma widgets (e.g. Plasma::LineEdit, etc.), you simply add an import line for them.
All properties, signals and slots from ordinary Plasma widgets are available there.
'''These widgets are provided as a transition tool, intended to be replaced by the Plasma version of QtComponents''', which is currently in development by a gsoc. (note that the Plasma QtComponents have nothing to do with the QtExtraComponents module described above)

<syntaxhighlight lang="javascript">
import QtQuick 1.0
import org.kde.plasma.graphicswidgets 0.1 as PlasmaWidgets

Item {
width: 64
height: 64
PlasmaWidgets.IconWidget {
id: icon
Component.onCompleted: setIcon("flag-red")
anchors.centerIn: parent
}
}
</syntaxhighlight>
To get a list of icons installed on system, run the command:
$ kdialog --geticon actions

Development/Tutorials/Plasma/QML/GettingStarted

2013-02-06T00:12:30Z

Hefee: /* Anchors */ adds a wrong example and points to the documenation of qt-project

== Abstract ==

Writing a plasma applet in QML is very easy, in fact, with KDE 4.6 and Qt 4.7 it just works.

== QML Basics ==

It is recommended that you have read through the [http://qt-project.org/doc/qt-4.8/qtquick.html Qt QML Tutorials], as there are quite a few and they are explained thoroughly. There is also a list of all [http://qt-project.org/doc/qt-4.8/qdeclarativeelements.html standard QML elements].

Essentially, most of the content is the same. The exceptions to be noted are how data is gathered...since we use Data Engines, it is a bit different. Text color and font should be made to use PlasmaCore.Theme.

See the [https://projects.kde.org/projects/kde/kdeexamples/repository KDE Examples] repository for more KDE-related helpful resources. Also of use (which use QML and Plasma) are: [https://projects.kde.org/projects/playground/base/plasma-mobile/repository Plasma Mobile], [https://projects.kde.org/projects/playground/base/declarative-plasmoids/repository Declarative Plasmoids (playground)], for WIP ports of C++ originals

=== Root Item ===

The root item can be anything that inherits QGraphicsItem. For example, in this case it is QGraphicsWidget which is a plasmoid. It can also simply be an Item. I also noticed that PathView does not respond to mouse inputs automatically (so flicking doesn't work). Probably because events are being intercepted. So take note, it'll have to be e.g. an Item, for that case.

=== Layouts ===

==== Row and Column ====

==== Anchors ====
Anchor layouts offer a nice way of grouping UI elements nicely together. The idea is that you connect edges or corners of one element to the edge or corner of another widget.
Some examples:
<syntaxhighlight lang="javascript">
import QtQuick 1.0
import org.kde.plasma.core 0.1 as PlasmaCore

Item {
width: 200
height: 300

Text {
id: first
text: i18n("1st line")
anchors {
top: parent.top;
left: parent.left;
right: parent.right;
}
}
Text {
id: second
text: i18n("2nd line")
anchors {
top: first.bottom;
left: parent.left;
right: parent.right;
bottom: parent.bottom;
}
}
}
</syntaxhighlight>

Keep in mind, that you can only use elements that are a parent or a sibling.

Here a WRONG example ('first'' and ''second'' are no siblings ):

<syntaxhighlight lang="javascript">
Text {
id: first
text: i18n("1st line")
}
Item{
id: breakIt
Text {
id: second
text: i18n("2nd line")
anchors {
top: first.bottom;
}
}
}
</syntaxhighlight>
Plasmoidviewer you show you folloing explanation:

file:///XXXX/contents/ui/main.qml:69:9: QML Text: Cannot anchor to an item that isn't a parent or sibling.

More examples you will find on the [http://qt-project.org/doc/qt-4.8/qml-anchor-layout.html Anchor-based Layout in QML from the qt-project].

=== Buttons ===

=== Animations ===

== Package Structure ==

You create a .desktop file and the .qml file. They have to be in the usual plasma package structure:

* plasmoid-qml/metadata.desktop
* plasmoid-qml/contents/ui/main.qml

=== <tt>metadata.desktop</tt> ===
<syntaxhighlight lang="ini">
[Desktop Entry]
Name=Hello QML
Comment=A hello world widget in QML
Icon=chronometer

X-Plasma-API=declarativeappletscript
X-Plasma-MainScript=ui/main.qml
X-Plasma-DefaultSize=200,100

X-KDE-PluginInfo-Author=Frederik Gladhorn
X-KDE-PluginInfo-Email=gladhorn@kde.org
X-KDE-PluginInfo-Website=http://plasma.kde.org/
X-KDE-PluginInfo-Category=Examples
X-KDE-PluginInfo-Name=org.kde.hello-qml
X-KDE-PluginInfo-Version=0.0

X-KDE-PluginInfo-Depends=
X-KDE-PluginInfo-License=GPL
X-KDE-PluginInfo-EnabledByDefault=true
X-KDE-ServiceTypes=Plasma/Applet
Type=Service
</syntaxhighlight>

The line below indicates the default size of the plasmoid. The applet's starting size will be this, when added to a scene:

<syntaxhighlight lang="ini">
X-Plasma-DefaultSize=200,100
</syntaxhighlight>

=== <tt>main.qml</tt> ===
<syntaxhighlight lang="javascript">
import QtQuick 1.0

Text {
text: "Hello world!";
}
</syntaxhighlight>

== Installing ==
You can install your plasmoid, though obviously this is just temporary. CMake, below, is recommended:
<syntaxhighlight lang="bash">
plasmapkg --install plasmoid-qml
</syntaxhighlight>

=== Installation through CMake ===
In your CMakeLists.txt:

<syntaxhighlight lang="cmake">
project(helloqml)

find_package(KDE4 REQUIRED)

include(KDE4Defaults)

install(DIRECTORY package/
DESTINATION ${DATA_INSTALL_DIR}/plasma/plasmoids/org.kde.plasma.applet.myapplet)

install(FILES package/metadata.desktop
DESTINATION ${SERVICES_INSTALL_DIR} RENAME plasma-applet-myapplet.desktop)
</syntaxhighlight>

Your directory structure should now be as follows:

<syntaxhighlight lang="bash">
myproject/CMakeLists.txt
myproject/package/
myproject/package/metadata.desktop
myproject/package/contents/
myproject/package/contents/ui/
myproject/package/contents/ui/helloworld.qml
</syntaxhighlight>

(if you have a configuration file (.ui file) to load the right-click 'plasmoid settings' menu, then your structure will also have myproject/package/contents/config/config.ui, or so)

== plasmoidviewer ==
You can run it in plasmoidviewer as usual:
plasmoidviewer plasmoid-qml

== qmlviewer ==
It's possible to use Plasma specific imports in qml files loaded by qmlviewer:

qmlviewer -I /usr/lib/kde4/imports/ plasmoid-qml/contents/qml/main.qml

Where the -I is the path to the plasma plugin for qml. Try to look for the path of
/usr/lib/kde4/imports/org/kde/plasma/graphicswidgets/libgraphicswidgetsbindingsplugin.so
and use everything up to org of that path.

Hovewer it's '''strongly discouraged''' to use qmlviewer to develop plasmoids, because '''some features won't be available there, like the following''':
* localization with i18n()
* access to the global ''plasmoid'' object
* device specific qml files imported with plasmapackage:// urls
* bindings for qicons, KJobs, services and KConfig
* retrieving data from a DataEngine

Therefore, it is recommended to simply use '''plasmoidviewer'''

= Features only available in Plasma widgets =
In order to have a better integration with the KDE platform and to reach an higher degree of expressivity, the stock features of QML have been expanded with the following features, that strictly follow the Plasmoid JavaScript API:

== Minimum size ==
if the root object of the plasmoid has the properties minimumWidth and minimumHeight, they will be used as the minimum size for the plasmoid. If they will change during the plasmoid execution, the plasmoid minimum size will be updated accordingly.
<syntaxhighlight lang="javascript">
import QtQuick 1.0

Text {
property int minimumWidth: paintedWidth
property int minimumHeight: paintedHeight
text: "Hello world!";
}
</syntaxhighlight>

In the above example, the minimum size is bound to the paintedWidth/paintedHeight properties of the Text element, ensuring there will always be enough room for the whole text to be displayed.

== Plasmoid object ==
Every QML plasmoid will have an object called ''plasmoid'', that will give access to the configuration, the formfactor, immutability and so on. It offers the same api as the object with the same name in the Javascript API.

For specific info on this, see [http://techbase.kde.org/Development/Tutorials/Plasma/JavaScript/API-PlasmoidObject Javascript API-Plasmoid Object]

== Localization ==
It is possible to localize strings with the usual i18n(), i18nc(), i18np() global functions.

== Extra types ==
Some extra types are available from withing JavaScript, namely

* KConfigGroup: it's an object with its config keys readable and writable as properties
* QIcon: can be constructed with QIcon("fdo name") such as QIcon("konqueror")
* KJob
* Plasma Service api

= Plasma specific imports =
To use some Plasma specific features and to take advantage of them in order for your applet to become a true Plasma applet, it is necessary to use some particular QML imports. See [http://techbase.kde.org/Development/Tutorials/Plasma/QML/API Plasma QML API].

== Extra Qt features ==
org.kde.qtextraimports
To use, do:

<syntaxhighlight lang="javascript">
import org.kde.qtextracomponents 0.1 as QtExtraComponents
</syntaxhighlight>

* QPixmapItem
* QImageItem
* QIconItem

== Plasma Widgets in QML ==
To use standard plasma widgets (e.g. Plasma::LineEdit, etc.), you simply add an import line for them.
All properties, signals and slots from ordinary Plasma widgets are available there.
'''These widgets are provided as a transition tool, intended to be replaced by the Plasma version of QtComponents''', which is currently in development by a gsoc. (note that the Plasma QtComponents have nothing to do with the QtExtraComponents module described above)

<syntaxhighlight lang="javascript">
import QtQuick 1.0
import org.kde.plasma.graphicswidgets 0.1 as PlasmaWidgets

Item {
width: 64
height: 64
PlasmaWidgets.IconWidget {
id: icon
Component.onCompleted: setIcon("flag-red")
anchors.centerIn: parent
}
}
</syntaxhighlight>
To get a list of icons installed on system, run the command:
$ kdialog --geticon actions

Schedules

2011-02-08T23:39:42Z

Hefee: /* KDE4 */ 4.7 Feature Plan

__NOTOC__

During development, the KDE project sets goals in features and dates for upcoming releases. This way, the team knows when it would be a good time to add a new feature or when it's time to
focus on cleaning up any bugs in preparation for a release. Any plans are tentative schedules and the final dates are generally decided on the kde-core-devel mailing list.

Learn more about [[Schedules/Release Schedules Guide|release schedules]].

== KDE4 ==
* [[Schedules/KDE4/Goals|KDE 4 Goals]]
* [[Schedules/KDE4/Application Porting Status|Application Porting Status]]

*'''KDE SC 4.7'''
** [[Schedules/KDE4/4.7 Release Schedule|Release Schedule]]
** [[Schedules/KDE4/4.7 Feature Plan|Feature Plan]]

*'''KDE SC 4.6'''
** [[Schedules/KDE4/4.6 Release Schedule|Release Schedule]]
** [[Schedules/KDE4/4.6 Feature Plan|Feature Plan]]

*'''KDE SC 4.5'''
** [[Schedules/KDE4/4.5 Release Schedule|Release Schedule]]
** [[Schedules/KDE4/4.5 Feature Plan|Feature Plan]]

*'''KDE SC 4.4'''
** [[Schedules/KDE4/4.4 Release Schedule|Release Schedule]]
** [[Schedules/KDE4/4.4 Release Goals|Release Goals]]
** [[Schedules/KDE4/4.4 Feature Plan|Feature Plan]]
** [[Schedules/Is KDE 4.4 for you?|Is KDE 4.4 for you?]]
** [[Schedules/KDE4/4.4 Upstream Issues|Release Critical Upstream Issues]]
** [[Schedules/KDE4/4.4 Requirements|Compilation Requirements]]

*'''KDE 4.3'''
** [[Schedules/KDE4/4.3 Release Schedule|Release Schedule]]
** [[Schedules/KDE4/4.3 Release Goals|Release Goals]]
** [[Schedules/KDE4/4.3 Feature Plan|Feature Plan]]
** [[Schedules/Is KDE 4.3 for you?|Is KDE 4.3 for you?]]
** [[Schedules/KDE4/4.3 Upstream Issues|Release Critical Upstream Issues]]
** [[Schedules/KDE4/4.3 Requirements|Compilation Requirements]]

*'''KDE 4.2'''
** [[Schedules/KDE4/4.2 Release Schedule|Release Schedule]]
** [[Schedules/KDE4/4.2 Release Goals|Release Goals]]
** [[Schedules/KDE4/4.2 Feature Plan|Feature Plan]]
** [[Schedules/Is KDE 4.2 for you?|Is KDE 4.2 for you?]]
** [[Schedules/KDE4/4.2 Upstream Issues|Release Critical Upstream Issues]]
** [[Schedules/KDE4/4.2 Requirements|Compilation Requirements]]

*'''KDE 4.1'''
** [[Schedules/KDE4/4.1 Release Schedule|Release Schedule]]
** [[Schedules/KDE4/4.1 Release Goals|Release Goals]]
** [[Schedules/KDE4/4.1 Feature Plan|Feature Plan]]
** [[Schedules/Is KDE 4.1 for you?|Is KDE 4.1 for you?]]

*'''KDE 4.0'''
** [[Schedules/KDE4/4.0 Release Schedule|Release Schedule]]
** [[Schedules/KDE4/4.0 Release Roadmap|Release Milestones]]
** [[Schedules/KDE4/4.0 Module_Status|Module Status and Pending Application Issues]]
** [[Schedules/KDE4/4.0 Upstream Issues|Release Critical Upstream Issues]]
** [[Schedules/KDE4/4.0 Announcements|Announcement Information]]
** [http://developer.kde.org/development-versions/kde-4.0-features.html Feature Plan]
** [[Schedules/KDE4/4.0 Requirements|Compilation Requirements]]

== KDE3 ==

*'''KDE 3.5''' [[Schedules/KDE 3.5 Release Schedule|release schedule]], [[Schedules/KDE 3.5 Feature Plan|feature plan]]

=== Previous releases ===

*'''KDE 3.4''' [[Schedules/KDE 3.4 Release Schedule|release schedule]], [[Schedules/KDE 3.4 Feature Plan|feature plan]]
*'''KDE 3.3''' [[Schedules/KDE 3.3 Release Schedule|release schedule]], [[Schedules/KDE 3.3 Feature Plan|feature plan]]
*'''KDE 3.2''' [[Schedules/KDE 3.2 Release Schedule|release schedule]], [[Schedules/KDE 3.2 Feature Plan|feature plan]]
*'''KDE 3.1''' [[Schedules/KDE 3.1 Release Schedule|release schedule]], [[Schedules/KDE 3.1 Feature Plan|feature plan]]
*'''KDE 3.0''' [[Schedules/KDE 3.0 Release Schedule|release schedule]], [[Schedules/KDE 3.0 Feature Plan|feature plan]]

== KOffice ==

=== Current releases ===

*'''KOffice 2.3''' [http://wiki.koffice.org/index.php?title=Schedules/KOffice/2.3/Release_Plan release schedule], [http://wiki.koffice.org/index.php?title=Schedules/KOffice/2.3/Feature_Plan feature plan]
*'''KOffice 2.2''' [http://wiki.koffice.org/index.php?title=Schedules/KOffice/2.2/Release_Plan release schedule], [http://wiki.koffice.org/index.php?title=Schedules/KOffice/2.2/Feature_Plan feature plan]
*'''KOffice 2.1''' [http://wiki.koffice.org/index.php?title=Schedules/KOffice/2.1/Release_Plan release schedule], [http://wiki.koffice.org/index.php?title=Schedules/KOffice/2.1/Feature_Plan feature plan]
*'''KOffice 2.0''' [http://wiki.koffice.org/index.php?title=Schedules/KOffice/2.0/Release_Plan release schedule], [http://wiki.koffice.org/index.php?title=Schedules/KOffice/2.0/Feature_Plan feature plan]

=== Previous releases ===

*'''KOffice 1.6''' [[Schedules/KOffice 1.6 Release Schedule|release schedule]]
*'''KOffice 1.5''' [[Schedules/KOffice 1.5 Release Schedule|release schedule]]

== Extragear ==
* [[Schedules/Extragear|Overview of upcoming Extragear releases]]

== Playground ==
* [[Schedules/Playground|Overview of upcoming Playground releases]]

Development/Languages/Python/PyKDE Knotify Tutorial/MyJob.py

2010-08-10T00:12:01Z

Hefee: Terimation

<code python>
#! /usr/bin/python
# -*- coding: utf-8 -*-
from PyQt4.QtCore import QObject,QTimer,QString
from PyKDE4.kdecore import KJob
from PyKDE4.kio import KIO

class MyJob(KJob):
def __init__(self,parent=QObject()):
KJob.__init__(self,parent)
#We want to have a Suspenable and Killable Job
self.setCapabilities(KJob.Capabilities(KJob.Suspendable|KJob.Killable))

#Just a maximum Variable
self.max=25

#index
self.i=0

def start(self):
#register the Job to the JobTracker
KIO.getJobTracker().registerJob(self)

#initalizing for work
self.i=0

#start the actual work in another thread
#this function has to terminate, before the work is done
QTimer().singleShot(0, self.doWork)

def doWork(self):
#the actual work
try:
#if we are killed or suspended just return
if self.error() or self.isSuspended():
return
except RuntimeError:
#if this class is killed before a RuntimeError will raise
return

#do a peace of hard work
self.i+=1

#fortunately we have made a peace of work
#-> show this to everybody
KJob.setPercent(self,self.i*4)

if self.i==self.max:
#jeah we have done the bunch of work
#send the result signal for showing, that we ended the work
self.emitResult()
return
#just go to sleep for 1000ms than go on
QTimer().singleShot(1000, self.doWork)

def doSuspend(self):
#the surounding function from KJob makes the isSuspended() become True
#returns True for signaling that this class supports to suspend
return True

def doResume(self):
#start with work again
QTimer().singleShot( 0, self.doWork )
#return True for signaling that this class supports resuming
return True

def doKill(self):
#return True for signaling that we support killing
return True

def handleResult(job):
#handleResult Function
#it is called when the job is terminating
if job.error():
print 'error happend'
else:
print 'job has terminated successfully'

#termination the whole application
sys.exit()

if __name__ == "__main__":
import sys

from PyKDE4.kdecore import KCmdLineArgs, KAboutData, KLocalizedString, ki18n
from PyKDE4.kdeui import KApplication

appName = "default"
catalog = ""
programName = ki18n ("default")
version = "1.0"
description = ki18n ("Default Example")
license = KAboutData.License_GPL
copyright = ki18n ("(c) 2010 Sandro Knauß")
text = ki18n ("none")
homePage = "techbase.kde.org"
bugEmail = "bugs@sandroknauss.de"

aboutData = KAboutData (appName, catalog, programName, version, description,
license, copyright, text, homePage, bugEmail)

KCmdLineArgs.init (sys.argv, aboutData)

app = KApplication ()

#create job
job=MyJob(app)

job.result.connect(handleResult)

#start job
job.start()

#wait till all is done
app.exec_()
</code>

Development/Languages/Python/PyKDE Knotify Tutorial

2010-08-10T00:10:51Z

Hefee: terimation

{{Template:I18n/Language Navigation Bar|Development/Languages/Python/PyKDE_Knotify_Tutorial}}

{{TutorialBrowser|

series=Python|

name=Python KNotify Tutorial|

next=|

reading=[http://techbase.kde.org/Development/Tutorials/Python_introduction_to_signals_and_slots Qt Signals and Slots in python], [http://www.learningpython.com/2008/09/20/an-introduction-to-pyqt/ Introduction to PyQT4], [http://techbase.kde.org/Development/Languages/Python/Using_PyKDE_4 Using PyKDE4]
}}

== Abstract ==

The aim of this tutorial is to give a sample class to include Notifications and Jobs to your own python programms, so the user can see what is going on (for example a backup system, that tells you that is backuping right now). It assumes a basic working knowledge of Python and PyKDE4.
For now only the Job part is mentioned, 'cause that is the only part I've created right now.

== Further plans ==
To add the Notification part also to this tutorial.

== Instruction ==

We start with a minimal KDE Appliciation ([http://techbase.kde.org/Development/Languages/Python/Using_PyKDE_4 Using PyKDE4]):

<code python>
#! /usr/bin/python
# -*- coding: utf-8 -*-

if __name__ == "__main__":
import sys

from PyKDE4.kdecore import KCmdLineArgs, KAboutData, KLocalizedString, ki18n
from PyKDE4.kdeui import KApplication

appName = "default"
catalog = ""
programName = ki18n ("default")
version = "1.0"
description = ki18n ("Default Example")
license = KAboutData.License_GPL
copyright = ki18n ("(c) 2010 Sandro Knauß")
text = ki18n ("none")
homePage = "techbase.kde.org"
bugEmail = "bugs@sandroknauss.de"

aboutData = KAboutData (appName, catalog, programName, version, description,
license, copyright, text, homePage, bugEmail)

KCmdLineArgs.init (sys.argv, aboutData)

app = KApplication ()
</code>

== Job class ==
The first step is to have a look to the [http://api.kde.org]. The intersting on is:
* [http://api.kde.org/pykde-4.3-api/kdecore/KJob.html KJob(KDE 4.3-PyKDE4)]- unfortunately this documention is only available for KDE 4.3. So we have also a look to the actual C++ Doumentation
* [http://api.kde.org/4.x-api/kdelibs-apidocs/kdecore/html/classKJob.html KJob(KJob 4.x-C++API)]

So it is easy to write a small Job-Class:

<code python>
from PyQt4.QtCore import QObject,QTimer,QString
from PyKDE4.kdecore import KJob

class MyJob(KJob):
def __init__(self,parent=QObject()):
KJob.__init__(self,parent)
#We want to have a Suspenable and Killable Job
self.setCapabilities(KJob.Capabilities(KJob.Suspendable|KJob.Killable))

#Just a maximum Variable
self.max=25

#index
self.i=0

def start(self):
#initalizing for work
self.i=0

#start the actual work in another thread
#this function has to terminate, before the work is done
QTimer().singleShot(0, self.doWork)

def doWork(self):
#the actual work
try:
#if we are killed or suspended just return
if self.error() or self.isSuspended():
return
except RuntimeError:
#if this class is killed before a RuntimeError will raise
return

#do a peace of hard work
self.i+=1

#fortunately we have made a peace of work
#-> show this to everybody
KJob.setPercent(self,self.i*4)

if self.i==self.max:
#jeah we have done the bunch of work
#send the result signal for showing, that we ended the work
self.emitResult()
return
#just go to sleep for 1000ms than go on
QTimer().singleShot(1000, self.doWork)

def doSuspend(self):
#the surounding function from KJob makes the isSuspended() become True
#returns True for signaling that this class supports to suspend
return True

def doResume(self):
#start with work again
QTimer().singleShot( 0, self.doWork )
#return True for signaling that this class supports resuming
return True

def doKill(self):
#return True for signaling that we support killing
return True
</code>

===What is going on?===
* '''MyJob.__init__''': First we create the class and initialize the counter ''i'' and the maximum ''max''. To make is visible for others we set the Capacities, so this job is suspendable and killable.
* '''MyJob.start''': Here the pre working setting are made, we will se later for what we use this. After initalizing the Work we start the actual work by using a QTimer. The start method should start the asyncron.
* '''MyJob.doWork''': Do actual work and handle, if this job is killed or suspended.
* '''MyJob.doSuspend'''/'''MyJob.doResume'''/'''MyJob.doKill''': These function indicate that this feature is supported by this class.

===How to use?===
Just create a instance of this class and start it:
<code python>
job=MyJob(app)
job.start()
</code>

===We want to know when the jobs done?===
Create a '''SLOT''' to the '''result'''-signal:
<code python>
def handleResult(job):
#handleResult Function
#it is called when the job is terminating
if job.error():
print 'error happend'
else:
print 'job has terminated successfully'

#for terimation the complete application
sys.exit()

job.result.connect(handleResult)
</code>

Now we also add '''app.exec_()''' at the end of the main part, to prevent the program to stop before the job is stopped.

===Visual feedback===
Till now, a normal user doesn't see anything what is going on. To change it we have to register the Job to a JobTracker. Now a user will see a progressbar and a suspend and a stop button. So we modify the start method:

<code python>
from PyKDE4.kio import KIO
...
def start(self):
#register the Job to the JobTracker
KIO.getJobTracker().registerJob(self)
self.i=0
QTimer().singleShot(0, self.doWork)
</code>

=== Conclusion ===
Here is the [[Development/Languages/Python/PyKDE_Knotify_Tutorial/MyJob.py|full code]] of this example.

Is is very easy to create a Job and make it visible to normal users. Unfortunately I have problems with setting the heading and description, so this will be added in later versions.

Development/Languages/Python/PyKDE Knotify Tutorial/MyJob.py

2010-08-09T23:56:13Z

Hefee: Version 1.0

<code python>
#! /usr/bin/python
# -*- coding: utf-8 -*-
from PyQt4.QtCore import QObject,QTimer,QString
from PyKDE4.kdecore import KJob
from PyKDE4.kio import KIO

class MyJob(KJob):
def __init__(self,parent=QObject()):
KJob.__init__(self,parent)
#We want to have a Suspenable and Killable Job
self.setCapabilities(KJob.Capabilities(KJob.Suspendable|KJob.Killable))

#Just a maximum Variable
self.max=25

#index
self.i=0

def start(self):
#register the Job to the JobTracker
KIO.getJobTracker().registerJob(self)

#initalizing for work
self.i=0

#start the actual work in another thread
#this function has to terminate, before the work is done
QTimer().singleShot(0, self.doWork)

def doWork(self):
#the actual work
try:
#if we are killed or suspended just return
if self.error() or self.isSuspended():
return
except RuntimeError:
#if this class is killed before a RuntimeError will raise
return

#do a peace of hard work
self.i+=1

#fortunately we have made a peace of work
#-> show this to everybody
KJob.setPercent(self,self.i*4)

if self.i==self.max:
#jeah we have done the bunch of work
#send the result signal for showing, that we ended the work
self.emitResult()
return
#just go to sleep for 1000ms than go on
QTimer().singleShot(1000, self.doWork)

def doSuspend(self):
#the surounding function from KJob makes the isSuspended() become True
#returns True for signaling that this class supports to suspend
return True

def doResume(self):
#start with work again
QTimer().singleShot( 0, self.doWork )
#return True for signaling that this class supports resuming
return True

def doKill(self):
#return True for signaling that we support killing
return True

def handleResult(job):
#handleResult Function
#it is called when the job is terminating
if job.error():
print 'error happend'
else:
print 'job has terminated successfully'

if __name__ == "__main__":
import sys

from PyKDE4.kdecore import KCmdLineArgs, KAboutData, KLocalizedString, ki18n
from PyKDE4.kdeui import KApplication

appName = "default"
catalog = ""
programName = ki18n ("default")
version = "1.0"
description = ki18n ("Default Example")
license = KAboutData.License_GPL
copyright = ki18n ("(c) 2010 Sandro Knauß")
text = ki18n ("none")
homePage = "techbase.kde.org"
bugEmail = "bugs@sandroknauss.de"

aboutData = KAboutData (appName, catalog, programName, version, description,
license, copyright, text, homePage, bugEmail)

KCmdLineArgs.init (sys.argv, aboutData)

app = KApplication ()

#create job
job=MyJob(app)

job.result.connect(handleResult)

#start job
job.start()

</code>

Development/Languages/Python/PyKDE Knotify Tutorial

2010-08-09T23:54:56Z

Hefee: /* Job class */ KDE 4.3

{{Template:I18n/Language Navigation Bar|Development/Languages/Python/PyKDE_Knotify_Tutorial}}

{{TutorialBrowser|

series=Python|

name=Python KNotify Tutorial|

next=|

reading=[http://techbase.kde.org/Development/Tutorials/Python_introduction_to_signals_and_slots Qt Signals and Slots in python], [http://www.learningpython.com/2008/09/20/an-introduction-to-pyqt/ Introduction to PyQT4], [http://techbase.kde.org/Development/Languages/Python/Using_PyKDE_4 Using PyKDE4]
}}

== Abstract ==

The aim of this tutorial is to give a sample class to include Notifications and Jobs to your own python programms, so the user can see what is going on (for example a backup system, that tells you that is backuping right now). It assumes a basic working knowledge of Python and PyKDE4.
For now only the Job part is mentioned, 'cause that is the only part I've created right now.

== Further plans ==
To add the Notification part also to this tutorial.

== Instruction ==

We start with a minimal KDE Appliciation ([http://techbase.kde.org/Development/Languages/Python/Using_PyKDE_4 Using PyKDE4]):

<code python>
#! /usr/bin/python
# -*- coding: utf-8 -*-

if __name__ == "__main__":
import sys

from PyKDE4.kdecore import KCmdLineArgs, KAboutData, KLocalizedString, ki18n
from PyKDE4.kdeui import KApplication

appName = "default"
catalog = ""
programName = ki18n ("default")
version = "1.0"
description = ki18n ("Default Example")
license = KAboutData.License_GPL
copyright = ki18n ("(c) 2010 Sandro Knauß")
text = ki18n ("none")
homePage = "techbase.kde.org"
bugEmail = "bugs@sandroknauss.de"

aboutData = KAboutData (appName, catalog, programName, version, description,
license, copyright, text, homePage, bugEmail)

KCmdLineArgs.init (sys.argv, aboutData)

app = KApplication ()
</code>

== Job class ==
The first step is to have a look to the [http://api.kde.org]. The intersting on is:
* [http://api.kde.org/pykde-4.3-api/kdecore/KJob.html KJob(KDE 4.3-PyKDE4)]- unfortunately this documention is only available for KDE 4.3. So we have also a look to the actual C++ Doumentation
* [http://api.kde.org/4.x-api/kdelibs-apidocs/kdecore/html/classKJob.html KJob(KJob 4.x-C++API)]

So it is easy to write a small Job-Class:

<code python>
from PyQt4.QtCore import QObject,QTimer,QString
from PyKDE4.kdecore import KJob

class MyJob(KJob):
def __init__(self,parent=QObject()):
KJob.__init__(self,parent)
#We want to have a Suspenable and Killable Job
self.setCapabilities(KJob.Capabilities(KJob.Suspendable|KJob.Killable))

#Just a maximum Variable
self.max=25

#index
self.i=0

def start(self):
#initalizing for work
self.i=0

#start the actual work in another thread
#this function has to terminate, before the work is done
QTimer().singleShot(0, self.doWork)

def doWork(self):
#the actual work
try:
#if we are killed or suspended just return
if self.error() or self.isSuspended():
return
except RuntimeError:
#if this class is killed before a RuntimeError will raise
return

#do a peace of hard work
self.i+=1

#fortunately we have made a peace of work
#-> show this to everybody
KJob.setPercent(self,self.i*4)

if self.i==self.max:
#jeah we have done the bunch of work
#send the result signal for showing, that we ended the work
self.emitResult()
return
#just go to sleep for 1000ms than go on
QTimer().singleShot(1000, self.doWork)

def doSuspend(self):
#the surounding function from KJob makes the isSuspended() become True
#returns True for signaling that this class supports to suspend
return True

def doResume(self):
#start with work again
QTimer().singleShot( 0, self.doWork )
#return True for signaling that this class supports resuming
return True

def doKill(self):
#return True for signaling that we support killing
return True
</code>

===What is going on?===
* '''MyJob.__init__''': First we create the class and initialize the counter ''i'' and the maximum ''max''. To make is visible for others we set the Capacities, so this job is suspendable and killable.
* '''MyJob.start''': Here the pre working setting are made, we will se later for what we use this. After initalizing the Work we start the actual work by using a QTimer. The start method should start the asyncron.
* '''MyJob.doWork''': Do actual work and handle, if this job is killed or suspended.
* '''MyJob.doSuspend'''/'''MyJob.doResume'''/'''MyJob.doKill''': These function indicate that this feature is supported by this class.

===How to use?===
Just create a instance of this class and start it:
<code python>
job=MyJob(app)
job.start()
</code>

===We want to know when the jobs done?===
Create a '''SLOT''' to the '''result'''-signal:
<code python>
def handleResult(job):
#handleResult Function
#it is called when the job is terminating
if job.error():
print 'error happend'
else:
print 'job has terminated successfully'

job.result.connect(handleResult)
</code>

===Visual feedback===
Till now, a normal user doesn't see anything what is going on. To change it we have to register the Job to a JobTracker. Now a user will see a progressbar and a suspend and a stop button. So we modify the start method:

<code python>
from PyKDE4.kio import KIO
...
def start(self):
#register the Job to the JobTracker
KIO.getJobTracker().registerJob(self)
self.i=0
QTimer().singleShot(0, self.doWork)
</code>

=== Conclusion ===
Here is the [[Development/Languages/Python/PyKDE_Knotify_Tutorial/MyJob.py|full code]] of this example.

Is is very easy to create a Job and make it visible to normal users. Unfortunately I have problems with setting the heading and description, so this will be added in later versions.

Development/Languages/Python/PyKDE Knotify Tutorial

2010-08-09T23:50:32Z

Hefee: /* Job class */ indent error

{{Template:I18n/Language Navigation Bar|Development/Languages/Python/PyKDE_Knotify_Tutorial}}

{{TutorialBrowser|

series=Python|

name=Python KNotify Tutorial|

next=|

reading=[http://techbase.kde.org/Development/Tutorials/Python_introduction_to_signals_and_slots Qt Signals and Slots in python], [http://www.learningpython.com/2008/09/20/an-introduction-to-pyqt/ Introduction to PyQT4], [http://techbase.kde.org/Development/Languages/Python/Using_PyKDE_4 Using PyKDE4]
}}

== Abstract ==

The aim of this tutorial is to give a sample class to include Notifications and Jobs to your own python programms, so the user can see what is going on (for example a backup system, that tells you that is backuping right now). It assumes a basic working knowledge of Python and PyKDE4.
For now only the Job part is mentioned, 'cause that is the only part I've created right now.

== Further plans ==
To add the Notification part also to this tutorial.

== Instruction ==

We start with a minimal KDE Appliciation ([http://techbase.kde.org/Development/Languages/Python/Using_PyKDE_4 Using PyKDE4]):

<code python>
#! /usr/bin/python
# -*- coding: utf-8 -*-

if __name__ == "__main__":
import sys

from PyKDE4.kdecore import KCmdLineArgs, KAboutData, KLocalizedString, ki18n
from PyKDE4.kdeui import KApplication

appName = "default"
catalog = ""
programName = ki18n ("default")
version = "1.0"
description = ki18n ("Default Example")
license = KAboutData.License_GPL
copyright = ki18n ("(c) 2010 Sandro Knauß")
text = ki18n ("none")
homePage = "techbase.kde.org"
bugEmail = "bugs@sandroknauss.de"

aboutData = KAboutData (appName, catalog, programName, version, description,
license, copyright, text, homePage, bugEmail)

KCmdLineArgs.init (sys.argv, aboutData)

app = KApplication ()
</code>

== Job class ==
The first step is to have a look to the [http://api.kde.org]. The intersting on is:
* [http://api.kde.org/pykde-4.1-api/kdecore/KJob.html KJob(KDE 4.1-PyKDE4)]- unfortunately this documention is only available for KDE 4.1. So we have also a look to the actual C++ Doumentation
* [http://api.kde.org/4.x-api/kdelibs-apidocs/kdecore/html/classKJob.html KJob(KJob 4.x-C++API)]

So it is easy to write a small Job-Class:

<code python>
from PyQt4.QtCore import QObject,QTimer,QString
from PyKDE4.kdecore import KJob

class MyJob(KJob):
def __init__(self,parent=QObject()):
KJob.__init__(self,parent)
#We want to have a Suspenable and Killable Job
self.setCapabilities(KJob.Capabilities(KJob.Suspendable|KJob.Killable))

#Just a maximum Variable
self.max=25

#index
self.i=0

def start(self):
#initalizing for work
self.i=0

#start the actual work in another thread
#this function has to terminate, before the work is done
QTimer().singleShot(0, self.doWork)

def doWork(self):
#the actual work
try:
#if we are killed or suspended just return
if self.error() or self.isSuspended():
return
except RuntimeError:
#if this class is killed before a RuntimeError will raise
return

#do a peace of hard work
self.i+=1

#fortunately we have made a peace of work
#-> show this to everybody
KJob.setPercent(self,self.i*4)

if self.i==self.max:
#jeah we have done the bunch of work
#send the result signal for showing, that we ended the work
self.emitResult()
return
#just go to sleep for 1000ms than go on
QTimer().singleShot(1000, self.doWork)

def doSuspend(self):
#the surounding function from KJob makes the isSuspended() become True
#returns True for signaling that this class supports to suspend
return True

def doResume(self):
#start with work again
QTimer().singleShot( 0, self.doWork )
#return True for signaling that this class supports resuming
return True

def doKill(self):
#return True for signaling that we support killing
return True
</code>

===What is going on?===
* '''MyJob.__init__''': First we create the class and initialize the counter ''i'' and the maximum ''max''. To make is visible for others we set the Capacities, so this job is suspendable and killable.
* '''MyJob.start''': Here the pre working setting are made, we will se later for what we use this. After initalizing the Work we start the actual work by using a QTimer. The start method should start the asyncron.
* '''MyJob.doWork''': Do actual work and handle, if this job is killed or suspended.
* '''MyJob.doSuspend'''/'''MyJob.doResume'''/'''MyJob.doKill''': These function indicate that this feature is supported by this class.

===How to use?===
Just create a instance of this class and start it:
<code python>
job=MyJob(app)
job.start()
</code>

===We want to know when the jobs done?===
Create a '''SLOT''' to the '''result'''-signal:
<code python>
def handleResult(job):
#handleResult Function
#it is called when the job is terminating
if job.error():
print 'error happend'
else:
print 'job has terminated successfully'

job.result.connect(handleResult)
</code>

===Visual feedback===
Till now, a normal user doesn't see anything what is going on. To change it we have to register the Job to a JobTracker. Now a user will see a progressbar and a suspend and a stop button. So we modify the start method:

<code python>
from PyKDE4.kio import KIO
...
def start(self):
#register the Job to the JobTracker
KIO.getJobTracker().registerJob(self)
self.i=0
QTimer().singleShot(0, self.doWork)
</code>

=== Conclusion ===
Here is the [[Development/Languages/Python/PyKDE_Knotify_Tutorial/MyJob.py|full code]] of this example.

Is is very easy to create a Job and make it visible to normal users. Unfortunately I have problems with setting the heading and description, so this will be added in later versions.

Development/Languages/Python/PyKDE Knotify Tutorial

2010-08-09T23:40:10Z

Hefee: How to use/Visible feed/Conclusion

{{Template:I18n/Language Navigation Bar|Development/Languages/Python/PyKDE_Knotify_Tutorial}}

{{TutorialBrowser|

series=Python|

name=Python KNotify Tutorial|

next=|

reading=[http://techbase.kde.org/Development/Tutorials/Python_introduction_to_signals_and_slots Qt Signals and Slots in python], [http://www.learningpython.com/2008/09/20/an-introduction-to-pyqt/ Introduction to PyQT4], [http://techbase.kde.org/Development/Languages/Python/Using_PyKDE_4 Using PyKDE4]
}}

== Abstract ==

The aim of this tutorial is to give a sample class to include Notifications and Jobs to your own python programms, so the user can see what is going on (for example a backup system, that tells you that is backuping right now). It assumes a basic working knowledge of Python and PyKDE4.
For now only the Job part is mentioned, 'cause that is the only part I've created right now.

== Further plans ==
To add the Notification part also to this tutorial.

== Instruction ==

We start with a minimal KDE Appliciation ([http://techbase.kde.org/Development/Languages/Python/Using_PyKDE_4 Using PyKDE4]):

<code python>
#! /usr/bin/python
# -*- coding: utf-8 -*-

if __name__ == "__main__":
import sys

from PyKDE4.kdecore import KCmdLineArgs, KAboutData, KLocalizedString, ki18n
from PyKDE4.kdeui import KApplication

appName = "default"
catalog = ""
programName = ki18n ("default")
version = "1.0"
description = ki18n ("Default Example")
license = KAboutData.License_GPL
copyright = ki18n ("(c) 2010 Sandro Knauß")
text = ki18n ("none")
homePage = "techbase.kde.org"
bugEmail = "bugs@sandroknauss.de"

aboutData = KAboutData (appName, catalog, programName, version, description,
license, copyright, text, homePage, bugEmail)

KCmdLineArgs.init (sys.argv, aboutData)

app = KApplication ()
</code>

== Job class ==
The first step is to have a look to the [http://api.kde.org]. The intersting on is:
* [http://api.kde.org/pykde-4.1-api/kdecore/KJob.html KJob(KDE 4.1-PyKDE4)]- unfortunately this documention is only available for KDE 4.1. So we have also a look to the actual C++ Doumentation
* [http://api.kde.org/4.x-api/kdelibs-apidocs/kdecore/html/classKJob.html KJob(KJob 4.x-C++API)]

So it is easy to write a small Job-Class:

<code python>
from PyQt4.QtCore import QObject,QTimer,QString
from PyKDE4.kdecore import KJob

class MyJob(KJob):
def __init__(self,parent=QObject()):
KJob.__init__(self,parent)
#We want to have a Suspenable and Killable Job
self.setCapabilities(KJob.Capabilities(KJob.Suspendable|KJob.Killable))

#Just a maximum Variable
self.max=25

#index
self.i=0

def start(self):
#initalizing for work
self.i=0

#start the actual work in another thread
#this function has to terminate, before the work is done
QTimer().singleShot(0, self.doWork)

def doWork(self):
#the actual work
try:
#if we are killed or suspended just return
if self.error() or self.isSuspended():
return
except RuntimeError:
#if this class is killed before a RuntimeError will raise
return

#do a peace of hard work
self.i+=1

#fortunately we have made a peace of work
#-> show this to everybody
KJob.setPercent(self,self.i*4)

if self.i==self.max:
#jeah we have done the bunch of work
#send the result signal for showing, that we ended the work
self.emitResult()
return
#just go to sleep for 1000ms than go on
QTimer().singleShot(1000, self.doWork)

def doSuspend(self):
#the surounding function from KJob makes the isSuspended() become True
#returns True for signaling that this class supports to suspend
return True

def doResume(self):
#start with work again
QTimer().singleShot( 0, self.doWork )
#return True for signaling that this class supports resuming
return True

def doKill(self):
#return True for signaling that we support killing
return True
</code>

===What is going on?===
* '''MyJob.__init__''': First we create the class and initialize the counter ''i'' and the maximum ''max''. To make is visible for others we set the Capacities, so this job is suspendable and killable.
* '''MyJob.start''': Here the pre working setting are made, we will se later for what we use this. After initalizing the Work we start the actual work by using a QTimer. The start method should start the asyncron.
* '''MyJob.doWork''': Do actual work and handle, if this job is killed or suspended.
* '''MyJob.doSuspend'''/'''MyJob.doResume'''/'''MyJob.doKill''': These function indicate that this feature is supported by this class.

===How to use?===
Just create a instance of this class and start it:
<code python>
job=MyJob(app)
job.start()
</code>

===We want to know when the jobs done?===
Create a '''SLOT''' to the '''result'''-signal:
<code python>
def handleResult(job):
#handleResult Function
#it is called when the job is terminating
if job.error():
print 'error happend'
else:
print 'job has terminated successfully'

job.result.connect(handleResult)
</code>

===Visual feedback===
Till now, a normal user doesn't see anything what is going on. To change it we have to register the Job to a JobTracker. Now a user will see a progressbar and a suspend and a stop button. So we modify the start method:

<code python>
from PyKDE4.kio import KIO
...
def start(self):
#register the Job to the JobTracker
KIO.getJobTracker().registerJob(self)
self.i=0
QTimer().singleShot(0, self.doWork)
</code>

=== Conclusion ===
Here is the [[Development/Languages/Python/PyKDE_Knotify_Tutorial/MyJob.py|full code]] of this example.

Is is very easy to create a Job and make it visible to normal users. Unfortunately I have problems with setting the heading and description, so this will be added in later versions.

Development/Languages/Python/PyKDE Knotify Tutorial

2010-08-09T23:18:46Z

Hefee: whats going on?

{{Template:I18n/Language Navigation Bar|Development/Languages/Python/PyKDE_Knotify_Tutorial}}

{{TutorialBrowser|

series=Python|

name=Python KNotify Tutorial|

next=|

reading=[http://techbase.kde.org/Development/Tutorials/Python_introduction_to_signals_and_slots Qt Signals and Slots in python], [http://www.learningpython.com/2008/09/20/an-introduction-to-pyqt/ Introduction to PyQT4], [http://techbase.kde.org/Development/Languages/Python/Using_PyKDE_4 Using PyKDE4]
}}

== Abstract ==

The aim of this tutorial is to give a sample class to include Notifications and Jobs to your own python programms, so the user can see what is going on (for example a backup system, that tells you that is backuping right now). It assumes a basic working knowledge of Python and PyKDE4.
For now only the Job part is mentioned, 'cause that is the only part I've created right now.

== Further plans ==
To add the Notification part also to this tutorial.

== Instruction ==

We start with a minimal KDE Appliciation ([http://techbase.kde.org/Development/Languages/Python/Using_PyKDE_4 Using PyKDE4]):

<code python>
#! /usr/bin/python
# -*- coding: utf-8 -*-

if __name__ == "__main__":
import sys

from PyKDE4.kdecore import KCmdLineArgs, KAboutData, KLocalizedString, ki18n
from PyKDE4.kdeui import KApplication

appName = "default"
catalog = ""
programName = ki18n ("default")
version = "1.0"
description = ki18n ("Default Example")
license = KAboutData.License_GPL
copyright = ki18n ("(c) 2010 Sandro Knauß")
text = ki18n ("none")
homePage = "techbase.kde.org"
bugEmail = "bugs@sandroknauss.de"

aboutData = KAboutData (appName, catalog, programName, version, description,
license, copyright, text, homePage, bugEmail)

KCmdLineArgs.init (sys.argv, aboutData)

app = KApplication ()
</code>

== Job class ==
The first step is to have a look to the [http://api.kde.org]. The intersting on is:
* [http://api.kde.org/pykde-4.1-api/kdecore/KJob.html KJob(KDE 4.1-PyKDE4)]- unfortunately this documention is only available for KDE 4.1. So we have also a look to the actual C++ Doumentation
* [http://api.kde.org/4.x-api/kdelibs-apidocs/kdecore/html/classKJob.html KJob(KJob 4.x-C++API)]

So it is easy to write a small Job-Class:

<code python>
from PyQt4.QtCore import QObject,QTimer,QString
from PyKDE4.kdecore import KJob

class MyJob(KJob):
def __init__(self,parent=QObject()):
KJob.__init__(self,parent)
#We want to have a Suspenable and Killable Job
self.setCapabilities(KJob.Capabilities(KJob.Suspendable|KJob.Killable))

#Just a maximum Variable
self.max=25

#index
self.i=0

def start(self):
#initalizing for work
self.i=0

#start the actual work in another thread
#this function has to terminate, before the work is done
QTimer().singleShot( 0, self.doWork )

def doWork(self):
#the actual work
try:
#if we are killed or suspended just return
if self.error() or self.isSuspended():
return
except RuntimeError:
#if this class is killed before a RuntimeError will raise
return

#do a peace of hard work
self.i+=1

#fortunately we have made a peace of work
#-> show this to everybody
KJob.setPercent(self,self.i*4)

if self.i==self.max:
#jeah we have done the bunch of work
#send the result signal for showing, that we ended the work
self.emitResult()
return
#just go to sleep for 1000ms than go on
QTimer().singleShot( 1000, self.doWork )

def doSuspend(self):
#the surounding function from KJob makes the isSuspended() become True
#returns True for signaling that this class supports to suspend
return True

def doResume(self):
#start with work again
QTimer().singleShot( 0, self.doWork )
#return True for signaling that this class supports resuming
return True

def doKill(self):
#return True for signaling that we support killing
return True
</code>

===What is going on?===
* '''MyJob.__init__''': First we create the class and initialize the counter ''i'' and the maximum ''max''. To make is visible for others we set the Capacities, so this job is suspendable and killable.
* '''MyJob.start''': Here the pre working setting are made, we will se later for what we use this. After initalizing the Work we start the actual work by using a QTimer. The start method should start the asyncron.
* '''MyJob.doWork''': Do actual work and handle, if this job is killed or suspended.
* '''MyJob.doSuspend'''/'''MyJob.doResume'''/'''MyJob.doKill''': These function indicate that this feature is supported by this class.

Development/Languages/Python/PyKDE Knotify Tutorial

2010-08-09T23:06:01Z

Hefee: i18n tamplate

Development/Languages/Python/PyKDE Knotify Tutorial

2010-08-09T23:01:37Z

Hefee: KJob class

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

{{TutorialBrowser|

series=Python|

name=Python KNotify Tutorial|

next=|

reading=[http://techbase.kde.org/Development/Tutorials/Python_introduction_to_signals_and_slots Qt Signals and Slots in python], [http://www.learningpython.com/2008/09/20/an-introduction-to-pyqt/ Introduction to PyQT4], [http://techbase.kde.org/Development/Languages/Python/Using_PyKDE_4 Using PyKDE4]
}}

== Abstract ==

The aim of this tutorial is to give a sample class to include Notifications and Jobs to your own python programms, so the user can see what is going on (for example a backup system, that tells you that is backuping right now). It assumes a basic working knowledge of Python and PyKDE4.
For now only the Job part is mentioned, 'cause that is the only part I've created right now.

== Further plans ==
To add the Notification part also to this tutorial.

== Instruction ==

We start with a minimal KDE Appliciation ([http://techbase.kde.org/Development/Languages/Python/Using_PyKDE_4 Using PyKDE4]):

<code python>
#! /usr/bin/python
# -*- coding: utf-8 -*-

if __name__ == "__main__":
import sys

from PyKDE4.kdecore import KCmdLineArgs, KAboutData, KLocalizedString, ki18n
from PyKDE4.kdeui import KApplication

appName = "default"
catalog = ""
programName = ki18n ("default")
version = "1.0"
description = ki18n ("Default Example")
license = KAboutData.License_GPL
copyright = ki18n ("(c) 2010 Sandro Knauß")
text = ki18n ("none")
homePage = "techbase.kde.org"
bugEmail = "bugs@sandroknauss.de"

aboutData = KAboutData (appName, catalog, programName, version, description,
license, copyright, text, homePage, bugEmail)

KCmdLineArgs.init (sys.argv, aboutData)

app = KApplication ()
</code>

== Job class ==
The first step is to have a look to the [http://api.kde.org]. The intersting on is:
* [http://api.kde.org/pykde-4.1-api/kdecore/KJob.html KJob(KDE 4.1-PyKDE4)]- unfortunately this documention is only available for KDE 4.1. So we have also a look to the actual C++ Doumentation
* [http://api.kde.org/4.x-api/kdelibs-apidocs/kdecore/html/classKJob.html KJob(KJob 4.x-C++API)]

So it is easy to write a small Job-Class:

<code python>
from PyQt4.QtCore import QObject,QTimer,QString
from PyKDE4.kdecore import KJob

class MyJob(KJob):
def __init__(self,parent=QObject()):
KJob.__init__(self,parent)
#We want to have a Suspenable and Killable Job
self.setCapabilities(KJob.Capabilities(KJob.Suspendable|KJob.Killable))

#Just a maximum Variable
self.max=25

#index
self.i=0

def start(self):
#initalizing for work
self.i=0

#start the actual work in another thread - this function has to terminate, before the work is done
QTimer().singleShot( 0, self.doWork )

def doWork(self):
#the actual work
try:
#if we are killed or suspended just return
if self.error() or self.isSuspended():
return
except RuntimeError:
#if this class is killed before this functions is called a RuntimeError will raise
return

#do a peace of hard work
self.i+=1

#fortunately we have made a peace of work -> show this to everybody
KJob.setPercent(self,self.i*4)

if self.i==self.max:
#jeah we have done the bunch of work
#send the result signal for showing, that we ended the work
self.emitResult()
return
#just go to sleep for 1000ms than go on
QTimer().singleShot( 1000, self.doWork )

def doSuspend(self):
#the surounding function from KJob makes the isSuspended() become True
#returns True for signaling that this class supports to suspend
return True

def doResume(self):
#start with work again
QTimer().singleShot( 0, self.doWork )
#return True for signaling that this class supports resuming
return True

def doKill(self):
#return True for signaling that we support killing
return True
</code>

Development/Languages/Python

2010-08-09T22:39:13Z

Hefee: /* Documentation and Tutorials */ KNotify

{{Template:I18n/Language Navigation Bar|Development/Languages/Python}}

Python is a powerful object oriented, dynamic language. You can find out more about the language itself on the Python website at http://www.python.org/.

Two important pieces of software are needed to develop KDE applications using Python, [http://www.riverbankcomputing.co.uk/software/pyqt/intro PyQt] and PyKDE. PyQt provides Python support for the Qt library which KDE is built on. PyQt can be obtained at http://www.riverbankcomputing.co.uk/software/pyqt/ . Riverbank Computing has a lot of good documentation about how to use PyQt to create pure Qt applications. If you are new to KDE / Python development, then learning how to use PyQt is the best first step.

PyKDE builds on top of PyQt and adds Python support for KDE's libraries and technologies.

PyKDE is distributed as part of the kdebindings module. Stable releases can be downloaded from the normal [http://kde.org/download/ KDE download page], although it is usually easier to install pre-built packages from your operating system distribution. You can also obtain PyKDE from KDE's subversion repository:

svn co svn://anonsvn.kde.org/home/kde/trunk/KDE/kdebindings/python/pykde4

The code in subversion can be browsed online via http://websvn.kde.org/trunk/KDE/kdebindings/python/pykde4/.

==Documentation and Tutorials==
* [http://www.riverbankcomputing.co.uk/software/pyqt/intro PyQt home page and documentation]
* [[/Using PyKDE 4|Using PyKDE 4]]
* [http://api.kde.org/pykde-4.3-api/toc.html PyKDE 4.3 Documentation]
* [http://api.kde.org/pykde-4.3-api/modules.html PyKDE 4.3 API class reference]
* [http://api.kde.org/pykde-4.2-api/ PyKDE 4.2 API class reference]
* [[/PyKDE_WebKit_Tutorial|PyKDE WebKit Tutorial]], a simple web browser application in PyKDE
* [[Development/Tutorials/Python introduction to signals and slots|introduction to signals and slots]]
* [http://www.rkblog.rk.edu.pl/w/p/introduction-pyqt4/ Introduction article about PyQt4]
* [http://lateral.netmanagers.com.ar/stories/BBS47.html PyQt by Example]
* [[/PyKDE_DBus_Tutorial|Python DBus Tutorial]]. See how to call dbus methods from PyKDE.
* [[/PyKDE_Knotify_Tutorial|Python KNotify Tutorial]]. How to use Notification and Jobs in your Applications
* [[Development/Tutorials/Phonon/Introduction/Python|Phonon Example]]
* [[Development/Tutorials/Plasma#Plasma_Programming_with_Python|Plasma tutorials]]

===KDE 3 and PyKDE 3===
Documentation and tutorials for the older PyQt and PyKDE 3.
* [http://vizzzion.org/?id=pyqt Python-Qt tutorial] '' In this tutorial, the basic steps of creating a Qt-based application with PyQt are explained. ''

==Further reading and information==
*[http://www.riverbankcomputing.com/mailman/listinfo/pyqt PyQt and PyKDE mailing list]
*[http://www.riverbankcomputing.co.uk/software/pykde/intro PyKDE Homepage]
*[http://www.diotavelli.net/PyQtWiki The PyQt and PyKDE community Wiki]
*The book [http://www.qtrac.eu/pyqtbook.html Rapid GUI Programming with Python and Qt] is available and covers Qt 4 programming with Python.
*The IRC channel ''#kubuntu-devel'' on freenode often has PyKDE programmers in it.
*The IRC channel ''#pyqt'' on freenode is used by some PyQt application developers.

==Applications using PyKDE==
*[http://utils.kde.org/projects/printer-applet/ printer-applet]
*[http://websvn.kde.org/trunk/KDE/kdeadmin/system-config-printer-kde/ system-config-printer-kde]
*[http://websvn.kde.org/trunk/extragear/utils/guidance-power-manager/ Guidance Power Manager], a battery applet
*[https://code.launchpad.net/ubiquity/trunk Ubiquity], installer for Kubuntu
*[https://code.launchpad.net/~ubuntu-core-dev/gdebi/ubuntu GDebi], .deb package installer
*[https://code.launchpad.net/~jr/install-package/trunk install-package], graphical apt-get
*[http://draketo.de/light/english/pyrad pyRad], wheel type command interface
*[http://websvn.kde.org/trunk/KDE/kdebindings/python/pykde4/examples/ some examples are in the PyKDE source]

[[Category:Python]]

Development/Languages/Python/PyKDE Knotify Tutorial

2010-08-09T22:37:10Z

Hefee: minimal kde application

Development/Tutorials

2010-08-09T22:15:43Z

Hefee: /* Python */ KNotify

{{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/Using Qt Creator|Using Qt Creator to develop your KDE program]]
:''How to integrate Qt Creator use into KDE development.''

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

;Source Code
: 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 KDE's 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.

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

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

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

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

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

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

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

Old links for KNS2 and KNS1 content: 

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

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

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

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