Maemo Wiki Mirror - User contributions [en]

Maemo-Barcelona Long Weekend

2009-11-03T17:51:26Z

200.184.118.130: /* Attendees */

A call to all Maemo, Linux and open source lovers:

Maemo-Barcelona Long Weekend
December 4-6 @ http://citilab.eu

Everything started willing to organize a '''UX meets Code''' hackfest. Then some local supporters asked about the possibility of having more activities around. Now the schedule is all yours / toda vuestra / tota vostra. See below.

Join the discussion: http://talk.maemo.org/showthread.php?p=364433

== UX meets Code ==
About 50 invited Maemo community developers and user experience professionals meet 3 days with 3 main goals:

* Improve the usability and visual appeal of great Maemo apps.
* Improve the UX documentation for Maemo developers.
* Get a critical mass of people interested in pushing forward UX meets Code activities online and face to face.

We are lining up the right UX professionals from the Maemo team, Forum Nokia and developer partners.

=== Interested? ===

If you want to be invited please provide in [http://talk.maemo.org/showthread.php?t=33719 this thread]:

* Your [http://maemo.org/profile/list/ maemo.org profile] making sure that there one can find info about or links to your current projects and your interests in Code or UX.
* If you are more into Code, a link to the app hosted in maemo.org, either under [http://maemo.org/packages/ Fremantle packages] or [http://maemo.org/downloads/OS2008/ OS2008 Downloads].
* If you are more into UX, a link to wherever your work can be seen.

Forward this to your colleagues working on great stuff!

For budgeting and also practical purposes we will keep the number of participants around 50 people even if we get more requests. The criteria will be defined more or less by fast response, travel costs, community involvement and of course Maemo excellence in Code or UX.

== But you want more ==

If you want more, bring more. http://citilab.eu is a great space with rooms of all sizes and an auditorium for 400 people. We are open to suggestions! We have got informal requests about developer training, a N900 presentation, something about localization, an evening together...

We are happy to discuss potential activities with groups like Hispalinux, GNOME Hispano, KDE Hispano, Softcatalà, LUGs, university organizations... Also with you alone if you have a great idea in mind.

Please explain your proposal below linking it to [http://maemo.org/profile/list/ maemo.org profile]. Feel free writing in Spanish or Catalan if your activities proposed are targeting local participants.

=== Example template ===
As a guideline only. Explain yourself in the way your prefer.

* Purpose of the activity
* Target audience
* How many people do you expect (approx)
* What would you need from us?
* Could you assume the coordination?
* Who are you anyway and are you on your own or representing an organization?

== Attendees ==

Please keep the list in alphabetical order by first name.

If you have requested invitation and you are waiting for confirmation put "Requested" in the Attendance field.

{| class="wikitable sortable"
|- style="background-color: #eef"
! Name !! Nick !! Attendance !! class="unsortable" | Main interests !! class="unsortable" | Coming from || Comments / Comentarios / Comentaris
|-
| Andrea Borgia || [http://maemo.org/profile/view/aboaboit/ aboaboit] || Requested
|| Maemo applications development || Bologna, IT || OpenVPN packager
|-
| Andrea Grandi || [http://maemo.org/profile/view/andy80/ andy80] || Requested || Maemo applications development || Valencia, ES || PyMaemo developer and CarrierInformation, QMediaShare/Qt4 libraries
|-
| Aniello Del Sorbo || [http://maemo.org/profile/view/anidel/ anidel] || Requested || Maemo applications development || London, UK || author of the Xournal port to Maemo
|-
| David Caabeiro || [http://maemo.org/profile/view/sequencepoint/ sequencepoint] || Planned || Symbian and Qt development || Barcelona || Author of ARound, plugin-based AR framework for Symbian
|-
| Keywan N. Tonekaboni || [http://maemo.org/profile/view/prometoys prometoys] || Requested || UI design and testing, new approaches in UX, usability || Bielefeld, Germany || Master student in Media Science
|-
| Marc Mauri || [http://maemo.org/profile/view/opengeek opengeek] || Planned || Learn maemo5 development and UI design, testing and paralel activities || Barcelona, ES || 2nd year student of IT on FIB, UPC
|-
| Matteo Nerozzi || [http://maemo.org/profile/view/Matteone Matteone] || Requested || Maemo applications development || Bologna, IT || Computer engineer
|-
| Quim Gil || [http://maemo.org/profile/view/qgil/ qgil] || Planned || Organization, meeting people || Helsinki || Attendance depends on the additional activities
|-
| Tamara Baia || [http://maemo.org/profile/view/tamara/ tamara] || Requested || UX and interaction design || Recife, Brazil || Interaction designer in Canola 1 and 2, Carman
|-
| Thomas Perl || [http://maemo.org/profile/view/thp/ thp] || Requested || Maemo app.dev. / UX testing || Vienna, AT || gPodder, Panucci, Tennix ([http://talk.maemo.org/showpost.php?p=363050&postcount=37 project links])
|-
| Valério Valério || [http://maemo.org/profile/view/vdvsx/ VDVsx] || Requested || Maemo app.dev / UI dev, parallel activities || Lisbon/Faro, PT || Author of BlueMaemo
|-
| Zaheer Merali || [http://maemo.org/profile/view/zaheerm/ zaheerm] || Requested || Maemo app dev, GStreamer || London, UK || GStreamer, Flumotion, Coherence, MaemoSpykee, Nahjul etc.
|-
|}

PyMaemo/UI tutorial/Data selection

2009-10-20T13:18:40Z

200.184.118.130: /* Custom columns */

= Data selection =
Hildon provides a set of widgets for data selection specially designed for touchscreens that allows to build simple and easy-to-use interfaces.

The key widget is a selector widget that allows users to select items from one to many predefined lists. It is similar to a combo box but allows several individual pannable columns.

In addition, Hildon also provides a specialized dialog and a specialized button to be used in combination with a selector.

==Touch selector ==
HildonTouchSelector is the mentioned selector widget. This widget can display several pannable columns. Each column is represented by a GtkTreeModel and single or multiple selection is allowed.

===Text Columns Example===
This is the simplest example: a selector that shows a single text column.

'''Example 6.1. Example of a single-column selector'''

[[Image:example-single-text-column-selector.png|400px]]

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 5.6, "Example of a single-column selector"

import gtk
import hildon

def selection_changed(selector, user_data):
current_selection = selector.get_current_text()
print "Current selection : %s" % (current_selection)

def create_simple_selector():
#Create a HildonTouchSelector with a single text column
selector = hildon.TouchSelector(text = True)

# Set a handler to "changed" signal
selector.connect("changed", selection_changed)

# Populate selector
for i in range(10):
label = "Item %d" % i
# Add item to the column
selector.append_text(label)

# Set selection mode to allow multiple selection
selector.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)

return selector

def app_quit(widget, data=None):
gtk.main_quit()

def main():
program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create touch selector
selector = create_simple_selector()
window.add(selector)

window.connect("destroy", app_quit)

window.show_all()

gtk.main()

if __name__ == "__main__":
main()

A HildonTouchSelector with a single text column is created in this program using the following convenience constructor.

hildon.TouchSelector(text = True)

To add text to a selector created by calling the constructor above, use the function.

def append(self, text):

Alternatively, you can use <code>prepend_text()</code> or <code>insert_text()</code> to add text to the selector in different positions.

You can set the desired selection with the function. In the example, the mode was set to allow multiple selection.

def set_column_selection_mode(self, mode):

This example shows a very common use case of this widget. Next section shows how to build a more complex selector with several columns of different types.

Also a simple function was set as a handler for the "changed" signal which is emitted each time the selected items change.

The callback retrieves a text representation of the currently selected items in the selector by calling <code>get_current_text()</code>. By default this function returns a concatenation of the items selected, separated by a comma.

To change how the text representation is generated, set your own function by calling <code>set_print_func()</code> and using the following signature for the function:

def user_function (selector):

===Custom columns===

In the previous section, a selector with a text column was created. That is probably the most common use case of touch selectors. Convenience functions to deal with text columns were used. However, you can also set other type of columns.

As each column is basically a treeview, you can use the same display for different data. You can also show information in different ways as you would do with a GtkTreeview. Thus, you can use the GtkCellRenderers available in GTK+ to display the data on each cell.

This section explains how to build a selector within a column displaying stock icons. Firstly, let us take a look on the function used for appending new columns to a touchable selector.

def append_column(self, model, cell_renderer):

This functions adds a new column to the widget whose data is obtained from the passed model. A GtkCellRenderer is also necessary.

This function basically adds a GtkTreeView to the widget. For more information about how GtkTreeviews works, see [http://library.gnome.org/devel/pygtk/stable/class-gtktreeview.html GTK+ widgets] before.
The following example shows how to set a column to display images in a selector.

'''Example 6.2. Example of a selector with a custom column'''

[[Image:example-single-column-selector.png|400px]]

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.2 "Example of a selector with a custom column"

import gtk
import hildon
import gobject

def selection_changed(selector, user_data):
current_selection = selector.get_current_text()
print "Current selection : %s" % (current_selection)

def create_customized_selector():
# Create a touch selector
selector = hildon.TouchSelector()

# Stock icons will be used for the example
icon_list = gtk.stock_list_ids()

# Create model to store selector's items
store_icons = gtk.ListStore(gobject.TYPE_STRING)

# Populate model
for item in icon_list:
new_iter = store_icons.append()
store_icons.set(new_iter, 0, item)

# Create and set up a pixbuf renderer to use in the selector
renderer = gtk.CellRendererPixbuf()
renderer.set_fixed_size(-1, 100)

# Add the column to the selector
column = selector.append_column(store_icons, renderer, stock_id = 0)

# Set the selection mode
selector.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)

# Set the property "text-column" that indicates the column
# of the model to get the string from
column.set_property("text-column", 0)

return selector

def app_quit(widget, data=None):
gtk.main_quit()

def main():
program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create touch selector
selector = create_customized_selector()
window.add(selector)

window.connect("destroy", app_quit)

window.show_all()

gtk.main()

if __name__ == "__main__":
main()

The first step in the example is to create and populate a GtkTreeModel. A GtkListStore is used in the example. In most use cases of the touchable selectors a GtkListStore fits well as selectors were designed to allow users to select from a list of items.

In this case, the model stores a list of GTK+ stock icons identifiers. The following call creates a list store with one column to store strings.

store_icons = gtk.ListStore(gobject.TYPE_STRING)

The following loop appends all stock identifiers in the newly created model. The identifiers were previously retrieved using

for item in icon_list:
new_iter = store_icons.append()
store_icons.set(new_iter, 0, item)

The next step is to set up the renderer which renders each row of the new column. We need a GtkCellRendererPixbuf to display the stock icons.

renderer = gtk.CellRendererPixbuf()

Finally, we create and append the new column, using the model and renderer previously created.

column = selector.append_column(store_icons, renderer, stock_id = 0)

To summarize, setting a new custom column in a touchable selector is quite similar to setting a new column in a normal GtkTreeview. Create a model to store the data and a cell renderer to properly show this data in each row, and finally add the new column.

==Picker dialog and picker buttons ==
Normally, you use HildonTouchSelector together with a HildonPickerDialog activated from a button. For most common cases you use HildonPickerButton.

This is the usual way to present a selector to the user. The picker button opens a dialog which presents the selector and properly manages user interaction.

'''Example'''

Previous sections showed you how to create a touchable selector. In most cases the next step is to attach the selector to a HildonPickerButton.

A HildonPickerButton is a special GtkButton which displays two labels, title and value, and brings up a HildonPickerDialog. The user chooses one or several items. A string representation of the chosen items is displayed in the value label of the picker button.

Below, a modified version of the previous main function is shown, in which you can check how a HildonPickerButton is created and attached to a selector. Also a callback to catch the signal "value-changed" emitted is added.

[[Image:example-picker-button.png|400px]]

'''Example 6.3. Example of a Hildon picker button'''

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.3, "Example of a Hildon picker button"

import gtk
import hildon
import gobject

def on_picker_value_changed(button, user_data=None):
print "Newly selected value: %s\n" % button.get_value()

def app_quit(widget, data=None):
gtk.main_quit()

def create_customized_selector():
# Create a touch selector
selector = hildon.TouchSelector()

# Stock icons will be used for the example
icon_list = gtk.stock_list_ids()

print icon_list

# Create model to store selector's items
store_icons = gtk.ListStore(gobject.TYPE_STRING)

# Populate model
for item in icon_list:
new_iter = store_icons.append()
store_icons.set_value(new_iter, 0, item)

# Create and set up a text renderer to use in the selector
renderer = gtk.CellRendererPixbuf()
renderer.set_fixed_size(-1, 100)

# Add the column to the selector
column = selector.append_column(store_icons, renderer, stock_id=0)

# Set the selection mode
selector.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)

# Set the property "text-column" that indicates the column
# of the model to get the string from
column.set_property("text-column", 0)

return selector

def main ():
program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create touch selector
selector = create_customized_selector()

# Create a picker button
picker_button = hildon.PickerButton(gtk.HILDON_SIZE_AUTO,
hildon.BUTTON_ARRANGEMENT_VERTICAL)

# Set a title to the button
picker_button.set_title("Select an item")

# Attach the touch selector to the picker button
picker_button.set_selector(selector)

# Attach callback to the "value-changed" signal
picker_button.connect("value-changed", on_picker_value_changed)

# Add button to main window
window.add(picker_button)

window.connect("destroy", app_quit)
window.show_all()
gtk.main()

if __name__ == "__main__":
main()

In the above example a picker button is created. The reference to the attached selector is stored in the property "touch-selector" of the picker button. To retrieve the attached selector , use function <code>hildon.PickerButton()</code>. To attach the selector, use the function <code>picker_button.set_selector()</code>.

Note that you do not need to take care of the HildonPickerDialog. The dialog is automatically brought up when users click the picker button and closed when the selection is done.

The dialog shows a button "Done" to allow users finish the selection when the touchable selector allows multiple selection. When the selector allows only single selection, the dialog does not show any button and closes when the user taps on one item.

The label of the button "Done" can be set by using <code>set_done_button_text()</code> and retrieved by using <code>get_done_button_text()</code>.

When users finish their selection, the value label on the button automatically changes to show a textual representation of the item or items selected.

In most cases you want to perform any action when selection is finished. To do that, add a handler to the signal "value-changed" of the picker button. In this example the handler attached to "value-changed" signal retrieves the value label of the button and prints a debug message.

==Touch selector entry ==
The HildonTouchSelectorEntry is a selector widget with a text entry that allows users to select an item from a predefined list or to enter a different one in a HildonEntry. Items can also be searched and selected by typing in the entry.

An additional feature is that the HildonEntry is auto-completed with the list's items as the user types their name.

Example below shows how to build a selector to pick a word in a list of words.

[[Image:Touch_selector_entry.png|400px]]

'''Example 6.4. Example of a Hildon picker button with a selector entry'''

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.4, "Hildon picker button with a selector entry"

import gtk
import hildon

def app_quit(widget, data=None):
gtk.main_quit()

def main ():
artists = [
"AC/DC",
"Aerosmith",
"Alice in Chains",
"Black Sabbath",
"Carcass",
"Danzig",
"Deep Purple",
"Dream Theater",
"Eric Clapton",
]

program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create a picker button
picker_button = hildon.PickerButton(gtk.HILDON_SIZE_AUTO,
hildon.BUTTON_ARRANGEMENT_VERTICAL)

# Set a title to the button
picker_button.set_title("Pick a band!")

# Create a touch selector entry
selector = hildon.TouchSelectorEntry(text=True)

# Populate the selector
for artist in artists:
selector.append_text(artist)

# Attach the touch selector to the picker button
picker_button.set_selector(selector)

# Add button to main window
window.add(picker_button)

window.connect("destroy", app_quit)
window.show_all()
gtk.main()

if __name__ == "__main__":
main()

As you can see in the example above, the use of this widget is similar to using a normal touchable selector.

You can also use custom columns in a HildonTouchableEntry but at least one column must be a text column. The text column is indicated by the property "text_column" which you set with <code>set_text_column()</code>.

==Pre-built selectors ==
The widgets HildonDateButton and HildonTimeButton are buttons displaying and allowing the selection of date and time, respectively. Developers can use them directly instead of building their own date or time selectors.

Both widgets are specialized picker buttons with a convenient touchable selector attached that you can use directly in your application.

Here is a simple application using a HildonDateButton.

'''Example 6.5. Example of a Hildon date button'''

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.5, "Example of a Hildon date button"

import gtk
import hildon

def app_quit(widget, data=None):
gtk.main_quit()

def main ():
program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create a date picker
date_button = hildon.DateButton(gtk.HILDON_SIZE_AUTO,
hildon.BUTTON_ARRANGEMENT_VERTICAL)

# Set a title to the button
date_button.set_title("Select an item")

# Add button to main window
window.add(date_button)

window.connect("destroy", app_quit)
window.show_all()
gtk.main()

if __name__ == "__main__":
main()

PyMaemo/UI tutorial/Data selection

2009-10-19T22:08:12Z

200.184.118.130: /* Custom columns */

= Data selection =
Hildon provides a set of widgets for data selection specially designed for touchscreens that allows to build simple and easy-to-use interfaces.

The key widget is a selector widget that allows users to select items from one to many predefined lists. It is similar to a combo box but allows several individual pannable columns.

In addition, Hildon also provides a specialized dialog and a specialized button to be used in combination with a selector.

==Touch selector ==
HildonTouchSelector is the mentioned selector widget. This widget can display several pannable columns. Each column is represented by a GtkTreeModel and single or multiple selection is allowed.

===Text Columns Example===
This is the simplest example: a selector that shows a single text column.

'''Example 6.1. Example of a single-column selector'''

[[Image:example-single-text-column-selector.png|400px]]

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 5.6, "Example of a single-column selector"

import gtk
import hildon

def selection_changed(selector, user_data):
current_selection = selector.get_current_text()
print "Current selection : %s" % (current_selection)

def create_simple_selector():
#Create a HildonTouchSelector with a single text column
selector = hildon.TouchSelector(text = True)

# Set a handler to "changed" signal
selector.connect("changed", selection_changed)

# Populate selector
for i in range(10):
label = "Item %d" % i
# Add item to the column
selector.append_text(label)

# Set selection mode to allow multiple selection
selector.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)

return selector

def app_quit(widget, data=None):
gtk.main_quit()

def main():
program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create touch selector
selector = create_simple_selector()
window.add(selector)

window.connect("destroy", app_quit)

window.show_all()

gtk.main()

if __name__ == "__main__":
main()

A HildonTouchSelector with a single text column is created in this program using the following convenience constructor.

hildon.TouchSelector(text = True)

To add text to a selector created by calling the constructor above, use the function.

def append(self, text):

Alternatively, you can use <code>prepend_text()</code> or <code>insert_text()</code> to add text to the selector in different positions.

You can set the desired selection with the function. In the example, the mode was set to allow multiple selection.

def set_column_selection_mode(self, mode):

This example shows a very common use case of this widget. Next section shows how to build a more complex selector with several columns of different types.

Also a simple function was set as a handler for the "changed" signal which is emitted each time the selected items change.

The callback retrieves a text representation of the currently selected items in the selector by calling <code>get_current_text()</code>. By default this function returns a concatenation of the items selected, separated by a comma.

To change how the text representation is generated, set your own function by calling <code>set_print_func()</code> and using the following signature for the function:

def user_function (selector):

===Custom columns===

In the previous section, a selector with a text column was created. That is probably the most common use case of touch selectors. Convenience functions to deal with text columns were used. However, you can also set other type of columns.

As each column is basically a treeview, you can use the same display for different data. You can also show information in different ways as you would do with a GtkTreeview. Thus, you can use the GtkCellRenderers available in GTK+ to display the data on each cell.

This section explains how to build a selector within a column displaying stock icons. Firstly, let us take a look on the function used for appending new columns to a touchable selector.

def append_column(self, model, cell_renderer):

This functions adds a new column to the widget whose data is obtained from the passed model. A GtkCellRenderer is also necessary.

This function basically adds a GtkTreeView to the widget. For more information about how GtkTreeviews works, see [http://library.gnome.org/devel/pygtk/stable/class-gtktreeview.html GTK+ widgets] before.
The following example shows how to set a column to display images in a selector.

'''Example 6.2. Example of a selector with a custom column'''

[[Image:example-single-column-selector.png|400px]]

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.2 "Example of a selector with a custom column"

import gtk
import hildon
import gobject

def selection_changed(selector, user_data):
current_selection = selector.get_current_text()
print "Current selection : %s" % (current_selection)

def create_customized_selector():
# Create a touch selector
selector = hildon.TouchSelector()

# Stock icons will be used for the example
icon_list = gtk.stock_list_ids()

# Create model to store selector's items
store_icons = gtk.ListStore(gobject.TYPE_STRING)

# Populate model
for item in icon_list:
new_iter = store_icons.append()
store_icons.set(new_iter, 0, item)

# Create and set up a pixbuf renderer to use in the selector
renderer = gtk.CellRendererPixbuf()
renderer.set_fixed_size(-1, 100)

# Add the column to the selector
column = selector.append_column(store_icons, renderer)

# Set the selection mode
selector.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)

# Set the property "text-column" that indicates the column
# of the model to get the string from
column.set_property("text-column", 0)

return selector

def app_quit(widget, data=None):
gtk.main_quit()

def main():
program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create touch selector
selector = create_customized_selector()
window.add(selector)

window.connect("destroy", app_quit)

window.show_all()

gtk.main()

if __name__ == "__main__":
main()

The first step in the example is to create and populate a GtkTreeModel. A GtkListStore is used in the example. In most use cases of the touchable selectors a GtkListStore fits well as selectors were designed to allow users to select from a list of items.

In this case, the model stores a list of GTK+ stock icons identifiers. The following call creates a list store with one column to store strings.

store_icons = gtk.ListStore(gobject.TYPE_STRING)

The following loop appends all stock identifiers in the newly created model. The identifiers were previously retrieved using

for item in icon_list:
new_iter = store_icons.append()
store_icons.set(new_iter, 0, item)

The next step is to set up the renderer which renders each row of the new column. We need a GtkCellRendererPixbuf to display the stock icons.

renderer = gtk.CellRendererPixbuf()

Finally, we create and append the new column, using the model and renderer previously created.

column = selector.append_column(store_icons, renderer)

To summarize, setting a new custom column in a touchable selector is quite similar to setting a new column in a normal GtkTreeview. Create a model to store the data and a cell renderer to properly show this data in each row, and finally add the new column.

==Picker dialog and picker buttons ==
Normally, you use HildonTouchSelector together with a HildonPickerDialog activated from a button. For most common cases you use HildonPickerButton.

This is the usual way to present a selector to the user. The picker button opens a dialog which presents the selector and properly manages user interaction.

'''Example'''

Previous sections showed you how to create a touchable selector. In most cases the next step is to attach the selector to a HildonPickerButton.

A HildonPickerButton is a special GtkButton which displays two labels, title and value, and brings up a HildonPickerDialog. The user chooses one or several items. A string representation of the chosen items is displayed in the value label of the picker button.

Below, a modified version of the previous main function is shown, in which you can check how a HildonPickerButton is created and attached to a selector. Also a callback to catch the signal "value-changed" emitted is added.

[[Image:example-picker-button.png|400px]]

'''Example 6.3. Example of a Hildon picker button'''

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.3, "Example of a Hildon picker button"

import gtk
import hildon
import gobject

def on_picker_value_changed(button, user_data=None):
print "Newly selected value: %s\n" % button.get_value()

def app_quit(widget, data=None):
gtk.main_quit()

def create_customized_selector():
# Create a touch selector
selector = hildon.TouchSelector()

# Stock icons will be used for the example
icon_list = gtk.stock_list_ids()

print icon_list

# Create model to store selector's items
store_icons = gtk.ListStore(gobject.TYPE_STRING)

# Populate model
for item in icon_list:
new_iter = store_icons.append()
store_icons.set_value(new_iter, 0, item)

# Create and set up a text renderer to use in the selector
renderer = gtk.CellRendererPixbuf()
renderer.set_fixed_size(-1, 100)

# Add the column to the selector
column = selector.append_column(store_icons, renderer, stock_id=0)

# Set the selection mode
selector.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)

# Set the property "text-column" that indicates the column
# of the model to get the string from
column.set_property("text-column", 0)

return selector

def main ():
program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create touch selector
selector = create_customized_selector()

# Create a picker button
picker_button = hildon.PickerButton(gtk.HILDON_SIZE_AUTO,
hildon.BUTTON_ARRANGEMENT_VERTICAL)

# Set a title to the button
picker_button.set_title("Select an item")

# Attach the touch selector to the picker button
picker_button.set_selector(selector)

# Attach callback to the "value-changed" signal
picker_button.connect("value-changed", on_picker_value_changed)

# Add button to main window
window.add(picker_button)

window.connect("destroy", app_quit)
window.show_all()
gtk.main()

if __name__ == "__main__":
main()

In the above example a picker button is created. The reference to the attached selector is stored in the property "touch-selector" of the picker button. To retrieve the attached selector , use function <code>hildon.PickerButton()</code>. To attach the selector, use the function <code>picker_button.set_selector()</code>.

Note that you do not need to take care of the HildonPickerDialog. The dialog is automatically brought up when users click the picker button and closed when the selection is done.

The dialog shows a button "Done" to allow users finish the selection when the touchable selector allows multiple selection. When the selector allows only single selection, the dialog does not show any button and closes when the user taps on one item.

The label of the button "Done" can be set by using <code>set_done_button_text()</code> and retrieved by using <code>get_done_button_text()</code>.

When users finish their selection, the value label on the button automatically changes to show a textual representation of the item or items selected.

In most cases you want to perform any action when selection is finished. To do that, add a handler to the signal "value-changed" of the picker button. In this example the handler attached to "value-changed" signal retrieves the value label of the button and prints a debug message.

==Touch selector entry ==
The HildonTouchSelectorEntry is a selector widget with a text entry that allows users to select an item from a predefined list or to enter a different one in a HildonEntry. Items can also be searched and selected by typing in the entry.

An additional feature is that the HildonEntry is auto-completed with the list's items as the user types their name.

Example below shows how to build a selector to pick a word in a list of words.

[[Image:Touch_selector_entry.png|400px]]

'''Example 6.4. Example of a Hildon picker button with a selector entry'''

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.4, "Hildon picker button with a selector entry"

import gtk
import hildon

def app_quit(widget, data=None):
gtk.main_quit()

def main ():
artists = [
"AC/DC",
"Aerosmith",
"Alice in Chains",
"Black Sabbath",
"Carcass",
"Danzig",
"Deep Purple",
"Dream Theater",
"Eric Clapton",
]

program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create a picker button
picker_button = hildon.PickerButton(gtk.HILDON_SIZE_AUTO,
hildon.BUTTON_ARRANGEMENT_VERTICAL)

# Set a title to the button
picker_button.set_title("Pick a band!")

# Create a touch selector entry
selector = hildon.TouchSelectorEntry(text=True)

# Populate the selector
for artist in artists:
selector.append_text(artist)

# Attach the touch selector to the picker button
picker_button.set_selector(selector)

# Add button to main window
window.add(picker_button)

window.connect("destroy", app_quit)
window.show_all()
gtk.main()

if __name__ == "__main__":
main()

As you can see in the example above, the use of this widget is similar to using a normal touchable selector.

You can also use custom columns in a HildonTouchableEntry but at least one column must be a text column. The text column is indicated by the property "text_column" which you set with <code>set_text_column()</code>.

==Pre-built selectors ==
The widgets HildonDateButton and HildonTimeButton are buttons displaying and allowing the selection of date and time, respectively. Developers can use them directly instead of building their own date or time selectors.

Both widgets are specialized picker buttons with a convenient touchable selector attached that you can use directly in your application.

Here is a simple application using a HildonDateButton.

'''Example 6.5. Example of a Hildon date button'''

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.5, "Example of a Hildon date button"

import gtk
import hildon

def app_quit(widget, data=None):
gtk.main_quit()

def main ():
program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create a date picker
date_button = hildon.DateButton(gtk.HILDON_SIZE_AUTO,
hildon.BUTTON_ARRANGEMENT_VERTICAL)

# Set a title to the button
date_button.set_title("Select an item")

# Add button to main window
window.add(date_button)

window.connect("destroy", app_quit)
window.show_all()
gtk.main()

if __name__ == "__main__":
main()

PyMaemo/UI tutorial/Data selection

2009-10-19T22:06:35Z

200.184.118.130: /* Custom columns */

= Data selection =
Hildon provides a set of widgets for data selection specially designed for touchscreens that allows to build simple and easy-to-use interfaces.

The key widget is a selector widget that allows users to select items from one to many predefined lists. It is similar to a combo box but allows several individual pannable columns.

In addition, Hildon also provides a specialized dialog and a specialized button to be used in combination with a selector.

==Touch selector ==
HildonTouchSelector is the mentioned selector widget. This widget can display several pannable columns. Each column is represented by a GtkTreeModel and single or multiple selection is allowed.

===Text Columns Example===
This is the simplest example: a selector that shows a single text column.

'''Example 6.1. Example of a single-column selector'''

[[Image:example-single-text-column-selector.png|400px]]

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 5.6, "Example of a single-column selector"

import gtk
import hildon

def selection_changed(selector, user_data):
current_selection = selector.get_current_text()
print "Current selection : %s" % (current_selection)

def create_simple_selector():
#Create a HildonTouchSelector with a single text column
selector = hildon.TouchSelector(text = True)

# Set a handler to "changed" signal
selector.connect("changed", selection_changed)

# Populate selector
for i in range(10):
label = "Item %d" % i
# Add item to the column
selector.append_text(label)

# Set selection mode to allow multiple selection
selector.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)

return selector

def app_quit(widget, data=None):
gtk.main_quit()

def main():
program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create touch selector
selector = create_simple_selector()
window.add(selector)

window.connect("destroy", app_quit)

window.show_all()

gtk.main()

if __name__ == "__main__":
main()

A HildonTouchSelector with a single text column is created in this program using the following convenience constructor.

hildon.TouchSelector(text = True)

To add text to a selector created by calling the constructor above, use the function.

def append(self, text):

Alternatively, you can use <code>prepend_text()</code> or <code>insert_text()</code> to add text to the selector in different positions.

You can set the desired selection with the function. In the example, the mode was set to allow multiple selection.

def set_column_selection_mode(self, mode):

This example shows a very common use case of this widget. Next section shows how to build a more complex selector with several columns of different types.

Also a simple function was set as a handler for the "changed" signal which is emitted each time the selected items change.

The callback retrieves a text representation of the currently selected items in the selector by calling <code>get_current_text()</code>. By default this function returns a concatenation of the items selected, separated by a comma.

To change how the text representation is generated, set your own function by calling <code>set_print_func()</code> and using the following signature for the function:

def user_function (selector):

===Custom columns===

In the previous section, a selector with a text column was created. That is probably the most common use case of touch selectors. Convenience functions to deal with text columns were used. However, you can also set other type of columns.

As each column is basically a treeview, you can use the same display for different data. You can also show information in different ways as you would do with a GtkTreeview. Thus, you can use the GtkCellRenderers available in GTK+ to display the data on each cell.

This section explains how to build a selector within a column displaying stock icons. Firstly, let us take a look on the function used for appending new columns to a touchable selector.

def append_column(self, model, cell_renderer):

This functions adds a new column to the widget whose data is obtained from the passed model. A GtkCellRenderer is also necessary.

This function basically adds a GtkTreeView to the widget. For more information about how GtkTreeviews works, see [http://library.gnome.org/devel/pygtk/stable/class-gtktreeview.html GTK+ widgets] before.
The following example shows how to set a column to display images in a selector.

'''Example 6.2. Example of a selector with a custom column'''

[[Image:example-single-column-selector.png|400px]]

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.2 "Example of a selector with a custom column"

import gtk
import hildon
import gobject

def selection_changed(selector, user_data):
current_selection = selector.get_current_text()
print "Current selection : %s" % (current_selection)

def create_customized_selector():
# Create a touch selector
selector = hildon.TouchSelector()

# Stock icons will be used for the example
icon_list = gtk.stock_list_ids()

# Create model to store selector's items
store_icons = gtk.ListStore(gobject.TYPE_STRING);

# Populate model
for item in icon_list:
new_iter = store_icons.append()
store_icons.set(new_iter, 0, item)

# Create and set up a pixbuf renderer to use in the selector
renderer = gtk.CellRendererPixbuf()
renderer.set_fixed_size(-1, 100)

# Add the column to the selector
column = selector.append_column(store_icons, renderer)

# Set the selection mode
selector.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)

# Set the property "text-column" that indicates the column
# of the model to get the string from
column.set_property("text-column", 0)

return selector

def app_quit(widget, data=None):
gtk.main_quit()

def main():
program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create touch selector
selector = create_customized_selector()
window.add(selector)

window.connect("destroy", app_quit)

window.show_all()

gtk.main()

if __name__ == "__main__":
main()

The first step in the example is to create and populate a GtkTreeModel. A GtkListStore is used in the example. In most use cases of the touchable selectors a GtkListStore fits well as selectors were designed to allow users to select from a list of items.

In this case, the model stores a list of GTK+ stock icons identifiers. The following call creates a list store with one column to store strings.

store_icons = gtk.ListStore(G_TYPE_STRING);

The following loop appends all stock identifiers in the newly created model. The identifiers were previously retrieved using

for item in icon_list:
new_iter = store_icons.append()
store_icons.set(new_iter, 0, item)

The next step is to set up the renderer which renders each row of the new column. We need a GtkCellRendererPixbuf to display the stock icons.

renderer = gtk.CellRendererPixbuf()

Finally, we create and append the new column, using the model and renderer previously created.

column = selector.append_column(store_icons, renderer)

To summarize, setting a new custom column in a touchable selector is quite similar to setting a new column in a normal GtkTreeview. Create a model to store the data and a cell renderer to properly show this data in each row, and finally add the new column.

==Picker dialog and picker buttons ==
Normally, you use HildonTouchSelector together with a HildonPickerDialog activated from a button. For most common cases you use HildonPickerButton.

This is the usual way to present a selector to the user. The picker button opens a dialog which presents the selector and properly manages user interaction.

'''Example'''

Previous sections showed you how to create a touchable selector. In most cases the next step is to attach the selector to a HildonPickerButton.

A HildonPickerButton is a special GtkButton which displays two labels, title and value, and brings up a HildonPickerDialog. The user chooses one or several items. A string representation of the chosen items is displayed in the value label of the picker button.

Below, a modified version of the previous main function is shown, in which you can check how a HildonPickerButton is created and attached to a selector. Also a callback to catch the signal "value-changed" emitted is added.

[[Image:example-picker-button.png|400px]]

'''Example 6.3. Example of a Hildon picker button'''

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.3, "Example of a Hildon picker button"

import gtk
import hildon
import gobject

def on_picker_value_changed(button, user_data=None):
print "Newly selected value: %s\n" % button.get_value()

def app_quit(widget, data=None):
gtk.main_quit()

def create_customized_selector():
# Create a touch selector
selector = hildon.TouchSelector()

# Stock icons will be used for the example
icon_list = gtk.stock_list_ids()

print icon_list

# Create model to store selector's items
store_icons = gtk.ListStore(gobject.TYPE_STRING)

# Populate model
for item in icon_list:
new_iter = store_icons.append()
store_icons.set_value(new_iter, 0, item)

# Create and set up a text renderer to use in the selector
renderer = gtk.CellRendererPixbuf()
renderer.set_fixed_size(-1, 100)

# Add the column to the selector
column = selector.append_column(store_icons, renderer, stock_id=0)

# Set the selection mode
selector.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)

# Set the property "text-column" that indicates the column
# of the model to get the string from
column.set_property("text-column", 0)

return selector

def main ():
program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create touch selector
selector = create_customized_selector()

# Create a picker button
picker_button = hildon.PickerButton(gtk.HILDON_SIZE_AUTO,
hildon.BUTTON_ARRANGEMENT_VERTICAL)

# Set a title to the button
picker_button.set_title("Select an item")

# Attach the touch selector to the picker button
picker_button.set_selector(selector)

# Attach callback to the "value-changed" signal
picker_button.connect("value-changed", on_picker_value_changed)

# Add button to main window
window.add(picker_button)

window.connect("destroy", app_quit)
window.show_all()
gtk.main()

if __name__ == "__main__":
main()

In the above example a picker button is created. The reference to the attached selector is stored in the property "touch-selector" of the picker button. To retrieve the attached selector , use function <code>hildon.PickerButton()</code>. To attach the selector, use the function <code>picker_button.set_selector()</code>.

Note that you do not need to take care of the HildonPickerDialog. The dialog is automatically brought up when users click the picker button and closed when the selection is done.

The dialog shows a button "Done" to allow users finish the selection when the touchable selector allows multiple selection. When the selector allows only single selection, the dialog does not show any button and closes when the user taps on one item.

The label of the button "Done" can be set by using <code>set_done_button_text()</code> and retrieved by using <code>get_done_button_text()</code>.

When users finish their selection, the value label on the button automatically changes to show a textual representation of the item or items selected.

In most cases you want to perform any action when selection is finished. To do that, add a handler to the signal "value-changed" of the picker button. In this example the handler attached to "value-changed" signal retrieves the value label of the button and prints a debug message.

==Touch selector entry ==
The HildonTouchSelectorEntry is a selector widget with a text entry that allows users to select an item from a predefined list or to enter a different one in a HildonEntry. Items can also be searched and selected by typing in the entry.

An additional feature is that the HildonEntry is auto-completed with the list's items as the user types their name.

Example below shows how to build a selector to pick a word in a list of words.

[[Image:Touch_selector_entry.png|400px]]

'''Example 6.4. Example of a Hildon picker button with a selector entry'''

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.4, "Hildon picker button with a selector entry"

import gtk
import hildon

def app_quit(widget, data=None):
gtk.main_quit()

def main ():
artists = [
"AC/DC",
"Aerosmith",
"Alice in Chains",
"Black Sabbath",
"Carcass",
"Danzig",
"Deep Purple",
"Dream Theater",
"Eric Clapton",
]

program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create a picker button
picker_button = hildon.PickerButton(gtk.HILDON_SIZE_AUTO,
hildon.BUTTON_ARRANGEMENT_VERTICAL)

# Set a title to the button
picker_button.set_title("Pick a band!")

# Create a touch selector entry
selector = hildon.TouchSelectorEntry(text=True)

# Populate the selector
for artist in artists:
selector.append_text(artist)

# Attach the touch selector to the picker button
picker_button.set_selector(selector)

# Add button to main window
window.add(picker_button)

window.connect("destroy", app_quit)
window.show_all()
gtk.main()

if __name__ == "__main__":
main()

As you can see in the example above, the use of this widget is similar to using a normal touchable selector.

You can also use custom columns in a HildonTouchableEntry but at least one column must be a text column. The text column is indicated by the property "text_column" which you set with <code>set_text_column()</code>.

==Pre-built selectors ==
The widgets HildonDateButton and HildonTimeButton are buttons displaying and allowing the selection of date and time, respectively. Developers can use them directly instead of building their own date or time selectors.

Both widgets are specialized picker buttons with a convenient touchable selector attached that you can use directly in your application.

Here is a simple application using a HildonDateButton.

'''Example 6.5. Example of a Hildon date button'''

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.5, "Example of a Hildon date button"

import gtk
import hildon

def app_quit(widget, data=None):
gtk.main_quit()

def main ():
program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create a date picker
date_button = hildon.DateButton(gtk.HILDON_SIZE_AUTO,
hildon.BUTTON_ARRANGEMENT_VERTICAL)

# Set a title to the button
date_button.set_title("Select an item")

# Add button to main window
window.add(date_button)

window.connect("destroy", app_quit)
window.show_all()
gtk.main()

if __name__ == "__main__":
main()

PyMaemo/UI tutorial/Data selection

2009-10-19T20:26:53Z

200.184.118.130: /* Custom columns */

= Data selection =
Hildon provides a set of widgets for data selection specially designed for touchscreens that allows to build simple and easy-to-use interfaces.

The key widget is a selector widget that allows users to select items from one to many predefined lists. It is similar to a combo box but allows several individual pannable columns.

In addition, Hildon also provides a specialized dialog and a specialized button to be used in combination with a selector.

==Touch selector ==
HildonTouchSelector is the mentioned selector widget. This widget can display several pannable columns. Each column is represented by a GtkTreeModel and single or multiple selection is allowed.

===Text Columns Example===
This is the simplest example: a selector that shows a single text column.

'''Example 6.1. Example of a single-column selector'''

[[Image:example-single-text-column-selector.png|400px]]

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 5.6, "Example of a single-column selector"

import gtk
import hildon

def selection_changed(selector, user_data):
current_selection = selector.get_current_text()
print "Current selection : %s" % (current_selection)

def create_simple_selector():
#Create a HildonTouchSelector with a single text column
selector = hildon.TouchSelector(text = True)

# Set a handler to "changed" signal
selector.connect("changed", selection_changed)

# Populate selector
for i in range(10):
label = "Item %d" % i
# Add item to the column
selector.append_text(label)

# Set selection mode to allow multiple selection
selector.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)

return selector

def app_quit(widget, data=None):
gtk.main_quit()

def main():
program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create touch selector
selector = create_simple_selector()
window.add(selector)

window.connect("destroy", app_quit)

window.show_all()

gtk.main()

if __name__ == "__main__":
main()

A HildonTouchSelector with a single text column is created in this program using the following convenience constructor.

hildon.TouchSelector(text = True)

To add text to a selector created by calling the constructor above, use the function.

def append(self, text):

Alternatively, you can use <code>prepend_text()</code> or <code>insert_text()</code> to add text to the selector in different positions.

You can set the desired selection with the function. In the example, the mode was set to allow multiple selection.

def set_column_selection_mode(self, mode):

This example shows a very common use case of this widget. Next section shows how to build a more complex selector with several columns of different types.

Also a simple function was set as a handler for the "changed" signal which is emitted each time the selected items change.

The callback retrieves a text representation of the currently selected items in the selector by calling <code>get_current_text()</code>. By default this function returns a concatenation of the items selected, separated by a comma.

To change how the text representation is generated, set your own function by calling <code>set_print_func()</code> and using the following signature for the function:

def user_function (selector):

===Custom columns===

In the previous section, a selector with a text column was created. That is probably the most common use case of touch selectors. Convenience functions to deal with text columns were used. However, you can also set other type of columns.

As each column is basically a treeview, you can use the same display for different data. You can also show information in different ways as you would do with a GtkTreeview. Thus, you can use the GtkCellRenderers available in GTK+ to display the data on each cell.

This section explains how to build a selector within a column displaying stock icons. Firstly, let us take a look on the function used for appending new columns to a touchable selector.

def append_column(self, model, cell_renderer):

This functions adds a new column to the widget whose data is obtained from the passed model. A GtkCellRenderer is also necessary.

This function basically adds a GtkTreeView to the widget. For more information about how GtkTreeviews works, see [http://library.gnome.org/devel/pygtk/stable/class-gtktreeview.html GTK+ widgets] before.
The following example shows how to set a column to display images in a selector.

'''Example 6.2. Example of a selector with a custom column'''

[[Image:example-single-column-selector.png|400px]]

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.2 "Example of a selector with a custom column"

import gtk
import hildon
import gobject

def selection_changed(selector, user_data):
current_selection = selector.get_current_text()
print "Current selection : %s" % (current_selection)

def create_customized_selector():
# Create a touch selector
selector = hildon.TouchSelector()

# Stock icons will be used for the example
icon_list = gtk.stock_list_ids()

# Create model to store selector's items
store_icons = gtk.ListStore(gobject.TYPE_STRING);

# Populate model
for item in icon_list:
new_iter = store_icons.append()
store_icons.set(new_iter, 0, item)

# Create and set up a pixbuf renderer to use in the selector
renderer = gtk.CellRendererPixbuf()
renderer.set_fixed_size(-1, 100)

# Add the column to the selector
column = selector.append_column(store_icons, renderer)

# Set the selection mode
selector.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)

# Set the property "text-column" that indicates the column
# of the model to get the string from
column.set_property("text-column", 0)

return selector

def app_quit(widget, data=None):
gtk.main_quit()

def main():
program = hildon.hildon_program_get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create touch selector
selector = create_customized_selector()
window.add(selector)

window.connect("destroy", app_quit)

window.show_all()

gtk.main()

if __name__ == "__main__":
main()

The first step in the example is to create and populate a GtkTreeModel. A GtkListStore is used in the example. In most use cases of the touchable selectors a GtkListStore fits well as selectors were designed to allow users to select from a list of items.

In this case, the model stores a list of GTK+ stock icons identifiers. The following call creates a list store with one column to store strings.

store_icons = gtk.ListStore(G_TYPE_STRING);

The following loop appends all stock identifiers in the newly created model. The identifiers were previously retrieved using

for item in icon_list:
new_iter = store_icons.append()
store_icons.set(new_iter, 0, item)

The next step is to set up the renderer which renders each row of the new column. We need a GtkCellRendererPixbuf to display the stock icons.

renderer = gtk.CellRendererPixbuf()

Finally, we create and append the new column, using the model and renderer previously created.

column = selector.append_column(store_icons, renderer)

To summarize, setting a new custom column in a touchable selector is quite similar to setting a new column in a normal GtkTreeview. Create a model to store the data and a cell renderer to properly show this data in each row, and finally add the new column.

==Picker dialog and picker buttons ==
Normally, you use HildonTouchSelector together with a HildonPickerDialog activated from a button. For most common cases you use HildonPickerButton.

This is the usual way to present a selector to the user. The picker button opens a dialog which presents the selector and properly manages user interaction.

'''Example'''

Previous sections showed you how to create a touchable selector. In most cases the next step is to attach the selector to a HildonPickerButton.

A HildonPickerButton is a special GtkButton which displays two labels, title and value, and brings up a HildonPickerDialog. The user chooses one or several items. A string representation of the chosen items is displayed in the value label of the picker button.

Below, a modified version of the previous main function is shown, in which you can check how a HildonPickerButton is created and attached to a selector. Also a callback to catch the signal "value-changed" emitted is added.

[[Image:example-picker-button.png|400px]]

'''Example 6.3. Example of a Hildon picker button'''

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.3, "Example of a Hildon picker button"

import gtk
import hildon
import gobject

def on_picker_value_changed(button, user_data=None):
print "Newly selected value: %s\n" % button.get_value()

def app_quit(widget, data=None):
gtk.main_quit()

def create_customized_selector():
# Create a touch selector
selector = hildon.TouchSelector()

# Stock icons will be used for the example
icon_list = gtk.stock_list_ids()

print icon_list

# Create model to store selector's items
store_icons = gtk.ListStore(gobject.TYPE_STRING)

# Populate model
for item in icon_list:
new_iter = store_icons.append()
store_icons.set_value(new_iter, 0, item)

# Create and set up a text renderer to use in the selector
renderer = gtk.CellRendererPixbuf()
renderer.set_fixed_size(-1, 100)

# Add the column to the selector
column = selector.append_column(store_icons, renderer, stock_id=0)

# Set the selection mode
selector.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)

# Set the property "text-column" that indicates the column
# of the model to get the string from
column.set_property("text-column", 0)

return selector

def main ():
program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create touch selector
selector = create_customized_selector()

# Create a picker button
picker_button = hildon.PickerButton(gtk.HILDON_SIZE_AUTO,
hildon.BUTTON_ARRANGEMENT_VERTICAL)

# Set a title to the button
picker_button.set_title("Select an item")

# Attach the touch selector to the picker button
picker_button.set_selector(selector)

# Attach callback to the "value-changed" signal
picker_button.connect("value-changed", on_picker_value_changed)

# Add button to main window
window.add(picker_button)

window.connect("destroy", app_quit)
window.show_all()
gtk.main()

if __name__ == "__main__":
main()

In the above example a picker button is created. The reference to the attached selector is stored in the property "touch-selector" of the picker button. To retrieve the attached selector , use function <code>hildon.PickerButton()</code>. To attach the selector, use the function <code>picker_button.set_selector()</code>.

Note that you do not need to take care of the HildonPickerDialog. The dialog is automatically brought up when users click the picker button and closed when the selection is done.

The dialog shows a button "Done" to allow users finish the selection when the touchable selector allows multiple selection. When the selector allows only single selection, the dialog does not show any button and closes when the user taps on one item.

The label of the button "Done" can be set by using <code>set_done_button_text()</code> and retrieved by using <code>get_done_button_text()</code>.

When users finish their selection, the value label on the button automatically changes to show a textual representation of the item or items selected.

In most cases you want to perform any action when selection is finished. To do that, add a handler to the signal "value-changed" of the picker button. In this example the handler attached to "value-changed" signal retrieves the value label of the button and prints a debug message.

==Touch selector entry ==
The HildonTouchSelectorEntry is a selector widget with a text entry that allows users to select an item from a predefined list or to enter a different one in a HildonEntry. Items can also be searched and selected by typing in the entry.

An additional feature is that the HildonEntry is auto-completed with the list's items as the user types their name.

Example below shows how to build a selector to pick a word in a list of words.

[[Image:Touch_selector_entry.png|400px]]

'''Example 6.4. Example of a Hildon picker button with a selector entry'''

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.4, "Hildon picker button with a selector entry"

import gtk
import hildon

def app_quit(widget, data=None):
gtk.main_quit()

def main ():
artists = [
"AC/DC",
"Aerosmith",
"Alice in Chains",
"Black Sabbath",
"Carcass",
"Danzig",
"Deep Purple",
"Dream Theater",
"Eric Clapton",
]

program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create a picker button
picker_button = hildon.PickerButton(gtk.HILDON_SIZE_AUTO,
hildon.BUTTON_ARRANGEMENT_VERTICAL)

# Set a title to the button
picker_button.set_title("Pick a band!")

# Create a touch selector entry
selector = hildon.TouchSelectorEntry(text=True)

# Populate the selector
for artist in artists:
selector.append_text(artist)

# Attach the touch selector to the picker button
picker_button.set_selector(selector)

# Add button to main window
window.add(picker_button)

window.connect("destroy", app_quit)
window.show_all()
gtk.main()

if __name__ == "__main__":
main()

As you can see in the example above, the use of this widget is similar to using a normal touchable selector.

You can also use custom columns in a HildonTouchableEntry but at least one column must be a text column. The text column is indicated by the property "text_column" which you set with <code>set_text_column()</code>.

==Pre-built selectors ==
The widgets HildonDateButton and HildonTimeButton are buttons displaying and allowing the selection of date and time, respectively. Developers can use them directly instead of building their own date or time selectors.

Both widgets are specialized picker buttons with a convenient touchable selector attached that you can use directly in your application.

Here is a simple application using a HildonDateButton.

'''Example 6.5. Example of a Hildon date button'''

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.5, "Example of a Hildon date button"

import gtk
import hildon

def app_quit(widget, data=None):
gtk.main_quit()

def main ():
program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create a date picker
date_button = hildon.DateButton(gtk.HILDON_SIZE_AUTO,
hildon.BUTTON_ARRANGEMENT_VERTICAL)

# Set a title to the button
date_button.set_title("Select an item")

# Add button to main window
window.add(date_button)

window.connect("destroy", app_quit)
window.show_all()
gtk.main()

if __name__ == "__main__":
main()

PyMaemo/UI tutorial/Data selection

2009-10-16T19:11:15Z

200.184.118.130: /* Text Columns Example */

= Data selection =
Hildon provides a set of widgets for data selection specially designed for touchscreens that allows to build simple and easy-to-use interfaces.

The key widget is a selector widget that allows users to select items from one to many predefined lists. It is similar to a combo box but allows several individual pannable columns.

In addition, Hildon also provides a specialized dialog and a specialized button to be used in combination with a selector.

==Touch selector ==
HildonTouchSelector is the mentioned selector widget. This widget can display several pannable columns. Each column is represented by a GtkTreeModel and single or multiple selection is allowed.

===Text Columns Example===
This is the simplest example: a selector that shows a single text column.

'''Example 6.1. Example of a single-column selector'''

[[Image:example-single-text-column-selector.png|400px]]

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 5.6, "Example of a single-column selector"

import gtk
import hildon

def selection_changed(selector, user_data):
current_selection = selector.get_current_text()
print "Current selection : %s" % (current_selection)

def create_simple_selector():
#Create a HildonTouchSelector with a single text column
selector = hildon.TouchSelector(text = True)

# Set a handler to "changed" signal
selector.connect("changed", selection_changed)

# Populate selector
for i in range(10):
label = "Item %d" % i
# Add item to the column
selector.append_text(label)

# Set selection mode to allow multiple selection
selector.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)

return selector

def app_quit(widget, data=None):
gtk.main_quit()

def main():
program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create touch selector
selector = create_simple_selector()
window.add(selector)

window.connect("destroy", app_quit)

window.show_all()

gtk.main()

if __name__ == "__main__":
main()

A HildonTouchSelector with a single text column is created in this program using the following convenience constructor.

hildon.TouchSelector(text = True)

To add text to a selector created by calling the constructor above, use the function.

def append(self, text):

Alternatively, you can use <code>prepend_text()</code> or <code>insert_text()</code> to add text to the selector in different positions.

You can set the desired selection with the function. In the example, the mode was set to allow multiple selection.

def set_column_selection_mode(self, mode):

This example shows a very common use case of this widget. Next section shows how to build a more complex selector with several columns of different types.

Also a simple function was set as a handler for the "changed" signal which is emitted each time the selected items change.

The callback retrieves a text representation of the currently selected items in the selector by calling <code>get_current_text()</code>. By default this function returns a concatenation of the items selected, separated by a comma.

To change how the text representation is generated, set your own function by calling <code>set_print_func()</code> and using the following signature for the function:

def user_function (selector):

===Custom columns===

In the previous section, a selector with a text column was created. That is probably the most common use case of touch selectors. Convenience functions to deal with text columns was used. However, you can also set other type of columns.

Because each column is basically a treeview, you can use the same display to different data and in different ways as you would do with a GtkTreeview. Thus, you can use the GtkCellRenderers available in GTK+ to display the data on each cell.

This section explains how to build a selector within a column displaying stock icons. Firstly, let us take a look on the function which used for appending new columns to a touchable selector.

def append_column(self, model, cell_renderer, ...):

This functions adds a new column to the widget whose data is obtained from the passed model. Pass also a GtkCellRenderer and a list of pairs property/value which is set as attributes of the renderer.

This function basically adds a GtkTreeView to the widget. For more information on how GtkTreeviews work, see [http://library.gnome.org/devel/pygtk/stable/class-gtktreeview.html GTK+ widgets] before.
The following example shows how to set a column to display images in a selector. For clarity, only the function which creates the selector is shown.

'''Example 6.2. Example of a selector with a custom column'''

[[Image:example-single-column-selector.png|400px]]

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.2 "Example of a selector with a custom column"

import gtk
import hildon
import gobject

def selection_changed(selector, user_data):
current_selection = selector.get_current_text()
print "Current selection : %s" % (current_selection)

def create_customized_selector():
# Create a touch selector
selector = hildon.TouchSelector()

# Stock icons will be used for the example
icon_list = gtk.stock_list_ids()

# Create model to store selector's items
store_icons = gtk.ListStore(gobject.TYPE_STRING);

# Populate model
for item in icon_list:
new_iter = store_icons.append()
store_icons.set(new_iter, 0, item)

# Create and set up a pixbuf renderer to use in the selector
renderer = gtk.CellRendererPixbuf()
renderer.set_fixed_size(-1, 100)

# Add the column to the selector
# FIXME: bug 4646
#column = selector.append_column(store_icons, renderer, "stock-id", 0)

# Set the selection mode
selector.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)

# Set the property "text-column" that indicates the column
# of the model to get the string from
column.set_property("text-column", 0)

return selector

def app_quit(widget, data=None):
gtk.main_quit()

def main():
program = hildon.hildon_program_get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create touch selector
selector = create_customized_selector()
window.add(selector)

window.connect("destroy", app_quit)

window.show_all()

gtk.main()

if __name__ == "__main__":
main()

The first step in the example is to create and populate a GtkTreeModel. A GtkListStore is used in the example. In most use cases of the touchable selectors a GtkListStore fits well as selectors were designed to allow users to select from a list of items.

In this case, the model stores a list of GTK+ stock icons identifiers. The following call creates a list store with one column to store strings.

store_icons = gtk.ListStore(G_TYPE_STRING);

The following loop appends all stock identifiers in the newly created model. The identifiers were previously retrieved using

for item in icon_list:
new_iter = store_icons.append()
store_icons.set(new_iter, 0, item)

The next step is to set up the renderer which renders each row of the new column. We need a GtkCellRendererPixbuf to display the stock icons.

renderer = gtk.CellRendererPixbuf()

Finally, we create and append the new column, using the model and renderer previously created.

This call also sets the property "stock-id" of the GtkCellrendererPixbuf. The value is set to 0 which is the number of the column in the GtkTreeModel that stores the stock-id.

column = selector.append_column(store_icons, renderer, "stock-id", 0)

To summarize, setting a new custom column in a touchable selector is quite similar to setting a new column in a normal GtkTreeview. Create a model to store the data and a cell renderer to properly show this data in each row, and finally add the new column.

==Picker dialog and picker buttons ==
Normally, you use HildonTouchSelector together with a HildonPickerDialog activated from a button. For most common cases you use HildonPickerButton.

This is the usual way to present a selector to the user. The picker button opens a dialog which presents the selector and properly manages user interaction.

'''Example'''

Previous sections showed you how to create a touchable selector. In most cases the next step is to attach the selector to a HildonPickerButton.

A HildonPickerButton is a special GtkButton which displays two labels, title and value, and brings up a HildonPickerDialog. The user chooses one or several items. A string representation of the chosen items is displayed in the value label of the picker button.

Below, a modified version of the previous main function is shown, in which you can check how a HildonPickerButton is created and attached to a selector. Also a callback to catch the signal "value-changed" emitted is added.

[[Image:example-picker-button.png|400px]]

'''Example 6.3. Example of a Hildon picker button'''

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.3, "Example of a Hildon picker button"

import gtk
import hildon
import gobject

def on_picker_value_changed(button, user_data=None):
print "Newly selected value: %s\n" % button.get_value()

def app_quit(widget, data=None):
gtk.main_quit()

def create_customized_selector():
# Create a touch selector
selector = hildon.TouchSelector()

# Stock icons will be used for the example
icon_list = gtk.stock_list_ids()

print icon_list

# Create model to store selector's items
store_icons = gtk.ListStore(gobject.TYPE_STRING)

# Populate model
for item in icon_list:
new_iter = store_icons.append()
store_icons.set_value(new_iter, 0, item)

# Create and set up a text renderer to use in the selector
renderer = gtk.CellRendererPixbuf()
renderer.set_fixed_size(-1, 100)

# Add the column to the selector
column = selector.append_column(store_icons, renderer, stock_id=0)

# Set the selection mode
selector.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)

# Set the property "text-column" that indicates the column
# of the model to get the string from
column.set_property("text-column", 0)

return selector

def main ():
program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create touch selector
selector = create_customized_selector()

# Create a picker button
picker_button = hildon.PickerButton(gtk.HILDON_SIZE_AUTO,
hildon.BUTTON_ARRANGEMENT_VERTICAL)

# Set a title to the button
picker_button.set_title("Select an item")

# Attach the touch selector to the picker button
picker_button.set_selector(selector)

# Attach callback to the "value-changed" signal
picker_button.connect("value-changed", on_picker_value_changed)

# Add button to main window
window.add(picker_button)

window.connect("destroy", app_quit)
window.show_all()
gtk.main()

if __name__ == "__main__":
main()

In the above example a picker button is created. The reference to the attached selector is stored in the property "touch-selector" of the picker button. To retrieve the attached selector , use function <code>hildon.PickerButton()</code>. To attach the selector, use the function <code>picker_button.set_selector()</code>.

Note that you do not need to take care of the HildonPickerDialog. The dialog is automatically brought up when users click the picker button and closed when the selection is done.

The dialog shows a button "Done" to allow users finish the selection when the touchable selector allows multiple selection. When the selector allows only single selection, the dialog does not show any button and closes when the user taps on one item.

The label of the button "Done" can be set by using <code>set_done_button_text()</code> and retrieved by using <code>get_done_button_text()</code>.

When users finish their selection, the value label on the button automatically changes to show a textual representation of the item or items selected.

In most cases you want to perform any action when selection is finished. To do that, add a handler to the signal "value-changed" of the picker button. In this example the handler attached to "value-changed" signal retrieves the value label of the button and prints a debug message.

==Touch selector entry ==
The HildonTouchSelectorEntry is a selector widget with a text entry that allows users to select an item from a predefined list or to enter a different one in a HildonEntry. Items can also be searched and selected by typing in the entry.

An additional feature is that the HildonEntry is auto-completed with the list's items as the user types their name.

Example below shows how to build a selector to pick a word in a list of words.

[[Image:Touch_selector_entry.png|400px]]

'''Example 6.4. Example of a Hildon picker button with a selector entry'''

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.4, "Hildon picker button with a selector entry"

import gtk
import hildon

def app_quit(widget, data=None):
gtk.main_quit()

def main ():
artists = [
"AC/DC",
"Aerosmith",
"Alice in Chains",
"Black Sabbath",
"Carcass",
"Danzig",
"Deep Purple",
"Dream Theater",
"Eric Clapton",
]

program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create a picker button
picker_button = hildon.PickerButton(gtk.HILDON_SIZE_AUTO,
hildon.BUTTON_ARRANGEMENT_VERTICAL)

# Set a title to the button
picker_button.set_title("Pick a band!")

# Create a touch selector entry
selector = hildon.TouchSelectorEntry(text=True)

# Populate the selector
for artist in artists:
selector.append_text(artist)

# Attach the touch selector to the picker button
picker_button.set_selector(selector)

# Add button to main window
window.add(picker_button)

window.connect("destroy", app_quit)
window.show_all()
gtk.main()

if __name__ == "__main__":
main()

As you can see in the example above, the use of this widget is similar to using a normal touchable selector.

You can also use custom columns in a HildonTouchableEntry but at least one column must be a text column. The text column is indicated by the property "text_column" which you set with <code>set_text_column()</code>.

==Pre-built selectors ==
The widgets HildonDateButton and HildonTimeButton are buttons displaying and allowing the selection of date and time, respectively. Developers can use them directly instead of building their own date or time selectors.

Both widgets are specialized picker buttons with a convenient touchable selector attached that you can use directly in your application.

Here is a simple application using a HildonDateButton.

'''Example 6.5. Example of a Hildon date button'''

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.5, "Example of a Hildon date button"

import gtk
import hildon

def app_quit(widget, data=None):
gtk.main_quit()

def main ():
program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create a date picker
date_button = hildon.DateButton(gtk.HILDON_SIZE_AUTO,
hildon.BUTTON_ARRANGEMENT_VERTICAL)

# Set a title to the button
date_button.set_title("Select an item")

# Add button to main window
window.add(date_button)

window.connect("destroy", app_quit)
window.show_all()
gtk.main()

if __name__ == "__main__":
main()

PyMaemo/UI tutorial/Data selection

2009-10-16T19:09:55Z

200.184.118.130: /* Text Columns Example */

= Data selection =
Hildon provides a set of widgets for data selection specially designed for touchscreens that allows to build simple and easy-to-use interfaces.

The key widget is a selector widget that allows users to select items from one to many predefined lists. It is similar to a combo box but allows several individual pannable columns.

In addition, Hildon also provides a specialized dialog and a specialized button to be used in combination with a selector.

==Touch selector ==
HildonTouchSelector is the mentioned selector widget. This widget can display several pannable columns. Each column is represented by a GtkTreeModel and single or multiple selection is allowed.

===Text Columns Example===
This is the simplest example: a selector that shows a single text column.

'''Example 6.1. Example of a single-column selector'''

[[Image:example-single-text-column-selector.png|400px]]

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 5.6, "Example of a single-column selector"

import gtk
import hildon

def selection_changed(selector, user_data):
current_selection = selector.get_current_text()
print "Current selection : %s" % (current_selection)

def create_simple_selector():
#Create a HildonTouchSelector with a single text column
selector = hildon.TouchSelector(text = True)

# Set a handler to "changed" signal
selector.connect("changed", selection_changed)

# Populate selector
for i in range(10):
label = "Item %d" % i
# Add item to the column
selector.append_text(label)

# Set selection mode to allow multiple selection
selector.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)

return selector

def app_quit(widget, data=None):
gtk.main_quit()

def main():
program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create touch selector
selector = create_simple_selector()
window.add(selector)

window.connect("destroy", app_quit)

window.show_all()

gtk.main()

if __name__ == "__main__":
main()

A HildonTouchSelector with a single text column is created in this program using the following convenience constructor.

hildon.touch_selector_new_text()

To add text to a selector created by calling the constructor above, use the function.

def append(self, text):

Alternatively, you can use <code>prepend_text()</code> or <code>insert_text()</code> to add text to the selector in different positions.

You can set the desired selection with the function. In the example, the mode was set to allow multiple selection.

def set_column_selection_mode(self, mode):

This example shows a very common use case of this widget. Next section shows how to build a more complex selector with several columns of different types.

Also a simple function was set as a handler for the "changed" signal which is emitted each time the selected items change.

The callback retrieves a text representation of the currently selected items in the selector by calling <code>get_current_text()</code>. By default this function returns a concatenation of the items selected, separated by a comma.

To change how the text representation is generated, set your own function by calling <code>set_print_func()</code> and using the following signature for the function:

def user_function (selector):

===Custom columns===

In the previous section, a selector with a text column was created. That is probably the most common use case of touch selectors. Convenience functions to deal with text columns was used. However, you can also set other type of columns.

Because each column is basically a treeview, you can use the same display to different data and in different ways as you would do with a GtkTreeview. Thus, you can use the GtkCellRenderers available in GTK+ to display the data on each cell.

This section explains how to build a selector within a column displaying stock icons. Firstly, let us take a look on the function which used for appending new columns to a touchable selector.

def append_column(self, model, cell_renderer, ...):

This functions adds a new column to the widget whose data is obtained from the passed model. Pass also a GtkCellRenderer and a list of pairs property/value which is set as attributes of the renderer.

This function basically adds a GtkTreeView to the widget. For more information on how GtkTreeviews work, see [http://library.gnome.org/devel/pygtk/stable/class-gtktreeview.html GTK+ widgets] before.
The following example shows how to set a column to display images in a selector. For clarity, only the function which creates the selector is shown.

'''Example 6.2. Example of a selector with a custom column'''

[[Image:example-single-column-selector.png|400px]]

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.2 "Example of a selector with a custom column"

import gtk
import hildon
import gobject

def selection_changed(selector, user_data):
current_selection = selector.get_current_text()
print "Current selection : %s" % (current_selection)

def create_customized_selector():
# Create a touch selector
selector = hildon.TouchSelector()

# Stock icons will be used for the example
icon_list = gtk.stock_list_ids()

# Create model to store selector's items
store_icons = gtk.ListStore(gobject.TYPE_STRING);

# Populate model
for item in icon_list:
new_iter = store_icons.append()
store_icons.set(new_iter, 0, item)

# Create and set up a pixbuf renderer to use in the selector
renderer = gtk.CellRendererPixbuf()
renderer.set_fixed_size(-1, 100)

# Add the column to the selector
# FIXME: bug 4646
#column = selector.append_column(store_icons, renderer, "stock-id", 0)

# Set the selection mode
selector.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)

# Set the property "text-column" that indicates the column
# of the model to get the string from
column.set_property("text-column", 0)

return selector

def app_quit(widget, data=None):
gtk.main_quit()

def main():
program = hildon.hildon_program_get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create touch selector
selector = create_customized_selector()
window.add(selector)

window.connect("destroy", app_quit)

window.show_all()

gtk.main()

if __name__ == "__main__":
main()

The first step in the example is to create and populate a GtkTreeModel. A GtkListStore is used in the example. In most use cases of the touchable selectors a GtkListStore fits well as selectors were designed to allow users to select from a list of items.

In this case, the model stores a list of GTK+ stock icons identifiers. The following call creates a list store with one column to store strings.

store_icons = gtk.ListStore(G_TYPE_STRING);

The following loop appends all stock identifiers in the newly created model. The identifiers were previously retrieved using

for item in icon_list:
new_iter = store_icons.append()
store_icons.set(new_iter, 0, item)

The next step is to set up the renderer which renders each row of the new column. We need a GtkCellRendererPixbuf to display the stock icons.

renderer = gtk.CellRendererPixbuf()

Finally, we create and append the new column, using the model and renderer previously created.

This call also sets the property "stock-id" of the GtkCellrendererPixbuf. The value is set to 0 which is the number of the column in the GtkTreeModel that stores the stock-id.

column = selector.append_column(store_icons, renderer, "stock-id", 0)

To summarize, setting a new custom column in a touchable selector is quite similar to setting a new column in a normal GtkTreeview. Create a model to store the data and a cell renderer to properly show this data in each row, and finally add the new column.

==Picker dialog and picker buttons ==
Normally, you use HildonTouchSelector together with a HildonPickerDialog activated from a button. For most common cases you use HildonPickerButton.

This is the usual way to present a selector to the user. The picker button opens a dialog which presents the selector and properly manages user interaction.

'''Example'''

Previous sections showed you how to create a touchable selector. In most cases the next step is to attach the selector to a HildonPickerButton.

A HildonPickerButton is a special GtkButton which displays two labels, title and value, and brings up a HildonPickerDialog. The user chooses one or several items. A string representation of the chosen items is displayed in the value label of the picker button.

Below, a modified version of the previous main function is shown, in which you can check how a HildonPickerButton is created and attached to a selector. Also a callback to catch the signal "value-changed" emitted is added.

[[Image:example-picker-button.png|400px]]

'''Example 6.3. Example of a Hildon picker button'''

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.3, "Example of a Hildon picker button"

import gtk
import hildon
import gobject

def on_picker_value_changed(button, user_data=None):
print "Newly selected value: %s\n" % button.get_value()

def app_quit(widget, data=None):
gtk.main_quit()

def create_customized_selector():
# Create a touch selector
selector = hildon.TouchSelector()

# Stock icons will be used for the example
icon_list = gtk.stock_list_ids()

print icon_list

# Create model to store selector's items
store_icons = gtk.ListStore(gobject.TYPE_STRING)

# Populate model
for item in icon_list:
new_iter = store_icons.append()
store_icons.set_value(new_iter, 0, item)

# Create and set up a text renderer to use in the selector
renderer = gtk.CellRendererPixbuf()
renderer.set_fixed_size(-1, 100)

# Add the column to the selector
column = selector.append_column(store_icons, renderer, stock_id=0)

# Set the selection mode
selector.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)

# Set the property "text-column" that indicates the column
# of the model to get the string from
column.set_property("text-column", 0)

return selector

def main ():
program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create touch selector
selector = create_customized_selector()

# Create a picker button
picker_button = hildon.PickerButton(gtk.HILDON_SIZE_AUTO,
hildon.BUTTON_ARRANGEMENT_VERTICAL)

# Set a title to the button
picker_button.set_title("Select an item")

# Attach the touch selector to the picker button
picker_button.set_selector(selector)

# Attach callback to the "value-changed" signal
picker_button.connect("value-changed", on_picker_value_changed)

# Add button to main window
window.add(picker_button)

window.connect("destroy", app_quit)
window.show_all()
gtk.main()

if __name__ == "__main__":
main()

In the above example a picker button is created. The reference to the attached selector is stored in the property "touch-selector" of the picker button. To retrieve the attached selector , use function <code>hildon.PickerButton()</code>. To attach the selector, use the function <code>picker_button.set_selector()</code>.

Note that you do not need to take care of the HildonPickerDialog. The dialog is automatically brought up when users click the picker button and closed when the selection is done.

The dialog shows a button "Done" to allow users finish the selection when the touchable selector allows multiple selection. When the selector allows only single selection, the dialog does not show any button and closes when the user taps on one item.

The label of the button "Done" can be set by using <code>set_done_button_text()</code> and retrieved by using <code>get_done_button_text()</code>.

When users finish their selection, the value label on the button automatically changes to show a textual representation of the item or items selected.

In most cases you want to perform any action when selection is finished. To do that, add a handler to the signal "value-changed" of the picker button. In this example the handler attached to "value-changed" signal retrieves the value label of the button and prints a debug message.

==Touch selector entry ==
The HildonTouchSelectorEntry is a selector widget with a text entry that allows users to select an item from a predefined list or to enter a different one in a HildonEntry. Items can also be searched and selected by typing in the entry.

An additional feature is that the HildonEntry is auto-completed with the list's items as the user types their name.

Example below shows how to build a selector to pick a word in a list of words.

[[Image:Touch_selector_entry.png|400px]]

'''Example 6.4. Example of a Hildon picker button with a selector entry'''

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.4, "Hildon picker button with a selector entry"

import gtk
import hildon

def app_quit(widget, data=None):
gtk.main_quit()

def main ():
artists = [
"AC/DC",
"Aerosmith",
"Alice in Chains",
"Black Sabbath",
"Carcass",
"Danzig",
"Deep Purple",
"Dream Theater",
"Eric Clapton",
]

program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create a picker button
picker_button = hildon.PickerButton(gtk.HILDON_SIZE_AUTO,
hildon.BUTTON_ARRANGEMENT_VERTICAL)

# Set a title to the button
picker_button.set_title("Pick a band!")

# Create a touch selector entry
selector = hildon.TouchSelectorEntry(text=True)

# Populate the selector
for artist in artists:
selector.append_text(artist)

# Attach the touch selector to the picker button
picker_button.set_selector(selector)

# Add button to main window
window.add(picker_button)

window.connect("destroy", app_quit)
window.show_all()
gtk.main()

if __name__ == "__main__":
main()

As you can see in the example above, the use of this widget is similar to using a normal touchable selector.

You can also use custom columns in a HildonTouchableEntry but at least one column must be a text column. The text column is indicated by the property "text_column" which you set with <code>set_text_column()</code>.

==Pre-built selectors ==
The widgets HildonDateButton and HildonTimeButton are buttons displaying and allowing the selection of date and time, respectively. Developers can use them directly instead of building their own date or time selectors.

Both widgets are specialized picker buttons with a convenient touchable selector attached that you can use directly in your application.

Here is a simple application using a HildonDateButton.

'''Example 6.5. Example of a Hildon date button'''

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.5, "Example of a Hildon date button"

import gtk
import hildon

def app_quit(widget, data=None):
gtk.main_quit()

def main ():
program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create a date picker
date_button = hildon.DateButton(gtk.HILDON_SIZE_AUTO,
hildon.BUTTON_ARRANGEMENT_VERTICAL)

# Set a title to the button
date_button.set_title("Select an item")

# Add button to main window
window.add(date_button)

window.connect("destroy", app_quit)
window.show_all()
gtk.main()

if __name__ == "__main__":
main()

PyMaemo/UI tutorial/Data selection

2009-10-16T19:09:10Z

200.184.118.130: /* Text Columns Example */

= Data selection =
Hildon provides a set of widgets for data selection specially designed for touchscreens that allows to build simple and easy-to-use interfaces.

The key widget is a selector widget that allows users to select items from one to many predefined lists. It is similar to a combo box but allows several individual pannable columns.

In addition, Hildon also provides a specialized dialog and a specialized button to be used in combination with a selector.

==Touch selector ==
HildonTouchSelector is the mentioned selector widget. This widget can display several pannable columns. Each column is represented by a GtkTreeModel and single or multiple selection is allowed.

===Text Columns Example===
This is the simplest example: a selector that shows a single text column.

'''Example 6.1. Example of a single-column selector'''

[[Image:example-single-text-column-selector.png|400px]]

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 5.6, "Example of a single-column selector"

import gtk
import hildon

def selection_changed(selector, user_data):
current_selection = selector.get_current_text()
print "Current selection : %s" % (current_selection)

def create_simple_selector():
#Create a HildonTouchSelector with a single text column
selector = hildon.TouchSelector(text = True)

# Set a handler to "changed" signal
selector.connect("changed", selection_changed)

# Populate selector
for i in range(10):
label = "Item %d" % i
# Add item to the column
selector.append_text(label)
# Set selection mode to allow multiple selection
selector.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)

return selector

def app_quit(widget, data=None):
gtk.main_quit()

def main():
program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create touch selector
selector = create_simple_selector()
window.add(selector)

window.connect("destroy", app_quit)

window.show_all()

gtk.main()

if __name__ == "__main__":
main()

A HildonTouchSelector with a single text column is created in this program using the following convenience constructor.

hildon.touch_selector_new_text()

To add text to a selector created by calling the constructor above, use the function.

def append(self, text):

Alternatively, you can use <code>prepend_text()</code> or <code>insert_text()</code> to add text to the selector in different positions.

You can set the desired selection with the function. In the example, the mode was set to allow multiple selection.

def set_column_selection_mode(self, mode):

This example shows a very common use case of this widget. Next section shows how to build a more complex selector with several columns of different types.

Also a simple function was set as a handler for the "changed" signal which is emitted each time the selected items change.

The callback retrieves a text representation of the currently selected items in the selector by calling <code>get_current_text()</code>. By default this function returns a concatenation of the items selected, separated by a comma.

To change how the text representation is generated, set your own function by calling <code>set_print_func()</code> and using the following signature for the function:

def user_function (selector):

===Custom columns===

In the previous section, a selector with a text column was created. That is probably the most common use case of touch selectors. Convenience functions to deal with text columns was used. However, you can also set other type of columns.

Because each column is basically a treeview, you can use the same display to different data and in different ways as you would do with a GtkTreeview. Thus, you can use the GtkCellRenderers available in GTK+ to display the data on each cell.

This section explains how to build a selector within a column displaying stock icons. Firstly, let us take a look on the function which used for appending new columns to a touchable selector.

def append_column(self, model, cell_renderer, ...):

This functions adds a new column to the widget whose data is obtained from the passed model. Pass also a GtkCellRenderer and a list of pairs property/value which is set as attributes of the renderer.

This function basically adds a GtkTreeView to the widget. For more information on how GtkTreeviews work, see [http://library.gnome.org/devel/pygtk/stable/class-gtktreeview.html GTK+ widgets] before.
The following example shows how to set a column to display images in a selector. For clarity, only the function which creates the selector is shown.

'''Example 6.2. Example of a selector with a custom column'''

[[Image:example-single-column-selector.png|400px]]

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.2 "Example of a selector with a custom column"

import gtk
import hildon
import gobject

def selection_changed(selector, user_data):
current_selection = selector.get_current_text()
print "Current selection : %s" % (current_selection)

def create_customized_selector():
# Create a touch selector
selector = hildon.TouchSelector()

# Stock icons will be used for the example
icon_list = gtk.stock_list_ids()

# Create model to store selector's items
store_icons = gtk.ListStore(gobject.TYPE_STRING);

# Populate model
for item in icon_list:
new_iter = store_icons.append()
store_icons.set(new_iter, 0, item)

# Create and set up a pixbuf renderer to use in the selector
renderer = gtk.CellRendererPixbuf()
renderer.set_fixed_size(-1, 100)

# Add the column to the selector
# FIXME: bug 4646
#column = selector.append_column(store_icons, renderer, "stock-id", 0)

# Set the selection mode
selector.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)

# Set the property "text-column" that indicates the column
# of the model to get the string from
column.set_property("text-column", 0)

return selector

def app_quit(widget, data=None):
gtk.main_quit()

def main():
program = hildon.hildon_program_get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create touch selector
selector = create_customized_selector()
window.add(selector)

window.connect("destroy", app_quit)

window.show_all()

gtk.main()

if __name__ == "__main__":
main()

The first step in the example is to create and populate a GtkTreeModel. A GtkListStore is used in the example. In most use cases of the touchable selectors a GtkListStore fits well as selectors were designed to allow users to select from a list of items.

In this case, the model stores a list of GTK+ stock icons identifiers. The following call creates a list store with one column to store strings.

store_icons = gtk.ListStore(G_TYPE_STRING);

The following loop appends all stock identifiers in the newly created model. The identifiers were previously retrieved using

for item in icon_list:
new_iter = store_icons.append()
store_icons.set(new_iter, 0, item)

The next step is to set up the renderer which renders each row of the new column. We need a GtkCellRendererPixbuf to display the stock icons.

renderer = gtk.CellRendererPixbuf()

Finally, we create and append the new column, using the model and renderer previously created.

This call also sets the property "stock-id" of the GtkCellrendererPixbuf. The value is set to 0 which is the number of the column in the GtkTreeModel that stores the stock-id.

column = selector.append_column(store_icons, renderer, "stock-id", 0)

To summarize, setting a new custom column in a touchable selector is quite similar to setting a new column in a normal GtkTreeview. Create a model to store the data and a cell renderer to properly show this data in each row, and finally add the new column.

==Picker dialog and picker buttons ==
Normally, you use HildonTouchSelector together with a HildonPickerDialog activated from a button. For most common cases you use HildonPickerButton.

This is the usual way to present a selector to the user. The picker button opens a dialog which presents the selector and properly manages user interaction.

'''Example'''

Previous sections showed you how to create a touchable selector. In most cases the next step is to attach the selector to a HildonPickerButton.

A HildonPickerButton is a special GtkButton which displays two labels, title and value, and brings up a HildonPickerDialog. The user chooses one or several items. A string representation of the chosen items is displayed in the value label of the picker button.

Below, a modified version of the previous main function is shown, in which you can check how a HildonPickerButton is created and attached to a selector. Also a callback to catch the signal "value-changed" emitted is added.

[[Image:example-picker-button.png|400px]]

'''Example 6.3. Example of a Hildon picker button'''

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.3, "Example of a Hildon picker button"

import gtk
import hildon
import gobject

def on_picker_value_changed(button, user_data=None):
print "Newly selected value: %s\n" % button.get_value()

def app_quit(widget, data=None):
gtk.main_quit()

def create_customized_selector():
# Create a touch selector
selector = hildon.TouchSelector()

# Stock icons will be used for the example
icon_list = gtk.stock_list_ids()

print icon_list

# Create model to store selector's items
store_icons = gtk.ListStore(gobject.TYPE_STRING)

# Populate model
for item in icon_list:
new_iter = store_icons.append()
store_icons.set_value(new_iter, 0, item)

# Create and set up a text renderer to use in the selector
renderer = gtk.CellRendererPixbuf()
renderer.set_fixed_size(-1, 100)

# Add the column to the selector
column = selector.append_column(store_icons, renderer, stock_id=0)

# Set the selection mode
selector.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)

# Set the property "text-column" that indicates the column
# of the model to get the string from
column.set_property("text-column", 0)

return selector

def main ():
program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create touch selector
selector = create_customized_selector()

# Create a picker button
picker_button = hildon.PickerButton(gtk.HILDON_SIZE_AUTO,
hildon.BUTTON_ARRANGEMENT_VERTICAL)

# Set a title to the button
picker_button.set_title("Select an item")

# Attach the touch selector to the picker button
picker_button.set_selector(selector)

# Attach callback to the "value-changed" signal
picker_button.connect("value-changed", on_picker_value_changed)

# Add button to main window
window.add(picker_button)

window.connect("destroy", app_quit)
window.show_all()
gtk.main()

if __name__ == "__main__":
main()

In the above example a picker button is created. The reference to the attached selector is stored in the property "touch-selector" of the picker button. To retrieve the attached selector , use function <code>hildon.PickerButton()</code>. To attach the selector, use the function <code>picker_button.set_selector()</code>.

Note that you do not need to take care of the HildonPickerDialog. The dialog is automatically brought up when users click the picker button and closed when the selection is done.

The dialog shows a button "Done" to allow users finish the selection when the touchable selector allows multiple selection. When the selector allows only single selection, the dialog does not show any button and closes when the user taps on one item.

The label of the button "Done" can be set by using <code>set_done_button_text()</code> and retrieved by using <code>get_done_button_text()</code>.

When users finish their selection, the value label on the button automatically changes to show a textual representation of the item or items selected.

In most cases you want to perform any action when selection is finished. To do that, add a handler to the signal "value-changed" of the picker button. In this example the handler attached to "value-changed" signal retrieves the value label of the button and prints a debug message.

==Touch selector entry ==
The HildonTouchSelectorEntry is a selector widget with a text entry that allows users to select an item from a predefined list or to enter a different one in a HildonEntry. Items can also be searched and selected by typing in the entry.

An additional feature is that the HildonEntry is auto-completed with the list's items as the user types their name.

Example below shows how to build a selector to pick a word in a list of words.

[[Image:Touch_selector_entry.png|400px]]

'''Example 6.4. Example of a Hildon picker button with a selector entry'''

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.4, "Hildon picker button with a selector entry"

import gtk
import hildon

def app_quit(widget, data=None):
gtk.main_quit()

def main ():
artists = [
"AC/DC",
"Aerosmith",
"Alice in Chains",
"Black Sabbath",
"Carcass",
"Danzig",
"Deep Purple",
"Dream Theater",
"Eric Clapton",
]

program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create a picker button
picker_button = hildon.PickerButton(gtk.HILDON_SIZE_AUTO,
hildon.BUTTON_ARRANGEMENT_VERTICAL)

# Set a title to the button
picker_button.set_title("Pick a band!")

# Create a touch selector entry
selector = hildon.TouchSelectorEntry(text=True)

# Populate the selector
for artist in artists:
selector.append_text(artist)

# Attach the touch selector to the picker button
picker_button.set_selector(selector)

# Add button to main window
window.add(picker_button)

window.connect("destroy", app_quit)
window.show_all()
gtk.main()

if __name__ == "__main__":
main()

As you can see in the example above, the use of this widget is similar to using a normal touchable selector.

You can also use custom columns in a HildonTouchableEntry but at least one column must be a text column. The text column is indicated by the property "text_column" which you set with <code>set_text_column()</code>.

==Pre-built selectors ==
The widgets HildonDateButton and HildonTimeButton are buttons displaying and allowing the selection of date and time, respectively. Developers can use them directly instead of building their own date or time selectors.

Both widgets are specialized picker buttons with a convenient touchable selector attached that you can use directly in your application.

Here is a simple application using a HildonDateButton.

'''Example 6.5. Example of a Hildon date button'''

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.5, "Example of a Hildon date button"

import gtk
import hildon

def app_quit(widget, data=None):
gtk.main_quit()

def main ():
program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create a date picker
date_button = hildon.DateButton(gtk.HILDON_SIZE_AUTO,
hildon.BUTTON_ARRANGEMENT_VERTICAL)

# Set a title to the button
date_button.set_title("Select an item")

# Add button to main window
window.add(date_button)

window.connect("destroy", app_quit)
window.show_all()
gtk.main()

if __name__ == "__main__":
main()

PyMaemo/UI tutorial/Data selection

2009-10-16T19:08:43Z

200.184.118.130: /* Text Columns Example */

= Data selection =
Hildon provides a set of widgets for data selection specially designed for touchscreens that allows to build simple and easy-to-use interfaces.

The key widget is a selector widget that allows users to select items from one to many predefined lists. It is similar to a combo box but allows several individual pannable columns.

In addition, Hildon also provides a specialized dialog and a specialized button to be used in combination with a selector.

==Touch selector ==
HildonTouchSelector is the mentioned selector widget. This widget can display several pannable columns. Each column is represented by a GtkTreeModel and single or multiple selection is allowed.

===Text Columns Example===
This is the simplest example: a selector that shows a single text column.

'''Example 6.1. Example of a single-column selector'''

[[Image:example-single-text-column-selector.png|400px]]

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 5.6, "Example of a single-column selector"

import gtk
import hildon

def selection_changed(selector, user_data):
current_selection = selector.get_current_text()
print "Current selection : %s" % (current_selection)

def create_simple_selector():
#Create a HildonTouchSelector with a single text column
selector = hildon.TouchSelector(text = True)

# Set a handler to "changed" signal
selector.connect("changed", selection_changed)

# Populate selector
for i in range(10):
label = "Item %d" % i
# Add item to the column
selector.append_text(label)
# Set selection mode to allow multiple selection
selector.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)

return selector

def app_quit(widget, data=None):
gtk.main_quit()

def main():
program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create touch selector
selector = create_simple_selector()
window.add(selector)

window.connect("destroy", app_quit)

window.show_all()

gtk.main()

if __name__ == "__main__":
main()

A HildonTouchSelector with a single text column is created in this program using the following convenience constructor.

hildon.touch_selector_new_text()

To add text to a selector created by calling the constructor above, use the function.

def append(self, text):

Alternatively, you can use <code>prepend_text()</code> or <code>insert_text()</code> to add text to the selector in different positions.

You can set the desired selection with the function. In the example, the mode was set to allow multiple selection.

def set_column_selection_mode(self, mode):

This example shows a very common use case of this widget. Next section shows how to build a more complex selector with several columns of different types.

Also a simple function was set as a handler for the "changed" signal which is emitted each time the selected items change.

The callback retrieves a text representation of the currently selected items in the selector by calling <code>get_current_text()</code>. By default this function returns a concatenation of the items selected, separated by a comma.

To change how the text representation is generated, set your own function by calling <code>set_print_func()</code> and using the following signature for the function:

def user_function (selector):

===Custom columns===

In the previous section, a selector with a text column was created. That is probably the most common use case of touch selectors. Convenience functions to deal with text columns was used. However, you can also set other type of columns.

Because each column is basically a treeview, you can use the same display to different data and in different ways as you would do with a GtkTreeview. Thus, you can use the GtkCellRenderers available in GTK+ to display the data on each cell.

This section explains how to build a selector within a column displaying stock icons. Firstly, let us take a look on the function which used for appending new columns to a touchable selector.

def append_column(self, model, cell_renderer, ...):

This functions adds a new column to the widget whose data is obtained from the passed model. Pass also a GtkCellRenderer and a list of pairs property/value which is set as attributes of the renderer.

This function basically adds a GtkTreeView to the widget. For more information on how GtkTreeviews work, see [http://library.gnome.org/devel/pygtk/stable/class-gtktreeview.html GTK+ widgets] before.
The following example shows how to set a column to display images in a selector. For clarity, only the function which creates the selector is shown.

'''Example 6.2. Example of a selector with a custom column'''

[[Image:example-single-column-selector.png|400px]]

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.2 "Example of a selector with a custom column"

import gtk
import hildon
import gobject

def selection_changed(selector, user_data):
current_selection = selector.get_current_text()
print "Current selection : %s" % (current_selection)

def create_customized_selector():
# Create a touch selector
selector = hildon.TouchSelector()

# Stock icons will be used for the example
icon_list = gtk.stock_list_ids()

# Create model to store selector's items
store_icons = gtk.ListStore(gobject.TYPE_STRING);

# Populate model
for item in icon_list:
new_iter = store_icons.append()
store_icons.set(new_iter, 0, item)

# Create and set up a pixbuf renderer to use in the selector
renderer = gtk.CellRendererPixbuf()
renderer.set_fixed_size(-1, 100)

# Add the column to the selector
# FIXME: bug 4646
#column = selector.append_column(store_icons, renderer, "stock-id", 0)

# Set the selection mode
selector.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)

# Set the property "text-column" that indicates the column
# of the model to get the string from
column.set_property("text-column", 0)

return selector

def app_quit(widget, data=None):
gtk.main_quit()

def main():
program = hildon.hildon_program_get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create touch selector
selector = create_customized_selector()
window.add(selector)

window.connect("destroy", app_quit)

window.show_all()

gtk.main()

if __name__ == "__main__":
main()

The first step in the example is to create and populate a GtkTreeModel. A GtkListStore is used in the example. In most use cases of the touchable selectors a GtkListStore fits well as selectors were designed to allow users to select from a list of items.

In this case, the model stores a list of GTK+ stock icons identifiers. The following call creates a list store with one column to store strings.

store_icons = gtk.ListStore(G_TYPE_STRING);

The following loop appends all stock identifiers in the newly created model. The identifiers were previously retrieved using

for item in icon_list:
new_iter = store_icons.append()
store_icons.set(new_iter, 0, item)

The next step is to set up the renderer which renders each row of the new column. We need a GtkCellRendererPixbuf to display the stock icons.

renderer = gtk.CellRendererPixbuf()

Finally, we create and append the new column, using the model and renderer previously created.

This call also sets the property "stock-id" of the GtkCellrendererPixbuf. The value is set to 0 which is the number of the column in the GtkTreeModel that stores the stock-id.

column = selector.append_column(store_icons, renderer, "stock-id", 0)

To summarize, setting a new custom column in a touchable selector is quite similar to setting a new column in a normal GtkTreeview. Create a model to store the data and a cell renderer to properly show this data in each row, and finally add the new column.

==Picker dialog and picker buttons ==
Normally, you use HildonTouchSelector together with a HildonPickerDialog activated from a button. For most common cases you use HildonPickerButton.

This is the usual way to present a selector to the user. The picker button opens a dialog which presents the selector and properly manages user interaction.

'''Example'''

Previous sections showed you how to create a touchable selector. In most cases the next step is to attach the selector to a HildonPickerButton.

A HildonPickerButton is a special GtkButton which displays two labels, title and value, and brings up a HildonPickerDialog. The user chooses one or several items. A string representation of the chosen items is displayed in the value label of the picker button.

Below, a modified version of the previous main function is shown, in which you can check how a HildonPickerButton is created and attached to a selector. Also a callback to catch the signal "value-changed" emitted is added.

[[Image:example-picker-button.png|400px]]

'''Example 6.3. Example of a Hildon picker button'''

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.3, "Example of a Hildon picker button"

import gtk
import hildon
import gobject

def on_picker_value_changed(button, user_data=None):
print "Newly selected value: %s\n" % button.get_value()

def app_quit(widget, data=None):
gtk.main_quit()

def create_customized_selector():
# Create a touch selector
selector = hildon.TouchSelector()

# Stock icons will be used for the example
icon_list = gtk.stock_list_ids()

print icon_list

# Create model to store selector's items
store_icons = gtk.ListStore(gobject.TYPE_STRING)

# Populate model
for item in icon_list:
new_iter = store_icons.append()
store_icons.set_value(new_iter, 0, item)

# Create and set up a text renderer to use in the selector
renderer = gtk.CellRendererPixbuf()
renderer.set_fixed_size(-1, 100)

# Add the column to the selector
column = selector.append_column(store_icons, renderer, stock_id=0)

# Set the selection mode
selector.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)

