Editing PyMaemo/UI tutorial/Controls

Warning: You are not logged in. Your IP address will be recorded in this page's edit history.

The edit can be undone. Please check the comparison below to verify that this is what you want to do, and then save the changes below to finish undoing the edit.

Learn more about Contributing to the wiki.

{{main|Legacy Maemo 5 Documentation/Graphical UI Tutorial/Controls}}

Hildon provides a set of controls specially designed for touchscreens that allows to build simple and easy-to-use interfaces. This chapter explains how to use these widgets.

== Buttons ==

A Hildon application can use several types of buttons. Hildon provides specialized buttons derived from <code>GtkButton</code> which provide additional commodities specific to the Hildon framework. Using <code>GtkButton</code>s and <code>GtkToggleButton</code>s is also recommended.

===Hildon Button===

<code>HildonButton</code> is a <code>GtkButton</code> which usually contains two labels, title and value. It can also include an image.

To create a <code>HildonButton</code>, use the following function:
<source lang="python">
    button = hildon.Button(size, arrangement, title='', value='')
</source>
Note that in the creation of a <code>HildonButton</code> you must indicate the value for the properties "size" and "arrangement", choosing a Hildon size and a horizontal or vertical arrangement of the labels.

You can set and retrieve both labels by using the following convenience functions:
<source lang="python">
    hildon.Button.set_title(title)
    hildon.Button.set_value(value)
    title = hildon.Button.get_title()
    value = hildon.Button.get_value()
</source>
Alternatively, use the following function to set both labels of a <code>HildonButton</code>:
<source lang="python">
    hildon.Button.set_text(title, value)
</source>
To add images to <code>HildonButton</code>s, use the following functions to set and retrieve the current image: <code>hildon_button_set_image()</code> and <code>hildon_button_get_image()</code>.

You can also set the position of the image.
<source lang="python">
    hildon.Button.set_image_position(position)
</source>
Currently supported positions are <code>gtk.POS_LEFT</code> or <code>gtk.POS_RIGHT</code>.

The visual style (color, fonts, etc.) of a <code>HildonButton</code> can be changed by using the function <code>set_style()</code>. Use <code>hildon.BUTTON_STYLE_NORMAL</code> to make it look like a normal <code>HildonButton</code>, or <code>hildon.BUTTON_STYLE_PICKER</code> to make it look like a <code>HildonPickerButton</code>.

The next simple example shows how to create a <code>HildonButton</code>, set the label text and add an image.

'''Example 7.1. Example of a Hildon button with a label and an image'''
<source lang="python">
def create_button():
    # Create a hildon button
    button = hildon.Button(gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT,
                           hildon.BUTTON_ARRANGEMENT_VERTICAL)

# Set labels value
    button.set_text("Some title", "Some value")

# Set image
    image = gtk.image_new_from_stock(gtk.STOCK_INFO, gtk.ICON_SIZE_BUTTON)
    button.set_image(image)
    button.set_image_position(gtk.POS_RIGHT)

return button
</source>
===Hildon Check Button===

<code>HildonCheckButton</code> is a button that contains a label and a check box. The check box toggles between checked or unchecked.

To create a <code>HildonCheckButton</code>:
<source lang="python">
    button = hildon.CheckButton(size)
</source>
Note that, again, you must specify the size of the button.

You can retrieve or set the current state of the button with the following functions, respectively:
<source lang="python">
    is_active = hildon.CheckButton.get_active()
    hildon.CheckButton.set_active(is_active)
</source>
The signal "toggled" is emitted when the state of the button changes. A handler can be attached to this signal if a further action is required.

Here is a simple example which creates a check button and a simple callback to handle the signal "toggled".

'''Example 7.2. Example of a Hildon check button'''
<source lang="python">
def button_toggled(checkbutton):
    if (checkbutton.get_active()):
       print "Button is active"
    else:
       print "Button is not active"

def create_check_button():
    button = hildon.CheckButton(gtk.HILDON_SIZE_AUTO)
    button.set_label("Click me")
    button.connect("toggled", button_toggled)
    return button
</source>
==Using Gtk Buttons and Toggles==

As was said above, apart from Hildon specific buttons, use <code>GtkButton</code> and <code>GtkToggleButton</code> also in the Hildon framework.

===GtkButton===

If only a label is needed, you do not need to use <code>HildonButton</code>s and a <code>GtkButton</code> can be used instead. You can use it as you would do in a GTK application. The only change is the creation function that you must use:
<source lang="python">
    button = hildon.GtkButton(size)
</source>
This alternative constructor allows you to set a Hildon size for the newly create function.

===GtkToggleButton===

To create a <code>GtkToggleButton</code> in a Hildon application you should use:
<source lang="python">
    togglebutton = hildon.GtkToggleButton(size)
