def __init__(self):
"""
Initialisieren
"""
self._selectedItem = None # (<Position>, <Key>, <Value>)
# Treeview
self._itemlist = gtk.ListStore(str, str)
self._itemView = gtk.TreeView(self._itemlist)
self._itemView.set_headers_visible(False)
self._itemView.get_selection().set_mode(gtk.SELECTION_SINGLE)
self._itemView.connect("cursor-changed", self._on_cursor_changed)
self._itemView.connect("row-activated", self._on_row_activated)
self._itemView.show()
# Key-Spalte hinzuf�gen
self._keyCell = gtk.CellRendererText()
self._keyColumn = gtk.TreeViewColumn("Key")
self._keyColumn.pack_start(self._keyCell, True)
self._keyColumn.add_attribute(self._keyCell, "text", self.KEY_IDX)
self._keyColumn.set_visible(False)
self._itemView.append_column(self._keyColumn)
# Value-Spalte hinzufügen
self._valueCell = gtk.CellRendererText()
self._valueCell.set_property("ellipsize", pango.ELLIPSIZE_END)
self._valueColumn = gtk.TreeViewColumn("Caption")
self._valueColumn.pack_start(self._valueCell, True)
self._valueColumn.add_attribute(self._valueCell, "text", self.VALUE_IDX)
self._itemView.append_column(self._valueColumn)
# Suchspalte setzen
# Leider funktioniert die Suche im Moment nicht so
# wie ich das möchte. Deshalb habe ich die Suche abgeschaltet.
self._itemView.set_enable_search(False)
self._maemo5HackVBox = gtk.VBox()
self._maemo5HackVBox.pack_start(self._itemView)
self._maemo5HackViewport = gtk.Viewport()
self._maemo5HackViewport.add(self._maemo5HackVBox)
# ScrolledWindow
self._scrolledWindow = gtk.ScrolledWindow()
self._scrolledWindow.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
self._scrolledWindow.set_shadow_type(gtk.SHADOW_IN)
self._scrolledWindow.add(self._maemo5HackViewport)
self._scrolledWindow = hildonize.hildonize_scrollwindow(self._scrolledWindow)
self._scrolledWindow.show()
def __init__(self, app, player, store, node):
BasicWindow.__init__(self, app, player, store)
self._node = node
self.connect_auto(self._player, "title-change", self._on_player_title_change)
self._loadingBanner = banners.GenericBanner()
modelTypes, columns = zip(*self._get_columns())
self._model = gtk.ListStore(*modelTypes)
self._treeView = gtk.TreeView()
self._treeView.connect("row-activated", self._on_row_activated)
self._treeView.set_property("fixed-height-mode", True)
self._treeView.set_headers_visible(False)
self._treeView.set_model(self._model)
for column in columns:
if column is not None:
self._treeView.append_column(column)
self._viewport = gtk.Viewport()
self._viewport.add(self._treeView)
self._treeScroller = gtk.ScrolledWindow()
self._treeScroller.add(self._viewport)
self._treeScroller.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
self._treeScroller = hildonize.hildonize_scrollwindow(self._treeScroller)
self._separator = gtk.HSeparator()
self._presenter = presenter.NavControl(self._player, self._store)
self.connect_auto(self._presenter, "home", self._on_home)
self.connect_auto(self._presenter, "jump-to", self._on_jump)
self._contentLayout = gtk.VBox(False)
self._contentLayout.pack_start(self._treeScroller, True, True)
self._contentLayout.pack_start(self._separator, False, True)
self._contentLayout.pack_start(self._presenter.toplevel, False, True)
self._layout.pack_start(self._loadingBanner.toplevel, False, False)
self._layout.pack_start(self._contentLayout, True, True)
def __init__(self, parent, db, liststorehandler):
self.__listStore = liststorehandler
self.__columnsSection = gtk.VBox()
for i, name in enumerate(self._iter_columns()):
checkbutton = gtk.CheckButton(name)
if i in [0, 1]:
default = "1"
else:
default = "0"
if db.ladeDirekt("showcol_"+name, default) == "1":
checkbutton.set_active(True)
self.__columnsSection.pack_start(checkbutton)
columnsFrame = gtk.Frame(_("Visible Columns"))
columnsFrame.add(self.__columnsSection)
self.__rotationSection = gtk.VBox()
self.__isPortraitCheckbutton = gtk.CheckButton(_("Portrait Mode"))
self.__rotationSection.pack_start(self.__isPortraitCheckbutton)
rotationFrame = gtk.Frame(_("Rotation"))
rotationFrame.add(self.__rotationSection)
settingsBox = gtk.VBox()
settingsBox.pack_start(rotationFrame)
settingsBox.pack_start(columnsFrame)
settingsView = gtk.Viewport()
settingsView.add(settingsBox)
settingsScrollView = gtk.ScrolledWindow()
settingsScrollView.add(settingsView)
settingsScrollView.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
parent.pack_start(settingsScrollView)
settingsScrollView = hildonize.hildonize_scrollwindow(settingsScrollView)
def __init__(self, parent):
self.window = None
self.__isPortraitCheckbutton = gtk.CheckButton("Portrait Mode")
self.__rotationSection = gtk.VBox()
self.__rotationSection.pack_start(self.__isPortraitCheckbutton, False, True)
rotationFrame = gtk.Frame("Rotation")
rotationFrame.add(self.__rotationSection)
self.__audioBooksPath = gtk.Entry()
self.__audioBooksPathButton = gtk.Button("Choose")
self.__audioBooksPathButton.connect("clicked", self._on_path_choose)
self.__audiobookPathSection = gtk.HBox()
self.__audiobookPathSection.pack_start(self.__audioBooksPath, True, True)
self.__audiobookPathSection.pack_start(self.__audioBooksPathButton, False, True)
self.__audiobookSection = gtk.VBox()
self.__audiobookSection.pack_start(self.__audiobookPathSection)
audiobookFrame = gtk.Frame("Audiobooks")
audiobookFrame.add(self.__audiobookSection)
settingsBox = gtk.VBox()
settingsBox.pack_start(rotationFrame, False, True)
settingsBox.pack_start(audiobookFrame, False, True)
settingsView = gtk.Viewport()
settingsView.add(settingsBox)
settingsScrollView = gtk.ScrolledWindow()
settingsScrollView.add(settingsView)
settingsScrollView.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
parent.pack_start(settingsScrollView, True, True)
settingsScrollView = hildonize.hildonize_scrollwindow(settingsScrollView)
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_title(
self._mainWindow, "%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 __init__(self):
self._initDone = False
self._connection = None
self._osso = None
self._deviceState = None
self._clipboard = gtk.clipboard_get()
self._credentials = ("", "")
self._selectedBackendId = self.NULL_BACKEND
self._defaultBackendId = self.GV_BACKEND
self._phoneBackends = None
self._dialpads = None
self._accountViews = None
self._messagesViews = None
self._historyViews = None
self._contactsViews = None
self._alarmHandler = None
self._ledHandler = None
self._originalCurrentLabels = []
self._fsContactsPath = os.path.join(constants._data_path_, "contacts")
for path in self._glade_files:
if os.path.isfile(path):
self._widgetTree = gtk.glade.XML(path)
break
else:
display_error_message("Cannot find dialcentral.glade")
gtk.main_quit()
return
self._window = self._widgetTree.get_widget("mainWindow")
self._notebook = self._widgetTree.get_widget("notebook")
errorBox = self._widgetTree.get_widget("errorEventBox")
errorDescription = self._widgetTree.get_widget("errorDescription")
errorClose = self._widgetTree.get_widget("errorClose")
self._errorDisplay = gtk_toolbox.ErrorDisplay(errorBox, errorDescription, errorClose)
self._credentialsDialog = gtk_toolbox.LoginWindow(self._widgetTree)
self._smsEntryWindow = None
self._isFullScreen = False
self.__isPortrait = False
self._app = hildonize.get_app_class()()
self._window = hildonize.hildonize_window(self._app, self._window)
hildonize.hildonize_text_entry(self._widgetTree.get_widget("usernameentry"))
hildonize.hildonize_password_entry(self._widgetTree.get_widget("passwordentry"))
for scrollingWidgetName in (
'history_scrolledwindow',
'message_scrolledwindow',
'contacts_scrolledwindow',
"smsMessages_scrolledwindow",
):
scrollingWidget = self._widgetTree.get_widget(scrollingWidgetName)
assert scrollingWidget is not None, scrollingWidgetName
hildonize.hildonize_scrollwindow(scrollingWidget)
for scrollingWidgetName in (
"smsMessage_scrolledEntry",
):
scrollingWidget = self._widgetTree.get_widget(scrollingWidgetName)
assert scrollingWidget is not None, scrollingWidgetName
hildonize.hildonize_scrollwindow_with_viewport(scrollingWidget)
for buttonName in (
"back",
"addressbookSelectButton",
"sendSmsButton",
"dialButton",
"callbackSelectButton",
"minutesEntryButton",
"clearcookies",
"phoneTypeSelection",
):
button = self._widgetTree.get_widget(buttonName)
assert button is not None, buttonName
hildonize.set_button_thumb_selectable(button)
menu = hildonize.hildonize_menu(
self._window,
self._widgetTree.get_widget("dialpad_menubar"),
)
if not hildonize.GTK_MENU_USED:
button = gtk.Button("New Login")
button.connect("clicked", self._on_clearcookies_clicked)
menu.append(button)
button = gtk.Button("Refresh")
button.connect("clicked", self._on_menu_refresh)
menu.append(button)
menu.show_all()
self._window.connect("key-press-event", self._on_key_press)
self._window.connect("window-state-event", self._on_window_state_change)
if not hildonize.IS_HILDON_SUPPORTED:
_moduleLogger.warning("No hildonization support")
hildonize.set_application_name("%s" % constants.__pretty_app_name__)
self._window.connect("destroy", self._on_close)
self._window.set_default_size(800, 300)
self._window.show_all()
self._loginSink = gtk_toolbox.threaded_stage(
gtk_toolbox.comap(
self._attempt_login,
gtk_toolbox.null_sink(),
)
)
if not PROFILE_STARTUP:
backgroundSetup = threading.Thread(target=self._idle_setup)
backgroundSetup.setDaemon(True)
backgroundSetup.start()
else:
self._idle_setup()
def __init__(self, app, player, store, node):
windows._base.BasicWindow.__init__(self, app, player, store)
self._node = node
self._childNode = None
self.connect_auto(self._player, "state-change", self._on_player_state_change)
self.connect_auto(self._player, "title-change", self._on_player_title_change)
self._loadingBanner = banners.GenericBanner()
self._programmingModel = gtk.ListStore(
gobject.TYPE_STRING,
gobject.TYPE_STRING,
)
textrenderer = gtk.CellRendererText()
timeColumn = gtk.TreeViewColumn("Time")
textrenderer.set_property("scale", 0.75)
timeColumn.set_property("sizing", gtk.TREE_VIEW_COLUMN_FIXED)
timeColumn.set_property("fixed-width", 80)
timeColumn.pack_start(textrenderer, expand=True)
timeColumn.add_attribute(textrenderer, "text", 0)
textrenderer = gtk.CellRendererText()
titleColumn = gtk.TreeViewColumn("Program")
titleColumn.set_property("sizing", gtk.TREE_VIEW_COLUMN_FIXED)
titleColumn.pack_start(textrenderer, expand=True)
titleColumn.add_attribute(textrenderer, "text", 1)
self._treeView = gtk.TreeView()
self._treeView.set_property("fixed-height-mode", True)
self._treeView.set_headers_visible(False)
self._treeView.set_model(self._programmingModel)
self._treeView.append_column(timeColumn)
self._treeView.append_column(titleColumn)
self._treeView.get_selection().connect("changed", self._on_row_changed)
self._viewport = gtk.Viewport()
self._viewport.add(self._treeView)
self._treeScroller = gtk.ScrolledWindow()
self._treeScroller.add(self._viewport)
self._treeScroller.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
self._treeScroller = hildonize.hildonize_scrollwindow(self._treeScroller)
self._presenter = presenter.StreamMiniPresenter(self._store)
self._presenterNavigation = presenter.NavigationBox()
self._presenterNavigation.toplevel.add(self._presenter.toplevel)
self.connect_auto(self._presenterNavigation, "action", self._on_nav_action)
self.connect_auto(self._presenterNavigation, "navigating", self._on_navigating)
self.connect_auto(self._player, "error", self._on_player_error)
self._radioLayout = gtk.VBox(False)
self._radioLayout.pack_start(self._treeScroller, True, True)
self._radioLayout.pack_start(self._presenterNavigation.toplevel, False, True)
self._layout.pack_start(self._loadingBanner.toplevel, False, False)
self._layout.pack_start(self._radioLayout, True, True)
self._dateShown = datetime.datetime.now(tz=time_utils.Mountain)
self._currentTime = self._dateShown
self._update_title()
self._continualUpdate = go_utils.Timeout(self._on_continual_update, once = False)
self._continualUpdate.start(seconds=60)