# Set the property "text-column" that indicates the column
# of the model to get the string from
column.set_property("text-column", 0)

return selector

def main ():
program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create touch selector
selector = create_customized_selector()

# Create a picker button
picker_button = hildon.PickerButton(gtk.HILDON_SIZE_AUTO,
hildon.BUTTON_ARRANGEMENT_VERTICAL)

# Set a title to the button
picker_button.set_title("Select an item")

# Attach the touch selector to the picker button
picker_button.set_selector(selector)

# Attach callback to the "value-changed" signal
picker_button.connect("value-changed", on_picker_value_changed)

# Add button to main window
window.add(picker_button)

window.connect("destroy", app_quit)
window.show_all()
gtk.main()

if __name__ == "__main__":
main()

In the above example a picker button is created. The reference to the attached selector is stored in the property "touch-selector" of the picker button. To retrieve the attached selector , use function <code>hildon.PickerButton()</code>. To attach the selector, use the function <code>picker_button.set_selector()</code>.

Note that you do not need to take care of the HildonPickerDialog. The dialog is automatically brought up when users click the picker button and closed when the selection is done.

The dialog shows a button "Done" to allow users finish the selection when the touchable selector allows multiple selection. When the selector allows only single selection, the dialog does not show any button and closes when the user taps on one item.