</source>
==GtkRadioButton==

To create a <code>GtkRadioButton</code> in a Hildon application, use:
<source lang="python">
    radiobutton = hildon.GtkRadioButton(size, group)
</source>
The most common use case of this type of buttons in a Hildon application is as filters in a application menu. For more information, see section Touch View Menu.

==Text display and handling ==

Text entry fields are used for entering one or more lines of plain text. Use a <code>HildonEntry</code> for a single-line text input or <code>HildonTextView</code> if you need a multi-line text input.

===Hildon Text Entry===

The <code>HildonEntry</code> is a GTK+ widget which represents a text entry. It is derived from the <code>GtkEntry</code> widget and provides additional commodities specific to the Hildon framework.

The main additional feature is a placeholder text to display if the entry is empty and not in focus.

Creating a new <code>HildonEntry</code>:
<source lang="python">
    entry = hildon.Entry(size)
</source>
Note that the creation function needs to specify a size from <code>HildonSizeType</code>.

The placeholder is stored as a property. To set it, use the following convenience function:
<source lang="python">
    hildon.Entry.set_placeholder(text)
</source>

Here's a very simple example showing how to create a <code>HildonEntry</code>.

'''Example 7.3. Example of a Hildon entry'''
<source lang="python">
def create_entry():
    entry = hildon.Entry(gtk.HILDON_SIZE_AUTO)
    entry.set_placeholder("First name")
    return entry
</source>
===Hildon Text Area===

The <code>HildonTextView</code> is a GTK+ widget which represents a text area in Hildon applications. It is derived from the <code>GtkTextView</code> widget and provides additional commodities specific to the Hildon framework.

Create a <code>HildonTextView</code>:
<source lang="python">
    textview = hildon.TextView()
</source>
Like for the <code>HildonEntry</code> presented above, you can store a placeholder as well using the function.
<source lang="python">
    hildon.TextView.set_placeholder(text)
</source>
The text that is being edited with a <code>HildonTextView</code> is represented by a object <code>GtkTextBuffer</code>. The following functions can be used to set and retrieve the buffer associated with a <code>HildonTextView</code>.
<source lang="python">
    hildon.TextView.set_buffer(buffer)
    textbuffer = hildon.TextView.get_buffer()
</source>
Here is an example that shows how to create a <code>HildonTextView</code> and how to set its placeholder. Also, the buffer is retrieved and a function is set as a handler to the "changed" of the buffer. The handler simply gets the text from the <code>HildonTextView</code>'s buffer and prints it.

'''Example 7.4. Example of a Hildon text view with a placeholder'''
<source lang="python">
def text_changed(buffer):
    start = buffer.get_start_iter()

end = buffer.get_end_iter()
    text = buffer.get_text(start, end, false)

print text

def create_text_view():
    text_view = hildon.TextView()
    text_view.set_placeholder("Type some text here")

buffer = text_view.get_buffer()
    buffer.connect("changed", text_changed)

return text_view
</source>
====Warning====

Although <code>HildonTextView</code> is derived from <code>GtkTextView</code>, <code>gtk_text_view_get_buffer()</code> and<code> gtk_text_view_set_buffer()</code> must never be used to get/set the buffer in this widget, <code>hildon_text_view_get_buffer()</code> and <code>hildon_text_view_set_buffer()</code> must be used instead.

==Notification widgets ==

To cover the main use cases regarding notification of users, Hildon provides banners and notes. Banner widgets display a text information during a certain period of time. Notes are specialized <code>GtkDialog</code>s that need a small amount of input from the user.

===Banners===

A <code>HildonBanner</code> is useful to display information which does not need any user response. This widget automatically disappears after a certain time period.

To create and show a banner, use the following function:
<source lang="python">
    banner = hildon.hildon_banner_show_information(widget, icon_name, text)

banner = hildon.hildon_banner_show_information_with_markup(widget, icon_name, markup)
</source>
All functions above require a widget as an argument that must be a pointer to the owner widget of the banner. Usually, the owner is the window that represents the currently displayed view.

Function <code>show_information()</code> shows a banner with the given text.

Function <code>show_informationf()</code> shows a banner which displays the text given by the printf-like formated string applied to the parameters that the rest of the function's arguments represent.

You can also apply a Pango markup and add some attributes to the displayed text. To do that, either use <code>show_information_with_markup()</code> to create the banner or setup the markup by calling <code>set_markup()</code> after the initialization. [@@COMMENT@@ LINK TO PANGO MARKUP]

====Warning====

Currently, icons are not displayed in banners, so any value that you pass as the icon_name is ignored.

The period of time after the banner automatically disappear is stored in the property "timeout" (in miliseconds). A convenience function to set this property is provided:

hildon.Banner.set_timeout(timeout)

====Banner example====

