From bea46f25697482098b137375e195ee102f11badc Mon Sep 17 00:00:00 2001 From: Max Usachev Date: Wed, 23 Jun 2010 09:55:25 +0300 Subject: [PATCH] more work on redesigning --- controller.py | 5 +- factory.py | 2 +- ui/hildon_ui/__init__.py | 2 + ui/hildon_ui/about.py | 36 +++++ ui/hildon_ui/common.py | 24 +++ ui/hildon_ui/configuration.py | 142 +++++++++++++++++ ui/hildon_ui/hildon_ui.py | 353 +++++++++++++++++++++++++++++++++++++++++ ui/hildon_ui/imports.py | 23 +++ ui/hildon_ui/info.py | 18 +++ ui/hildon_ui/search.py | 47 ++++++ ui/ui.py | 18 ++- 11 files changed, 667 insertions(+), 3 deletions(-) create mode 100644 ui/hildon_ui/__init__.py create mode 100644 ui/hildon_ui/about.py create mode 100644 ui/hildon_ui/common.py create mode 100644 ui/hildon_ui/configuration.py create mode 100644 ui/hildon_ui/hildon_ui.py create mode 100644 ui/hildon_ui/imports.py create mode 100644 ui/hildon_ui/info.py create mode 100644 ui/hildon_ui/search.py diff --git a/controller.py b/controller.py index f2f348f..278d57c 100644 --- a/controller.py +++ b/controller.py @@ -100,7 +100,8 @@ class MeabookController: def show_configuration_dialog(self): """Shows view Configuration Dialog.""" - self.view.create_configuration_dialog(self, self.config) + self.view.create_configuration_dialog(self, self.config.get_fields(), \ + self.config.get_order()) def show_fields_configuration_dialog(self, parent): """Shows FieldsConfigurationDialog.""" @@ -109,6 +110,7 @@ class MeabookController: self.get_localized_fields(), self.config.get_fields(), parent) if selected_fields is not None: self.config.set_fields(selected_fields) + return selected_fields def show_fields_order_configuration_dialog(self): """Shows FieldsOrderConfigurationDialog.""" @@ -117,6 +119,7 @@ class MeabookController: self.get_localized_fields(), self.config.get_order()) if selected_fields is not None: self.config.set_order(selected_fields) + return selected_fields def show_search_dialog(self): """Shows view Search Dialog.""" diff --git a/factory.py b/factory.py index a55e0f9..6aa8c7a 100644 --- a/factory.py +++ b/factory.py @@ -4,7 +4,7 @@ UI factory def app_factory(interface=None): if not interface or interface == 'hildon': - from meabook.ui.hildon_ui import HildonMeabook + from meabook.ui.hildon_ui.hildon_ui import HildonMeabook from meabook.renderers.hildon_renderer import HildonRenderer return HildonMeabook, HildonRenderer elif interface == 'text': diff --git a/ui/hildon_ui/__init__.py b/ui/hildon_ui/__init__.py new file mode 100644 index 0000000..139597f --- /dev/null +++ b/ui/hildon_ui/__init__.py @@ -0,0 +1,2 @@ + + diff --git a/ui/hildon_ui/about.py b/ui/hildon_ui/about.py new file mode 100644 index 0000000..d481a89 --- /dev/null +++ b/ui/hildon_ui/about.py @@ -0,0 +1,36 @@ +""" +About dialogs +""" + +import gtk +import hildon +from gettext import gettext as _ +from meabook.version import version + + +class AboutDialog(): + """Hildon About Dialog.""" + + def __init__(self): + pass + + def run(self): + dialog = hildon.Dialog() + dialog.set_title(_('About')) + info_label = gtk.Label() + info_label.set_use_markup(True) + info_label.set_justify(gtk.JUSTIFY_CENTER) + info_label.set_markup("" \ + "Meabook - " \ + "Enterprise address book\nVersion %s\n\n\nDevelopers:\nTanya Makova | tanyshk@gmail.com\nMax Usachev | maxusachev@gmail.com" \ + "\n" % version) + dialog.vbox.add(info_label) + dialog.vbox.show_all() + dialog.run() + dialog.destroy() diff --git a/ui/hildon_ui/common.py b/ui/hildon_ui/common.py new file mode 100644 index 0000000..8d0e010 --- /dev/null +++ b/ui/hildon_ui/common.py @@ -0,0 +1,24 @@ +""" +Common UI functions +""" + +import gtk +import hildon + + +def create_button(title, value): + """Create HildonButton.""" + + button = hildon.Button(gtk.HILDON_SIZE_AUTO | \ + gtk.HILDON_SIZE_FINGER_HEIGHT, \ + hildon.BUTTON_ARRANGEMENT_VERTICAL, title, value) + button.set_style(hildon.BUTTON_STYLE_PICKER) + button.set_alignment(0, 0, 0, 0) + return button + + +def create_menu_button(title): + """Create HildonMenu button.""" + + return hildon.Button(gtk.HILDON_SIZE_AUTO, \ + hildon.BUTTON_ARRANGEMENT_HORIZONTAL, title) diff --git a/ui/hildon_ui/configuration.py b/ui/hildon_ui/configuration.py new file mode 100644 index 0000000..ba5ae25 --- /dev/null +++ b/ui/hildon_ui/configuration.py @@ -0,0 +1,142 @@ +""" +Configuration dialogs +""" + +import gtk +import hildon +from gettext import gettext as _ +from meabook.ui.hildon_ui.common import create_button + + +class ConfigurationDialog: + """Main configuration dialog.""" + + def __init__(self, controller, fields_to_show, ordered_fields): + dialog = hildon.Dialog() + dialog.set_title(_('Settings')) + button_fields = create_button(_('Fields to show'), \ + self._update_value(None, fields_to_show)) + button_fields.connect('clicked', self.show_fields_settings_cb, dialog) + button_order = create_button(_('Fields order'), \ + self._update_value(None, ordered_fields)) + dialog.vbox.pack_start(button_fields, expand=False) + button_order.connect('clicked', self.show_order_settings_cb) + dialog.vbox.pack_start(button_order, expand=False) + dialog.vbox.show_all() + # create class attributes + self.dialog = dialog + self.controller = controller + + def run(self): + self.dialog.run() + self.dialog.destroy() + + def _update_value(self, widget, fields): + """Updates widget title.""" + + if fields is None: + return + value = ', '.join([_(field) for field in fields]) + if widget is not None: + widget.set_value(value) + return value + + def show_fields_settings_cb(self, widget, parent): + """Shows dialog for selecting fields to show.""" + + selected_fields = self.controller.show_fields_configuration_dialog( \ + parent) + self._update_value(widget, selected_fields) + + def show_order_settings_cb(self, widget): + """Shows dialog for setting fields order.""" + + selected_fields = \ + self.controller.show_fields_order_configuration_dialog() + self._update_value(widget, selected_fields) + + + +class FieldsConfigurationDialog(): + """Fields to show configuration dialog.""" + + def __init__(self, fields, fields_to_select, parent): + dialog = hildon.PickerDialog(parent) + dialog.set_title(_('Fields to show')) + selector = hildon.TouchSelector(text=True) + # fill items list + for field in fields.keys(): + selector.append_text(field) + selector.set_column_selection_mode( \ + hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE) + selector.unselect_all(0) + # mark necessary fields + model = selector.get_model(0) + for index, field in enumerate(fields.values()): + if field in fields_to_select: + selector.select_iter(0, model.get_iter(index), False) + dialog.set_selector(selector) + # creates class attributes + self.fields = fields + self.dialog = dialog + self.selector = selector + + def run(self): + if self.dialog.run() == gtk.RESPONSE_OK: + indexes = [item[0] for item in self.selector.get_selected_rows(0)] + self.dialog.destroy() + return [self.fields.values()[index] for index in indexes] + self.dialog.destroy() + return None + + + +class FieldsOrderConfigurationDialog(): + """Fields order configuration dialog.""" + + def __init__(self, fields, ordered_fields): + dialog = hildon.Dialog() + dialog.set_title(_('Fields order')) + pannable_area = hildon.PannableArea() + pannable_area.set_size_request_policy(hildon.SIZE_REQUEST_CHILDREN) + vbox = gtk.VBox() + for index, field in enumerate(ordered_fields): + button = create_button(' '.join([_('Position'), str(index)]), \ + _(field)) + button.connect('clicked', self.show_fields_chooser, fields.keys(), \ + dialog) + vbox.pack_start(button, expand=False) + pannable_area.add_with_viewport(vbox) + dialog.add_button(_('Done'), gtk.RESPONSE_OK) + dialog.vbox.pack_start(pannable_area) + dialog.vbox.show_all() + # create class attributes + self.dialog = dialog + self.fields = fields + self.widgets_box = vbox + + def run(self): + if self.dialog.run() == gtk.RESPONSE_OK: + selected_fields = [self.fields[button.get_value().decode('utf-8')] \ + for button in self.widgets_box.get_children()] + self.dialog.destroy() + return selected_fields + self.dialog.destroy() + return None + + def show_fields_chooser(self, widget, fields, parent): + """Shows dialog to select field from fields list.""" + + dialog = hildon.PickerDialog(parent) + dialog.set_title(_('Fields')) + selector = hildon.TouchSelector(text=True) + dialog.set_selector(selector) + selector.set_column_selection_mode( \ + hildon.TOUCH_SELECTOR_SELECTION_MODE_SINGLE) + # fill fields list + for field in fields: + selector.append_text(field) + dialog.run() + widget.set_value(selector.get_current_text()) + dialog.destroy() + diff --git a/ui/hildon_ui/hildon_ui.py b/ui/hildon_ui/hildon_ui.py new file mode 100644 index 0000000..10e046a --- /dev/null +++ b/ui/hildon_ui/hildon_ui.py @@ -0,0 +1,353 @@ +""" +Hildon UI for Meabook +""" + +import gtk +import hildon +import gobject +from gettext import gettext as _ +from meabook.constants import * +from meabook.ui.ui import MeabookUI +from meabook.ui.hildon_ui.common import * +from meabook.ui.hildon_ui.info import InfoDialog +from meabook.ui.hildon_ui.about import AboutDialog +from meabook.ui.hildon_ui.search import SearchDialog +from meabook.ui.hildon_ui.imports import ImportDialog +from meabook.ui.hildon_ui.configuration import ConfigurationDialog, \ + FieldsConfigurationDialog, FieldsOrderConfigurationDialog + + +def set_selector_content(selector, handler, items=[]): + """Updates selector widget content.""" + + selector.handler_block(handler) # temporary block handler + # setting new content + # model: name, internal_name, type + model = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_INT, \ + gobject.TYPE_STRING) + for name, internal_name, item_type in items: + model.append((name, internal_name, item_type)) + if selector.get_num_columns(): + selector.remove_column(0) + selector.append_text_column(model, False) + selector.unselect_all(0) + selector.handler_unblock(handler) # reconnect callback + + +def set_box_content(box, handler, items=[]): + """Updates box widget content.""" + + def on_button_click(widget): + handler(widget.get_title(), widget.get_data('iname')) + + for child in box.get_children(): + box.remove(child) + for title, value, internal_name, item_type in items: + button = create_button(title, value) + button.connect('clicked', on_button_click) + button.set_data('iname', internal_name) + button.set_relief(gtk.RELIEF_NONE) + button.show() + box.pack_start(button, expand=False) + + + +class HildonMeabook(MeabookUI): + """Main Meabook UI.""" + + def __init__(self, controller, renderer, config): + MeabookUI.__init__(self, controller, renderer, config) + self.handler = None + self.window = hildon.StackableWindow() + self.window.set_title(_('Meabook')) + self.window.connect('destroy', self.exit) + # create menu buttons + menu = hildon.AppMenu() + settings_button = create_menu_button(_('Settings')) + about_button = create_menu_button(_('About')) + import_button = create_menu_button(_('Import')) + search_button = create_menu_button(_('Search')) + # create filter widgets and connect signals + self.level1_filter = gtk.RadioButton(None, _('level1')) + self.level2_filter = gtk.RadioButton(self.level1_filter, _('level2')) + self.level3_filter = gtk.RadioButton(self.level2_filter, _('level3')) + for filter_widget in [self.level1_filter, self.level2_filter, \ + self.level3_filter]: + filter_widget.set_mode(False) + filter_widget.connect('toggled', self.apply_filter_cb) + # create items widgets + self.selector = hildon.TouchSelector() + self.box_container = hildon.PannableArea() + self.box = gtk.VBox() + # create search widgets + widgets_box = gtk.VBox() + self.search_widgets_box = gtk.HBox() + self.search_entry = hildon.Entry(gtk.HILDON_SIZE_AUTO | \ + gtk.HILDON_SIZE_FINGER_HEIGHT) + clear_search_entry_container = gtk.EventBox() + clear_search_entry_image = gtk.image_new_from_icon_name( \ + 'general_delete', gtk.HILDON_SIZE_FINGER_HEIGHT) + # connect signals + settings_button.connect('clicked', self.show_settings_dialog_cb) + about_button.connect('clicked', self.show_about_dialog_cb) + import_button.connect('clicked', self.show_import_dialog_cb) + search_button.connect('clicked', self.show_search_dialog_cb) + self.handler = self.selector.connect('changed', self.select_item_cb) + self.search_entry.connect('key-release-event', self.search_item_cb) + clear_search_entry_container.connect('button-press-event', \ + self.clear_search_entry_cb) + # packing widgets + # packing search widgets + clear_search_entry_container.add(clear_search_entry_image) + self.search_widgets_box.pack_start(self.search_entry, expand=True) + self.search_widgets_box.pack_start(clear_search_entry_container, \ + expand=False, padding=24) + # packing items widgets + self.box_container.add_with_viewport(self.box) + widgets_box.pack_start(self.selector, expand=True) + widgets_box.pack_start(self.box_container, expand=True) + widgets_box.pack_end(self.search_widgets_box, expand=False) + self.window.add(widgets_box) + # packing menu widgets + menu.add_filter(self.level1_filter) + menu.add_filter(self.level2_filter) + menu.add_filter(self.level3_filter) + menu.append(settings_button) + menu.append(import_button) + menu.append(search_button) + menu.append(about_button) + menu.show_all() + self.window.set_app_menu(menu) + self.window.show_all() + + def _show_ui(self, view='selector', show_search=False): + """Shows necessary widgets for selected view.""" + + if view == 'selector': + self.box_container.hide() + self.selector.show() + elif view == 'box': + self.selector.hide() + self.box_container.show_all() + else: + self.selector.hide() + self.box_container.hide() + if show_search: + self.search_entry.set_text('') + self.search_entry.set_placeholder(_('Enter search text here')) + self.search_widgets_box.show_all() + else: + self.search_widgets_box.hide() + + def _unfreeze_ui(self): + while gtk.events_pending(): + gtk.main_iteration(False) + + def _update_title(self, title): + if title is not None: + self.window.set_title(title) + + def _show_items_dialog(self, title, items, touch_selector_view=True): + """Creates dialog with items. If 'touch_selector_view' is True, + then items will be shown in TouchSelector widget, else each item + will be shown as Button in PannableArea.""" + + window = hildon.StackableWindow() + window.set_title(title) + if touch_selector_view: + container = hildon.TouchSelector() + handler = container.connect('changed', self.select_item_cb) + set_selector_content(container, handler, items) + else: + widgets_box = gtk.VBox() + container = hildon.PannableArea() + container.add_with_viewport(widgets_box) + set_box_content(widgets_box, self._show_item_dialog, items) + window.add(container) + window.show_all() + + def _show_item_dialog(self, title, entry_id): + """Shows detailed item information.""" + + def show_fields_settings_dialog_cb(widget, parent, entry_id, func): + self.controller.show_fields_configuration_dialog(parent) + func(parent, entry_id) + + def show_fields_order_settings_dialog_cb(widget, parent, entry_id, \ + func): + self.controller.show_fields_order_configuration_dialog() + func(parent, entry_id) + + def update_entry(window, entry_id): + # create widgets + entry = self.controller.get_item(entry_id) + widgets_table = gtk.Table(rows=1, columns=1) + info_box = gtk.VBox() + image_box = gtk.VBox() + pannable_area = hildon.PannableArea() + pannable_area.set_property('mov-mode', hildon.MOVEMENT_MODE_BOTH) + image = self.renderer.render_image(dict(entry)) + for fname, fvalue in entry: + if fname == 'image': + continue + button = self.renderer.render_button(_(fname) , fvalue, fname) + if fname in (FIELD_PHONE_HOME, FIELD_PHONE_GENERAL, \ + FIELD_PHONE_INTERNAL, FIELD_PHONE_MOBILE): + button.connect('clicked', self.call_cb) + info_box.pack_start(button, expand=False) + # pack widgets + image_box.pack_start(image, expand=False) + widgets_table.attach(image_box, 0, 1, 0, 1, xoptions=gtk.FILL| \ + gtk.SHRINK, yoptions=gtk.FILL, xpadding=14, ypadding=8) + pannable_area.add_with_viewport(info_box) + widgets_table.attach(pannable_area, 1, 2, 0, 1, ypadding=8) + child = window.get_child() + if child: + child.destroy() + window.add(widgets_table) + widgets_table.show_all() + + + # create widgets + window = hildon.StackableWindow() + window.set_title(title) + menu = hildon.AppMenu() + fields_button = create_menu_button(_('Fields to show')) + order_button = create_menu_button(_('Fields order')) + fields_button.connect('clicked', show_fields_settings_dialog_cb, \ + window, entry_id, update_entry) + order_button.connect('clicked', show_fields_order_settings_dialog_cb, \ + window, entry_id, update_entry) + menu.append(fields_button) + menu.append(order_button) + + update_entry(window, entry_id) + window.set_app_menu(menu) + menu.show_all() + window.show_all() + + + # Implementation of Base UI interface + def start(self): + self.apply_filter_cb(self.level1_filter) + gtk.main() + + def exit(self, event): + gtk.main_quit() + self.controller.stop() + + def create_information_dialog(self, title, message): + InfoDialog(title, message).run() + + def create_about_dialog(self): + AboutDialog().run() + + def create_import_dialog(self): + return ImportDialog().run() + + def create_progress_dialog(self, title=None): + self._update_title(title) + self._show_ui('hide', False) + hildon.hildon_gtk_window_set_progress_indicator(self.window, 1) + self._unfreeze_ui() + + def create_configuration_dialog(self, all_fields, fields_to_show, \ + ordered_fields): + dialog = ConfigurationDialog(all_fields, fields_to_show, ordered_fields) + dialog.run() + + def create_fields_configuration_dialog(self, all_fields, fields_to_show, \ + parent): + dialog = FieldsConfigurationDialog(all_fields, fields_to_show, parent) + return dialog.run() + + def create_fields_order_configuration_dialog(self, all_fields, \ + ordered_fields): + dialog = FieldsOrderConfigurationDialog(all_fields, ordered_fields) + return dialog.run() + + def create_search_dialog(self, controller): + results = SearchDialog(controller).run() + if results: + self._show_items_dialog(_('Search results'), + self.controller.get_files_by_pattern_ex(results[0], results[1]), + touch_selector_view=False) + + + # Hildon UI callbacks + def show_about_dialog_cb(self, widget): + """Shows About Dialog.""" + + self.controller.show_about_dialog() + + def show_import_dialog_cb(self, widget): + """Shows Import Dialog.""" + + if self.controller.show_import_dialog(): + self._show_ui('selector') + self.apply_filter_cb(self.level1_filter) + hildon.hildon_gtk_window_set_progress_indicator(self.window, 0) + + def show_settings_dialog_cb(self, widget): + """Shows Config dialog.""" + + self.controller.show_configuration_dialog() + + def show_search_dialog_cb(self, widget): + """Show Search dialog.""" + + self.controller.show_search_dialog() + + def apply_filter_cb(self, widget): + """Updates toplevel selector with different level items.""" + + if not widget.get_active(): + return + + self._update_title(' - '.join([_('Meabook'), widget.get_label()])) + + if widget == self.level1_filter: + self._show_ui() + set_selector_content(self.selector, self.handler, \ + self.controller.get_all_folders()) + elif widget == self.level2_filter: + self._show_ui() + set_selector_content(self.selector, self.handler, \ + self.controller.get_all_subfolders()) + else: + self._show_ui(view='box', show_search=True) + set_box_content(self.box, self._show_item_dialog, \ + self.controller.get_files_by_pattern()) + + def select_item_cb(self, widget, column): + """ + Emits when changes selector content. + Opens new StackableWindow with new content. + """ + + item_name, internal_name, item_type = \ + widget.get_model(0)[widget.get_active(0)] + if item_type == TYPE_DIRECTORY: + self._show_items_dialog(item_name, self.controller.get_items( \ + internal_name)) + else: + self._show_item_dialog(item_name, internal_name) + + def search_item_cb(self, widget, event): + """Emits every time when user enter letter in search entry.""" + + set_box_content(self.box, self._show_item_dialog, \ + self.controller.get_files_by_pattern(widget.get_text())) + widget.grab_focus() + + def clear_search_entry_cb(self, widget, event): + """Clears search entry content.""" + + self.search_entry.set_text('') + set_box_content(self.box, self._show_item_dialog, \ + self.controller.get_files_by_pattern()) + + def call_cb(self, widget): + """Make a phone call.""" + + self.controller.call(widget.get_value()) diff --git a/ui/hildon_ui/imports.py b/ui/hildon_ui/imports.py new file mode 100644 index 0000000..eebd952 --- /dev/null +++ b/ui/hildon_ui/imports.py @@ -0,0 +1,23 @@ +""" +Import dialogs +""" + +import gtk +import hildon +import gobject + + +class ImportDialog: + """Import dialog.""" + + def __init__(self): + chooser = gobject.new(hildon.FileChooserDialog, \ + action=gtk.FILE_CHOOSER_ACTION_OPEN) + chooser.set_property('show-files', True) + chooser.run() + self.path = chooser.get_filename() + chooser.destroy() + + def run(self): + return self.path + diff --git a/ui/hildon_ui/info.py b/ui/hildon_ui/info.py new file mode 100644 index 0000000..1350405 --- /dev/null +++ b/ui/hildon_ui/info.py @@ -0,0 +1,18 @@ +""" +Information dialogs +""" + +class InfoDialog: + def __init__(self, title, message): + self.title = title + self.message = message + + def run(self): + dialog = hildon.Dialog() + dialog.set_title(title) + label = gtk.Label(message) + dialog.vbox.add(label) + dialog.vbox.show_all() + dialog.run() + dialog.destroy() + diff --git a/ui/hildon_ui/search.py b/ui/hildon_ui/search.py new file mode 100644 index 0000000..0f12fbb --- /dev/null +++ b/ui/hildon_ui/search.py @@ -0,0 +1,47 @@ +""" +Search dialogs +""" + +import gtk +import hildon +from gettext import gettext as _ + + +class SearchDialog: + """Hildon Search Dialog.""" + + def __init__(self, controller): + self.controller = controller + + def run(self): + dialog = hildon.Dialog() + dialog.set_title(_('Search')) + + selector = hildon.TouchSelector(text=True) + #for item in ('cn', 'mobile'): + for item in self.controller.get_fields(): + selector.append_text(_(item)) + selector.set_active(0, 0) + + button = hildon.PickerButton(gtk.HILDON_SIZE_AUTO | \ + gtk.HILDON_SIZE_FINGER_HEIGHT, hildon.BUTTON_ARRANGEMENT_VERTICAL) + button.set_alignment(0, 0, 0, 0) + button.set_title(_("Search criterion")) + button.set_selector(selector) + + entry = hildon.Entry(gtk.HILDON_SIZE_AUTO | \ + gtk.HILDON_SIZE_FINGER_HEIGHT) + entry.set_placeholder(_("Enter search text here")) + + dialog.vbox.pack_start(button, expand=False) + dialog.vbox.pack_end(entry, expand=False) + dialog.vbox.show_all() + dialog.add_button(_('Search'), gtk.RESPONSE_OK) + response = dialog.run() + if response == gtk.RESPONSE_OK: + result = (self.controller.get_localized_fields()[ \ + button.get_value().decode('utf-8')], entry.get_text()) + dialog.destroy() + return result + dialog.destroy() + return False diff --git a/ui/ui.py b/ui/ui.py index 4f97ea7..4349e3e 100644 --- a/ui/ui.py +++ b/ui/ui.py @@ -5,7 +5,7 @@ General Meabook UI class MeabookUI: def __init__(self, controller, renderer, config): self.config = config - self.renderer = renderer + self.renderer = renderer self.controller = controller def start(self): @@ -22,6 +22,10 @@ class MeabookUI: """Creates About Dialog.""" pass + def create_import_dialog(self): + """Creates Import Dialog.""" + pass + def create_configuration_dialog(self, controller, config): """Creates Configuration Dialog.""" pass @@ -37,3 +41,15 @@ class MeabookUI: def create_progress_dialog(self): """Creates Progress Dialog.""" pass + + def create_fields_configuration_dialog(self): + """Creates Fields to show Configuration Dialog.""" + pass + + def create_fields_order_configuration_dialog(self): + """Creates Fields order Configuration Dialog.""" + pass + + def create_search_dialog(self): + """Creates Search Dialog.""" + pass -- 1.7.9.5