The label of the button "Done" can be set by using <code>set_done_button_text()</code> and retrieved by using <code>get_done_button_text()</code>.

When users finish their selection, the value label on the button automatically changes to show a textual representation of the item or items selected.

In most cases you want to perform any action when selection is finished. To do that, add a handler to the signal "value-changed" of the picker button. In this example the handler attached to "value-changed" signal retrieves the value label of the button and prints a debug message.

==Touch selector entry ==
The HildonTouchSelectorEntry is a selector widget with a text entry that allows users to select an item from a predefined list or to enter a different one in a HildonEntry. Items can also be searched and selected by typing in the entry.

An additional feature is that the HildonEntry is auto-completed with the list's items as the user types their name.

Example below shows how to build a selector to pick a word in a list of words.

[[Image:Touch_selector_entry.png|400px]]

'''Example 6.4. Example of a Hildon picker button with a selector entry'''

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.4, "Hildon picker button with a selector entry"

import gtk
import hildon

def app_quit(widget, data=None):
gtk.main_quit()

def main ():
artists = [
"AC/DC",
"Aerosmith",
"Alice in Chains",
"Black Sabbath",
"Carcass",
"Danzig",
"Deep Purple",
"Dream Theater",
"Eric Clapton",
]

program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create a picker button
picker_button = hildon.PickerButton(gtk.HILDON_SIZE_AUTO,
hildon.BUTTON_ARRANGEMENT_VERTICAL)

