From 8ac54bf6591a8f35f463393755a2558b3de1ece9 Mon Sep 17 00:00:00 2001 From: Ed Page Date: Sat, 16 Oct 2010 13:36:47 -0500 Subject: [PATCH] Removing GTK support --- data/gonvert.glade | 349 -------------------- src/gonvert_glade.py | 892 -------------------------------------------------- src/gtk_toolbox.py | 772 ------------------------------------------- src/hildonize.py | 766 ------------------------------------------- 4 files changed, 2779 deletions(-) delete mode 100644 data/gonvert.glade delete mode 100755 src/gonvert_glade.py delete mode 100644 src/gtk_toolbox.py delete mode 100755 src/hildonize.py diff --git a/data/gonvert.glade b/data/gonvert.glade deleted file mode 100644 index d3c809b..0000000 --- a/data/gonvert.glade +++ /dev/null @@ -1,349 +0,0 @@ - - - - - - Gonvert - - - True - - - True - - - True - _File - True - - - - - True - _Exit - True - - - - - - - - - - True - _Edit - True - - - True - - - gtk-find - True - True - True - - - - - - - - - True - _Help - True - - - - - True - _About - True - - - - - - - - - False - False - 0 - - - - - True - - - 260 - True - True - automatic - automatic - in - - - 250 - True - True - False - - - - - 0 - - - - - True - vertical - - - ERROR - True - True - True - False - - - False - 0 - - - - - True - - - True - True - False - ● - - - 0 - - - - - True - True - ● - - - 1 - - - - - 60 - True - 0.10000000149011612 - - - False - False - 2 - - - - - False - 1 - - - - - True - - - True - True - False - ● - - - 0 - - - - - True - True - ● - - - 1 - - - - - 60 - True - 0.10000000149011612 - - - False - False - 2 - - - - - False - 2 - - - - - True - vertical - - - 300 - True - True - never - automatic - - - True - queue - - - True - vertical - - - True - True - - - 0 - - - - - - - - - 0 - - - - - True - True - automatic - automatic - in - - - True - queue - - - True - True - False - word - - - - - - - 1 - - - - - 3 - - - - - True - - - gtk-find - True - True - True - True - True - - - - False - False - 0 - - - - - True - True - Enter unit to find here - ● - - - False - 1 - - - - - True - Press to find text. - center - - - False - False - 2 - - - - - True - True - True - - - True - gtk-close - 1 - - - - - 3 - - - - - False - 4 - - - - - 1 - - - - - 1 - - - - - - diff --git a/src/gonvert_glade.py b/src/gonvert_glade.py deleted file mode 100755 index 5dd5580..0000000 --- a/src/gonvert_glade.py +++ /dev/null @@ -1,892 +0,0 @@ -#!/usr/bin/env python -# -*- coding: UTF8 -*- - -from __future__ import with_statement - -import os -import math -import pickle -import logging - -import pango -import gobject -import gtk -import gtk.glade -import gtk.gdk - -import constants -import hildonize -import gtk_toolbox -import unit_data - -try: - import gettext -except ImportError: - _ = lambda x: x - gettext = None -else: - _ = gettext.gettext - - -_moduleLogger = logging.getLogger(__name__) - - -if gettext is not None: - gettext.bindtextdomain('gonvert', '/usr/share/locale') - gettext.textdomain('gonvert') - - -def change_menu_label(widgets, labelname, newtext): - item_label = widgets.get_widget(labelname).get_children()[0] - item_label.set_text(newtext) - - -def split_number(number): - try: - fractional, integer = math.modf(number) - except TypeError: - integerDisplay = number - fractionalDisplay = "" - else: - integerDisplay = str(integer) - fractionalDisplay = str(fractional) - if "e+" in integerDisplay: - integerDisplay = number - fractionalDisplay = "" - elif "e-" in fractionalDisplay and 0.0 < integer: - integerDisplay = number - fractionalDisplay = "" - elif "e-" in fractionalDisplay: - integerDisplay = "" - fractionalDisplay = number - else: - integerDisplay = integerDisplay.split(".", 1)[0] + "." - fractionalDisplay = fractionalDisplay.rsplit(".", 1)[-1] - - return integerDisplay, fractionalDisplay - - -class Gonvert(object): - - _glade_files = [ - os.path.join(os.path.dirname(__file__), "gonvert.glade"), - os.path.join(os.path.dirname(__file__), "../data/gonvert.glade"), - os.path.join(os.path.dirname(__file__), "../share/gonvert.glade"), - '/usr/share/gonvert/gonvert.glade', - ] - - UNITS_NAME_IDX = 0 - UNITS_VALUE_IDX = 1 - UNITS_SYMBOL_IDX = 2 - UNITS_INTEGER_IDX = 3 - UNITS_FRACTION_IDX = 4 - - def __init__(self): - self._unitDataInCategory = None - self._unit_sort_direction = False - self._value_sort_direction = False - self._units_sort_direction = False - self.__isPortrait = False - self._isFullScreen = False - self._clipboard = gtk.clipboard_get() - - self._find_result = [] # empty find result list - self._findIndex = 0 # default to find result number zero - - self._selectedCategoryName = '' # preset to no selected category - self._defaultUnitForCategory = {} # empty dictionary for later use - - #check to see if glade file is in current directory (user must be - # running from download untar directory) - for gladePath in self._glade_files: - if os.path.isfile(gladePath): - homepath = os.path.dirname(gladePath) - pixmapspath = "/".join((homepath, "pixmaps")) - widgets = gtk.glade.XML(gladePath) - break - else: - _moduleLogger.error("UI Descriptor not found!") - gtk.main_quit() - return - - self._mainWindow = widgets.get_widget('mainWindow') - self._app = hildonize.get_app_class()() - self._mainWindow = hildonize.hildonize_window(self._app, self._mainWindow) - - change_menu_label(widgets, 'fileMenuItem', _('File')) - change_menu_label(widgets, 'exitMenuItem', _('Exit')) - change_menu_label(widgets, 'helpMenuItem', _('Help')) - change_menu_label(widgets, 'aboutMenuItem', _('About')) - - self._categorySelectionButton = widgets.get_widget("categorySelectionButton") - self._categoryView = widgets.get_widget('categoryView') - - self._unitsView = widgets.get_widget('unitsView') - self._unitsView.set_property('rules_hint', 1) - self._unitsView_selection = self._unitsView.get_selection() - - self._unitName = widgets.get_widget('unitName') - self._unitValue = widgets.get_widget('unitValue') - self._previousUnitName = widgets.get_widget('previousUnitName') - self._previousUnitValue = widgets.get_widget('previousUnitValue') - - self._unitSymbol = widgets.get_widget('unitSymbol') - self._previousUnitSymbol = widgets.get_widget('previousUnitSymbol') - - self._unitDescription = widgets.get_widget('unitDescription') - - self._searchLayout = widgets.get_widget('searchLayout') - self._searchLayout.hide() - self._findEntry = widgets.get_widget('findEntry') - self._findLabel = widgets.get_widget('findLabel') - self._findButton = widgets.get_widget('findButton') - self._closeSearchButton = widgets.get_widget('closeSearchButton') - - self._unitsNameRenderer = gtk.CellRendererText() - self._unitsNameRenderer.set_property("scale", 0.75) - if constants.FORCE_HILDON_LIKE: - self._unitsNameRenderer.set_property("ellipsize", pango.ELLIPSIZE_END) - self._unitsNameRenderer.set_property("width-chars", 5) - self._unitNameColumn = gtk.TreeViewColumn(_('Name'), self._unitsNameRenderer) - self._unitNameColumn.set_property('resizable', True) - self._unitNameColumn.add_attribute(self._unitsNameRenderer, 'text', self.UNITS_NAME_IDX) - self._unitNameColumn.set_clickable(True) - self._unitNameColumn.connect("clicked", self._on_click_unit_column) - self._unitsView.append_column(self._unitNameColumn) - - renderer = gtk.CellRendererText() - renderer.set_property("xalign", 1.0) - renderer.set_property("alignment", pango.ALIGN_RIGHT) - hildonize.set_cell_thumb_selectable(renderer) - self._unitIntegerColumn = gtk.TreeViewColumn(_('Value'), renderer) - self._unitIntegerColumn.set_property('resizable', True) - self._unitIntegerColumn.add_attribute(renderer, 'text', self.UNITS_INTEGER_IDX) - self._unitIntegerColumn.set_clickable(True) - self._unitIntegerColumn.connect("clicked", self._on_click_unit_column) - self._unitsView.append_column(self._unitIntegerColumn) - - renderer = gtk.CellRendererText() - renderer.set_property("xalign", 0.0) - renderer.set_property("alignment", pango.ALIGN_LEFT) - renderer.set_property("scale", 0.75) - self._unitFractionalColumn = gtk.TreeViewColumn(_(''), renderer) - self._unitFractionalColumn.set_property('resizable', True) - self._unitFractionalColumn.add_attribute(renderer, 'text', self.UNITS_FRACTION_IDX) - self._unitFractionalColumn.set_clickable(True) - self._unitFractionalColumn.connect("clicked", self._on_click_unit_column) - self._unitsView.append_column(self._unitFractionalColumn) - - renderer = gtk.CellRendererText() - renderer.set_property("ellipsize", pango.ELLIPSIZE_END) - #renderer.set_property("scale", 0.5) - self._unitSymbolColumn = gtk.TreeViewColumn(_('Units'), renderer) - self._unitSymbolColumn.set_property('resizable', True) - self._unitSymbolColumn.add_attribute(renderer, 'text', self.UNITS_SYMBOL_IDX) - self._unitSymbolColumn.set_clickable(True) - self._unitSymbolColumn.connect("clicked", self._on_click_unit_column) - self._unitsView.append_column(self._unitSymbolColumn) - - self._unitModel = gtk.ListStore( - gobject.TYPE_STRING, # UNITS_NAME_IDX - gobject.TYPE_STRING, # UNITS_VALUE_IDX - gobject.TYPE_STRING, # UNITS_SYMBOL_IDX - gobject.TYPE_STRING, # UNITS_INTEGER_IDX - gobject.TYPE_STRING, # UNITS_FRACTION_IDX - ) - self._sortedUnitModel = gtk.TreeModelSort(self._unitModel) - columns = self._get_column_sort_stuff() - for columnIndex, (column, sortDirection, col_cmp) in enumerate(columns): - self._sortedUnitModel.set_sort_func(columnIndex, col_cmp) - self._unitsView.set_model(self._sortedUnitModel) - - #Insert a column into the category list even though the heading will not be seen - renderer = gtk.CellRendererText() - self._categoryColumn = gtk.TreeViewColumn('Title', renderer) - self._categoryColumn.set_property('resizable', 1) - self._categoryColumn.add_attribute(renderer, 'text', 0) - self._categoryView.append_column(self._categoryColumn) - - self._categoryModel = gtk.ListStore(gobject.TYPE_STRING) - self._categoryView.set_model(self._categoryModel) - #colourize each row differently for easier reading - self._categoryView.set_property('rules_hint', 1) - - #Populate the catagories list - for key in unit_data.UNIT_CATEGORIES: - row = (key, ) - self._categoryModel.append(row) - - #--------- connections to GUI ---------------- - self._mainWindow.connect("destroy", self._on_user_exit) - self._mainWindow.connect("key-press-event", self._on_key_press) - self._mainWindow.connect("window-state-event", self._on_window_state_change) - self._categorySelectionButton.connect("clicked", self._on_category_selector_clicked) - self._categoryView.connect("cursor-changed", self._on_click_category) - self._findButton.connect("clicked", self._on_find_activate) - self._findEntry.connect("activate", self._on_find_activate) - self._findEntry.connect("changed", self._on_findEntry_changed) - self._closeSearchButton.connect("clicked", self._on_toggle_search) - self._previousUnitValue.connect("changed", self._on_previous_unit_value_changed) - self._unitValue.connect("changed", self._on_unit_value_changed) - self._unitValue.connect("key-press-event", self._on_browse_key_press) - self._unitsView.connect("cursor-changed", self._on_click_unit) - self._unitsView.connect("key-press-event", self._on_browse_key_press) - if hildonize.GTK_MENU_USED: - widgets.get_widget("aboutMenuItem").connect("activate", self._on_about_clicked) - widgets.get_widget("searchMenuItem").connect("activate", self._on_toggle_search) - widgets.get_widget("exitMenuItem").connect("activate", self._on_user_exit) - - for scrollingWidgetName in ( - "unitsViewScrolledWindow", - ): - scrollingWidget = widgets.get_widget(scrollingWidgetName) - assert scrollingWidget is not None, scrollingWidgetName - scroller = hildonize.hildonize_scrollwindow(scrollingWidget) - scroller.show_all() - - # Simplify the UI - if hildonize.IS_HILDON_SUPPORTED or constants.FORCE_HILDON_LIKE: - self._categoryView.get_parent().hide() - self._unitsView.set_headers_visible(False) - self._previousUnitName.get_parent().hide() - self._unitDescription.get_parent().get_parent().hide() - else: - self._categorySelectionButton.hide() - - menu = hildonize.hildonize_menu( - self._mainWindow, - widgets.get_widget("mainMenuBar"), - ) - if not hildonize.GTK_MENU_USED: - button = gtk.Button("Search") - button.connect("clicked", self._on_toggle_search) - menu.append(button) - - button = hildonize.hildon.GtkRadioButton(gtk.HILDON_SIZE_AUTO, None) - button.set_label("Name") - menu.add_filter(button) - button.connect("clicked", self._on_click_menu_filter, self._unitNameColumn) - button.set_mode(False) - filterGroup = button - - button = hildonize.hildon.GtkRadioButton(gtk.HILDON_SIZE_AUTO, filterGroup) - button.set_label("Value") - menu.add_filter(button) - button.connect("clicked", self._on_click_menu_filter, self._unitIntegerColumn) - button.set_mode(False) - - button = hildonize.hildon.GtkRadioButton(gtk.HILDON_SIZE_AUTO, filterGroup) - button.set_label("Unit") - menu.add_filter(button) - button.connect("clicked", self._on_click_menu_filter, self._unitSymbolColumn) - button.set_mode(False) - - menu.show_all() - - if not hildonize.IS_HILDON_SUPPORTED: - _moduleLogger.info("No hildonization support") - - hildonize.set_application_name( - "%s - Unit Conversion Utility" % constants.__pretty_app_name__ - ) - iconPath = pixmapspath + '/gonvert.png' - if os.path.exists(iconPath): - self._mainWindow.set_icon(gtk.gdk.pixbuf_new_from_file(iconPath)) - else: - _moduleLogger.warn("Error: Could not find gonvert icon: %s" % iconPath) - - self._load_settings() - self._mainWindow.show() - - def _load_settings(self): - #Restore window size from previously saved settings if it exists and is valid. - windowDatPath = "/".join((constants._data_path_, "window.dat")) - if os.path.exists(windowDatPath): - saved_window = pickle.load(open(windowDatPath, "r")) - try: - a, b = saved_window['size'] - except KeyError: - pass - else: - self._mainWindow.resize(a, b) - try: - isFullscreen = saved_window["isFullscreen"] - except KeyError: - pass - else: - if isFullscreen: - self._mainWindow.fullscreen() - try: - isPortrait = saved_window["isPortrait"] - except KeyError: - pass - else: - if isPortrait ^ self.__isPortrait: - if isPortrait: - orientation = gtk.ORIENTATION_VERTICAL - else: - orientation = gtk.ORIENTATION_HORIZONTAL - self.set_orientation(orientation) - - #Restore selections from previously saved settings if it exists and is valid. - categoryIndex = 0 - selectedCategoryName = unit_data.UNIT_CATEGORIES[0] - selectionsDatPath = "/".join((constants._data_path_, "selections.dat")) - if os.path.exists(selectionsDatPath): - selections = pickle.load(open(selectionsDatPath, 'r')) - try: - self._defaultUnitForCategory = selections['selected_units'] - except KeyError: - pass - - try: - selectedCategoryName = selections['selected_category'] - except KeyError: - pass - else: - try: - categoryIndex = unit_data.UNIT_CATEGORIES.index(selectedCategoryName) - except ValueError: - _moduleLogger.warn("Unknown category: %s" % selectedCategoryName) - - self._categorySelectionButton.get_child().set_markup("%s" % selectedCategoryName) - self._categoryView.set_cursor(categoryIndex, self._categoryColumn, False) - self._categoryView.grab_focus() - - self._select_default_unit() - - def _save_settings(self): - """ - This routine saves the selections to a file, and - should therefore only be called when exiting the program. - - Update selections dictionary which consists of the following keys: - 'self._selectedCategoryName': full name of selected category - 'self._defaultUnitForCategory': self._defaultUnitForCategory dictionary which contains: - [categoryname: #1 displayed unit, #2 displayed unit] - """ - #Determine the contents of the selected category row - selected, iter = self._categoryView.get_selection().get_selected() - self._selectedCategoryName = self._categoryModel.get_value(iter, 0) - - selections = { - 'selected_category': self._selectedCategoryName, - 'selected_units': self._defaultUnitForCategory - } - selectionsDatPath = "/".join((constants._data_path_, "selections.dat")) - pickle.dump(selections, open(selectionsDatPath, 'w')) - - #Get last size of app and save it - window_settings = { - 'size': self._mainWindow.get_size(), - "isFullscreen": self._isFullScreen, - "isPortrait": self.__isPortrait, - } - windowDatPath = "/".join((constants._data_path_, "window.dat")) - pickle.dump(window_settings, open(windowDatPath, 'w')) - - def _refresh_columns(self): - self._unitsView.remove_column(self._unitNameColumn) - self._unitsView.remove_column(self._unitIntegerColumn) - self._unitsView.remove_column(self._unitFractionalColumn) - self._unitsView.remove_column(self._unitSymbolColumn) - - self._unitsView.append_column(self._unitNameColumn) - self._unitsView.append_column(self._unitIntegerColumn) - self._unitsView.append_column(self._unitFractionalColumn) - self._unitsView.append_column(self._unitSymbolColumn) - - def _clear_find(self): - # switch to "new find" state - self._find_result = [] - self._findIndex = 0 - - # Clear our user message - self._findLabel.set_text('') - - def _find_first(self): - assert len(self._find_result) == 0 - assert self._findIndex == 0 - findString = self._findEntry.get_text().strip().lower() - if not findString: - return - - # Gather info on all the matching units from all categories - for catIndex, category in enumerate(unit_data.UNIT_CATEGORIES): - units = unit_data.get_units(category) - for unitIndex, unit in enumerate(units): - loweredUnit = unit.lower() - if loweredUnit in findString or findString in loweredUnit: - self._find_result.append((category, unit, catIndex, unitIndex)) - - def _update_find_selection(self): - assert 0 < len(self._find_result) - - #check if next find is in a new category (prevent category changes when unnecessary - searchCategoryName = self._find_result[self._findIndex][0] - if self._selectedCategoryName != searchCategoryName: - self._categorySelectionButton.get_child().set_markup("%s" % searchCategoryName) - self._categoryView.set_cursor( - self._find_result[self._findIndex][2], self._categoryColumn, False - ) - - self._unitsView.set_cursor( - self._find_result[self._findIndex][3], self._unitNameColumn, True - ) - - def _find_next(self): - if len(self._find_result) == 0: - self._find_first() - else: - if self._findIndex == len(self._find_result)-1: - self._findIndex = 0 - else: - self._findIndex += 1 - - if not self._find_result: - self._findLabel.set_text('Text not found') - else: - self._update_find_selection() - resultsLeft = len(self._find_result) - self._findIndex - 1 - self._findLabel.set_text( - '%s result(s) left' % (resultsLeft, ) - ) - - def _find_previous(self): - if len(self._find_result) == 0: - self._find_first() - else: - if self._findIndex == 0: - self._findIndex = len(self._find_result)-1 - else: - self._findIndex -= 1 - - if not self._find_result: - self._findLabel.set_text('Text not found') - else: - self._update_find_selection() - resultsLeft = len(self._find_result) - self._findIndex - 1 - self._findLabel.set_text( - '%s result(s) left' % (resultsLeft, ) - ) - - def _toggle_find(self): - if self._searchLayout.get_property("visible"): - self._searchLayout.hide() - self._unitsView.grab_focus() - else: - self._searchLayout.show() - self._findEntry.grab_focus() - - def _unit_model_cmp(self, sortedModel, leftItr, rightItr): - leftUnitText = self._unitModel.get_value(leftItr, self.UNITS_NAME_IDX) - rightUnitText = self._unitModel.get_value(rightItr, self.UNITS_NAME_IDX) - return cmp(leftUnitText, rightUnitText) - - def _symbol_model_cmp(self, sortedModel, leftItr, rightItr): - leftSymbolText = self._unitModel.get_value(leftItr, self.UNITS_SYMBOL_IDX) - rightSymbolText = self._unitModel.get_value(rightItr, self.UNITS_SYMBOL_IDX) - return cmp(leftSymbolText, rightSymbolText) - - def _value_model_cmp(self, sortedModel, leftItr, rightItr): - #special sorting exceptions for ascii values (instead of float values) - if self._selectedCategoryName == "Computer Numbers": - leftValue = self._unitModel.get_value(leftItr, self.UNITS_VALUE_IDX) - rightValue = self._unitModel.get_value(rightItr, self.UNITS_VALUE_IDX) - else: - leftValueText = self._unitModel.get_value(leftItr, self.UNITS_VALUE_IDX) - leftValue = float(leftValueText) if leftValueText else 0.0 - - rightValueText = self._unitModel.get_value(rightItr, self.UNITS_VALUE_IDX) - rightValue = float(rightValueText) if rightValueText else 0.0 - return cmp(leftValue, rightValue) - - def _get_column_sort_stuff(self): - columns = ( - (self._unitNameColumn, "_unit_sort_direction", self._unit_model_cmp), - (self._unitIntegerColumn, "_value_sort_direction", self._value_model_cmp), - (self._unitFractionalColumn, "_value_sort_direction", self._value_model_cmp), - (self._unitSymbolColumn, "_units_sort_direction", self._symbol_model_cmp), - ) - return columns - - def _switch_category(self, category): - self._selectedCategoryName = category - self._unitDataInCategory = unit_data.UNIT_DESCRIPTIONS[self._selectedCategoryName] - - #Fill up the units descriptions and clear the value cells - self._clear_visible_unit_data() - nameLength = 0 - for key in unit_data.get_units(self._selectedCategoryName): - row = key, '0.0', self._unitDataInCategory[key][1], '0.', '0' - self._unitModel.append(row) - nameLength = max(nameLength, len(key)) - self._sortedUnitModel.sort_column_changed() - - if constants.FORCE_HILDON_LIKE: - maxCatCharWidth = int(nameLength * 0.75) - maxCharWidth = int(len("nibble | hexit | quadbit") * 0.75) - charWidth = min(maxCatCharWidth, maxCharWidth) - self._unitsNameRenderer.set_property("width-chars", charWidth) - - self._select_default_unit() - - def _clear_visible_unit_data(self): - self._unitDescription.get_buffer().set_text("") - self._unitName.set_text('') - self._unitValue.set_text('') - self._unitSymbol.set_text('') - - self._previousUnitName.set_text('') - self._previousUnitValue.set_text('') - self._previousUnitSymbol.set_text('') - - self._unitModel.clear() - - def _select_default_unit(self): - # Restore the previous historical settings of previously selected units - # in this newly selected category - defaultPrimary = unit_data.get_base_unit(self._selectedCategoryName) - defaultSecondary = "" - if self._selectedCategoryName in self._defaultUnitForCategory: - if self._defaultUnitForCategory[self._selectedCategoryName][0]: - defaultPrimary = self._defaultUnitForCategory[self._selectedCategoryName][0] - if self._defaultUnitForCategory[self._selectedCategoryName][1]: - defaultSecondary = self._defaultUnitForCategory[self._selectedCategoryName][1] - - units = unit_data.get_units(self._selectedCategoryName) - - #Restore oldest selection first. - if defaultPrimary: - try: - unitIndex = units.index(defaultPrimary) - except ValueError: - unitIndex = 0 - self._unitsView.set_cursor(unitIndex, self._unitNameColumn, True) - - #Restore newest selection second. - if defaultSecondary: - try: - unitIndex = units.index(defaultSecondary) - except ValueError: - unitIndex = 0 - self._unitsView.set_cursor(unitIndex, self._unitNameColumn, True) - - # select the text so user can start typing right away - self._unitValue.grab_focus() - self._unitValue.select_region(0, -1) - - def _sanitize_value(self, userEntry): - if self._selectedCategoryName == "Computer Numbers": - if userEntry == '': - value = '0' - else: - value = userEntry - else: - if userEntry == '': - value = 0.0 - else: - value = float(userEntry) - return value - - def _select_sort_column(self, col): - #Determine which column requires sorting - columns = self._get_column_sort_stuff() - for columnIndex, (maybeCol, directionName, col_cmp) in enumerate(columns): - if col is maybeCol: - direction = getattr(self, directionName) - gtkDirection = gtk.SORT_ASCENDING if direction else gtk.SORT_DESCENDING - - # cause a sort - self._sortedUnitModel.set_sort_column_id(columnIndex, gtkDirection) - - # set the visual for sorting - col.set_sort_indicator(True) - col.set_sort_order(not direction) - - setattr(self, directionName, not direction) - break - else: - maybeCol.set_sort_indicator(False) - else: - assert False, "Unknown column: %s" % (col.get_title(), ) - - def set_orientation(self, orientation): - if orientation == gtk.ORIENTATION_VERTICAL: - hildonize.window_to_portrait(self._mainWindow) - self.__isPortrait = True - elif orientation == gtk.ORIENTATION_HORIZONTAL: - hildonize.window_to_landscape(self._mainWindow) - self.__isPortrait = False - else: - raise NotImplementedError(orientation) - - def get_orientation(self): - return gtk.ORIENTATION_VERTICAL if self.__isPortrait else gtk.ORIENTATION_HORIZONTAL - - def _toggle_rotate(self): - if self.__isPortrait: - self.set_orientation(gtk.ORIENTATION_HORIZONTAL) - else: - self.set_orientation(gtk.ORIENTATION_VERTICAL) - - @gtk_toolbox.log_exception(_moduleLogger) - def _on_key_press(self, widget, event, *args): - """ - @note Hildon specific - """ - RETURN_TYPES = (gtk.keysyms.Return, gtk.keysyms.ISO_Enter, gtk.keysyms.KP_Enter) - if ( - event.keyval == gtk.keysyms.F6 or - event.keyval in RETURN_TYPES and event.get_state() & gtk.gdk.CONTROL_MASK - ): - if self._isFullScreen: - self._mainWindow.unfullscreen() - else: - self._mainWindow.fullscreen() - elif event.keyval == gtk.keysyms.f and event.get_state() & gtk.gdk.CONTROL_MASK: - if not hildonize.GTK_MENU_USED: - self._toggle_find() - elif event.keyval == gtk.keysyms.p and event.get_state() & gtk.gdk.CONTROL_MASK: - self._find_previous() - elif event.keyval == gtk.keysyms.n and event.get_state() & gtk.gdk.CONTROL_MASK: - self._find_next() - elif event.keyval == gtk.keysyms.o and event.get_state() & gtk.gdk.CONTROL_MASK: - self._toggle_rotate() - elif ( - event.keyval in (gtk.keysyms.w, gtk.keysyms.q) and - event.get_state() & gtk.gdk.CONTROL_MASK - ): - self._mainWindow.destroy() - elif event.keyval == gtk.keysyms.l and event.get_state() & gtk.gdk.CONTROL_MASK: - with open(constants._user_logpath_, "r") as f: - logLines = f.xreadlines() - log = "".join(logLines) - self._clipboard.set_text(str(log)) - - @gtk_toolbox.log_exception(_moduleLogger) - def _on_toggle_search(self, *args): - self._toggle_find() - - @gtk_toolbox.log_exception(_moduleLogger) - def _on_browse_key_press(self, widget, event, *args): - if event.keyval == gtk.keysyms.uparrow or event.keyval == gtk.keysyms.Up: - index, column = self._unitsView.get_cursor() - newIndex = max(index[0]-1, 0) - path = (newIndex, ) - self._unitsView.set_cursor(path, column, True) - self._unitsView.scroll_to_cell(path, column, False, 0, 0) - return True # override default behavior - elif event.keyval == gtk.keysyms.downarrow or event.keyval == gtk.keysyms.Down: - index, column = self._unitsView.get_cursor() - newIndex = min(index[0]+1, len(self._unitModel)-1) - path = (newIndex, ) - self._unitsView.set_cursor(path, column, True) - self._unitsView.scroll_to_cell(path, column, False, 0, 0) - return True # override default behavior - - @gtk_toolbox.log_exception(_moduleLogger) - def _on_window_state_change(self, widget, event, *args): - """ - @note Hildon specific - """ - if event.new_window_state & gtk.gdk.WINDOW_STATE_FULLSCREEN: - self._isFullScreen = True - else: - self._isFullScreen = False - - @gtk_toolbox.log_exception(_moduleLogger) - def _on_findEntry_changed(self, *args): - """ - Clear out find results since the user wants to look for something new - """ - self._clear_find() - - @gtk_toolbox.log_exception(_moduleLogger) - def _on_find_activate(self, *args): - self._find_next() - self._findButton.grab_focus() - - @gtk_toolbox.log_exception(_moduleLogger) - def _on_click_menu_filter(self, button, col): - self._select_sort_column(col) - - @gtk_toolbox.log_exception(_moduleLogger) - def _on_click_unit_column(self, col): - """ - Sort the contents of the col when the user clicks on the title. - """ - self._select_sort_column(col) - - @gtk_toolbox.log_exception(_moduleLogger) - def _on_category_selector_clicked(self, *args): - currenntIndex = unit_data.UNIT_CATEGORIES.index(self._selectedCategoryName) - newIndex = hildonize.touch_selector( - self._mainWindow, - "Categories", - unit_data.UNIT_CATEGORIES, - currenntIndex, - ) - - selectedCategoryName = unit_data.UNIT_CATEGORIES[newIndex] - self._categorySelectionButton.get_child().set_markup("%s" % selectedCategoryName) - self._switch_category(selectedCategoryName) - - @gtk_toolbox.log_exception(_moduleLogger) - def _on_click_category(self, *args): - selected, iter = self._categoryView.get_selection().get_selected() - if iter is None: - # User is typing in an invalid string, not selecting any category - return - selectedCategory = self._categoryModel.get_value(iter, 0) - self._switch_category(selectedCategory) - - @gtk_toolbox.log_exception(_moduleLogger) - def _on_click_unit(self, *args): - selected, iter = self._unitsView.get_selection().get_selected() - selected_unit = selected.get_value(iter, self.UNITS_NAME_IDX) - unit_spec = self._unitDataInCategory[selected_unit] - - showSymbol = False - - if self._unitName.get_text() != selected_unit: - self._previousUnitName.set_text(self._unitName.get_text()) - self._previousUnitValue.set_text(self._unitValue.get_text()) - self._previousUnitSymbol.set_text(self._unitSymbol.get_text()) - if self._unitSymbol.get_text(): - showSymbol = True - - self._unitName.set_text(selected_unit) - self._unitValue.set_text(selected.get_value(iter, self.UNITS_VALUE_IDX)) - buffer = self._unitDescription.get_buffer() - buffer.set_text(unit_spec[2]) - self._unitSymbol.set_text(unit_spec[1]) # put units into label text - if unit_spec[1]: - showSymbol = True - else: - showSymbol = False - - if showSymbol: - self._unitSymbol.show() - self._previousUnitSymbol.show() - else: - self._unitSymbol.hide() - self._previousUnitSymbol.hide() - - if self._unitValue.get_text() == '': - if self._selectedCategoryName == "Computer Numbers": - self._unitValue.set_text("0") - else: - self._unitValue.set_text("0.0") - - self._defaultUnitForCategory[self._selectedCategoryName] = [ - self._unitName.get_text(), self._previousUnitName.get_text() - ] - - # select the text so user can start typing right away - self._unitValue.grab_focus() - self._unitValue.select_region(0, -1) - - @gtk_toolbox.log_exception(_moduleLogger) - def _on_unit_value_changed(self, *args): - if self._unitName.get_text() == '': - return - if not self._unitValue.is_focus(): - return - - #retrieve the conversion function and value from the selected unit - value = self._sanitize_value(self._unitValue.get_text()) - func, arg = self._unitDataInCategory[self._unitName.get_text()][0] - base = func.to_base(value, arg) - - #point to the first row - for row in self._unitModel: - func, arg = self._unitDataInCategory[row[self.UNITS_NAME_IDX]][0] - newValue = func.from_base(base, arg) - - newValueDisplay = str(newValue) - integerDisplay, fractionalDisplay = split_number(newValue) - - row[self.UNITS_VALUE_IDX] = newValueDisplay - row[self.UNITS_INTEGER_IDX] = integerDisplay - row[self.UNITS_FRACTION_IDX] = fractionalDisplay - - # Update the secondary unit entry - if self._previousUnitName.get_text() != '': - func, arg = self._unitDataInCategory[self._previousUnitName.get_text()][0] - self._previousUnitValue.set_text(str(func.from_base(base, arg, ))) - - self._sortedUnitModel.sort_column_changed() - self._refresh_columns() - - @gtk_toolbox.log_exception(_moduleLogger) - def _on_previous_unit_value_changed(self, *args): - if self._previousUnitName.get_text() == '': - return - if not self._previousUnitValue.is_focus(): - return - - #retrieve the conversion function and value from the selected unit - value = self._sanitize_value(self._previousUnitValue.get_text()) - func, arg = self._unitDataInCategory[self._previousUnitName.get_text()][0] - base = func.to_base(value, arg) - - #point to the first row - for row in self._unitModel: - func, arg = self._unitDataInCategory[row[self.UNITS_NAME_IDX]][0] - newValue = func.from_base(base, arg) - - newValueDisplay = str(newValue) - integerDisplay, fractionalDisplay = split_number(newValue) - - row[self.UNITS_VALUE_IDX] = newValueDisplay - row[self.UNITS_INTEGER_IDX] = integerDisplay - row[self.UNITS_FRACTION_IDX] = fractionalDisplay - - # Update the primary unit entry - func, arg = self._unitDataInCategory[self._unitName.get_text()][0] - self._unitValue.set_text(str(func.from_base(base, arg, ))) - - self._sortedUnitModel.sort_column_changed() - self._refresh_columns() - - @gtk_toolbox.log_exception(_moduleLogger) - def _on_about_clicked(self, a): - dlg = gtk.AboutDialog() - dlg.set_name(constants.__pretty_app_name__) - dlg.set_version("%s-%d" % (constants.__version__, constants.__build__)) - dlg.set_copyright("Copyright 2009 - GPL") - dlg.set_comments("") - dlg.set_website("http://unihedron.com/projects/gonvert/gonvert.php") - dlg.set_authors(["Anthony Tekatch ", "Ed Page (Blame him for the most recent bugs)"]) - dlg.run() - dlg.destroy() - - @gtk_toolbox.log_exception(_moduleLogger) - def _on_user_exit(self, *args): - try: - self._save_settings() - except Exception: - pass - finally: - gtk.main_quit() - - -def run_gonvert(): - gtk.gdk.threads_init() - if hildonize.IS_HILDON_SUPPORTED: - gtk.set_application_name(constants.__pretty_app_name__) - handle = Gonvert() - if not constants.PROFILE_STARTUP: - gtk.main() - - -if __name__ == "__main__": - logging.basicConfig(level = logging.DEBUG) - try: - os.makedirs(constants._data_path_) - except OSError, e: - if e.errno != 17: - raise - - run_gonvert() diff --git a/src/gtk_toolbox.py b/src/gtk_toolbox.py deleted file mode 100644 index f687e6b..0000000 --- a/src/gtk_toolbox.py +++ /dev/null @@ -1,772 +0,0 @@ -#!/usr/bin/python - -from __future__ import with_statement - -import os -import errno -import sys -import time -import itertools -import functools -import contextlib -import logging -import threading -import Queue - -import gobject -import gtk - - -_moduleLogger = logging.getLogger(__name__) - - -def get_screen_orientation(): - width, height = gtk.gdk.get_default_root_window().get_size() - if width < height: - return gtk.ORIENTATION_VERTICAL - else: - return gtk.ORIENTATION_HORIZONTAL - - -def orientation_change_connect(handler, *args): - """ - @param handler(orientation, *args) -> None(?) - """ - initialScreenOrientation = get_screen_orientation() - orientationAndArgs = list(itertools.chain((initialScreenOrientation, ), args)) - - def _on_screen_size_changed(screen): - newScreenOrientation = get_screen_orientation() - if newScreenOrientation != orientationAndArgs[0]: - orientationAndArgs[0] = newScreenOrientation - handler(*orientationAndArgs) - - rootScreen = gtk.gdk.get_default_root_window() - return gtk.connect(rootScreen, "size-changed", _on_screen_size_changed) - - -@contextlib.contextmanager -def flock(path, timeout=-1): - WAIT_FOREVER = -1 - DELAY = 0.1 - timeSpent = 0 - - acquired = False - - while timeSpent <= timeout or timeout == WAIT_FOREVER: - try: - fd = os.open(path, os.O_CREAT | os.O_EXCL | os.O_RDWR) - acquired = True - break - except OSError, e: - if e.errno != errno.EEXIST: - raise - time.sleep(DELAY) - timeSpent += DELAY - - assert acquired, "Failed to grab file-lock %s within timeout %d" % (path, timeout) - - try: - yield fd - finally: - os.unlink(path) - - -@contextlib.contextmanager -def gtk_lock(): - gtk.gdk.threads_enter() - try: - yield - finally: - gtk.gdk.threads_leave() - - -def find_parent_window(widget): - while True: - parent = widget.get_parent() - if isinstance(parent, gtk.Window): - return parent - widget = parent - - -def make_idler(func): - """ - Decorator that makes a generator-function into a function that will continue execution on next call - """ - a = [] - - @functools.wraps(func) - def decorated_func(*args, **kwds): - if not a: - a.append(func(*args, **kwds)) - try: - a[0].next() - return True - except StopIteration: - del a[:] - return False - - return decorated_func - - -def asynchronous_gtk_message(original_func): - """ - @note Idea came from http://www.aclevername.com/articles/python-webgui/ - """ - - def execute(allArgs): - args, kwargs = allArgs - with gtk_lock(): - original_func(*args, **kwargs) - return False - - @functools.wraps(original_func) - def delayed_func(*args, **kwargs): - gobject.idle_add(execute, (args, kwargs)) - - return delayed_func - - -def synchronous_gtk_message(original_func): - """ - @note Idea came from http://www.aclevername.com/articles/python-webgui/ - """ - - @functools.wraps(original_func) - def immediate_func(*args, **kwargs): - with gtk_lock(): - return original_func(*args, **kwargs) - - return immediate_func - - -def autostart(func): - """ - >>> @autostart - ... def grep_sink(pattern): - ... print "Looking for %s" % pattern - ... while True: - ... line = yield - ... if pattern in line: - ... print line, - >>> g = grep_sink("python") - Looking for python - >>> g.send("Yeah but no but yeah but no") - >>> g.send("A series of tubes") - >>> g.send("python generators rock!") - python generators rock! - >>> g.close() - """ - - @functools.wraps(func) - def start(*args, **kwargs): - cr = func(*args, **kwargs) - cr.next() - return cr - - return start - - -@autostart -def printer_sink(format = "%s"): - """ - >>> pr = printer_sink("%r") - >>> pr.send("Hello") - 'Hello' - >>> pr.send("5") - '5' - >>> pr.send(5) - 5 - >>> p = printer_sink() - >>> p.send("Hello") - Hello - >>> p.send("World") - World - >>> # p.throw(RuntimeError, "Goodbye") - >>> # p.send("Meh") - >>> # p.close() - """ - while True: - item = yield - print format % (item, ) - - -@autostart -def null_sink(): - """ - Good for uses like with cochain to pick up any slack - """ - while True: - item = yield - - -@autostart -def comap(function, target): - """ - >>> p = printer_sink() - >>> cm = comap(lambda x: x+1, p) - >>> cm.send((0, )) - 1 - >>> cm.send((1.0, )) - 2.0 - >>> cm.send((-2, )) - -1 - """ - while True: - try: - item = yield - mappedItem = function(*item) - target.send(mappedItem) - except Exception, e: - _moduleLogger.exception("Forwarding exception!") - target.throw(e.__class__, str(e)) - - -def _flush_queue(queue): - while not queue.empty(): - yield queue.get() - - -@autostart -def queue_sink(queue): - """ - >>> q = Queue.Queue() - >>> qs = queue_sink(q) - >>> qs.send("Hello") - >>> qs.send("World") - >>> qs.throw(RuntimeError, "Goodbye") - >>> qs.send("Meh") - >>> qs.close() - >>> print [i for i in _flush_queue(q)] - [(None, 'Hello'), (None, 'World'), (, 'Goodbye'), (None, 'Meh'), (, None)] - """ - while True: - try: - item = yield - queue.put((None, item)) - except Exception, e: - queue.put((e.__class__, str(e))) - except GeneratorExit: - queue.put((GeneratorExit, None)) - raise - - -def decode_item(item, target): - if item[0] is None: - target.send(item[1]) - return False - elif item[0] is GeneratorExit: - target.close() - return True - else: - target.throw(item[0], item[1]) - return False - - -def nonqueue_source(queue, target): - isDone = False - while not isDone: - item = queue.get() - isDone = decode_item(item, target) - while not queue.empty(): - queue.get_nowait() - - -def threaded_stage(target, thread_factory = threading.Thread): - messages = Queue.Queue() - - run_source = functools.partial(nonqueue_source, messages, target) - thread = thread_factory(target=run_source) - thread.setDaemon(True) - thread.start() - - # Sink running in current thread - return queue_sink(messages) - - -def log_exception(logger): - - def log_exception_decorator(func): - - @functools.wraps(func) - def wrapper(*args, **kwds): - try: - return func(*args, **kwds) - except Exception: - logger.exception(func.__name__) - - return wrapper - - return log_exception_decorator - - -class LoginWindow(object): - - def __init__(self, widgetTree): - """ - @note Thread agnostic - """ - self._dialog = widgetTree.get_widget("loginDialog") - self._parentWindow = widgetTree.get_widget("mainWindow") - self._serviceCombo = widgetTree.get_widget("serviceCombo") - self._usernameEntry = widgetTree.get_widget("usernameentry") - self._passwordEntry = widgetTree.get_widget("passwordentry") - - self._serviceList = gtk.ListStore(gobject.TYPE_INT, gobject.TYPE_STRING) - self._serviceCombo.set_model(self._serviceList) - cell = gtk.CellRendererText() - self._serviceCombo.pack_start(cell, True) - self._serviceCombo.add_attribute(cell, 'text', 1) - self._serviceCombo.set_active(0) - - widgetTree.get_widget("loginbutton").connect("clicked", self._on_loginbutton_clicked) - widgetTree.get_widget("logins_close_button").connect("clicked", self._on_loginclose_clicked) - - def request_credentials(self, - parentWindow = None, - defaultCredentials = ("", "") - ): - """ - @note UI Thread - """ - if parentWindow is None: - parentWindow = self._parentWindow - - self._serviceCombo.hide() - self._serviceList.clear() - - self._usernameEntry.set_text(defaultCredentials[0]) - self._passwordEntry.set_text(defaultCredentials[1]) - - try: - self._dialog.set_transient_for(parentWindow) - self._dialog.set_default_response(gtk.RESPONSE_OK) - response = self._dialog.run() - if response != gtk.RESPONSE_OK: - raise RuntimeError("Login Cancelled") - - username = self._usernameEntry.get_text() - password = self._passwordEntry.get_text() - self._passwordEntry.set_text("") - finally: - self._dialog.hide() - - return username, password - - def request_credentials_from(self, - services, - parentWindow = None, - defaultCredentials = ("", "") - ): - """ - @note UI Thread - """ - if parentWindow is None: - parentWindow = self._parentWindow - - self._serviceList.clear() - for serviceIdserviceName in services: - self._serviceList.append(serviceIdserviceName) - self._serviceCombo.set_active(0) - self._serviceCombo.show() - - self._usernameEntry.set_text(defaultCredentials[0]) - self._passwordEntry.set_text(defaultCredentials[1]) - - try: - self._dialog.set_transient_for(parentWindow) - self._dialog.set_default_response(gtk.RESPONSE_OK) - response = self._dialog.run() - if response != gtk.RESPONSE_OK: - raise RuntimeError("Login Cancelled") - - username = self._usernameEntry.get_text() - password = self._passwordEntry.get_text() - finally: - self._dialog.hide() - - itr = self._serviceCombo.get_active_iter() - serviceId = int(self._serviceList.get_value(itr, 0)) - self._serviceList.clear() - return serviceId, username, password - - def _on_loginbutton_clicked(self, *args): - self._dialog.response(gtk.RESPONSE_OK) - - def _on_loginclose_clicked(self, *args): - self._dialog.response(gtk.RESPONSE_CANCEL) - - -def safecall(f, errorDisplay=None, default=None, exception=Exception): - ''' - Returns modified f. When the modified f is called and throws an - exception, the default value is returned - ''' - def _safecall(*args, **argv): - try: - return f(*args,**argv) - except exception, e: - if errorDisplay is not None: - errorDisplay.push_exception(e) - return default - return _safecall - - -class ErrorDisplay(object): - - def __init__(self, widgetTree): - super(ErrorDisplay, self).__init__() - self.__errorBox = widgetTree.get_widget("errorEventBox") - self.__errorDescription = widgetTree.get_widget("errorDescription") - self.__errorClose = widgetTree.get_widget("errorClose") - self.__parentBox = self.__errorBox.get_parent() - - self.__errorBox.connect("button_release_event", self._on_close) - - self.__messages = [] - self.__parentBox.remove(self.__errorBox) - - def push_message_with_lock(self, message): - with gtk_lock(): - self.push_message(message) - - def push_message(self, message): - self.__messages.append(message) - if 1 == len(self.__messages): - self.__show_message(message) - - def push_exception_with_lock(self): - with gtk_lock(): - self.push_exception() - - def push_exception(self): - userMessage = str(sys.exc_info()[1]) - self.push_message(userMessage) - _moduleLogger.exception(userMessage) - - def pop_message(self): - del self.__messages[0] - if 0 == len(self.__messages): - self.__hide_message() - else: - self.__errorDescription.set_text(self.__messages[0]) - - def _on_close(self, *args): - self.pop_message() - - def __show_message(self, message): - self.__errorDescription.set_text(message) - self.__parentBox.pack_start(self.__errorBox, False, False) - self.__parentBox.reorder_child(self.__errorBox, 1) - - def __hide_message(self): - self.__errorDescription.set_text("") - self.__parentBox.remove(self.__errorBox) - - -class DummyErrorDisplay(object): - - def __init__(self): - super(DummyErrorDisplay, self).__init__() - - self.__messages = [] - - def push_message_with_lock(self, message): - self.push_message(message) - - def push_message(self, message): - if 0 < len(self.__messages): - self.__messages.append(message) - else: - self.__show_message(message) - - def push_exception(self, exception = None): - userMessage = str(sys.exc_value) - _moduleLogger.exception(userMessage) - - def pop_message(self): - if 0 < len(self.__messages): - self.__show_message(self.__messages[0]) - del self.__messages[0] - - def __show_message(self, message): - _moduleLogger.debug(message) - - -class MessageBox(gtk.MessageDialog): - - def __init__(self, message): - parent = None - gtk.MessageDialog.__init__( - self, - parent, - gtk.DIALOG_MODAL|gtk.DIALOG_DESTROY_WITH_PARENT, - gtk.MESSAGE_ERROR, - gtk.BUTTONS_OK, - message, - ) - self.set_default_response(gtk.RESPONSE_OK) - self.connect('response', self._handle_clicked) - - def _handle_clicked(self, *args): - self.destroy() - - -class MessageBox2(gtk.MessageDialog): - - def __init__(self, message): - parent = None - gtk.MessageDialog.__init__( - self, - parent, - gtk.DIALOG_DESTROY_WITH_PARENT, - gtk.MESSAGE_ERROR, - gtk.BUTTONS_OK, - message, - ) - self.set_default_response(gtk.RESPONSE_OK) - self.connect('response', self._handle_clicked) - - def _handle_clicked(self, *args): - self.destroy() - - -class PopupCalendar(object): - - def __init__(self, parent, displayDate, title = ""): - self._displayDate = displayDate - - self._calendar = gtk.Calendar() - self._calendar.select_month(self._displayDate.month, self._displayDate.year) - self._calendar.select_day(self._displayDate.day) - self._calendar.set_display_options( - gtk.CALENDAR_SHOW_HEADING | - gtk.CALENDAR_SHOW_DAY_NAMES | - gtk.CALENDAR_NO_MONTH_CHANGE | - 0 - ) - self._calendar.connect("day-selected", self._on_day_selected) - - self._popupWindow = gtk.Window() - self._popupWindow.set_title(title) - self._popupWindow.add(self._calendar) - self._popupWindow.set_transient_for(parent) - self._popupWindow.set_modal(True) - self._popupWindow.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG) - self._popupWindow.set_skip_pager_hint(True) - self._popupWindow.set_skip_taskbar_hint(True) - - def run(self): - self._popupWindow.show_all() - - def _on_day_selected(self, *args): - try: - self._calendar.select_month(self._displayDate.month, self._displayDate.year) - self._calendar.select_day(self._displayDate.day) - except Exception, e: - _moduleLogger.exception(e) - - -class QuickAddView(object): - - def __init__(self, widgetTree, errorDisplay, signalSink, prefix): - self._errorDisplay = errorDisplay - self._manager = None - self._signalSink = signalSink - - self._clipboard = gtk.clipboard_get() - - self._taskNameEntry = widgetTree.get_widget(prefix+"-nameEntry") - self._addTaskButton = widgetTree.get_widget(prefix+"-addButton") - self._pasteTaskNameButton = widgetTree.get_widget(prefix+"-pasteNameButton") - self._clearTaskNameButton = widgetTree.get_widget(prefix+"-clearNameButton") - self._onAddId = None - self._onAddClickedId = None - self._onAddReleasedId = None - self._addToEditTimerId = None - self._onClearId = None - self._onPasteId = None - - def enable(self, manager): - self._manager = manager - - self._onAddId = self._addTaskButton.connect("clicked", self._on_add) - self._onAddClickedId = self._addTaskButton.connect("pressed", self._on_add_pressed) - self._onAddReleasedId = self._addTaskButton.connect("released", self._on_add_released) - self._onPasteId = self._pasteTaskNameButton.connect("clicked", self._on_paste) - self._onClearId = self._clearTaskNameButton.connect("clicked", self._on_clear) - - def disable(self): - self._manager = None - - self._addTaskButton.disconnect(self._onAddId) - self._addTaskButton.disconnect(self._onAddClickedId) - self._addTaskButton.disconnect(self._onAddReleasedId) - self._pasteTaskNameButton.disconnect(self._onPasteId) - self._clearTaskNameButton.disconnect(self._onClearId) - - def set_addability(self, addability): - self._addTaskButton.set_sensitive(addability) - - def _on_add(self, *args): - try: - name = self._taskNameEntry.get_text() - self._taskNameEntry.set_text("") - - self._signalSink.stage.send(("add", name)) - except Exception, e: - self._errorDisplay.push_exception() - - def _on_add_edit(self, *args): - try: - name = self._taskNameEntry.get_text() - self._taskNameEntry.set_text("") - - self._signalSink.stage.send(("add-edit", name)) - except Exception, e: - self._errorDisplay.push_exception() - - def _on_add_pressed(self, widget): - try: - self._addToEditTimerId = gobject.timeout_add(1000, self._on_add_edit) - except Exception, e: - self._errorDisplay.push_exception() - - def _on_add_released(self, widget): - try: - if self._addToEditTimerId is not None: - gobject.source_remove(self._addToEditTimerId) - self._addToEditTimerId = None - except Exception, e: - self._errorDisplay.push_exception() - - def _on_paste(self, *args): - try: - entry = self._taskNameEntry.get_text() - addedText = self._clipboard.wait_for_text() - if addedText: - entry += addedText - self._taskNameEntry.set_text(entry) - except Exception, e: - self._errorDisplay.push_exception() - - def _on_clear(self, *args): - try: - self._taskNameEntry.set_text("") - except Exception, e: - self._errorDisplay.push_exception() - - -class TapOrHold(object): - - def __init__(self, widget): - self._widget = widget - self._isTap = True - self._isPointerInside = True - self._holdTimeoutId = None - self._tapTimeoutId = None - self._taps = 0 - - self._bpeId = None - self._breId = None - self._eneId = None - self._lneId = None - - def enable(self): - self._bpeId = self._widget.connect("button-press-event", self._on_button_press) - self._breId = self._widget.connect("button-release-event", self._on_button_release) - self._eneId = self._widget.connect("enter-notify-event", self._on_enter) - self._lneId = self._widget.connect("leave-notify-event", self._on_leave) - - def disable(self): - self._widget.disconnect(self._bpeId) - self._widget.disconnect(self._breId) - self._widget.disconnect(self._eneId) - self._widget.disconnect(self._lneId) - - def on_tap(self, taps): - print "TAP", taps - - def on_hold(self, taps): - print "HOLD", taps - - def on_holding(self): - print "HOLDING" - - def on_cancel(self): - print "CANCEL" - - def _on_button_press(self, *args): - # Hack to handle weird notebook behavior - self._isPointerInside = True - self._isTap = True - - if self._tapTimeoutId is not None: - gobject.source_remove(self._tapTimeoutId) - self._tapTimeoutId = None - - # Handle double taps - if self._holdTimeoutId is None: - self._tapTimeoutId = None - - self._taps = 1 - self._holdTimeoutId = gobject.timeout_add(1000, self._on_hold_timeout) - else: - self._taps = 2 - - def _on_button_release(self, *args): - assert self._tapTimeoutId is None - # Handle release after timeout if user hasn't double-clicked - self._tapTimeoutId = gobject.timeout_add(100, self._on_tap_timeout) - - def _on_actual_press(self, *args): - if self._holdTimeoutId is not None: - gobject.source_remove(self._holdTimeoutId) - self._holdTimeoutId = None - - if self._isPointerInside: - if self._isTap: - self.on_tap(self._taps) - else: - self.on_hold(self._taps) - else: - self.on_cancel() - - def _on_tap_timeout(self, *args): - self._tapTimeoutId = None - self._on_actual_press() - return False - - def _on_hold_timeout(self, *args): - self._holdTimeoutId = None - self._isTap = False - self.on_holding() - return False - - def _on_enter(self, *args): - self._isPointerInside = True - - def _on_leave(self, *args): - self._isPointerInside = False - - -if __name__ == "__main__": - if True: - win = gtk.Window() - win.set_title("Tap'N'Hold") - eventBox = gtk.EventBox() - win.add(eventBox) - - context = ContextHandler(eventBox, coroutines.printer_sink()) - context.enable() - win.connect("destroy", lambda w: gtk.main_quit()) - - win.show_all() - - if False: - import datetime - cal = PopupCalendar(None, datetime.datetime.now()) - cal._popupWindow.connect("destroy", lambda w: gtk.main_quit()) - cal.run() - - gtk.main() diff --git a/src/hildonize.py b/src/hildonize.py deleted file mode 100755 index 339eb2a..0000000 --- a/src/hildonize.py +++ /dev/null @@ -1,766 +0,0 @@ -#!/usr/bin/env python - -""" -Open Issues - @bug not all of a message is shown - @bug Buttons are too small -""" - - -import gobject -import gtk -import dbus - - -class _NullHildonModule(object): - pass - - -try: - import hildon as _hildon - hildon = _hildon # Dumb but gets around pyflakiness -except (ImportError, OSError): - hildon = _NullHildonModule - - -IS_HILDON_SUPPORTED = hildon is not _NullHildonModule - - -class _NullHildonProgram(object): - - def add_window(self, window): - pass - - -def _hildon_get_app_class(): - return hildon.Program - - -def _null_get_app_class(): - return _NullHildonProgram - - -try: - hildon.Program - get_app_class = _hildon_get_app_class -except AttributeError: - get_app_class = _null_get_app_class - - -def _hildon_set_application_name(name): - gtk.set_application_name(name) - - -def _null_set_application_name(name): - pass - - -try: - gtk.set_application_name - set_application_name = _hildon_set_application_name -except AttributeError: - set_application_name = _null_set_application_name - - -def _fremantle_hildonize_window(app, window): - oldWindow = window - newWindow = hildon.StackableWindow() - if oldWindow.get_child() is not None: - oldWindow.get_child().reparent(newWindow) - app.add_window(newWindow) - return newWindow - - -def _hildon_hildonize_window(app, window): - oldWindow = window - newWindow = hildon.Window() - if oldWindow.get_child() is not None: - oldWindow.get_child().reparent(newWindow) - app.add_window(newWindow) - return newWindow - - -def _null_hildonize_window(app, window): - return window - - -try: - hildon.StackableWindow - hildonize_window = _fremantle_hildonize_window -except AttributeError: - try: - hildon.Window - hildonize_window = _hildon_hildonize_window - except AttributeError: - hildonize_window = _null_hildonize_window - - -def _fremantle_hildonize_menu(window, gtkMenu): - appMenu = hildon.AppMenu() - window.set_app_menu(appMenu) - gtkMenu.get_parent().remove(gtkMenu) - return appMenu - - -def _hildon_hildonize_menu(window, gtkMenu): - hildonMenu = gtk.Menu() - for child in gtkMenu.get_children(): - child.reparent(hildonMenu) - window.set_menu(hildonMenu) - gtkMenu.destroy() - return hildonMenu - - -def _null_hildonize_menu(window, gtkMenu): - return gtkMenu - - -try: - hildon.AppMenu - GTK_MENU_USED = False - IS_FREMANTLE_SUPPORTED = True - hildonize_menu = _fremantle_hildonize_menu -except AttributeError: - GTK_MENU_USED = True - IS_FREMANTLE_SUPPORTED = False - if IS_HILDON_SUPPORTED: - hildonize_menu = _hildon_hildonize_menu - else: - hildonize_menu = _null_hildonize_menu - - -def _hildon_set_button_auto_selectable(button): - button.set_theme_size(hildon.HILDON_SIZE_AUTO_HEIGHT) - - -def _null_set_button_auto_selectable(button): - pass - - -try: - hildon.HILDON_SIZE_AUTO_HEIGHT - gtk.Button.set_theme_size - set_button_auto_selectable = _hildon_set_button_auto_selectable -except AttributeError: - set_button_auto_selectable = _null_set_button_auto_selectable - - -def _hildon_set_button_finger_selectable(button): - button.set_theme_size(hildon.HILDON_SIZE_FINGER_HEIGHT) - - -def _null_set_button_finger_selectable(button): - pass - - -try: - hildon.HILDON_SIZE_FINGER_HEIGHT - gtk.Button.set_theme_size - set_button_finger_selectable = _hildon_set_button_finger_selectable -except AttributeError: - set_button_finger_selectable = _null_set_button_finger_selectable - - -def _hildon_set_button_thumb_selectable(button): - button.set_theme_size(hildon.HILDON_SIZE_THUMB_HEIGHT) - - -def _null_set_button_thumb_selectable(button): - pass - - -try: - hildon.HILDON_SIZE_THUMB_HEIGHT - gtk.Button.set_theme_size - set_button_thumb_selectable = _hildon_set_button_thumb_selectable -except AttributeError: - set_button_thumb_selectable = _null_set_button_thumb_selectable - - -def _hildon_set_cell_thumb_selectable(renderer): - renderer.set_property("scale", 1.5) - - -def _null_set_cell_thumb_selectable(renderer): - pass - - -if IS_HILDON_SUPPORTED: - set_cell_thumb_selectable = _hildon_set_cell_thumb_selectable -else: - set_cell_thumb_selectable = _null_set_cell_thumb_selectable - - -def _hildon_set_pix_cell_thumb_selectable(renderer): - renderer.set_property("stock-size", 48) - - -def _null_set_pix_cell_thumb_selectable(renderer): - pass - - -if IS_HILDON_SUPPORTED: - set_pix_cell_thumb_selectable = _hildon_set_pix_cell_thumb_selectable -else: - set_pix_cell_thumb_selectable = _null_set_pix_cell_thumb_selectable - - -def _fremantle_show_information_banner(parent, message): - hildon.hildon_banner_show_information(parent, "", message) - - -def _hildon_show_information_banner(parent, message): - hildon.hildon_banner_show_information(parent, None, message) - - -def _null_show_information_banner(parent, message): - pass - - -if IS_FREMANTLE_SUPPORTED: - show_information_banner = _fremantle_show_information_banner -else: - try: - hildon.hildon_banner_show_information - show_information_banner = _hildon_show_information_banner - except AttributeError: - show_information_banner = _null_show_information_banner - - -def _fremantle_show_busy_banner_start(parent, message): - hildon.hildon_gtk_window_set_progress_indicator(parent, True) - return parent - - -def _fremantle_show_busy_banner_end(banner): - hildon.hildon_gtk_window_set_progress_indicator(banner, False) - - -def _hildon_show_busy_banner_start(parent, message): - return hildon.hildon_banner_show_animation(parent, None, message) - - -def _hildon_show_busy_banner_end(banner): - banner.destroy() - - -def _null_show_busy_banner_start(parent, message): - return None - - -def _null_show_busy_banner_end(banner): - assert banner is None - - -try: - hildon.hildon_gtk_window_set_progress_indicator - show_busy_banner_start = _fremantle_show_busy_banner_start - show_busy_banner_end = _fremantle_show_busy_banner_end -except AttributeError: - try: - hildon.hildon_banner_show_animation - show_busy_banner_start = _hildon_show_busy_banner_start - show_busy_banner_end = _hildon_show_busy_banner_end - except AttributeError: - show_busy_banner_start = _null_show_busy_banner_start - show_busy_banner_end = _null_show_busy_banner_end - - -def _hildon_hildonize_text_entry(textEntry): - textEntry.set_property('hildon-input-mode', 7) - - -def _null_hildonize_text_entry(textEntry): - pass - - -if IS_HILDON_SUPPORTED: - hildonize_text_entry = _hildon_hildonize_text_entry -else: - hildonize_text_entry = _null_hildonize_text_entry - - -def _hildon_window_to_portrait(window): - # gtk documentation is unclear whether this does a "=" or a "|=" - flags = hildon.PORTRAIT_MODE_SUPPORT | hildon.PORTRAIT_MODE_REQUEST - hildon.hildon_gtk_window_set_portrait_flags(window, flags) - - -def _hildon_window_to_landscape(window): - # gtk documentation is unclear whether this does a "=" or a "&= ~" - flags = hildon.PORTRAIT_MODE_SUPPORT - hildon.hildon_gtk_window_set_portrait_flags(window, flags) - - -def _null_window_to_portrait(window): - pass - - -def _null_window_to_landscape(window): - pass - - -try: - hildon.PORTRAIT_MODE_SUPPORT - hildon.PORTRAIT_MODE_REQUEST - hildon.hildon_gtk_window_set_portrait_flags - - window_to_portrait = _hildon_window_to_portrait - window_to_landscape = _hildon_window_to_landscape -except AttributeError: - window_to_portrait = _null_window_to_portrait - window_to_landscape = _null_window_to_landscape - - -def get_device_orientation(): - bus = dbus.SystemBus() - try: - rawMceRequest = bus.get_object("com.nokia.mce", "/com/nokia/mce/request") - mceRequest = dbus.Interface(rawMceRequest, dbus_interface="com.nokia.mce.request") - orientation, standState, faceState, xAxis, yAxis, zAxis = mceRequest.get_device_orientation() - except dbus.exception.DBusException: - # catching for documentation purposes that when a system doesn't - # support this, this is what to expect - raise - - if orientation == "": - return gtk.ORIENTATION_HORIZONTAL - elif orientation == "": - return gtk.ORIENTATION_VERTICAL - else: - raise RuntimeError("Unknown orientation: %s" % orientation) - - -def _hildon_hildonize_password_entry(textEntry): - textEntry.set_property('hildon-input-mode', 7 | (1 << 29)) - - -def _null_hildonize_password_entry(textEntry): - pass - - -if IS_HILDON_SUPPORTED: - hildonize_password_entry = _hildon_hildonize_password_entry -else: - hildonize_password_entry = _null_hildonize_password_entry - - -def _hildon_hildonize_combo_entry(comboEntry): - comboEntry.set_property('hildon-input-mode', 1 << 4) - - -def _null_hildonize_combo_entry(textEntry): - pass - - -if IS_HILDON_SUPPORTED: - hildonize_combo_entry = _hildon_hildonize_combo_entry -else: - hildonize_combo_entry = _null_hildonize_combo_entry - - -def _null_create_seekbar(): - adjustment = gtk.Adjustment(0, 0, 101, 1, 5, 1) - seek = gtk.HScale(adjustment) - seek.set_draw_value(False) - return seek - - -def _fremantle_create_seekbar(): - seek = hildon.Seekbar() - seek.set_range(0.0, 100) - seek.set_draw_value(False) - seek.set_update_policy(gtk.UPDATE_DISCONTINUOUS) - return seek - - -try: - hildon.Seekbar - create_seekbar = _fremantle_create_seekbar -except AttributeError: - create_seekbar = _null_create_seekbar - - -def _fremantle_hildonize_scrollwindow(scrolledWindow): - pannableWindow = hildon.PannableArea() - - child = scrolledWindow.get_child() - scrolledWindow.remove(child) - pannableWindow.add(child) - - parent = scrolledWindow.get_parent() - if parent is not None: - parent.remove(scrolledWindow) - parent.add(pannableWindow) - - return pannableWindow - - -def _hildon_hildonize_scrollwindow(scrolledWindow): - hildon.hildon_helper_set_thumb_scrollbar(scrolledWindow, True) - return scrolledWindow - - -def _null_hildonize_scrollwindow(scrolledWindow): - return scrolledWindow - - -try: - hildon.PannableArea - hildonize_scrollwindow = _fremantle_hildonize_scrollwindow - hildonize_scrollwindow_with_viewport = _hildon_hildonize_scrollwindow -except AttributeError: - try: - hildon.hildon_helper_set_thumb_scrollbar - hildonize_scrollwindow = _hildon_hildonize_scrollwindow - hildonize_scrollwindow_with_viewport = _hildon_hildonize_scrollwindow - except AttributeError: - hildonize_scrollwindow = _null_hildonize_scrollwindow - hildonize_scrollwindow_with_viewport = _null_hildonize_scrollwindow - - -def _hildon_request_number(parent, title, range, default): - spinner = hildon.NumberEditor(*range) - spinner.set_value(default) - - dialog = gtk.Dialog( - title, - parent, - gtk.DIALOG_MODAL|gtk.DIALOG_DESTROY_WITH_PARENT, - (gtk.STOCK_OK, gtk.RESPONSE_OK, gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL), - ) - dialog.set_default_response(gtk.RESPONSE_CANCEL) - dialog.get_child().add(spinner) - - try: - dialog.show_all() - response = dialog.run() - - if response == gtk.RESPONSE_OK: - return spinner.get_value() - elif response == gtk.RESPONSE_CANCEL or response == gtk.RESPONSE_DELETE_EVENT: - raise RuntimeError("User cancelled request") - else: - raise RuntimeError("Unrecognized response %r", response) - finally: - dialog.hide() - dialog.destroy() - - -def _null_request_number(parent, title, range, default): - adjustment = gtk.Adjustment(default, range[0], range[1], 1, 5, 0) - spinner = gtk.SpinButton(adjustment, 0, 0) - spinner.set_wrap(False) - - dialog = gtk.Dialog( - title, - parent, - gtk.DIALOG_MODAL|gtk.DIALOG_DESTROY_WITH_PARENT, - (gtk.STOCK_OK, gtk.RESPONSE_OK, gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL), - ) - dialog.set_default_response(gtk.RESPONSE_CANCEL) - dialog.get_child().add(spinner) - - try: - dialog.show_all() - response = dialog.run() - - if response == gtk.RESPONSE_OK: - return spinner.get_value_as_int() - elif response == gtk.RESPONSE_CANCEL or response == gtk.RESPONSE_DELETE_EVENT: - raise RuntimeError("User cancelled request") - else: - raise RuntimeError("Unrecognized response %r", response) - finally: - dialog.hide() - dialog.destroy() - - -try: - hildon.NumberEditor # TODO deprecated in fremantle - request_number = _hildon_request_number -except AttributeError: - request_number = _null_request_number - - -def _hildon_touch_selector(parent, title, items, defaultIndex): - model = gtk.ListStore(gobject.TYPE_STRING) - for item in items: - model.append((item, )) - - selector = hildon.TouchSelector() - selector.append_text_column(model, True) - selector.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_SINGLE) - selector.set_active(0, defaultIndex) - - dialog = hildon.PickerDialog(parent) - dialog.set_selector(selector) - - try: - dialog.show_all() - response = dialog.run() - - if response == gtk.RESPONSE_OK: - return selector.get_active(0) - elif response == gtk.RESPONSE_CANCEL or response == gtk.RESPONSE_DELETE_EVENT: - raise RuntimeError("User cancelled request") - else: - raise RuntimeError("Unrecognized response %r", response) - finally: - dialog.hide() - dialog.destroy() - - -def _on_null_touch_selector_activated(treeView, path, column, dialog, pathData): - dialog.response(gtk.RESPONSE_OK) - pathData[0] = path - - -def _null_touch_selector(parent, title, items, defaultIndex = -1): - parentSize = parent.get_size() - - model = gtk.ListStore(gobject.TYPE_STRING) - for item in items: - model.append((item, )) - - cell = gtk.CellRendererText() - set_cell_thumb_selectable(cell) - column = gtk.TreeViewColumn(title) - column.pack_start(cell, expand=True) - column.add_attribute(cell, "text", 0) - - treeView = gtk.TreeView() - treeView.set_model(model) - treeView.append_column(column) - selection = treeView.get_selection() - selection.set_mode(gtk.SELECTION_SINGLE) - if 0 < defaultIndex: - selection.select_path((defaultIndex, )) - - scrolledWin = gtk.ScrolledWindow() - scrolledWin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) - scrolledWin.add(treeView) - - dialog = gtk.Dialog( - title, - parent, - gtk.DIALOG_MODAL|gtk.DIALOG_DESTROY_WITH_PARENT, - (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL), - ) - dialog.set_default_response(gtk.RESPONSE_CANCEL) - dialog.get_child().add(scrolledWin) - dialog.resize(parentSize[0], max(parentSize[1]-100, 100)) - - scrolledWin = hildonize_scrollwindow(scrolledWin) - pathData = [None] - treeView.connect("row-activated", _on_null_touch_selector_activated, dialog, pathData) - - try: - dialog.show_all() - response = dialog.run() - - if response == gtk.RESPONSE_OK: - if pathData[0] is None: - raise RuntimeError("No selection made") - return pathData[0][0] - elif response == gtk.RESPONSE_CANCEL or response == gtk.RESPONSE_DELETE_EVENT: - raise RuntimeError("User cancelled request") - else: - raise RuntimeError("Unrecognized response %r", response) - finally: - dialog.hide() - dialog.destroy() - - -try: - hildon.PickerDialog - hildon.TouchSelector - touch_selector = _hildon_touch_selector -except AttributeError: - touch_selector = _null_touch_selector - - -def _hildon_touch_selector_entry(parent, title, items, defaultItem): - # Got a segfault when using append_text_column with TouchSelectorEntry, so using this way - try: - selector = hildon.TouchSelectorEntry(text=True) - except TypeError: - selector = hildon.hildon_touch_selector_entry_new_text() - defaultIndex = -1 - for i, item in enumerate(items): - selector.append_text(item) - if item == defaultItem: - defaultIndex = i - - dialog = hildon.PickerDialog(parent) - dialog.set_selector(selector) - - if 0 < defaultIndex: - selector.set_active(0, defaultIndex) - else: - selector.get_entry().set_text(defaultItem) - - try: - dialog.show_all() - response = dialog.run() - finally: - dialog.hide() - - if response == gtk.RESPONSE_OK: - return selector.get_entry().get_text() - elif response == gtk.RESPONSE_CANCEL or response == gtk.RESPONSE_DELETE_EVENT: - raise RuntimeError("User cancelled request") - else: - raise RuntimeError("Unrecognized response %r", response) - - -def _on_null_touch_selector_entry_entry_changed(entry, result, selection, defaultIndex): - custom = entry.get_text().strip() - if custom: - result[0] = custom - selection.unselect_all() - else: - result[0] = None - selection.select_path((defaultIndex, )) - - -def _on_null_touch_selector_entry_entry_activated(customEntry, dialog, result): - dialog.response(gtk.RESPONSE_OK) - result[0] = customEntry.get_text() - - -def _on_null_touch_selector_entry_tree_activated(treeView, path, column, dialog, result): - dialog.response(gtk.RESPONSE_OK) - model = treeView.get_model() - itr = model.get_iter(path) - if itr is not None: - result[0] = model.get_value(itr, 0) - - -def _null_touch_selector_entry(parent, title, items, defaultItem): - parentSize = parent.get_size() - - model = gtk.ListStore(gobject.TYPE_STRING) - defaultIndex = -1 - for i, item in enumerate(items): - model.append((item, )) - if item == defaultItem: - defaultIndex = i - - cell = gtk.CellRendererText() - set_cell_thumb_selectable(cell) - column = gtk.TreeViewColumn(title) - column.pack_start(cell, expand=True) - column.add_attribute(cell, "text", 0) - - treeView = gtk.TreeView() - treeView.set_model(model) - treeView.append_column(column) - selection = treeView.get_selection() - selection.set_mode(gtk.SELECTION_SINGLE) - - scrolledWin = gtk.ScrolledWindow() - scrolledWin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) - scrolledWin.add(treeView) - - customEntry = gtk.Entry() - - layout = gtk.VBox() - layout.pack_start(customEntry, expand=False) - layout.pack_start(scrolledWin) - - dialog = gtk.Dialog( - title, - parent, - gtk.DIALOG_MODAL|gtk.DIALOG_DESTROY_WITH_PARENT, - (gtk.STOCK_OK, gtk.RESPONSE_OK, gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL), - ) - dialog.set_default_response(gtk.RESPONSE_CANCEL) - dialog.get_child().add(layout) - dialog.resize(parentSize[0], max(parentSize[1]-100, 100)) - - scrolledWin = hildonize_scrollwindow(scrolledWin) - - result = [None] - if 0 < defaultIndex: - selection.select_path((defaultIndex, )) - result[0] = defaultItem - else: - customEntry.set_text(defaultItem) - - customEntry.connect("activate", _on_null_touch_selector_entry_entry_activated, dialog, result) - customEntry.connect("changed", _on_null_touch_selector_entry_entry_changed, result, selection, defaultIndex) - treeView.connect("row-activated", _on_null_touch_selector_entry_tree_activated, dialog, result) - - try: - dialog.show_all() - response = dialog.run() - - if response == gtk.RESPONSE_OK: - _, itr = selection.get_selected() - if itr is not None: - return model.get_value(itr, 0) - else: - enteredText = customEntry.get_text().strip() - if enteredText: - return enteredText - elif result[0] is not None: - return result[0] - else: - raise RuntimeError("No selection made") - elif response == gtk.RESPONSE_CANCEL or response == gtk.RESPONSE_DELETE_EVENT: - raise RuntimeError("User cancelled request") - else: - raise RuntimeError("Unrecognized response %r", response) - finally: - dialog.hide() - dialog.destroy() - - -try: - hildon.PickerDialog - hildon.TouchSelectorEntry - touch_selector_entry = _hildon_touch_selector_entry -except AttributeError: - touch_selector_entry = _null_touch_selector_entry - - -if __name__ == "__main__": - app = get_app_class()() - - label = gtk.Label("Hello World from a Label!") - - win = gtk.Window() - win.add(label) - win = hildonize_window(app, win) - if False and IS_FREMANTLE_SUPPORTED: - appMenu = hildon.AppMenu() - for i in xrange(5): - b = gtk.Button(str(i)) - appMenu.append(b) - win.set_app_menu(appMenu) - win.show_all() - appMenu.show_all() - gtk.main() - elif False: - print touch_selector(win, "Test", ["A", "B", "C", "D"], 2) - elif False: - print touch_selector_entry(win, "Test", ["A", "B", "C", "D"], "C") - print touch_selector_entry(win, "Test", ["A", "B", "C", "D"], "Blah") - elif False: - import pprint - name, value = "", "" - goodLocals = [ - (name, value) for (name, value) in locals().iteritems() - if not name.startswith("_") - ] - pprint.pprint(goodLocals) - elif False: - import time - show_information_banner(win, "Hello World") - time.sleep(5) - elif False: - import time - banner = show_busy_banner_start(win, "Hello World") - time.sleep(5) - show_busy_banner_end(banner) -- 1.7.9.5