Here is a simple example showing how to setup and show an informational banner.

'''Example 7.5. Setting up an informational banner'''
<source lang="python">
    # Create a banner with a markup
    banner = hildon.Banner.show_information_with_markup(widget, None,   "<b>Information banner</b>")
    banner.set_timeout(9000)
</source>
===Note===

Only one timed banner can exist for each window in your application. If you spawn a new banner before the previous one has timed out, the first one is replaced.

====Notes====

<code>HildonNote</code>s are <code>GtkDialog</code>s designed to request a small amount of input from users. Usually, notes show an information text and buttons to confirm and cancel, for example, according to their type.

Unlike banners, notes always need a user action, that is, notes do not disappear automatically after a period of time.

The <code>HildonNote</code> widget provides functions to create and show different types of notes: information notes, confirmation notes and cancel notes.
<source lang="python">
def hildon_note_new_information(parent, description)
def hildon_note_new_information_with_icon_name(parent, description, icon_name)
def hildon_note_new_confirmation(parent, description)
def hildon_note_new_confirmation_with_icon_name(parent, description,  icon_name)
def hildon_note_new_cancel_with_progress_bar(parent, description, progressbar)
</source>
Every function to create notes receives as a parameter the parent window of the newly created note. This is important in order to allow the window manager to handle the windows properly.

====Information Notes====

Information notes are used to show an information to the users. This note disappears when user taps outside the note's area. Otherwise the note remains visible.

Here is an example of how to show an information note and handle the user's answer.

'''Example 7.6. Example of a Hildon information note'''
<source lang="python">
def show_information_note(parent):
    note = hildon.hildon_note_new_information(parent, \
        "Lorem ipsum dolor sit amet, consectetur adipiscing elit." \
        "Maecenas tristique dictum est. Aenean rhoncus aliquam mi." \
        "In hac habitasse platea dictumst.")

response = gtk.Dialog.run(note)

if response == gtk.RESPONSE_DELETE_EVENT:
        print "show_information_note: gtk.RESPONSE_DELETE_EVENT"
</source>
====Confirmation Notes====

Confirmation notes show an information text that is usually a question and two buttons labelled "Yes" and "No".

To create a confirmation note with the text you specify and two buttons labelled "Yes"/"No", use <code>hildon.Note.add_buttons()</code> as follows:

'''Example 7.7. Example of a Hildon confirmation note'''
<source lang="python">
def show_confirmation_note(parent):
    note = hildon.hildon_note_new_confirmation(parent, "Do you want foo ?")

response = gtk.Dialog.run(note)

if response == gtk.RESPONSE_DELETE_EVENT:
        print "show_information_note: gtk.RESPONSE_DELETE_EVENT"
</source>
Alternatively, you can use <code>hildon.Note.add_buttons()</code> to create a confirmation note with custom buttons.

'''Example 7.8. Example of a Hildon copnfirmation note with custom buttons'''
<source lang="python">
def show_confirmation_note_with_buttons(parent):
    note = hildon.hildon_note_new_confirmation(parent, "Do you want foo ?")
    note.add_buttons("ACCEPT", gtk.RESPONSE_OK, \
                     "CANCEL", gtk.RESPONSE_CANCEL, \
                     "DELETE", gtk.RESPONSE_DELETE_EVENT)

response = gtk.Dialog.run(note)

if response == gtk.RESPONSE_DELETE_EVENT:
        print "show_information_note: gtk.RESPONSE_DELETE_EVENT"
</source>

[[Category:Python]]

Please note that all contributions to maemo.org wiki may be edited, altered, or removed by other contributors. If you do not want your writing to be edited mercilessly, then do not submit it here.
You are also promising us that you wrote this yourself, or copied it from a public domain or similar free resource (see maemo.org wiki:Copyrights for details). Do not submit copyrighted work without permission!

Summary:

Cancel | Editing help (opens in new window)

Templates used on this page:

Template:Main (view source) (protected)

Retrieved from "http://wiki.maemo.org/PyMaemo/UI_tutorial/Controls"

Personal tools

Navigation

Views

Editing PyMaemo/UI tutorial/Controls

@@ Line 208: / Line 208: @@
 Function <code>show_informationf()</code> shows a banner which displays the text given by the printf-like formated string applied to the parameters that the rest of the function's arguments represent.
-You can also apply a Pango markup and add some attributes to the displayed text. To do that, either use <code>show_information_with_markup()</code> to create the banner or setup the markup by calling <code>set_markup()</code> after the initialization
+You can also apply a Pango markup and add some attributes to the displayed text. To do that, either use <code>show_information_with_markup()</code> to create the banner or setup the markup by calling <code>set_markup()</code> after the initialization. [@@COMMENT@@ LINK TO PANGO MARKUP]
 ====Warning====