# Set a title to the button
picker_button.set_title("Pick a band!")

# Create a touch selector entry
selector = hildon.TouchSelectorEntry(text=True)

# Populate the selector
for artist in artists:
selector.append_text(artist)

# Attach the touch selector to the picker button
picker_button.set_selector(selector)

# Add button to main window
window.add(picker_button)

window.connect("destroy", app_quit)
window.show_all()
gtk.main()

if __name__ == "__main__":
main()

As you can see in the example above, the use of this widget is similar to using a normal touchable selector.

You can also use custom columns in a HildonTouchableEntry but at least one column must be a text column. The text column is indicated by the property "text_column" which you set with <code>set_text_column()</code>.

==Pre-built selectors ==
The widgets HildonDateButton and HildonTimeButton are buttons displaying and allowing the selection of date and time, respectively. Developers can use them directly instead of building their own date or time selectors.

Both widgets are specialized picker buttons with a convenient touchable selector attached that you can use directly in your application.

Here is a simple application using a HildonDateButton.

'''Example 6.5. Example of a Hildon date button'''

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.5, "Example of a Hildon date button"

import gtk
import hildon

def app_quit(widget, data=None):
gtk.main_quit()

def main ():
program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create a date picker
date_button = hildon.DateButton(gtk.HILDON_SIZE_AUTO,
hildon.BUTTON_ARRANGEMENT_VERTICAL)

