4 from __future__ import with_statement
31 _moduleLogger = logging.getLogger("gonvert_glade")
33 if gettext is not None:
34 gettext.bindtextdomain('gonvert', '/usr/share/locale')
35 gettext.textdomain('gonvert')
38 def change_menu_label(widgets, labelname, newtext):
39 item_label = widgets.get_widget(labelname).get_children()[0]
40 item_label.set_text(newtext)
43 def split_number(number):
45 fractional, integer = math.modf(number)
47 integerDisplay = number
48 fractionalDisplay = ""
50 integerDisplay = str(integer)
51 fractionalDisplay = str(fractional)
52 if "e+" in integerDisplay:
53 integerDisplay = number
54 fractionalDisplay = ""
55 elif "e-" in fractionalDisplay and 0.0 < integer:
56 integerDisplay = number
57 fractionalDisplay = ""
58 elif "e-" in fractionalDisplay:
60 fractionalDisplay = number
62 integerDisplay = integerDisplay.split(".", 1)[0] + "."
63 fractionalDisplay = fractionalDisplay.rsplit(".", 1)[-1]
65 return integerDisplay, fractionalDisplay
68 class Gonvert(object):
71 os.path.join(os.path.dirname(__file__), "gonvert.glade"),
72 os.path.join(os.path.dirname(__file__), "../data/gonvert.glade"),
73 os.path.join(os.path.dirname(__file__), "../share/gonvert.glade"),
74 '/usr/share/gonvert/gonvert.glade',
81 UNITS_FRACTION_IDX = 4
84 self._unitDataInCategory = None
85 self._unit_sort_direction = False
86 self._value_sort_direction = False
87 self._units_sort_direction = False
88 self.__isPortrait = False
89 self._isFullScreen = False
90 self._clipboard = gtk.clipboard_get()
92 self._find_result = [] # empty find result list
93 self._findIndex = 0 # default to find result number zero
95 self._selectedCategoryName = '' # preset to no selected category
96 self._defaultUnitForCategory = {} # empty dictionary for later use
98 #check to see if glade file is in current directory (user must be
99 # running from download untar directory)
100 for gladePath in self._glade_files:
101 if os.path.isfile(gladePath):
102 homepath = os.path.dirname(gladePath)
103 pixmapspath = "/".join((homepath, "pixmaps"))
104 widgets = gtk.glade.XML(gladePath)
107 _moduleLogger.error("UI Descriptor not found!")
111 self._mainWindow = widgets.get_widget('mainWindow')
112 self._app = hildonize.get_app_class()()
113 self._mainWindow = hildonize.hildonize_window(self._app, self._mainWindow)
115 change_menu_label(widgets, 'fileMenuItem', _('File'))
116 change_menu_label(widgets, 'exitMenuItem', _('Exit'))
117 change_menu_label(widgets, 'helpMenuItem', _('Help'))
118 change_menu_label(widgets, 'aboutMenuItem', _('About'))
120 self._categorySelectionButton = widgets.get_widget("categorySelectionButton")
121 self._categoryView = widgets.get_widget('categoryView')
123 self._unitsView = widgets.get_widget('unitsView')
124 self._unitsView.set_property('rules_hint', 1)
125 self._unitsView_selection = self._unitsView.get_selection()
127 self._unitName = widgets.get_widget('unitName')
128 self._unitValue = widgets.get_widget('unitValue')
129 self._previousUnitName = widgets.get_widget('previousUnitName')
130 self._previousUnitValue = widgets.get_widget('previousUnitValue')
132 self._unitSymbol = widgets.get_widget('unitSymbol')
133 self._previousUnitSymbol = widgets.get_widget('previousUnitSymbol')
135 self._unitDescription = widgets.get_widget('unitDescription')
137 self._searchLayout = widgets.get_widget('searchLayout')
138 self._searchLayout.hide()
139 self._findEntry = widgets.get_widget('findEntry')
140 self._findLabel = widgets.get_widget('findLabel')
141 self._findButton = widgets.get_widget('findButton')
142 self._closeSearchButton = widgets.get_widget('closeSearchButton')
144 self._unitsNameRenderer = gtk.CellRendererText()
145 self._unitsNameRenderer.set_property("scale", 0.75)
146 if constants.FORCE_HILDON_LIKE:
147 self._unitsNameRenderer.set_property("ellipsize", pango.ELLIPSIZE_END)
148 self._unitsNameRenderer.set_property("width-chars", 5)
149 self._unitNameColumn = gtk.TreeViewColumn(_('Name'), self._unitsNameRenderer)
150 self._unitNameColumn.set_property('resizable', True)
151 self._unitNameColumn.add_attribute(self._unitsNameRenderer, 'text', self.UNITS_NAME_IDX)
152 self._unitNameColumn.set_clickable(True)
153 self._unitNameColumn.connect("clicked", self._on_click_unit_column)
154 self._unitsView.append_column(self._unitNameColumn)
156 renderer = gtk.CellRendererText()
157 renderer.set_property("xalign", 1.0)
158 renderer.set_property("alignment", pango.ALIGN_RIGHT)
159 hildonize.set_cell_thumb_selectable(renderer)
160 self._unitIntegerColumn = gtk.TreeViewColumn(_('Value'), renderer)
161 self._unitIntegerColumn.set_property('resizable', True)
162 self._unitIntegerColumn.add_attribute(renderer, 'text', self.UNITS_INTEGER_IDX)
163 self._unitIntegerColumn.set_clickable(True)
164 self._unitIntegerColumn.connect("clicked", self._on_click_unit_column)
165 self._unitsView.append_column(self._unitIntegerColumn)
167 renderer = gtk.CellRendererText()
168 renderer.set_property("xalign", 0.0)
169 renderer.set_property("alignment", pango.ALIGN_LEFT)
170 renderer.set_property("scale", 0.75)
171 self._unitFractionalColumn = gtk.TreeViewColumn(_(''), renderer)
172 self._unitFractionalColumn.set_property('resizable', True)
173 self._unitFractionalColumn.add_attribute(renderer, 'text', self.UNITS_FRACTION_IDX)
174 self._unitFractionalColumn.set_clickable(True)
175 self._unitFractionalColumn.connect("clicked", self._on_click_unit_column)
176 self._unitsView.append_column(self._unitFractionalColumn)
178 renderer = gtk.CellRendererText()
179 renderer.set_property("ellipsize", pango.ELLIPSIZE_END)
180 #renderer.set_property("scale", 0.5)
181 self._unitSymbolColumn = gtk.TreeViewColumn(_('Units'), renderer)
182 self._unitSymbolColumn.set_property('resizable', True)
183 self._unitSymbolColumn.add_attribute(renderer, 'text', self.UNITS_SYMBOL_IDX)
184 self._unitSymbolColumn.set_clickable(True)
185 self._unitSymbolColumn.connect("clicked", self._on_click_unit_column)
186 self._unitsView.append_column(self._unitSymbolColumn)
188 self._unitModel = gtk.ListStore(
189 gobject.TYPE_STRING, # UNITS_NAME_IDX
190 gobject.TYPE_STRING, # UNITS_VALUE_IDX
191 gobject.TYPE_STRING, # UNITS_SYMBOL_IDX
192 gobject.TYPE_STRING, # UNITS_INTEGER_IDX
193 gobject.TYPE_STRING, # UNITS_FRACTION_IDX
195 self._sortedUnitModel = gtk.TreeModelSort(self._unitModel)
196 columns = self._get_column_sort_stuff()
197 for columnIndex, (column, sortDirection, col_cmp) in enumerate(columns):
198 self._sortedUnitModel.set_sort_func(columnIndex, col_cmp)
199 self._unitsView.set_model(self._sortedUnitModel)
201 #Insert a column into the category list even though the heading will not be seen
202 renderer = gtk.CellRendererText()
203 self._categoryColumn = gtk.TreeViewColumn('Title', renderer)
204 self._categoryColumn.set_property('resizable', 1)
205 self._categoryColumn.add_attribute(renderer, 'text', 0)
206 self._categoryView.append_column(self._categoryColumn)
208 self._categoryModel = gtk.ListStore(gobject.TYPE_STRING)
209 self._categoryView.set_model(self._categoryModel)
210 #colourize each row differently for easier reading
211 self._categoryView.set_property('rules_hint', 1)
213 #Populate the catagories list
214 for key in unit_data.UNIT_CATEGORIES:
216 self._categoryModel.append(row)
218 #--------- connections to GUI ----------------
219 self._mainWindow.connect("destroy", self._on_user_exit)
220 self._mainWindow.connect("key-press-event", self._on_key_press)
221 self._mainWindow.connect("window-state-event", self._on_window_state_change)
222 self._categorySelectionButton.connect("clicked", self._on_category_selector_clicked)
223 self._categoryView.connect("cursor-changed", self._on_click_category)
224 self._findButton.connect("clicked", self._on_find_activate)
225 self._findEntry.connect("activate", self._on_find_activate)
226 self._findEntry.connect("changed", self._on_findEntry_changed)
227 self._closeSearchButton.connect("clicked", self._on_toggle_search)
228 self._previousUnitValue.connect("changed", self._on_previous_unit_value_changed)
229 self._unitValue.connect("changed", self._on_unit_value_changed)
230 self._unitValue.connect("key-press-event", self._on_browse_key_press)
231 self._unitsView.connect("cursor-changed", self._on_click_unit)
232 self._unitsView.connect("key-press-event", self._on_browse_key_press)
233 if hildonize.GTK_MENU_USED:
234 widgets.get_widget("aboutMenuItem").connect("activate", self._on_about_clicked)
235 widgets.get_widget("searchMenuItem").connect("activate", self._on_toggle_search)
236 widgets.get_widget("exitMenuItem").connect("activate", self._on_user_exit)
238 for scrollingWidgetName in (
239 "unitsViewScrolledWindow",
241 scrollingWidget = widgets.get_widget(scrollingWidgetName)
242 assert scrollingWidget is not None, scrollingWidgetName
243 scroller = hildonize.hildonize_scrollwindow(scrollingWidget)
247 if hildonize.IS_HILDON_SUPPORTED or constants.FORCE_HILDON_LIKE:
248 self._categoryView.get_parent().hide()
249 self._unitsView.set_headers_visible(False)
250 self._previousUnitName.get_parent().hide()
251 self._unitDescription.get_parent().get_parent().hide()
253 self._categorySelectionButton.hide()
255 menu = hildonize.hildonize_menu(
257 widgets.get_widget("mainMenuBar"),
259 if not hildonize.GTK_MENU_USED:
260 button = gtk.Button("Search")
261 button.connect("clicked", self._on_toggle_search)
264 button = hildonize.hildon.GtkRadioButton(gtk.HILDON_SIZE_AUTO, None)
265 button.set_label("Name")
266 menu.add_filter(button)
267 button.connect("clicked", self._on_click_menu_filter, self._unitNameColumn)
268 button.set_mode(False)
271 button = hildonize.hildon.GtkRadioButton(gtk.HILDON_SIZE_AUTO, filterGroup)
272 button.set_label("Value")
273 menu.add_filter(button)
274 button.connect("clicked", self._on_click_menu_filter, self._unitIntegerColumn)
275 button.set_mode(False)
277 button = hildonize.hildon.GtkRadioButton(gtk.HILDON_SIZE_AUTO, filterGroup)
278 button.set_label("Unit")
279 menu.add_filter(button)
280 button.connect("clicked", self._on_click_menu_filter, self._unitSymbolColumn)
281 button.set_mode(False)
285 if not hildonize.IS_HILDON_SUPPORTED:
286 _moduleLogger.info("No hildonization support")
288 hildonize.set_application_name(
289 "%s - Unit Conversion Utility" % constants.__pretty_app_name__
291 iconPath = pixmapspath + '/gonvert.png'
292 if os.path.exists(iconPath):
293 self._mainWindow.set_icon(gtk.gdk.pixbuf_new_from_file(iconPath))
295 _moduleLogger.warn("Error: Could not find gonvert icon: %s" % iconPath)
297 self._load_settings()
298 self._mainWindow.show()
300 def _load_settings(self):
301 #Restore window size from previously saved settings if it exists and is valid.
302 windowDatPath = "/".join((constants._data_path_, "window.dat"))
303 if os.path.exists(windowDatPath):
304 saved_window = pickle.load(open(windowDatPath, "r"))
306 a, b = saved_window['size']
310 self._mainWindow.resize(a, b)
312 isFullscreen = saved_window["isFullscreen"]
317 self._mainWindow.fullscreen()
319 isPortrait = saved_window["isPortrait"]
323 if isPortrait ^ self.__isPortrait:
325 orientation = gtk.ORIENTATION_VERTICAL
327 orientation = gtk.ORIENTATION_HORIZONTAL
328 self.set_orientation(orientation)
330 #Restore selections from previously saved settings if it exists and is valid.
332 selectedCategoryName = unit_data.UNIT_CATEGORIES[0]
333 selectionsDatPath = "/".join((constants._data_path_, "selections.dat"))
334 if os.path.exists(selectionsDatPath):
335 selections = pickle.load(open(selectionsDatPath, 'r'))
337 self._defaultUnitForCategory = selections['selected_units']
342 selectedCategoryName = selections['selected_category']
347 categoryIndex = unit_data.UNIT_CATEGORIES.index(selectedCategoryName)
349 _moduleLogger.warn("Unknown category: %s" % selectedCategoryName)
351 self._categorySelectionButton.get_child().set_markup("<big>%s</big>" % selectedCategoryName)
352 self._categoryView.set_cursor(categoryIndex, self._categoryColumn, False)
353 self._categoryView.grab_focus()
355 self._select_default_unit()
357 def _save_settings(self):
359 This routine saves the selections to a file, and
360 should therefore only be called when exiting the program.
362 Update selections dictionary which consists of the following keys:
363 'self._selectedCategoryName': full name of selected category
364 'self._defaultUnitForCategory': self._defaultUnitForCategory dictionary which contains:
365 [categoryname: #1 displayed unit, #2 displayed unit]
367 #Determine the contents of the selected category row
368 selected, iter = self._categoryView.get_selection().get_selected()
369 self._selectedCategoryName = self._categoryModel.get_value(iter, 0)
372 'selected_category': self._selectedCategoryName,
373 'selected_units': self._defaultUnitForCategory
375 selectionsDatPath = "/".join((constants._data_path_, "selections.dat"))
376 pickle.dump(selections, open(selectionsDatPath, 'w'))
378 #Get last size of app and save it
380 'size': self._mainWindow.get_size(),
381 "isFullscreen": self._isFullScreen,
382 "isPortrait": self.__isPortrait,
384 windowDatPath = "/".join((constants._data_path_, "window.dat"))
385 pickle.dump(window_settings, open(windowDatPath, 'w'))
387 def _refresh_columns(self):
388 self._unitsView.remove_column(self._unitNameColumn)
389 self._unitsView.remove_column(self._unitIntegerColumn)
390 self._unitsView.remove_column(self._unitFractionalColumn)
391 self._unitsView.remove_column(self._unitSymbolColumn)
393 self._unitsView.append_column(self._unitNameColumn)
394 self._unitsView.append_column(self._unitIntegerColumn)
395 self._unitsView.append_column(self._unitFractionalColumn)
396 self._unitsView.append_column(self._unitSymbolColumn)
398 def _clear_find(self):
399 # switch to "new find" state
400 self._find_result = []
403 # Clear our user message
404 self._findLabel.set_text('')
406 def _find_first(self):
407 assert len(self._find_result) == 0
408 assert self._findIndex == 0
409 findString = self._findEntry.get_text().strip().lower()
413 # Gather info on all the matching units from all categories
414 for catIndex, category in enumerate(unit_data.UNIT_CATEGORIES):
415 units = unit_data.get_units(category)
416 for unitIndex, unit in enumerate(units):
417 loweredUnit = unit.lower()
418 if loweredUnit in findString or findString in loweredUnit:
419 self._find_result.append((category, unit, catIndex, unitIndex))
421 def _update_find_selection(self):
422 assert 0 < len(self._find_result)
424 #check if next find is in a new category (prevent category changes when unnecessary
425 searchCategoryName = self._find_result[self._findIndex][0]
426 if self._selectedCategoryName != searchCategoryName:
427 self._categorySelectionButton.get_child().set_markup("<big>%s</big>" % searchCategoryName)
428 self._categoryView.set_cursor(
429 self._find_result[self._findIndex][2], self._categoryColumn, False
432 self._unitsView.set_cursor(
433 self._find_result[self._findIndex][3], self._unitNameColumn, True
436 def _find_next(self):
437 if len(self._find_result) == 0:
440 if self._findIndex == len(self._find_result)-1:
445 if not self._find_result:
446 self._findLabel.set_text('Text not found')
448 self._update_find_selection()
449 resultsLeft = len(self._find_result) - self._findIndex - 1
450 self._findLabel.set_text(
451 '%s result(s) left' % (resultsLeft, )
454 def _find_previous(self):
455 if len(self._find_result) == 0:
458 if self._findIndex == 0:
459 self._findIndex = len(self._find_result)-1
463 if not self._find_result:
464 self._findLabel.set_text('Text not found')
466 self._update_find_selection()
467 resultsLeft = len(self._find_result) - self._findIndex - 1
468 self._findLabel.set_text(
469 '%s result(s) left' % (resultsLeft, )
472 def _toggle_find(self):
473 if self._searchLayout.get_property("visible"):
474 self._searchLayout.hide()
475 self._unitsView.grab_focus()
477 self._searchLayout.show()
478 self._findEntry.grab_focus()
480 def _unit_model_cmp(self, sortedModel, leftItr, rightItr):
481 leftUnitText = self._unitModel.get_value(leftItr, self.UNITS_NAME_IDX)
482 rightUnitText = self._unitModel.get_value(rightItr, self.UNITS_NAME_IDX)
483 return cmp(leftUnitText, rightUnitText)
485 def _symbol_model_cmp(self, sortedModel, leftItr, rightItr):
486 leftSymbolText = self._unitModel.get_value(leftItr, self.UNITS_SYMBOL_IDX)
487 rightSymbolText = self._unitModel.get_value(rightItr, self.UNITS_SYMBOL_IDX)
488 return cmp(leftSymbolText, rightSymbolText)
490 def _value_model_cmp(self, sortedModel, leftItr, rightItr):
491 #special sorting exceptions for ascii values (instead of float values)
492 if self._selectedCategoryName == "Computer Numbers":
493 leftValue = self._unitModel.get_value(leftItr, self.UNITS_VALUE_IDX)
494 rightValue = self._unitModel.get_value(rightItr, self.UNITS_VALUE_IDX)
496 leftValueText = self._unitModel.get_value(leftItr, self.UNITS_VALUE_IDX)
497 leftValue = float(leftValueText) if leftValueText else 0.0
499 rightValueText = self._unitModel.get_value(rightItr, self.UNITS_VALUE_IDX)
500 rightValue = float(rightValueText) if rightValueText else 0.0
501 return cmp(leftValue, rightValue)
503 def _get_column_sort_stuff(self):
505 (self._unitNameColumn, "_unit_sort_direction", self._unit_model_cmp),
506 (self._unitIntegerColumn, "_value_sort_direction", self._value_model_cmp),
507 (self._unitFractionalColumn, "_value_sort_direction", self._value_model_cmp),
508 (self._unitSymbolColumn, "_units_sort_direction", self._symbol_model_cmp),
512 def _switch_category(self, category):
513 self._selectedCategoryName = category
514 self._unitDataInCategory = unit_data.UNIT_DESCRIPTIONS[self._selectedCategoryName]
516 #Fill up the units descriptions and clear the value cells
517 self._clear_visible_unit_data()
519 for key in unit_data.get_units(self._selectedCategoryName):
520 row = key, '0.0', self._unitDataInCategory[key][1], '0.', '0'
521 self._unitModel.append(row)
522 nameLength = max(nameLength, len(key))
523 self._sortedUnitModel.sort_column_changed()
525 if constants.FORCE_HILDON_LIKE:
526 maxCatCharWidth = int(nameLength * 0.75)
527 maxCharWidth = int(len("nibble | hexit | quadbit") * 0.75)
528 charWidth = min(maxCatCharWidth, maxCharWidth)
529 self._unitsNameRenderer.set_property("width-chars", charWidth)
531 self._select_default_unit()
533 def _clear_visible_unit_data(self):
534 self._unitDescription.get_buffer().set_text("")
535 self._unitName.set_text('')
536 self._unitValue.set_text('')
537 self._unitSymbol.set_text('')
539 self._previousUnitName.set_text('')
540 self._previousUnitValue.set_text('')
541 self._previousUnitSymbol.set_text('')
543 self._unitModel.clear()
545 def _select_default_unit(self):
546 # Restore the previous historical settings of previously selected units
547 # in this newly selected category
548 defaultPrimary = unit_data.get_base_unit(self._selectedCategoryName)
549 defaultSecondary = ""
550 if self._selectedCategoryName in self._defaultUnitForCategory:
551 if self._defaultUnitForCategory[self._selectedCategoryName][0]:
552 defaultPrimary = self._defaultUnitForCategory[self._selectedCategoryName][0]
553 if self._defaultUnitForCategory[self._selectedCategoryName][1]:
554 defaultSecondary = self._defaultUnitForCategory[self._selectedCategoryName][1]
556 units = unit_data.get_units(self._selectedCategoryName)
558 #Restore oldest selection first.
561 unitIndex = units.index(defaultPrimary)
564 self._unitsView.set_cursor(unitIndex, self._unitNameColumn, True)
566 #Restore newest selection second.
569 unitIndex = units.index(defaultSecondary)
572 self._unitsView.set_cursor(unitIndex, self._unitNameColumn, True)
574 # select the text so user can start typing right away
575 self._unitValue.grab_focus()
576 self._unitValue.select_region(0, -1)
578 def _sanitize_value(self, userEntry):
579 if self._selectedCategoryName == "Computer Numbers":
588 value = float(userEntry)
591 def _select_sort_column(self, col):
592 #Determine which column requires sorting
593 columns = self._get_column_sort_stuff()
594 for columnIndex, (maybeCol, directionName, col_cmp) in enumerate(columns):
596 direction = getattr(self, directionName)
597 gtkDirection = gtk.SORT_ASCENDING if direction else gtk.SORT_DESCENDING
600 self._sortedUnitModel.set_sort_column_id(columnIndex, gtkDirection)
602 # set the visual for sorting
603 col.set_sort_indicator(True)
604 col.set_sort_order(not direction)
606 setattr(self, directionName, not direction)
609 maybeCol.set_sort_indicator(False)
611 assert False, "Unknown column: %s" % (col.get_title(), )
613 def set_orientation(self, orientation):
614 if orientation == gtk.ORIENTATION_VERTICAL:
615 hildonize.window_to_portrait(self._mainWindow)
616 self.__isPortrait = True
617 elif orientation == gtk.ORIENTATION_HORIZONTAL:
618 hildonize.window_to_landscape(self._mainWindow)
619 self.__isPortrait = False
621 raise NotImplementedError(orientation)
623 def get_orientation(self):
624 return gtk.ORIENTATION_VERTICAL if self.__isPortrait else gtk.ORIENTATION_HORIZONTAL
626 def _toggle_rotate(self):
627 if self.__isPortrait:
628 self.set_orientation(gtk.ORIENTATION_HORIZONTAL)
630 self.set_orientation(gtk.ORIENTATION_VERTICAL)
632 @gtk_toolbox.log_exception(_moduleLogger)
633 def _on_key_press(self, widget, event, *args):
635 @note Hildon specific
637 RETURN_TYPES = (gtk.keysyms.Return, gtk.keysyms.ISO_Enter, gtk.keysyms.KP_Enter)
639 event.keyval == gtk.keysyms.F6 or
640 event.keyval in RETURN_TYPES and event.get_state() & gtk.gdk.CONTROL_MASK
642 if self._isFullScreen:
643 self._mainWindow.unfullscreen()
645 self._mainWindow.fullscreen()
646 elif event.keyval == gtk.keysyms.f and event.get_state() & gtk.gdk.CONTROL_MASK:
647 if not hildonize.GTK_MENU_USED:
649 elif event.keyval == gtk.keysyms.p and event.get_state() & gtk.gdk.CONTROL_MASK:
650 self._find_previous()
651 elif event.keyval == gtk.keysyms.n and event.get_state() & gtk.gdk.CONTROL_MASK:
653 elif event.keyval == gtk.keysyms.o and event.get_state() & gtk.gdk.CONTROL_MASK:
654 self._toggle_rotate()
656 event.keyval in (gtk.keysyms.w, gtk.keysyms.q) and
657 event.get_state() & gtk.gdk.CONTROL_MASK
659 self._mainWindow.destroy()
660 elif event.keyval == gtk.keysyms.l and event.get_state() & gtk.gdk.CONTROL_MASK:
661 with open(constants._user_logpath_, "r") as f:
662 logLines = f.xreadlines()
663 log = "".join(logLines)
664 self._clipboard.set_text(str(log))
666 @gtk_toolbox.log_exception(_moduleLogger)
667 def _on_toggle_search(self, *args):
670 @gtk_toolbox.log_exception(_moduleLogger)
671 def _on_browse_key_press(self, widget, event, *args):
672 if event.keyval == gtk.keysyms.uparrow or event.keyval == gtk.keysyms.Up:
673 index, column = self._unitsView.get_cursor()
674 newIndex = max(index[0]-1, 0)
676 self._unitsView.set_cursor(path, column, True)
677 self._unitsView.scroll_to_cell(path, column, False, 0, 0)
678 return True # override default behavior
679 elif event.keyval == gtk.keysyms.downarrow or event.keyval == gtk.keysyms.Down:
680 index, column = self._unitsView.get_cursor()
681 newIndex = min(index[0]+1, len(self._unitModel)-1)
683 self._unitsView.set_cursor(path, column, True)
684 self._unitsView.scroll_to_cell(path, column, False, 0, 0)
685 return True # override default behavior
687 @gtk_toolbox.log_exception(_moduleLogger)
688 def _on_window_state_change(self, widget, event, *args):
690 @note Hildon specific
692 if event.new_window_state & gtk.gdk.WINDOW_STATE_FULLSCREEN:
693 self._isFullScreen = True
695 self._isFullScreen = False
697 @gtk_toolbox.log_exception(_moduleLogger)
698 def _on_findEntry_changed(self, *args):
700 Clear out find results since the user wants to look for something new
704 @gtk_toolbox.log_exception(_moduleLogger)
705 def _on_find_activate(self, *args):
707 self._findButton.grab_focus()
709 @gtk_toolbox.log_exception(_moduleLogger)
710 def _on_click_menu_filter(self, button, col):
711 self._select_sort_column(col)
713 @gtk_toolbox.log_exception(_moduleLogger)
714 def _on_click_unit_column(self, col):
716 Sort the contents of the col when the user clicks on the title.
718 self._select_sort_column(col)
720 @gtk_toolbox.log_exception(_moduleLogger)
721 def _on_category_selector_clicked(self, *args):
722 currenntIndex = unit_data.UNIT_CATEGORIES.index(self._selectedCategoryName)
723 newIndex = hildonize.touch_selector(
726 unit_data.UNIT_CATEGORIES,
730 selectedCategoryName = unit_data.UNIT_CATEGORIES[newIndex]
731 self._categorySelectionButton.get_child().set_markup("<big>%s</big>" % selectedCategoryName)
732 self._switch_category(selectedCategoryName)
734 @gtk_toolbox.log_exception(_moduleLogger)
735 def _on_click_category(self, *args):
736 selected, iter = self._categoryView.get_selection().get_selected()
738 # User is typing in an invalid string, not selecting any category
740 selectedCategory = self._categoryModel.get_value(iter, 0)
741 self._switch_category(selectedCategory)
743 @gtk_toolbox.log_exception(_moduleLogger)
744 def _on_click_unit(self, *args):
745 selected, iter = self._unitsView.get_selection().get_selected()
746 selected_unit = selected.get_value(iter, self.UNITS_NAME_IDX)
747 unit_spec = self._unitDataInCategory[selected_unit]
751 if self._unitName.get_text() != selected_unit:
752 self._previousUnitName.set_text(self._unitName.get_text())
753 self._previousUnitValue.set_text(self._unitValue.get_text())
754 self._previousUnitSymbol.set_text(self._unitSymbol.get_text())
755 if self._unitSymbol.get_text():
758 self._unitName.set_text(selected_unit)
759 self._unitValue.set_text(selected.get_value(iter, self.UNITS_VALUE_IDX))
760 buffer = self._unitDescription.get_buffer()
761 buffer.set_text(unit_spec[2])
762 self._unitSymbol.set_text(unit_spec[1]) # put units into label text
769 self._unitSymbol.show()
770 self._previousUnitSymbol.show()
772 self._unitSymbol.hide()
773 self._previousUnitSymbol.hide()
775 if self._unitValue.get_text() == '':
776 if self._selectedCategoryName == "Computer Numbers":
777 self._unitValue.set_text("0")
779 self._unitValue.set_text("0.0")
781 self._defaultUnitForCategory[self._selectedCategoryName] = [
782 self._unitName.get_text(), self._previousUnitName.get_text()
785 # select the text so user can start typing right away
786 self._unitValue.grab_focus()
787 self._unitValue.select_region(0, -1)
789 @gtk_toolbox.log_exception(_moduleLogger)
790 def _on_unit_value_changed(self, *args):
791 if self._unitName.get_text() == '':
793 if not self._unitValue.is_focus():
796 #retrieve the conversion function and value from the selected unit
797 value = self._sanitize_value(self._unitValue.get_text())
798 func, arg = self._unitDataInCategory[self._unitName.get_text()][0]
799 base = func.to_base(value, arg)
801 #point to the first row
802 for row in self._unitModel:
803 func, arg = self._unitDataInCategory[row[self.UNITS_NAME_IDX]][0]
804 newValue = func.from_base(base, arg)
806 newValueDisplay = str(newValue)
807 integerDisplay, fractionalDisplay = split_number(newValue)
809 row[self.UNITS_VALUE_IDX] = newValueDisplay
810 row[self.UNITS_INTEGER_IDX] = integerDisplay
811 row[self.UNITS_FRACTION_IDX] = fractionalDisplay
813 # Update the secondary unit entry
814 if self._previousUnitName.get_text() != '':
815 func, arg = self._unitDataInCategory[self._previousUnitName.get_text()][0]
816 self._previousUnitValue.set_text(str(func.from_base(base, arg, )))
818 self._sortedUnitModel.sort_column_changed()
819 self._refresh_columns()
821 @gtk_toolbox.log_exception(_moduleLogger)
822 def _on_previous_unit_value_changed(self, *args):
823 if self._previousUnitName.get_text() == '':
825 if not self._previousUnitValue.is_focus():
828 #retrieve the conversion function and value from the selected unit
829 value = self._sanitize_value(self._previousUnitValue.get_text())
830 func, arg = self._unitDataInCategory[self._previousUnitName.get_text()][0]
831 base = func.to_base(value, arg)
833 #point to the first row
834 for row in self._unitModel:
835 func, arg = self._unitDataInCategory[row[self.UNITS_NAME_IDX]][0]
836 newValue = func.from_base(base, arg)
838 newValueDisplay = str(newValue)
839 integerDisplay, fractionalDisplay = split_number(newValue)
841 row[self.UNITS_VALUE_IDX] = newValueDisplay
842 row[self.UNITS_INTEGER_IDX] = integerDisplay
843 row[self.UNITS_FRACTION_IDX] = fractionalDisplay
845 # Update the primary unit entry
846 func, arg = self._unitDataInCategory[self._unitName.get_text()][0]
847 self._unitValue.set_text(str(func.from_base(base, arg, )))
849 self._sortedUnitModel.sort_column_changed()
850 self._refresh_columns()
852 @gtk_toolbox.log_exception(_moduleLogger)
853 def _on_about_clicked(self, a):
854 dlg = gtk.AboutDialog()
855 dlg.set_name(constants.__pretty_app_name__)
856 dlg.set_version("%s-%d" % (constants.__version__, constants.__build__))
857 dlg.set_copyright("Copyright 2009 - GPL")
859 dlg.set_website("http://unihedron.com/projects/gonvert/gonvert.php")
860 dlg.set_authors(["Anthony Tekatch <anthony@unihedron.com>", "Ed Page <eopage@byu.net> (Blame him for the most recent bugs)"])
864 @gtk_toolbox.log_exception(_moduleLogger)
865 def _on_user_exit(self, *args):
867 self._save_settings()
875 gtk.gdk.threads_init()
876 if hildonize.IS_HILDON_SUPPORTED:
877 gtk.set_application_name(constants.__pretty_app_name__)
879 if not constants.PROFILE_STARTUP:
883 if __name__ == "__main__":
884 logging.basicConfig(level = logging.DEBUG)
886 os.makedirs(constants._data_path_)