# Set a title to the button
date_button.set_title("Select an item")

# Add button to main window
window.add(date_button)

window.connect("destroy", app_quit)
window.show_all()
gtk.main()

if __name__ == "__main__":
main()

PyMaemo/UI tutorial/Data selection

2009-10-16T17:11:09Z

200.184.118.130: /* Text Columns Example */

= Data selection =
Hildon provides a set of widgets for data selection specially designed for touchscreens that allows to build simple and easy-to-use interfaces.

The key widget is a selector widget that allows users to select items from one to many predefined lists. It is similar to a combo box but allows several individual pannable columns.

In addition, Hildon also provides a specialized dialog and a specialized button to be used in combination with a selector.

==Touch selector ==
HildonTouchSelector is the mentioned selector widget. This widget can display several pannable columns. Each column is represented by a GtkTreeModel and single or multiple selection is allowed.

===Text Columns Example===
This is the simplest example: a selector that shows a single text column.

'''Example 6.1. Example of a single-column selector'''

[[Image:example-single-text-column-selector.png|400px]]

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 5.6, "Example of a single-column selector"

import gtk
import hildon

def selection_changed(selector, user_data):
current_selection = selector.get_current_text()
print "Current selection : %s" % (current_selection)

def create_simple_selector():
#Create a HildonTouchSelector with a single text column
# selector = hildon.TouchSelector()
selector = hildon.hildon_touch_selector_new_text()

# Set selection mode to allow multiple selection
selector.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)

# Set a handler to "changed" signal
selector.connect("changed", selection_changed)

# Populate selector
for i in range(10):
label = "Item %d" % i
# Add item to the column
selector.append_text(label)

return selector

def app_quit(widget, data=None):
gtk.main_quit()

def main():
program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create touch selector
selector = create_simple_selector()
window.add(selector)

window.connect("destroy", app_quit)

window.show_all()

gtk.main()

if __name__ == "__main__":
main()

A HildonTouchSelector with a single text column is created in this program using the following convenience constructor.

hildon.touch_selector_new_text()

To add text to a selector created by calling the constructor above, use the function.

def append(self, text):

Alternatively, you can use <code>prepend_text()</code> or <code>insert_text()</code> to add text to the selector in different positions.

You can set the desired selection with the function. In the example, the mode was set to allow multiple selection.

def set_column_selection_mode(self, mode):

This example shows a very common use case of this widget. Next section shows how to build a more complex selector with several columns of different types.

Also a simple function was set as a handler for the "changed" signal which is emitted each time the selected items change.

The callback retrieves a text representation of the currently selected items in the selector by calling <code>get_current_text()</code>. By default this function returns a concatenation of the items selected, separated by a comma.

To change how the text representation is generated, set your own function by calling <code>set_print_func()</code> and using the following signature for the function:

def user_function (selector):

===Custom columns===

In the previous section, a selector with a text column was created. That is probably the most common use case of touch selectors. Convenience functions to deal with text columns was used. However, you can also set other type of columns.

Because each column is basically a treeview, you can use the same display to different data and in different ways as you would do with a GtkTreeview. Thus, you can use the GtkCellRenderers available in GTK+ to display the data on each cell.

This section explains how to build a selector within a column displaying stock icons. Firstly, let us take a look on the function which used for appending new columns to a touchable selector.

def append_column(self, model, cell_renderer, ...):

This functions adds a new column to the widget whose data is obtained from the passed model. Pass also a GtkCellRenderer and a list of pairs property/value which is set as attributes of the renderer.

This function basically adds a GtkTreeView to the widget. For more information on how GtkTreeviews work, see [http://library.gnome.org/devel/pygtk/stable/class-gtktreeview.html GTK+ widgets] before.
The following example shows how to set a column to display images in a selector. For clarity, only the function which creates the selector is shown.

'''Example 6.2. Example of a selector with a custom column'''

[[Image:example-single-column-selector.png|400px]]

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.2 "Example of a selector with a custom column"

import gtk
import hildon
import gobject

def selection_changed(selector, user_data):
current_selection = selector.get_current_text()
print "Current selection : %s" % (current_selection)

def create_customized_selector():
# Create a touch selector
selector = hildon.TouchSelector()

# Stock icons will be used for the example
icon_list = gtk.stock_list_ids()

# Create model to store selector's items
store_icons = gtk.ListStore(gobject.TYPE_STRING);

# Populate model
for item in icon_list:
new_iter = store_icons.append()
store_icons.set(new_iter, 0, item)

# Create and set up a pixbuf renderer to use in the selector
renderer = gtk.CellRendererPixbuf()
renderer.set_fixed_size(-1, 100)

# Add the column to the selector
# FIXME: bug 4646
#column = selector.append_column(store_icons, renderer, "stock-id", 0)

# Set the selection mode
selector.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)

# Set the property "text-column" that indicates the column
# of the model to get the string from
column.set_property("text-column", 0)

return selector

def app_quit(widget, data=None):
gtk.main_quit()

def main():
program = hildon.hildon_program_get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create touch selector
selector = create_customized_selector()
window.add(selector)

window.connect("destroy", app_quit)

window.show_all()

gtk.main()

if __name__ == "__main__":
main()

The first step in the example is to create and populate a GtkTreeModel. A GtkListStore is used in the example. In most use cases of the touchable selectors a GtkListStore fits well as selectors were designed to allow users to select from a list of items.

In this case, the model stores a list of GTK+ stock icons identifiers. The following call creates a list store with one column to store strings.

store_icons = gtk.ListStore(G_TYPE_STRING);

The following loop appends all stock identifiers in the newly created model. The identifiers were previously retrieved using

for item in icon_list:
new_iter = store_icons.append()
store_icons.set(new_iter, 0, item)

The next step is to set up the renderer which renders each row of the new column. We need a GtkCellRendererPixbuf to display the stock icons.

renderer = gtk.CellRendererPixbuf()

Finally, we create and append the new column, using the model and renderer previously created.

This call also sets the property "stock-id" of the GtkCellrendererPixbuf. The value is set to 0 which is the number of the column in the GtkTreeModel that stores the stock-id.

column = selector.append_column(store_icons, renderer, "stock-id", 0)

To summarize, setting a new custom column in a touchable selector is quite similar to setting a new column in a normal GtkTreeview. Create a model to store the data and a cell renderer to properly show this data in each row, and finally add the new column.

==Picker dialog and picker buttons ==
Normally, you use HildonTouchSelector together with a HildonPickerDialog activated from a button. For most common cases you use HildonPickerButton.

This is the usual way to present a selector to the user. The picker button opens a dialog which presents the selector and properly manages user interaction.

'''Example'''

Previous sections showed you how to create a touchable selector. In most cases the next step is to attach the selector to a HildonPickerButton.

A HildonPickerButton is a special GtkButton which displays two labels, title and value, and brings up a HildonPickerDialog. The user chooses one or several items. A string representation of the chosen items is displayed in the value label of the picker button.

Below, a modified version of the previous main function is shown, in which you can check how a HildonPickerButton is created and attached to a selector. Also a callback to catch the signal "value-changed" emitted is added.

[[Image:example-picker-button.png|400px]]

'''Example 6.3. Example of a Hildon picker button'''

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.3, "Example of a Hildon picker button"

import gtk
import hildon
import gobject

def on_picker_value_changed(button, user_data=None):
print "Newly selected value: %s\n" % button.get_value()

def app_quit(widget, data=None):
gtk.main_quit()

def create_customized_selector():
# Create a touch selector
selector = hildon.TouchSelector()

# Stock icons will be used for the example
icon_list = gtk.stock_list_ids()

print icon_list

# Create model to store selector's items
store_icons = gtk.ListStore(gobject.TYPE_STRING)

# Populate model
for item in icon_list:
new_iter = store_icons.append()
store_icons.set_value(new_iter, 0, item)

# Create and set up a text renderer to use in the selector
renderer = gtk.CellRendererPixbuf()
renderer.set_fixed_size(-1, 100)

# Add the column to the selector
column = selector.append_column(store_icons, renderer, stock_id=0)

# Set the selection mode
selector.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)

# Set the property "text-column" that indicates the column
# of the model to get the string from
column.set_property("text-column", 0)

return selector

def main ():
program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create touch selector
selector = create_customized_selector()

# Create a picker button
picker_button = hildon.PickerButton(gtk.HILDON_SIZE_AUTO,
hildon.BUTTON_ARRANGEMENT_VERTICAL)

# Set a title to the button
picker_button.set_title("Select an item")

# Attach the touch selector to the picker button
picker_button.set_selector(selector)

# Attach callback to the "value-changed" signal
picker_button.connect("value-changed", on_picker_value_changed)

# Add button to main window
window.add(picker_button)

window.connect("destroy", app_quit)
window.show_all()
gtk.main()

if __name__ == "__main__":
main()

In the above example a picker button is created. The reference to the attached selector is stored in the property "touch-selector" of the picker button. To retrieve the attached selector , use function <code>hildon.PickerButton()</code>. To attach the selector, use the function <code>picker_button.set_selector()</code>.

Note that you do not need to take care of the HildonPickerDialog. The dialog is automatically brought up when users click the picker button and closed when the selection is done.

The dialog shows a button "Done" to allow users finish the selection when the touchable selector allows multiple selection. When the selector allows only single selection, the dialog does not show any button and closes when the user taps on one item.

The label of the button "Done" can be set by using <code>set_done_button_text()</code> and retrieved by using <code>get_done_button_text()</code>.

When users finish their selection, the value label on the button automatically changes to show a textual representation of the item or items selected.

In most cases you want to perform any action when selection is finished. To do that, add a handler to the signal "value-changed" of the picker button. In this example the handler attached to "value-changed" signal retrieves the value label of the button and prints a debug message.

==Touch selector entry ==
The HildonTouchSelectorEntry is a selector widget with a text entry that allows users to select an item from a predefined list or to enter a different one in a HildonEntry. Items can also be searched and selected by typing in the entry.

An additional feature is that the HildonEntry is auto-completed with the list's items as the user types their name.

Example below shows how to build a selector to pick a word in a list of words.

[[Image:Touch_selector_entry.png|400px]]

'''Example 6.4. Example of a Hildon picker button with a selector entry'''

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.4, "Hildon picker button with a selector entry"

import gtk
import hildon

def app_quit(widget, data=None):
gtk.main_quit()

def main ():
artists = [
"AC/DC",
"Aerosmith",
"Alice in Chains",
"Black Sabbath",
"Carcass",
"Danzig",
"Deep Purple",
"Dream Theater",
"Eric Clapton",
]

program = hildon.hildon_program_get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create a picker button
picker_button = hildon.PickerButton(gtk.HILDON_SIZE_AUTO,
hildon.BUTTON_ARRANGEMENT_VERTICAL)

# Set a title to the button
picker_button.set_title("Pick a band!")

# Create a touch selector entry */
# FIXME: bug 4647
selector = hildon.hildon_touch_selector_entry_new_text()

# Populate the selector
for artist in artists:
selector.append_text(artist)

# Attach the touch selector to the picker button
picker_button.set_selector(selector)

# Add button to main window
window.add(picker_button)

window.connect("destroy", app_quit)
window.show_all()
gtk.main()

if __name__ == "__main__":
main()

As you can see in the example above, the use of this widget is similar to using a normal touchable selector.

You can also use custom columns in a HildonTouchableEntry but at least one column must be a text column. The text column is indicated by the property "text_column" which you set with <code>set_text_column()</code>.

==Pre-built selectors ==
The widgets HildonDateButton and HildonTimeButton are buttons displaying and allowing the selection of date and time, respectively. Developers can use them directly instead of building their own date or time selectors.

Both widgets are specialized picker buttons with a convenient touchable selector attached that you can use directly in your application.

Here is a simple application using a HildonDateButton.

'''Example 6.5. Example of a Hildon date button'''

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.5, "Example of a Hildon date button"

import gtk
import hildon

def app_quit(widget, data=None):
gtk.main_quit()

def main ():
program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create a date picker
date_button = hildon.DateButton(gtk.HILDON_SIZE_AUTO,
hildon.BUTTON_ARRANGEMENT_VERTICAL)

# Set a title to the button
date_button.set_title("Select an item")

# Add button to main window
window.add(date_button)

window.connect("destroy", app_quit)
window.show_all()
gtk.main()

if __name__ == "__main__":
main()

PyMaemo/UI tutorial/Data selection

2009-10-16T16:49:52Z

200.184.118.130: /* Text Columns Example */

= Data selection =
Hildon provides a set of widgets for data selection specially designed for touchscreens that allows to build simple and easy-to-use interfaces.

The key widget is a selector widget that allows users to select items from one to many predefined lists. It is similar to a combo box but allows several individual pannable columns.

In addition, Hildon also provides a specialized dialog and a specialized button to be used in combination with a selector.

==Touch selector ==
HildonTouchSelector is the mentioned selector widget. This widget can display several pannable columns. Each column is represented by a GtkTreeModel and single or multiple selection is allowed.

===Text Columns Example===
This is the simplest possible example. A selector that shows a single text column.

'''Example 6.1. Example of a single-column selector'''

[[Image:example-single-text-column-selector.png|400px]]

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 5.6, "Example of a single-column selector"

import gtk
import hildon

def selection_changed(selector, user_data):
current_selection = selector.get_current_text()
print "Current selection : %s" % (current_selection)

def create_simple_selector():
#Create a HildonTouchSelector with a single text column
# selector = hildon.TouchSelector()
selector = hildon.hildon_touch_selector_new_text()

# Set selection mode to allow multiple selection
selector.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)

# Set a handler to "changed" signal
selector.connect("changed", selection_changed)

# Populate selector
for i in range(10):
label = "Item %d" % i
# Add item to the column
selector.append_text(label)

return selector

def app_quit(widget, data=None):
gtk.main_quit()

def main():
program = hildon.hildon_program_get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create touch selector
selector = create_simple_selector()
window.add(selector)

window.connect("destroy", app_quit)

window.show_all()

gtk.main()

if __name__ == "__main__":
main()

A HildonTouchSelector with a single text column is created in this program using the following convenience constructor.

hildon.touch_selector_new_text()

To add text to a selector created by calling the constructor above, use the function.

def append(self, text):

Alternatively, you can use <code>prepend_text()</code> or <code>insert_text()</code> to add text to the selector in different positions.

You can set the desired selection with the function. In the example, the mode was set to allow multiple selection.

def set_column_selection_mode(self, mode):

This example shows a very common use case of this widget. Next section shows how to build a more complex selector with several columns of different types.

Also a simple function was set as a handler for the "changed" signal which is emitted each time the selected items change.

The callback retrieves a text representation of the currently selected items in the selector by calling <code>get_current_text()</code>. By default this function returns a concatenation of the items selected, separated by a comma.

To change how the text representation is generated, set your own function by calling <code>set_print_func()</code> and using the following signature for the function:

def user_function (selector):

===Custom columns===

In the previous section, a selector with a text column was created. That is probably the most common use case of touch selectors. Convenience functions to deal with text columns was used. However, you can also set other type of columns.

Because each column is basically a treeview, you can use the same display to different data and in different ways as you would do with a GtkTreeview. Thus, you can use the GtkCellRenderers available in GTK+ to display the data on each cell.

This section explains how to build a selector within a column displaying stock icons. Firstly, let us take a look on the function which used for appending new columns to a touchable selector.

def append_column(self, model, cell_renderer, ...):

This functions adds a new column to the widget whose data is obtained from the passed model. Pass also a GtkCellRenderer and a list of pairs property/value which is set as attributes of the renderer.

This function basically adds a GtkTreeView to the widget. For more information on how GtkTreeviews work, see [http://library.gnome.org/devel/pygtk/stable/class-gtktreeview.html GTK+ widgets] before.
The following example shows how to set a column to display images in a selector. For clarity, only the function which creates the selector is shown.

'''Example 6.2. Example of a selector with a custom column'''

[[Image:example-single-column-selector.png|400px]]

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.2 "Example of a selector with a custom column"

import gtk
import hildon
import gobject

def selection_changed(selector, user_data):
current_selection = selector.get_current_text()
print "Current selection : %s" % (current_selection)

def create_customized_selector():
# Create a touch selector
selector = hildon.TouchSelector()

# Stock icons will be used for the example
icon_list = gtk.stock_list_ids()

# Create model to store selector's items
store_icons = gtk.ListStore(gobject.TYPE_STRING);

# Populate model
for item in icon_list:
new_iter = store_icons.append()
store_icons.set(new_iter, 0, item)

# Create and set up a pixbuf renderer to use in the selector
renderer = gtk.CellRendererPixbuf()
renderer.set_fixed_size(-1, 100)

# Add the column to the selector
# FIXME: bug 4646
#column = selector.append_column(store_icons, renderer, "stock-id", 0)

# Set the selection mode
selector.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)

# Set the property "text-column" that indicates the column
# of the model to get the string from
column.set_property("text-column", 0)

return selector

def app_quit(widget, data=None):
gtk.main_quit()

def main():
program = hildon.hildon_program_get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create touch selector
selector = create_customized_selector()
window.add(selector)

window.connect("destroy", app_quit)

window.show_all()

gtk.main()

if __name__ == "__main__":
main()

The first step in the example is to create and populate a GtkTreeModel. A GtkListStore is used in the example. In most use cases of the touchable selectors a GtkListStore fits well as selectors were designed to allow users to select from a list of items.

In this case, the model stores a list of GTK+ stock icons identifiers. The following call creates a list store with one column to store strings.

store_icons = gtk.ListStore(G_TYPE_STRING);

The following loop appends all stock identifiers in the newly created model. The identifiers were previously retrieved using

for item in icon_list:
new_iter = store_icons.append()
store_icons.set(new_iter, 0, item)

The next step is to set up the renderer which renders each row of the new column. We need a GtkCellRendererPixbuf to display the stock icons.

renderer = gtk.CellRendererPixbuf()

Finally, we create and append the new column, using the model and renderer previously created.

This call also sets the property "stock-id" of the GtkCellrendererPixbuf. The value is set to 0 which is the number of the column in the GtkTreeModel that stores the stock-id.

column = selector.append_column(store_icons, renderer, "stock-id", 0)

To summarize, setting a new custom column in a touchable selector is quite similar to setting a new column in a normal GtkTreeview. Create a model to store the data and a cell renderer to properly show this data in each row, and finally add the new column.

==Picker dialog and picker buttons ==
Normally, you use HildonTouchSelector together with a HildonPickerDialog activated from a button. For most common cases you use HildonPickerButton.

This is the usual way to present a selector to the user. The picker button opens a dialog which presents the selector and properly manages user interaction.

'''Example'''

Previous sections showed you how to create a touchable selector. In most cases the next step is to attach the selector to a HildonPickerButton.

A HildonPickerButton is a special GtkButton which displays two labels, title and value, and brings up a HildonPickerDialog. The user chooses one or several items. A string representation of the chosen items is displayed in the value label of the picker button.

Below, a modified version of the previous main function is shown, in which you can check how a HildonPickerButton is created and attached to a selector. Also a callback to catch the signal "value-changed" emitted is added.

[[Image:example-picker-button.png|400px]]

'''Example 6.3. Example of a Hildon picker button'''

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.3, "Example of a Hildon picker button"

import gtk
import hildon
import gobject

def on_picker_value_changed(button, user_data=None):
print "Newly selected value: %s\n" % button.get_value()

def app_quit(widget, data=None):
gtk.main_quit()

def create_customized_selector():
# Create a touch selector
selector = hildon.TouchSelector()

# Stock icons will be used for the example
icon_list = gtk.stock_list_ids()

print icon_list

# Create model to store selector's items
store_icons = gtk.ListStore(gobject.TYPE_STRING)

# Populate model
for item in icon_list:
new_iter = store_icons.append()
store_icons.set_value(new_iter, 0, item)

# Create and set up a text renderer to use in the selector
renderer = gtk.CellRendererPixbuf()
renderer.set_fixed_size(-1, 100)

# Add the column to the selector
column = selector.append_column(store_icons, renderer, stock_id=0)

# Set the selection mode
selector.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)

# Set the property "text-column" that indicates the column
# of the model to get the string from
column.set_property("text-column", 0)

return selector

def main ():
program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create touch selector
selector = create_customized_selector()

# Create a picker button
picker_button = hildon.PickerButton(gtk.HILDON_SIZE_AUTO,
hildon.BUTTON_ARRANGEMENT_VERTICAL)

# Set a title to the button
picker_button.set_title("Select an item")

# Attach the touch selector to the picker button
picker_button.set_selector(selector)

# Attach callback to the "value-changed" signal
picker_button.connect("value-changed", on_picker_value_changed)

# Add button to main window
window.add(picker_button)

window.connect("destroy", app_quit)
window.show_all()
gtk.main()

if __name__ == "__main__":
main()

In the above example a picker button is created. The reference to the attached selector is stored in the property "touch-selector" of the picker button. To retrieve the attached selector , use function <code>hildon.PickerButton()</code>. To attach the selector, use the function <code>picker_button.set_selector()</code>.

Note that you do not need to take care of the HildonPickerDialog. The dialog is automatically brought up when users click the picker button and closed when the selection is done.

The dialog shows a button "Done" to allow users finish the selection when the touchable selector allows multiple selection. When the selector allows only single selection, the dialog does not show any button and closes when the user taps on one item.

The label of the button "Done" can be set by using <code>set_done_button_text()</code> and retrieved by using <code>get_done_button_text()</code>.

When users finish their selection, the value label on the button automatically changes to show a textual representation of the item or items selected.

In most cases you want to perform any action when selection is finished. To do that, add a handler to the signal "value-changed" of the picker button. In this example the handler attached to "value-changed" signal retrieves the value label of the button and prints a debug message.

==Touch selector entry ==
The HildonTouchSelectorEntry is a selector widget with a text entry that allows users to select an item from a predefined list or to enter a different one in a HildonEntry. Items can also be searched and selected by typing in the entry.

An additional feature is that the HildonEntry is auto-completed with the list's items as the user types their name.

Example below shows how to build a selector to pick a word in a list of words.

[[Image:Touch_selector_entry.png|400px]]

'''Example 6.4. Example of a Hildon picker button with a selector entry'''

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.4, "Hildon picker button with a selector entry"

import gtk
import hildon

def app_quit(widget, data=None):
gtk.main_quit()

def main ():
artists = [
"AC/DC",
"Aerosmith",
"Alice in Chains",
"Black Sabbath",
"Carcass",
"Danzig",
"Deep Purple",
"Dream Theater",
"Eric Clapton",
]

program = hildon.hildon_program_get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create a picker button
picker_button = hildon.PickerButton(gtk.HILDON_SIZE_AUTO,
hildon.BUTTON_ARRANGEMENT_VERTICAL)

# Set a title to the button
picker_button.set_title("Pick a band!")

# Create a touch selector entry */
# FIXME: bug 4647
selector = hildon.hildon_touch_selector_entry_new_text()

# Populate the selector
for artist in artists:
selector.append_text(artist)

# Attach the touch selector to the picker button
picker_button.set_selector(selector)

# Add button to main window
window.add(picker_button)

window.connect("destroy", app_quit)
window.show_all()
gtk.main()

if __name__ == "__main__":
main()

As you can see in the example above, the use of this widget is similar to using a normal touchable selector.

You can also use custom columns in a HildonTouchableEntry but at least one column must be a text column. The text column is indicated by the property "text_column" which you set with <code>set_text_column()</code>.

==Pre-built selectors ==
The widgets HildonDateButton and HildonTimeButton are buttons displaying and allowing the selection of date and time, respectively. Developers can use them directly instead of building their own date or time selectors.

Both widgets are specialized picker buttons with a convenient touchable selector attached that you can use directly in your application.

Here is a simple application using a HildonDateButton.

'''Example 6.5. Example of a Hildon date button'''

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 6.5, "Example of a Hildon date button"

import gtk
import hildon

def app_quit(widget, data=None):
gtk.main_quit()

def main ():
program = hildon.Program.get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create a date picker
date_button = hildon.DateButton(gtk.HILDON_SIZE_AUTO,
hildon.BUTTON_ARRANGEMENT_VERTICAL)

# Set a title to the button
date_button.set_title("Select an item")

# Add button to main window
window.add(date_button)

window.connect("destroy", app_quit)
window.show_all()
gtk.main()

if __name__ == "__main__":
main()

PyMaemo/UI tutorial/Menus

2009-10-16T13:55:30Z

200.184.118.130: /* Touch view menu */

=Menus =
Hildon applications use menus in a completely different way from the traditional application menus - Hildon applications does not have a menu bar.

Each window has an attached menu that activates when the user presses the window title area. Also, unlike typical menus in desktop applications, view menus do not follow a hierarchical structure. This menu, attached to a view, is called Touch View Menu.

Additionally Hildon provides Context menus, but they should be avoided whenever possible.

==Touch view menu ==

The HildonAppmenu is a widget that acts like a menu in the windows of a Hildon application.

This widget opens at the top of the screen, obscuring the topmost window, and contains several entries organized in one or two columns, depending on screen orientation. Besides entries, application menus can also contain a group of filter buttons.

The entries are GtkButtons. Assign an action to the menu item for when they are activated.

Filters are toggle buttons that can be used for presentation/sorting purposes. For example, sorting alphabetically a list of contacts or changing the size of icons in a list.

To create a HildonAppMenu, use the following command:

hildon.AppMenu()

When the application menu is created, add entries to the menu by using the following functions:

def append(self, item)
def prepend(self, item)
def insert(self, item, position)

These functions allow you to append, prepend an entry or add it in a certain position (from 0 to N-1, where N is the number of menus).

It is important to keep the UI simple. Try to create the menu as short as possible and avoid adding unnecessary options. An application menu with more than 10 items probably will not have a good appearance.

To add filter buttons, use the following:

def add_filter(self, filter)

Again, be careful with the number of filters that you add to the application menu. More than 4 might not be well displayed, even less, depending on the length of the labels. Filters should be grouped and act as radio buttons, that is, for any filter, at least another filter with a different/opposite action must exist. Actually, GtkRadioButtons can be easily used to accomplish this by having them grouped (using <code>gtk_radio_button_new_from_widget()</code> like the next example shows) and by not drawing their indicator - with the function gtk_toggle_button_set_mode().

When the menu is properly created and filled up with entries and filters, add the menu to a HildonWindow. To set and retrieve a window's menu, use the following functions:

def set_app_menu(self, menu)
def get_app_menu(self)

The following example shows how to create and set up an application menu.

'''Example 3.1. Example of a Hildon application menu'''

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 3.1, "Example of a Hildon application menu"

import sys

import gtk
import hildon

def menu_button_clicked(button, label):
buttontext = button.get_label()
text = "Last option selected:\n%s" % buttontext
label.set_text(text)
print >>sys.stderr, "Button clicked: %s" % buttontext

def create_menu(label):
menu = hildon.AppMenu()

for i in xrange(1, 6):
# Create menu entries
button = hildon.GtkButton(gtk.HILDON_SIZE_AUTO)
command_id = "Menu command %d" % i
button.set_label(command_id)

# Attach callback to clicked signal
button.connect("clicked", menu_button_clicked, label)

# Add entry to the view menu
menu.append(button)

# Create filters
button = hildon.GtkRadioButton(gtk.HILDON_SIZE_AUTO, None)
button.set_label("filter one")
button.connect("clicked", menu_button_clicked, label)
menu.add_filter(button)
button.set_mode(False)

button = hildon.GtkRadioButton(gtk.HILDON_SIZE_AUTO, button)
button.set_label("filter two")
button.connect("clicked", menu_button_clicked, label)
menu.add_filter(button)
button.set_mode(False)

menu.show_all()

return menu

def main():
win = hildon.StackableWindow()

# Create and pack labels
label = gtk.Label("This is an example of the\nHildonAppMenu widget.\n\n"
"Click on the titlebar\nto pop up the menu.")
label2 = gtk.Label("No menu option has been selected yet.")

label.set_justify(gtk.JUSTIFY_CENTER)
label2.set_justify(gtk.JUSTIFY_CENTER)

vbox = gtk.VBox(False, 10)

vbox.pack_start(label, True, True, 0)
vbox.pack_start(label2, True, True, 0)

# Create menu
menu = create_menu(label2)

# Attach menu to the window
win.set_app_menu(menu)

# Add label's box to window
win.add(vbox)

win.connect("delete_event", gtk.main_quit)

win.show_all()

gtk.main()

if __name__ == "__main__":
main()

Each entry and filter button in this example is attached to a function that simply changes a label in the main window.

==Application menus and views ==

The previous example had only one view. In applications with several views, you can attach a different menu to each view and add only the options that are relevant to the displayed view.

The function <code>hildon_window_set_app_menu()</code>allows to set a menu to a HildonWindow and its descendant HildonStackableWindow widget.

window.set_app_menu(menu)

Note that submenus are not supported by view menus. Usually a menu item that would have suboptions in a desktop application is implemented as a new subview in a Hildon application.

A callback function for a complex menu entry can create a new hildon.StackableWindow to accomplish the task that the option refers to. The new window can contain a different view menu that aggregates buttons to perform the action. The buttons can even reside in the window area.

==Context menu ==
The Context menu is usually invoked through a long press over an item on the screen, like holding a finger over an image thumbnail. The menu must contain commands directly related to the chosen item.

Avoid using context menus, because they are a hidden and inconvenient way of interacting with the UI. Use HildonAppMenus instead.

To create a GtkMenu in a Hildon application, use the following function instead of <code>gtk_menu_new()</code><nowiki>: </nowiki>

gtk.Menu()

This function creates a GtkMenu that allows Hildon specific styling.

When you use a GtkMenu in your Hildon application, consider how many menu items you are going to use, because screen space is limited. Also consider the fact that in the interests of keeping the UI clear, submenus are not allowed.

PyMaemo/UI tutorial/Menus

2009-10-16T12:50:14Z

200.184.118.130: /* Menus */

=Menus =
Hildon applications use menus in a completely different way from the traditional application menus - Hildon applications does not have a menu bar.

Each window has an attached menu that activates when the user presses the window title area. Also, unlike typical menus in desktop applications, view menus do not follow a hierarchical structure. This menu, attached to a view, is called Touch View Menu.

Additionally Hildon provides Context menus, but they should be avoided whenever possible.

==Touch view menu ==

The HildonAppmenu is a widget that acts like a menu in the windows of a Hildon application.

This widget opens at the top of the screen, obscuring the topmost window, and contains several entries organized in one or two columns, depending on screen orientation. Besides entries, application menus can also contain a group of filter buttons.

The entries are GtkButtons. Assign an action to the menu item for when they are activated.

Filters are toggle buttons that can be used for presentation/sorting purposes. For example, sorting alphabetically a list of contacts or changing the size of icons in a list.

To create a HildonAppMenu, use the following command:

hildon.AppMenu()

When the application menu is created, add entries to the menu by using the following functions:

def append(self, item)
def prepend(self, item)
def insert(self, item, position)

These functions allow you to append, prepend an entry or add it in a certain position (from 0 to N-1, where N is the number of menus).

It is important to keep the UI simple. Try to create the menu as short as possible and avoid adding unnecessary options. An application menu with more than 10 items probably will not have a good appearance.

To add filter buttons, use the following:

def add_filter(self, filter)

Again, be careful with the number of filters that you add to the application menu. More than 4 might not be well displayed, even less, depending on the length of the labels. Filters should be grouped and act as radio buttons, that is, for any filter, at least another filter with a different/opposite action must exist. Actually, GtkRadioButtons can be easily used to accomplish this by having them grouped (using <code>gtk_radio_button_new_from_widget()</code> like the next example shows) and by not drawing their indicator - with the function gtk_toggle_button_set_mode().

When the menu is properly created and filled up with entries and filters, add the menu to a HildonWindow. To set and retrieve a window's menu, use the following functions:

def set_app_menu(self, menu)
def get_app_menu(self)

The following example shows how to create and set up an application menu.

'''Example 3.1. Example of a Hildon application menu'''

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 3.1, "Example of a Hildon application menu"

import sys

import gtk
import hildon

def menu_button_clicked(button, label):
buttontext = button.get_label()
text = "Last option selected:\n%s" % buttontext
label.set_text(text)
print >>sys.stderr, "Button clicked: %s" % buttontext

def create_menu(label):
menu = hildon.AppMenu()

for i in xrange(1, 6):
# Create menu entries
button = hildon.GtkButton(gtk.HILDON_SIZE_AUTO)
command_id = "Menu command %d" % i
button.set_label(command_id)

# Attach callback to clicked signal
button.connect("clicked", menu_button_clicked, label)

# Add entry to the view menu
menu.append(button)

# Create filters
# FIXME: hildon_gtk_radio_button_new() is not exposed to Python, using a
# plain gtk.RadioButton for now
#button = hildon.GtkRadioButton(gtk.HILDON_SIZE_AUTO, None)
button = gtk.RadioButton()
button.set_label("filter one")
button.connect("clicked", menu_button_clicked, label)
menu.add_filter(button)
button.set_mode(False)

button = gtk.RadioButton(button)
button.set_label("filter two")
button.connect("clicked", menu_button_clicked, label)
menu.add_filter(button)
button.set_mode(False)

menu.show_all()

return menu

def main():
win = hildon.StackableWindow()

# Create and pack labels
label = gtk.Label("This is an example of the\nHildonAppMenu widget.\n\n"
"Click on the titlebar\nto pop up the menu.")
label2 = gtk.Label("No menu option has been selected yet.")

label.set_justify(gtk.JUSTIFY_CENTER)
label2.set_justify(gtk.JUSTIFY_CENTER)

vbox = gtk.VBox(False, 10)

vbox.pack_start(label, True, True, 0)
vbox.pack_start(label2, True, True, 0)

# Create menu
menu = create_menu(label2)

# Attach menu to the window
win.set_app_menu(menu)

# Add label's box to window
win.add(vbox)

win.connect("delete_event", gtk.main_quit)

win.show_all()

gtk.main()

if __name__ == "__main__":
main()

Each entry and filter button in this example is attached to a function that simply changes a label in the main window.

==Application menus and views ==

The previous example had only one view. In applications with several views, you can attach a different menu to each view and add only the options that are relevant to the displayed view.

The function <code>hildon_window_set_app_menu()</code>allows to set a menu to a HildonWindow and its descendant HildonStackableWindow widget.

window.set_app_menu(menu)

Note that submenus are not supported by view menus. Usually a menu item that would have suboptions in a desktop application is implemented as a new subview in a Hildon application.

A callback function for a complex menu entry can create a new hildon.StackableWindow to accomplish the task that the option refers to. The new window can contain a different view menu that aggregates buttons to perform the action. The buttons can even reside in the window area.

==Context menu ==
The Context menu is usually invoked through a long press over an item on the screen, like holding a finger over an image thumbnail. The menu must contain commands directly related to the chosen item.

Avoid using context menus, because they are a hidden and inconvenient way of interacting with the UI. Use HildonAppMenus instead.

To create a GtkMenu in a Hildon application, use the following function instead of <code>gtk_menu_new()</code><nowiki>: </nowiki>

gtk.Menu()

This function creates a GtkMenu that allows Hildon specific styling.

When you use a GtkMenu in your Hildon application, consider how many menu items you are going to use, because screen space is limited. Also consider the fact that in the interests of keeping the UI clear, submenus are not allowed.

PyMaemo/UI tutorial/Toolbars

2009-10-15T20:18:27Z

200.184.118.130: /* Edit toolbars */

= Toolbars =
Toolbars usually simplify the customization of widget look and layout by grouping widgets. The Hildon framework provides two specialized toolbars: HildonFindToolbar and HildonEditToolbar. You can also use GtkToolbars in your Hildon application.

==Find toolbars ==
HildonFindToolbar is a toolbar that contains a search entry and a dropdown list with previously searched strings. An internal GtkListStore stores the items in the dropdown list. This list is a property of the widget called "list".

To create a HildonFindToolbar, use the following:

hildon.FindToolbar(label, model=None, column=-1)

In both functions the argument label is used as label which be displayed as label for the dropdown box.

The second function above allows you to set the model used for storing the dropdown box. Also indicate which column the search retrieves the string from.

If you use the first function to create the toolbar, set the properties "list" and "column" manually.

This widget provides the function f for set and retrieve the index in the model of the current active item on the combo. An index -1 indicates no active items in both functions.

def set_active(self, index)
def get_active(self)

To get the index of the most recently added item in the toolbar, use the following function:

def get_last_index(self)

Alternatively, you can use a GtkTreeIter to reference the current active item.

def set_active_iter(self, iter)
def get_active_iter(self)

After creating and properly setting up the toolbar, attach it to any window. HildonWindow provides the following function to attach a toolbar:

def add_toolbar(self, toolbar)

In case you need to add a common toolbar to all windows in your program, HildonProgram provides the following function to set and retrtieve a common toolbar to each window registered into the curretn program:

def set_common_toolbar(self, toolbar)
def get_common_toolbar(self)

Here a simple example that shows how to deal with a HildonFindToolbar.

[[Image:example-toolbar.png|400px]]

'''Example 4.1. Using a Find Toolbar'''

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 4.1, "Using a Find Toolbar"

import sys

import gobject
import gtk
import hildon

def on_history_append(toolbar, user_data):
# Get last added index
index = toolbar.get_last_index()

# Get the inner list
list = toolbar.get("list")

# Get the item
iter = list.get_iter_from_string("%d" % index)

item, = list.get(iter, 0)

print sys.stderr, "ADDED TO THE LIST : %s" % item

def main():
program = hildon.hildon_program_get_instance()
window = hildon.Window()

program.add_window(window)

# Create and populate history list model
store = gtk.ListStore(gobject.TYPE_STRING)

iter = store.append()
store.set(iter, 0, "Foo")

iter = store.append()
store.set(iter, 0, "Bar")

iter = store.append()
store.set(iter, 0, "Baz")

# Create find toolbar
toolbar = hildon.FindToolbar("Find", store, 0)

# Set item on index 0 as the current active
toolbar.set_active(0)

# Attach a callback to handle "history-append" signal
toolbar.connect_after("history-append", on_history_append, None)

# Attach toolbar to window
window.add_toolbar(toolbar)

window.show_all()

gtk.main()

if __name__ == "__main__":
main()

In the example above a callback is set to handle the signal "history-append", emitted by the toolbar when a new item is added to the history. Other signals like "history-append" can trigger additional actions when emitted.

Apart from the property which stores the internal list, other properties are available such as "max-characters", which set the maximum length of the search string. For a complete description of the signals and properties available, see the Hildon reference manual.

==Edit toolbars ==
Edit toolbars are implemented by the widget HildonEditToolbar. This widget is a toolbar to be used as a main control and navigation interface for the edit UI mode. The toolbar contains a label and two buttons, being one of them an arrow pointing backwards and the other a button to perform a certain action. It also displays a label which explain to the users the action that the second button performs and gives intructions on how to perform the action properly.

A typical example could be a view to delete several items in a list. The label would advise the user to select the desired items that will be deleted clicking the button.

Typically the toolbar is attached to an edit view (a HildonStackableWindow) used by the program to perform a certain editing action.

The action to be performed by clicking the action button should be implemented in a callback that handles the signal "button-clicked". More will be shown in the example.

To create a new HildonEditToolbar use:

hildon.EditToolbar(label = None, button = None)

If you have used the default constructor function you can set label and button label later using:

def set_label(self, label)
def set_button_label(self, label)

When the edit toolbar is configured, attach it to a window by using:

def add_toolbar(self, toolbar)

The example below shows how to use an edit toolbar. It has a main window containing a list of items plus a button that calls an edit view. The user can select several items and deleted by clicking the action button of the toolbar.

The action to be done by clicking the button should be implemented in a callback. It has to be attached to the signal "button-clicked". There is also another signal called "arrow-clicked", emitted when users click the arrow (to go back to the previous screen). Typically the callback for this later signal destroys the current edit view.

[[Image:Edit_toolbar_list_view.png|400px]]

'''Example 4.2. Using an Edit Toolbar'''

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 4.2, "Using an Edit Toolbar"

import gobject
import gtk
import hildon

store = None

def get_model():
global store

if store is not None:
return store

store = gtk.ListStore(gobject.TYPE_STRING)
for i in xrange(50):
str = "\nRow %d\n" % i
store.insert(i, [str])

return store

def create_treeview(tvmode):
tv = hildon.GtkTreeView(tvmode)
renderer = gtk.CellRendererText()
col = gtk.TreeViewColumn("Title", renderer, text=0)

tv.append_column(col)

# Set multiple selection mode
selection = tv.get_selection()
selection.set_mode(gtk.SELECTION_MULTIPLE)

model = get_model()

tv.set_model(model)

return tv

def delete_button_clicked(button, treeview):
selection = treeview.get_selection()

(model, selected_rows) = selection.get_selected_rows()

row_references = []
for path in selected_rows:
ref = gtk.TreeRowReference(model, path)
row_references.append(ref)

for ref in row_references:
path = ref.get_path()
iter = model.get_iter(path)
model.remove(iter)

def edit_window(button):
window = hildon.StackableWindow()
window.set_border_width(6)

# Create a new edit toolbar
toolbar = hildon.EditToolbar("Choose items to delete", "Delete")

area = hildon.PannableArea()
tree_view = create_treeview(gtk.HILDON_UI_MODE_EDIT)

# Add toolbar to the window
window.set_edit_toolbar(toolbar)

area.add(tree_view)
window.add(area)

toolbar.connect("button-clicked", delete_button_clicked, tree_view)

toolbar.connect_object("arrow-clicked", gtk.Window.destroy, window)

window.show_all()

# Set window to fullscreen
window.fullscreen()

def main():
window = hildon.StackableWindow()
window.connect("destroy", gtk.main_quit)

vbox = gtk.VBox(False, 10)
area = hildon.PannableArea()

tree_view = create_treeview(gtk.HILDON_UI_MODE_NORMAL)

button = hildon.GtkButton(gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT)
button.set_label("Delete some items")

area.add(tree_view)
vbox.pack_start(area, True, True, 0)
vbox.pack_start(button, False, False, 0)

window.add(vbox)

button.connect("clicked", edit_window)

window.show_all()

gtk.main()

if __name__ == "__main__":
main()

Most of the things related to HildonEditToolbar are in the function edit_window. It creates an edit view (a new HildonStackableWindow) containing a treeview where the user can select several items.

Note: the edit window is set to fullscreen hiding the usual window controls.

== Using GtkToolbars in Hildon applications ==
Use the widget GtkToolbar as you would use it in a GTK+ application, but consider the following:

* Use GtkToolbars when only one content item is visible (for example when editing a single image or editing a single email).
* Provide no menu commands or settings for hiding or showing toolbar. The toolbar is always shown in the view where you decided to put it.

Like the others toolbars, attach a GtkToolbar to a window by using:

def add_toolbar(self, toolbar)

The following example shows how to use a GtkToolBar. The use is very close to how it would be use in a normal GTK+ application.

[[Image:example-gtktoolbar.png|400px]]

'''Example 4.3. Using a GtkToolbar in a Hildon application'''

# Based on C code from:
# "Hildon Tutorial" version 2009-04-28
# Example 4.3, "Using a GtkToolbar in a Hildon application"

import gtk
import hildon

def app_quit(widget, data=None):
gtk.main_quit()

def on_clicked (toolbutton, index):
print "Index of clicked item : %d" % index

def main():
program = hildon.hildon_program_get_instance()
gtk.set_application_name("hildon-touch-selector example program")

window = hildon.StackableWindow()
program.add_window(window)

# Create a toolbar
toolbar = gtk.Toolbar()

# Add items to the toolbar
toolitem = gtk.ToolButton(gtk.image_new_from_stock(gtk.STOCK_HOME,
gtk.ICON_SIZE_LARGE_TOOLBAR),
"Home")
toolitem.connect("clicked", on_clicked, 0)
toolbar.insert(toolitem, 0)

toolitem = gtk.ToolButton(gtk.image_new_from_stock(gtk.STOCK_GO_BACK,
gtk.ICON_SIZE_LARGE_TOOLBAR),
"Back")
toolitem.connect("clicked", on_clicked, 1)
toolbar.insert(toolitem, 1)

toolitem = gtk.ToolButton(gtk.image_new_from_stock(gtk.STOCK_GO_FORWARD,
gtk.ICON_SIZE_LARGE_TOOLBAR),
"Forward")
toolitem.connect("clicked", on_clicked, 2)
toolbar.insert(toolitem, 2)

# Add toolbar to the window
window.add_toolbar(toolbar)

window.connect("destroy", app_quit)
window.show_all()
gtk.main()

if __name__ == "__main__":
main()

PyMaemo/HildonDesktop

2009-10-14T13:56:55Z

200.184.118.130: /* Example - Home widgets (Fremantle only) */

== Python bindings for libhildondesktop ==

These bindings allow to create the so called Hildon Home and Status Menu applets (or widgets, in Maemo 5). It consists of two binary packages:

* python-hildondesktop: the actual Python bindings. Can be used to write standalone widgets, or ones that can be added by the user using the "Add widget" option in Maemo 5.
* hildon-desktop-python-loader: this is a Hildon Desktop loader for Python plugins.

=== API changes for Fremantle ===

The libhildondesktop version in Fremantle contains some API changes that also reflect on the Python bindings. Namely, you should pay attention to the following differences when migrating Home Widgets from older Maemo releases to Fremantle:

* The base class for Home Widgets is now called "HomePluginItem", instead of the older "HomeItem" name.
* The base class for Status menu widgets is now called "StatusMenuItem", instead of the older "StatusBarItem".
* The callback function that is called by the load is now called "hd_plugin_get_object", instead of the older "hd_plugin_get_objects". This is so because in fremantle the plugin is can create only one plugin object.
* Also note that the "hd_plugin_get_object" function should return a single object, instead of a list.
* The returned object must be instantiated using the gobject.new() function (see the example below). This is necessary because the plugin-id property needs to be set, otherwise the hildon-home process will crash.

NOTE: this last requirement might change in future, to avoid the mentioned crash.

=== Example - Home widgets (Fremantle only) ===

The code below was based on the C example that can be found on the maemo-examples package sources [https://garage.maemo.org/svn/maemoexamples/branches/fremantle-sdk-testing/maemo-examples/hello-world-home.c].

<pre>
import gobject
import gtk
import hildondesktop

class HelloWorldButton(gtk.Button):
def __init__(self, padding):
gtk.Button.__init__(self)
icon_theme = gtk.icon_theme_get_default()
icon = icon_theme.load_icon("hello", 40, 0)
if icon is None:
icon = icon_theme.load_icon("qgn_list_gene_default_app", 40, 0)
icon_image = gtk.Image()
icon_image.set_from_pixbuf(icon)
icon_image.set_padding(padding, padding)
self.add(icon_image)
self.show_all()

class HelloWorldDialog(gtk.Dialog):
def __init__(self):
gtk.Dialog.__init__(self, "Hello World", None,
gtk.DIALOG_DESTROY_WITH_PARENT | gtk.DIALOG_NO_SEPARATOR,
("Close", gtk.RESPONSE_OK))
self.vbox.add(gtk.Label("Hello World!"))
self.show_all()

def hello_world_dialog_show(button):
dialog = HelloWorldDialog()
dialog.run()
dialog.destroy()

class HelloHomePlugin(hildondesktop.HomePluginItem):
__gtype_name__ = 'HelloHomePlugin'

def __init__(self):
hildondesktop.HomePluginItem.__init__(self)
button = HelloWorldButton(10)
button.connect("clicked", hello_world_dialog_show)
button.show_all()
self.add(button)

def hd_plugin_get_object():
return gobject.new(HelloHomePlugin, plugin_id="hello_world_home.desktop-0")

if __name__ == "__main__":
obj = hd_plugin_get_object()
obj.show_all()
gtk.main()
</pre>

=== Testing the example ===

First, add Fremantle extras-devel to the /etc/apt/sources.list in your scratchbox target and install the required packages:

<pre>
[sbox]> fakeroot apt-get install python-hildondesktop hildon-desktop-python-loader
</pre>

Save the example code shown above as /usr/lib/hildon-desktop/hello_world_home.py inside your FREMANTLE_X86 target. Next, save the following text as /usr/share/applications/hildon-home/hello_world_home.desktop:

<pre>
[Desktop Entry]
Name=Hello, World! (Python)
Comment=Example Home Python plugin
Type=python
X-Path=hello_world_home.py
</pre>

Make sure the hildon desktop and hildon-home are running. For that, you can use the following commands:

<pre>
[sbox]> export DISPLAY=:2 # if you are using scratchbox + Xephyr
[sbox]> af-sb-init.sh start
[sbox]> run-standalone.sh maemo-summoner /usr/bin/hildon-home.launch &
</pre>

Now you need to add the newly installed home widget to the desktop. For that you can either manually add it to the ~/.config/hildon-desktop/home.plugins file, or follow these instructions to add it using the Hildon Desktop interface:

# Click anywhere on the Maemo desktop background.
# You should see a "engine" icon on the top right. Click on it.
# It will be shown a menu bar containing "Desktop menu" and "Done". Click on "Desktop menu".
# You should now see a menu with 4 buttons. Click on the "Add widget" button.
# A menu containing the list of installed widgets will appear. Select the one we installed, called "Hello, World! (Python)".
# Finally, click on "Done".

You should then see the following (the images look distorted because they were taken on Xephyr):

[[Image:Hello_world_home_python1.png]]

After clicking on the widget button, you should see:

[[Image:Hello_world_home_python2.png]]

=== Example - Status menu widgets (Fremantle only) ===

The code below was based on the C example that can be found on the Maemo 5 Developer Guide [http://wiki.maemo.org/Documentation/Maemo_5_Developer_Guide/Application_Development/Writing_Desktop_Widgets#Status_Menu_widgets].
<pre>
import gobject
import gtk
import hildondesktop

class ExampleStatusPlugin(hildondesktop.StatusMenuItem):
__gtype_name__ = 'ExampleStatusPlugin'

def __init__(self):
hildondesktop.StatusMenuItem.__init__(self)

STATUS_AREA_EXAMPLE_ICON_SIZE = 22
icon_theme = gtk.icon_theme_get_default()
pixbuf = icon_theme.load_icon("general_email", STATUS_AREA_EXAMPLE_ICON_SIZE, gtk.ICON_LOOKUP_NO_SVG)
self.set_status_area_icon(pixbuf)

label = gtk.Label("Example message")
self.add(label)
self.show_all()

def hd_plugin_get_object():
return gobject.new(ExampleStatusPlugin, plugin_id="example_status_plugin")

if __name__ == "__main__":
obj = hd_plugin_get_object()
obj.show_all()
gtk.main()
</pre>

=== Testing the example ===

First, install the same packages needed for Home widgets, then save the example above as as /usr/lib/hildon-desktop/hello_world_status_menu.py inside your FREMANTLE_X86 target. Next, save the following text as /usr/share/applications/hildon-status-menu/hello_world_status_menu.desktop:

<pre>
[Desktop Entry]
Name=Hello, World! (Python)
Comment=Example Status Menu Python plugin
Type=python
X-Path=hello_world_status_menu.py
</pre>

Make sure the hildon desktop and hildon-status-menu are running. For that, you can use the following commands:

<pre>
[sbox]> export DISPLAY=:2 # if you are using scratchbox + Xephyr
[sbox]> af-sb-init.sh start
[sbox]> run-standalone.sh maemo-summoner /usr/bin/hildon-status-menu.launch &
</pre>

The example status menu widget should appear as soon as hildon-status-menu process is started, as the plugin used in this example is of the permanent category. See [http://wiki.maemo.org/Documentation/Maemo_5_Developer_Guide/Application_Development/Writing_Desktop_Widgets#Status_Menu_widgets] for more information of status menu widgets categories.

This is a screenshot taken on Xephyr showing how the widget will look like:

[[Image:Status-menu-1.png]]

When clicked, it will show the specified message, enclosed in a gtk.Label:

[[Image:Status-menu-2.png]]

PyMaemo/Python-GPSbt

2009-09-21T19:03:10Z

200.184.118.130: Python-GPSbt is a binding, based on libgpsbt, that provides access to GPS data through osso-gpsd.

== Introduction ==

Python-GPSbt is a binding, based on libgpsbt, that provides access to GPS data through osso-gpsd. It only depends on a Bluetooth GPS device already paired.
How it works

Libgpsbt allows to connect with Bluetooth GPS devices and uses osso-gpsd daemon to provide a socket where you can send/receive information.

After a gps.start() its possible to send commands (trhough query) and receive data from GPS. Almost all information acquired from socket is stored inside a structure called 'fix'. To fill it just call the get_fix(). It does a query to get all necessary information from GPS device.

To finish the Bluetooth connection just call the gps.stop() method, providing the context (returned by gps.start()).
API

* gpsbt.start - establishes a new GPS connection and returns a context. This one is is used to inform stop method what connection to be ended.

context = gps.start()

* gpsbt.stop - ends an active connection, passed through the context. gps.stop(context)
* gpsbt.gps() - the class that gets information from GPS. Through it its possible to query, get_fix, get_position, etc.
* gpsbt.gps.get_fix() - fills in the 'fix' structure with GPS data. The fields are: mode, time, ept, latitude, longitude, eph, altitude (meters), epv, track (degrees from true north), speed (knots), climb (meters per second), epd, eps and epc.
* gpsbt.gps.get_position() - its a shortcut to return (latitude, longitude) info.
* gpsbt.gps.query() - allows user to send one letter commands to the GPS device. Its possible to group a sequence of commands to send, e.g.:
** gpsbt.gps.query('a') fills in the altitude field of 'fix' structure
** gpsbt.gps.query('as') fills in the altitude and speed fields
* gpsbt.gps.satellites - contains a list of detected satellites, including information about usage and quality.

== Example ==

The code below shows how to connect with a GPS device, get data and close this connection:

import gpsbt
import time

def main():
context = gpsbt.start()

if context == None:
print 'Problem while connecting!'
return

# ensure that GPS device is ready to connect and to receive commands
time.sleep(2)
gpsdevice = gpsbt.gps()

# read 3 times and show information
for a in range(4):
gpsdevice.get_fix()
time.sleep(2)

# print information stored under 'fix' variable
print 'Altitude: %.3f'%gpsdevice.fix.altitude
# dump all information available
print gpsdevice

# ends Bluetooth connection
gpsbt.stop(context)

main()

Download source code [http://pymaemo.garage.maemo.org/documentation/python_gps_examples/gpsbt-example.py here].

Maemo Summit 2009/Submissions

2009-09-09T23:19:18Z

200.184.118.130:

= Talk submissions for Maemo Summit 2009 =

Please add your submission to this page at the bottom. Have a look at the [[../Call for content| Call for content]] for some guidelines.

Please follow the template for each presentation that you would like to submit. Thanks!

''Maemo Summit community content committee:
* Dave Neary
* Jamie Bennett
* Valério Valério
''
== Submission template ==

Copy & paste the following template, and fill in the details specific to your presentation.

=== Talk Title Goes Here ===
*Author name and contact details
*Intended audience (users/application developers/platform developers)
*Talk type (presentation/lightning talk)
*Abstract/description
: Abstract goes here. A two paragraph overview of the proposed talk content is sufficient.
*Additional Information (optional)
: Additional information on extra equipment you might need or something else goes here
*Author bio
: A short (1 paragraph) note about who the author is goes here

-----

== Talk Submissions ==

=== PySide: Python for Qt And Automatic Bindings Generation ===

* Marcelo Lira dos Santos - marcelo.lira@openbossa.org - setanta on #maemo
* Intended audience: application developers/platform developers
* Talk type: presentation
* Abstract/description:
: The Python bindings for the Maemo Platform provided by PyMaemo are an all-time favorite among the Maemo developer community. Python must keep up with the recent addition of Qt to the Nokia offering for Maemo developers.
: PySide are the Python bindings for Qt framework developed by INdT (Instuto Nokia de Tecnologia) [http://www.indt.org.br], and recently released under a LGPL license. The PySide [http://www.pyside.org] bindings target not only the desktop but were conceived to provide Qt for Python on the Maemo platform.
: Qt being a huge library, the task of creating bindings for any high level language must be automated as much as possible, while retaining the developer ability to adjust details to satisfy the particular target language demands. To tackle this problem, a binding generator for Python was developed based on QtScript Generator from Qt Development Frameworks. Developers of bindings for other Qt-based libraries could also benefit of this automated generation scheme.
: This talk will present PySide, describe its characteristics, show its current status on Maemo Platform and where the project is headed to. The binding generation tool will also be explained, as well as the common problems that arise when wrapping C++ libraries to high level languages such as Python.

*Author bio
: Marcelo is an active developer of PySide and PyMaemo projects at INdT and has been involved with Maemo apps development since N800. Nowadays he is working with automatic binding generation for C++ based libraries, like Qt.

=== From corporations to communities: responsible and effective engagement ===
*Randall "Texrat" Arnold, fabricator at cynicalsigns dot com, http://tabulacrypticum.wordpress.com
*Intended audience is Nokia PR; Nokia Maemo team; Maemo developer, tester and superuser community; other interested parties
*Talk type : best practice/lessons learned presentation
*Abstract/description
: The presentation covers the following subject areas: general best practices in the area of corporate/community relations and how they apply to Maemo, as well as possibly a post mortem of lessons learned vis a vis community outreach from both Maemo and user perspectives (via interviews).

: This will not be a "what Nokia did wrong" as much as it is a clear, appropriate guide for future public relations in the murky world of commercial enterprise meets open source development; a path forward
.
*Author bio
: I am a former Nokia employee (Alliance factory and DSNM trade customer logistics) who was a principal on the US launch team for the N800. As Quality Engineer I managed the delivery of 200 devices to CES 2007 and ensured quality on devices delivered until their production relocation to Mexico. I became one of the first Nokia employees to reach out to the new community of tablet software developers and have continued in a voluntary representative role. I also tested internal applications such as the enterprise support suite (including VPN) and field tested the N810 WiMAX Edition tablet. I also developed a prototype mobile auditing solution using the internet tablets. Today I still cover the internet tablets and their applications at http://tabulacrypticum.wordpress.com

=== Midgard2: Content repository for your tablet and the web ===
*Author: Henri Bergius, henri.bergius at iki dot fi
*Intended audience: Application Developers
*Talk type: presentation
*Abstract/description
: Midgard2 is an Open Source Content Repository providing an objectified view to the data and services surrounding it. At the basic level it abstracts the database access (SQLite, MySql, PostgreSQL) but this is only where it all starts. Serialization & replication, managing own storage objects, multi-process access to data are all covered. The fully object-oriented (GObject-oriented) API allows you to focus on the data, not the database syntax, regardless of what programming language you are working with. Midgard's content repository services allow you to easily write applications that keep their data synchronized between tablets, web and user's desktop computers.

*Author bio
: Henri Bergius is a former Viking based in the Nordic country of Finland. When he is not exploring the cave cities of Georgia or running with bulls in Pamplona, Bergie works on web services built on top of the Midgard toolkit. His company Nemein provides web solutions for several major companies in Finland and abroad. After half decade of regular web development, Henri got involved with free software in 1999 when he coordinated the public release of the Midgard content management system. Since then he has been actively working on integrating standards like RSS and Microformats into the system and traveling the world advocating for interoperation between open source CMSs. Henri's current passion is combining web services, mobile applications and socially produced geographical data together to build useful tools for travelers and mobile companies. To this end he is working on the GeoClue library that allows mobile Linux applications to easily become geo-aware. When duties allow, Bergie escapes the crunch to explore the hills of Lapland or rides his classic motorcycle. He is also an amateur pilot.

=== Developing applications using Plasma ===
* Artur Duque de Souza - asouza AT kde DOT org / morpheuz AT gmail DOT com
* Intended audience: application developers
*Talk type: presentation
*Abstract/description

: KDE4 brought a new concept of desktop called "Plasma" where everything is a "live object". To achieve this, a library called libplasma was created and this is a very powerful library that enables any application to create modular and rich UIs. During this presentation I'll talk more about libplasma and how it can help the developer to create more attractive and rich UIs easily.

*Author bio

: Linux user since 1997, MoRpHeUz (a.k.a. Artur de Souza) worked for IBM (Linux Technology Center) and currently is working for INdT as a researcher at the openBossa stream, developing open-source solutions for mobile devices. One of the main core developers of Canola 2, now he works on bringing rich UIs to Qt applications.

=== Extras/autobuilder/interfaces round-table ===
*Author: Ed Bartosh, Alexander Kanevskiy, Niels Breet
*Intended audience: application and platform developers
*Talk type: round-table
*Room: Oostelijk Meterhuis
*Duration: 1 hour
*Abstract/description
:The purpose of this round-table is to discuss future features that can be added to autobuilder and all Extras related services. We want to gather opinions and see what the needs of developers are. Suggestions about enhancements or new features are appreciated.
*Author bio
: Ed Bartosh and Alexander Kanevskiy both work at Nokia, in their spare time they work on the autobuilder for Extras. Niels Breet is the maemo.org webmaster, working on web services available at maemo.org.

=== Designing Emulators for Mobile Devices ===
*Marat Fayzullin - RST38h on #maemo
*Intended audience: application developers
*Talk type: presentation
*Abstract/description
: Computer system emulation has been known for years. Recent revolution in mobile hardware makes it possible to run usable emulators on mobile devices, but some problems still remain. Limited performance, lack of proper controls, and widely varying screen sizes make it difficult to provide users with proper experience. This presentation will describe how the above problems can be worked around.
*Author bio
: Marat Fayzullin is an independent application developer specializing in software emulation of computer hardware. He has authored and maintains eight different emulators (some free, others commercial) for multiple platforms, from MSDOS to Maemo and Symbian. See http://fms.komkon.org/ for details.

=== WebKit Community: How It Works ===
*Ariya Hidayat, ariya dot hidayat at nokia dot com
*Intended audience: application developers
*Talk type: introduction and workshop
*Abstract/description
: WebKit has evolved over time into one of the most compelling HTML rendering engine currently in use. As an open-source project it stands out because of its size and because of the special collaboration between volunteer developers and companies.
: This presentation is not so much a presentation in the classic sense but planned as an introduction to the team rules of the WebKit project, e.g. how to create patches, ask for review, get in contact with the developer, etc. It will be followed by an extended question and answers session that should cover the most important and mots common questions.

*Author bio
: Ariya is a software engineer at Nokia, Qt Development Frameworks in Oslo. He is an open-source advocate for almost a decade, writing code for projects like KDE, WebKit and of course Qt. He posts lots of examples for Qt Labs Blogs on a biweekly basis, under the pretext of attracting more developers to use Qt (and hopefully grabbing the Most Prolific Blogger award). Ariya obtained his PhD in the field of high-speed optical communications. He speaks English with an Asian accent and cannot play any musical instruments.

=== 10 Tips for Designing Mobile Widgets ===
*Author: [http://maemo.org/profile/view/rajeshlal Rajesh Lal], rajesh.lal at nokia dot com
*Intended audience: Widget Developers/Mobile Application Developers
*Talk type: Presentation

*Abstract/description
: Do you know why only 1 percent of Mobile Widgets are successful ? What makes some widgets thrive and used by millions, and others with equal functionality bite the dust ? Make no mistakes, design of a widget is not about graphics, color or fonts. This presentation will demystify this 'invisible' layer below the surface with 10 pragmatic tips. The tips will uncover some of the most useful, and often ignored standard design principles and how to apply them in a mobile context.

*Author bio
: Rajesh lal is a Designer, Author, Technology Evangelist, and a Senior Nokia Engineer with a decade of experience in Information Technology. He has been involved in Widget design and development for last 5 years and have authored multiple books on Gadgets and Widgets. He has experience in a variety of Mobile devices, namely Sony Mylo, Window's Mobile, Apple's Iphone, Nokia S60 and Maemo devices. His blog on design and user experience can be found at http://abcofdesign.com

=== Conboy, Tomboy and Snowy ===
*[http://maemo.org/profile/view/conny Cornelius Hald]
*Intended audience: users and application developers
*Talk type: lightning talk
*Abstract/description
: Short introduction to Conboy and the new (not yet released) features, which are online synchronization with Tomboy/Gnote via the Snowy web service and plug-in support. Could include a demo if wanted.

*Author bio
: I'm a computer science student looking for distraction while writing my final thesis.

=== Behaviour-Driven Development on Maemo ===
*[http://wiki.maemo.org/User:Japolinario Jose Teixeira]
*Intended audience: Application developers & platform developers
*Talk type: Kightning talk
*Abstract/description
: '''What''' is Behaviour-Driven Development (BDD)? '''Why''' BDD matters to Maemo developers? And '''How''' to setup and open-source BDD tool-chain for Maemo ? And, finally '''How''' to make BDD funnier on a N810 device with [http://www.ruby-lang.org Ruby], [http://rspec.info/ Rspec], [http://cukes.info/ Cucumber] and [http://doc.trolltech.com/4.5/qtscript.html QtScript].
* I already made a deep dive in the subject. I try now to capture the attention of others to follow.
*Author bio
: [http://wiki.maemo.org/User:Japolinario Jose Teixeira] participated in the development of the Maemo Application Framework as Nokia trainer. Right now, he his a full-time researcher, teaching IT in a Finnish university as well. On his free-time, he contributes to open-source projects and incite many others to to the same.

=== Maemo and oFono ===

* By Rémi Denis-Courmont (remi dot denis-courmont at nokia dot com) and Aki Niemi (aki dot niemi at nokia dot com)
* For platform developers
* Presentation (could be shortened to lightning talk but...)
* oFono is an open source telephony stack for Linux. It provides an easy-to-use D-Bus interface and has support for a variety of cellular modem hardware, including Nokia cellular modems. The project is a joint effort between Intel and Nokia.

:How is it different from earlier attempts? What is it all about? What can you do with Ofono and Nokia N900?

* For demoing purpose, the presenter will need to use his own laptop and Nokia devices.

* Rémi Denis-Courmont currently works for Nokia, where he maintains the Phonet stack for the Linux kernel, the Maemo platform and the Ofono project. Outside Nokia, he's also been involved in the VideoLAN project.

=== Maemo Platform Security: Consepts, Architecture, Implementation ===

* Elena Reshetova - elena.reshetova@nokia.com
* Intended audience: users, application developers, platform developers
* Talk type: presentation
* Abstract/description:

: The purpose of the Platform Security in the Maemo platform is to protect the owner of a Maemo-powered device from getting her personal, private data and passwords from being stolen and used for malicious purposes, to prevent a malware from misusing a device and incurring costs on user, to prevent a user from accidentally breaking the device and to make the platform meet the requirements set by such third party software that requires a safe execution environment.

: The main design goal is to have all this accomplished without any significant penalty in terms of performance or usability, by using established open standards and having as much of the implementation open-sourced as possible. Another goal is to minimize an entry barrier for 3rd party programmers by reusing the existing Linux programming environment and introducing only needed additional features.

: The presentation will cover the main concepts, architecture choices and implementation of the Maemo Platform Security.

*Author bio
: Elena is a senior security engineer and representative of Maemo security team at the Maemo summit. The current task of the team is development of the Maemo Security FW.

=== Hacking officially unsupported Bluetooth profiles to work in Fremantle ===
*Johan Hedberg - johan.hedberg at nokia.com
*Intended audience: users,application developers,platform developers
*Talk type: presentation
*Abstract/description
: Fremantle doesn't come with out-of-the-box support of several Bluetooth profiles that are could in theory be supported with upstream components. These include e.g. DUN, HID and PAN. The presentation intends to be a hands-on session demonstrating how to enable support for these profiles through the act of changing config files and random hacking.
*Author bio
: Johan has been a software developer in the Maemo team ever since the first Maemo device, the 770 came out. His main responsibility area is Bluetooth and through active upstream involvement he has become a co-maintainer of BlueZ.

=== Continous Integration with CruiseControl and Scratchbox ===
*Jani Mikkonen, ext dash jani dot mikkonen at nokia dot com, rasjani @ #mer
*Application developers / QA People
*Lightning talk / Can extend to presentation if interest demands
*Abstract/description
: Topic is about how to harness Cruisecontrol to full build / packaging / testing and repository update cycle for development teams big and small.
*Additional Information (optional)
: Projector for showing live demostration and own laptop.
*Author bio
: Jani has been working with Maemo since Diablo/N800 on various tasks from maintenance to testing and is a long time linux user with developer & bofh background.

=== Intelligent Usage of Fremantle Location Framework For Location-aware Applications ===

*Quanyi Sun
*Intended audience: users/application developers/platform developers
*Talk type: presentation
*Abstract/description
: Abstract:
Location API is part of the Maemo 5 (Fremantle) API offerings. The location API for the first time now has introduced concept of hybrid locationing methods, i.e., supports of multiple locationing technologies seemlessly in a transparent way. In addition to the benefits of hybrid locationing methods, there are some issues, e.g., power consumption, that must be handled properly in order to maximize the benefits.

This presentation intends to hightlight the major issues when using location API, and provides best recommendations for developing location-aware applications in Maemo 5.

*Author bio:
Quanyi Sun has been working for Maemo as technical product owner in location area, with 13+ years of industrial experiences, e.g., in mission-critical realtime onboard software project in my early days.

=== Tracker: Dial M for Metadata ===
*Ivan Frade <ifrade@gnome.org>
*Intended audience: application developers/platform developers
*Presentation
*Abstract/description
: Tracker is a freedesktop project (with GNOME roots) included in the maemo platform for the first time in maemo5. In fremantle it is a simple index engine with support for basic metadata. For harmattan Tracker takes a great leap forward becoming a central storage for *user information*. The important data for the user (contacts, messages, multimedia, ...) will not only be stored in an application independent way, but also in a "linkable" format. This enables a new user experience: it makes it possible to integrate contacts everywhere, mix IM/email/twitter history of a contact, and so on.

In this presentation, Application developers can see how data is linked and obtained from Tracker to enrich their applications; platform contributors can learn how to integrate new information sources.

*Author bio
: Ivan Frade is an open source enthusiast who works in nokia building a data management solution for maemo based on tracker. On his free time, helps the world to tag properly their Mp3s with his pet-project.

=== Mobile Office based on KOffice Open Source Project===
*Suresh Chande, suresh.chande at nokia.com
*Intended audience: Application & Platform developers
*Talk type: Presentation
*Abstract/description
: We will present here Mobile Office project developed for Fremantle based on KOffice, a QT based open source project.

*Additional Information (optional)
: We will demonstrate Mobile Office (KOffice) running on the N900.

*Author bio
: Suresh Chande, works for Nokia in Device R&D(Maemo ) as Technical Product Owner for the Office Domain. Suresh has worked at Nokia Research Center for over 11 years focusing Mobile Business and Enterprise Application research. His vision is to have Office tools free for use by everybody.

=== Designing QT application for Maemo 5 and Maemo 6===
*Sergiy Dubovik, sergiy dot dubovik "at sign" nokia point com
*Intended audience: application developers
*Talk type: presentation
*Abstract/description

:How application developers should design their applications to work on Maemo 5 and Maemo 6 platforms? Which widgets will be supported? How to handle possible virtual keyboard? Where to store application settings? Which QT services will be available? These questions will be answered.

*Additional information on extra equipment you might need or something else goes here
:Just a projector

*Author bio
:Sergiy Dubovik is a senior software developer working in Nokia, designing and developing UI frameworks for Harmattan program.

=== MicroB browser, why it fastest "Mozilla based" browser, features, extensions for MicroB ===
*Oleg Romashin, oleg dot romashin at nokia dot com / Nagineni Sudarsana
*Intended audience: application developers
*Talk type: presentation
*Abstract/description
: Maemo 5, MicroB browser currently is fastest "Mozilla based" browser available on mobile platform.
: This presentation is some sort of description of architecture and principles of MicroB browser, why it so fast, what is difference between MicroB and Fennec browser.
: Also some description about how to write extensions for MicroB browser.

=== ContextKit - context awareness for Maemo and everybody else ===
*Author: Marius Vollmer <marius.vollmer@nokia.com>
*Intended audience: application developers/platform developers)
*Type: presentation
*Abstract
A lot of information is available from sensors and other sources that can make applications more 'aware' of the situation that a mobile device is in. The current location is an obvious example.

A new ContextKit collects these information about the environment of a device, combines many of them into something more abstract and exports it all in the form of simple key/value pairs to applications and other consumers. A long list of 'standard' properties is defined.

This presentation introduces the ContextKit to application and platform developers.

*Author bio:
Marius moved to Helsinki some uncounted years ago to work for Nokia on the Maemo platform. Now he has to re-learn C++ and compensates for this by finally learning Perl as well.

=== BlueMaemo - Bluetooth HID mouse & keyboard for Maemo ===
*[http://maemo.org/profile/view/vdvsx/ Valério Valério]
*Intended audience: users
*Talk type: lightning talk
*Abstract/description
: BlueMaemo is a remote controller application that turns your Maemo device in a mixed Bluetooth keyboard-and-mouse device through the HID Bluetooth profile.
: This presentation will be a showcase of the application new UI, and some new features that will be introduced in Fremantle will be shown as well.

*Author bio
: Valério is a MSc researcher at University of Évora, Portugal. During his free time he have actively participated in several open source community's and projects.

=== Qt 4.6: What is comming ===

* Authors: Anselmo Lacerda Silveira de Melo - anselmo.melo AT openbossa DOT org / Jesus Sanchez-Palencia jesus.palencia AT openbossa DOT org
* Intended audience: application developers
* Talk type: presentation
* Abstract/description

The next release of Qt is comming with brand new features, such as the State Machine Framework, the Animations API, S60 port, Scoped Pointers, Anchor Layout, performance optimizations in QGraphicsView, Multi-touch Gestures, Audio Services, GraphicsEffects, etc. The goal of the talk is to provide an overview of the benefits of each new feature and how they shall change the development of Qt applications.
Also, some applications will be shown, running on Maemo 5 and S60, demonstrating how cross-platform Qt can be and what is ready for the new generation of Maemo devices.

* Author bio
Anselmo is a GNU/Linux user since 2002, works with Linux on embedded devices since 2006. Works for INdT as a researcher at the openBossa open-source stream, where develops rich UIs features for Qt and is also part of the Qt Labs Americas initiative. Whenever possible, he likes hunting bugs with the KDE Bugsquad.

Jesus works with Maemo since 2007, besides other embedded Linux projects since 2006. Has contributions to the ERESI project (Elf Reverse Engineering Software Interface), and nowadays works at openBossa, INdT open-source stream, where develops rich UIs features for Qt and is also part of the Qt Labs Americas initiative.

=== Spreading Qt in the New World ===

* Author: Anselmo Lacerda Silveira de Melo - anselmo.melo AT openbossa DOT org
* Intended audience: Users / Application Developers
* Talk type: lightning talk
* Abstract/description

An introduction to Qt Labs Americas (http://qtlabs.openbossa.org), an initiative of openBossa stream of INdT aiming to spread Qt in the American continent, starting in Brazil. What have been done, what are the future plans and how the community can benefit from it.

* Author bio

GNU/Linux user since 2002, works with Linux on embedded devices since 2006. Works for INdT as a researcher at the openBossa open-source stream where develops rich UIs features for Qt and is also part of the Qt Labs Americas initiative. Whenever possible, he likes hunting bugs with the KDE Bugsquad.

=== Next generation layouts in Qt 4.6 ===

* Author: Caio Marcelo de Oliveira Filho - caio.oliveira AT openbossa.org
* Author: Eduardo M. Fleury - eduardo.fleury AT openbossa.org
* Intended audience: Users / Application Developers
* Talk type: presentation
* Abstract/description

With the release of N900, the first Maemo phone from Nokia, the
importance of developing rich UI applications is higher than ever.
As a consequence, new challenges are posed to both application
and framework developers.

One of these challenges is how to distribute items on the screen
in a flexible and dynamic way. This talk will present the next
generation layouts we have been developing, together with Qt
Development Frameworks, to fullfil such requirements

We will cover the new QGraphicsAnchorLayout, to be released in
Qt 4.6, including the use cases that drove us, its usage and
examples showing the benefits of such technology.

* Author bio

Caio Marcelo de Oliveira Filho graduated in computer engineering at
UNICAMP (in Brazil) and GNU/Linux user for more than a decade.
Contributed to the development of Canola2 and the Enlightenment
Foundation Libraries. Today works for Openbossa/INdT developing new
solutions for mobile applications using Qt framework and related
technologies.

Eduardo Fleury is Brazilian, graduated as Computer Engineer at Unicamp, in 2006. Since then has been working in Linux-related projects. Currently works at INdT (Nokia Institute of Technology) developing, among other projects, the Qt framework. Has been working on tools designed for the creation of rich interfaces, including AnchorLayout and animated Layouts.

Talk:Maemo Summit 2009/Submissions

2009-08-03T12:54:30Z

200.184.118.130: /* Developments in The Qt WebKit Integration */

== Presentations under consideration ==

Please add comments you have about presentations under consideration here.

=== liqbase-playground ===

I would like to see this grouped with the other Fremantle Star projects into a keynote presentation. If we can get the majority of the other Star project authors together for this it would be a great talk. Feel free to submit a more liqbase focused talk if you have idea's for a longer session. -- [[User:baloo|baloo]] 22:48, 12 July 2009 (UTC)

'''Agreement: Propose Fremantle Stars plenary session, 10 to 15 mins each'''
'''Session confirmed, at least OMWeather, OSM2Go, liqbase and Mauku will present'''

=== Evangelizing Mer, and Tips on Promoting Your Own Project ===

Not sure this would stand up as a full session, suited more to a lightning talk? -- [[User:baloo|baloo]] 22:48, 12 July 2009 (UTC)

Unless the author came up with a bigger plane, I also vote to convert it in a LT. --[[User:vdvsx| Valério Valério]] 09:33, 13 July 2009 (UTC)

I think an evangelisation presentation might be good. Let's see what else comes along in that style before saying yes. --[[User:dneary|Dave Neary]] 15:36, 13 July 2009 (UTC)
:On reflection, I think that this is not a great and potentially interesting session to a large number of people. Voting no. --[[User:dneary|Dave Neary]] 13:48, 31 July 2009 (UTC)

'''Wait & see'''

=== How to speed up your Maemo application development ===

Yes from me although this is a pretty hard-core platform developer talk. ESbox and PluThon are important parts of tablet development and as a lightning session you could 'scratch the itch' of the attendee. Maybe a little more information about how you intend to do this as a full session? -- [[User:baloo|baloo]] 22:48, 12 July 2009 (UTC)

Maybe. Seems like an application developer presentation to me, rather than platform developer. Let's see what other proposals come in. --[[User:dneary|Dave Neary]] 15:36, 13 July 2009 (UTC)

'''Wait and see'''

=== Creating Python bindings for C libraries in Maemo ===

I don't think Python bindings for C in Maemo have something special/different than bindings for other linux 'distros'. Since we have a lot of proposed talks for the dev's track, I would prefer to have others instead of this one. Maybe a LT, but IMO, this is a big topic for a 5 min presentation. So is a no for me. --[[User:vdvsx| Valério Valério]] 11:46, 31 July 2009 (UTC)

There's already a pymaemo presentation, I think that we should leave it at that, and start solliciting presentations to fill gaps we have in the schedule. --[[User:dneary|Dave Neary]] 13:48, 31 July 2009 (UTC)
: It's been pointed out to me that there isn't. A pymaemo presentation ("RAD for Maemo with PyMaemo" or something like that) would be a pretty cool presentation. --[[User:dneary|Dave Neary]] 12:39, 3 August 2009 (UTC)

=== Developments in The Qt WebKit Integration ===

Is this a presentation about Webkit ''and'' its Qt wrapper, or just about the wrapper? I don't think the latter is a big enough subject to hold people's attention for a full presentation. --[[User:dneary|Dave Neary]] 13:48, 31 July 2009 (UTC)

Doing an introduction about WebKit is ofcourse a part of the presentation, and there will also be demos showing what is possible using the Qt API. Please keep in mind that there is not talk of a wrapper; each port of WebKit has to implement its own API using the WebCore + JavaScript engine, and as such the Qt API have API that are not found in any other port, such as a simple jQuery like API to manipulate the DOM. -- Kenneth 09:53, Aug 3rd 2009.

=== Development Nirvana: How Maemo Application Development Should Be ===

Nice talk proposal. I would encourage a portion of this talk be given over to audience comment too to hear their views. --[[User:baloo|baloo]] 12:49, 3 August 2009 (UTC)

=== Life outdoor event with Maemo ===

Could be part of the Stars keynote for OSM2Go. --[[User:dneary|Dave Neary]] 16:15, 30 July 2009 (UTC)

Agree. --[[User:vdvsx| Valério Valério]] 11:22, 31 July 2009 (UTC)

I like the subject, but I'm not sure it should be grouped with OSM2Go. There is a wider talk here that could look at geocaching, GPX recording for geotagging photo's, e.t.c. --[[User:baloo|baloo]] 12:45, 3 August 2009 (UTC)

'''Agreement: Propose Fremantle Stars plenary session, 10 to 15 mins each'''
'''Session confirmed, at least OMWeather, OSM2Go, liqbase and Mauku will present'''

=== Writing plugins for MAFW ===

I would like input from platform developers as to whether this is a subject they are really interested in. No objections to inclusion if it is. --[[User:dneary|Dave Neary]] 13:48, 31 July 2009 (UTC)

I would like to see this. MAFW is a big part of the framework and learning more about it would be good for developers. --[[User:baloo|baloo]] 12:50, 3 August 2009 (UTC)

=== Creating packages for the Maemo platform ===

Useful for the application developer. Should be a nice simple overview of Debian packaging, with examples and links to helpful tools for publishing. I'd like to see Jeremiah provide a more in-depth abstract. --[[User:dneary|Dave Neary]] 13:48, 31 July 2009 (UTC)

Some insights about maemo packaging will be also useful, maybe referring the little differences between maemo packaging and debian packaging. --[[User:vdvsx| Valério Valério]] 10:28, 3 August 2009 (UTC)

Definite yes from me. The troubles I've had packaging are a testament to the fact that this isn't always easy. --[[User:baloo|baloo]] 12:53, 3 August 2009 (UTC)

=== GUPnP and Rygel: The UPnP/DLNA solution for Maemo ===

Could be nice if the theme is "show people how to do cool shit with GUPnP and Rygel" instead of "explain how it was cool to make GUPnP and Rygel". --[[User:dneary|Dave Neary]] 13:48, 31 July 2009 (UTC)

Yes for a users oriented talk, as Dave described above. --[[User:vdvsx| Valério Valério]] 14:52, 31 July 2009 (UTC)

Indeed, this will make a better user talk. --[[User:baloo|baloo]] 12:39, 3 August 2009 (UTC)

=== Handheld Glom: Easy database applications. ===

Nice for the user track. Vote yes. --[[User:dneary|Dave Neary]] 13:48, 31 July 2009 (UTC)

Seems 'only' dev oriented to me. --[[User:vdvsx| Valério Valério]] 14:49, 31 July 2009 (UTC)

It's definitely for developers. It's a (simple) development environment. Users would only be interested in things that could be created with it. Also, there will be some technical discussion about features that Glom needs for Maemo. --[[User:murrayc|murrayc]] 10:29, 3 August 2009 (UTC)

=== maemo.org Bug Management ===

Big yes. I hope this presentation will 'open' the Bugzilla and Brainstorm platform for more people --[[User:vdvsx| Valério Valério]] 11:29, 31 July 2009 (UTC)

I'd like to see Andre provide much more detail in his abstract. Why should bpeople go? What's his goal in the session? A one sentence abstract isn't enough for me. --[[User:dneary|Dave Neary]] 13:48, 31 July 2009 (UTC)

=== Giving Great Presentations ===

Big yes, isn't directly related to maemo, but is a very good topic for the summit, willing to attend :) .--[[User:vdvsx| Valério Valério]] 11:25, 31 July 2009 (UTC)

No comment --[[User:dneary|Dave Neary]] 13:48, 31 July 2009 (UTC)

=== Money for nothing: Making money off free software ===
No comment --[[User:dneary|Dave Neary]] 13:48, 31 July 2009 (UTC)

=== Maemo documentation co-creation ===

Definitely yes, same expectations as for the Bugzilla session. --[[User:vdvsx| Valério Valério]] 11:37, 31 July 2009 (UTC)

No comment --[[User:dneary|Dave Neary]] 13:48, 31 July 2009 (UTC)

=== Automatic binding generation for Qt based libraries ===

== Accepted Presentation proposals ==

When presentations have been accepted and moved from the "Submissions" page to the schedule, the discussion about them is removed, but remains visible in the [http://wiki.maemo.org/index.php?title=Talk:Maemo_Summit_2009/Submissions&action=history history].

== Declined presentation proposals ==

=== Attracting the Masses ===

Presentation declined. We felt that the content wasn't compelling enough for the presentation, and there will be considerable duplication with presentations during the Nokia day, which will concentrate on cracking the mass market, and during the Fremantle Stars presentations we expect to have. Please add any comments you might have below. [[User:dneary|Dave Neary]] 16:45, 1 July 2009 (UTC)

* Daniel Gentleman, thoughtfix at gmail dot com or thoughtfix anywhere.
* Intended audience: Developers - but other parties may be interested
* Talk type: Presentation (req: projector with VGA or DVI input for a Keynote presentation)
* Abstract/description
: Tablets have hundreds of applications now - but who are they for? If the Internet Tablets are intended to attract a more mainstream mobile market, the maemo community needs to get in touch with the needs of the target market.
: The first part of this presentation will give an overview of the most popular applications on competing platforms. This information will be collected through app store sales/download counts, direct communication with a sampling of mobile consumers, and communication with some other high-profile mobile technology journalists. This will include actual applications, connectivity options, peripherals, interface (touch/keyboard/icon/etc) preferences, and related consumer desires.
: The second part of this presentation will give an overview of the state of the existing maemo platform including commercial partners, independent contributors, and ports of more popular Linux software.
: The conclusion will analyze mobile consumer desires compared to maemo offerings and, hopefully, give developers ideas on what they can write to make the platform more appealing.

*Author bio
: The seeds of TabletBlog started in 2005 when some geek named Daniel Gentleman picked up the original Nokia 770 and started a blog. Since then, I've published thousands of bits of material reaching millions of visitors and video views. So far, I've been present for the Nokia N800 launch in CES 2007, the N810 launch at the Web2Summit, BossaConference 2008 in Recife, Brazil, and the first Maemo Summit.

=== Challenges of Multimedia within a Freely Distributable Tablet Framework ===

Seems a little too abstract for a Maemo Summit as I think these issues effect a much wider audience. A good talk but again, in the interests of keeping this a very Maemo Summit focused event, I'm saying no unless a more compelling argument is there. -- [[User:baloo|baloo]] 22:48, 12 July 2009 (UTC)

Same opinion here, in the current state I say no. --[[User:vdvsx| Valério Valério]] 09:28, 13 July 2009 (UTC)

Same here. No. There are many more compelling Mer presentations possible. --[[User:dneary|Dave Neary]] 15:23, 13 July 2009 (UTC)

'''Agreement: No'''

* Author: Matthew Craig, mtc in #Mer
* Intended audience: Users and Platform engineers
* Talk type: Presentation
* Abstract/description
: Multimedia technology has the very real potential of framing the next generation of the web, and it is becoming a primary vehicle for communication worldwide. The Mer Project faces unique challenges in handling this important technology, as it based on embedded architectures and strives to be freely distributable. For example, license restrictions of MPEG technologies prevent the free distribution of the popular "MP3" audio playback. With the current and rapid adoption of HTML-5 Video specifications, these difficult challenges are ones that must be addressed immediately. This talk will review the obstacles, and the practical solutions, to using multimedia within the Mer Project.
* Author bio
: See ''Evangelizing Mer'' below.

Maemo Summit 2009/Submissions

2009-07-15T17:24:41Z

200.184.118.130: /* Talk Submissions */