4 from __future__ import with_statement
30 _moduleLogger = logging.getLogger("gonvert_glade")
31 PROFILE_STARTUP = False
32 FORCE_HILDON_LIKE = False
34 if gettext is not None:
35 gettext.bindtextdomain('gonvert', '/usr/share/locale')
36 gettext.textdomain('gonvert')
39 def change_menu_label(widgets, labelname, newtext):
40 item_label = widgets.get_widget(labelname).get_children()[0]
41 item_label.set_text(newtext)
44 def split_number(number):
46 fractional, integer = math.modf(number)
48 integerDisplay = number
49 fractionalDisplay = ""
51 integerDisplay = str(integer)
52 fractionalDisplay = str(fractional)
53 if "e+" in integerDisplay:
54 integerDisplay = number
55 fractionalDisplay = ""
56 elif "e-" in fractionalDisplay and 0.0 < integer:
57 integerDisplay = number
58 fractionalDisplay = ""
59 elif "e-" in fractionalDisplay:
61 fractionalDisplay = number
63 integerDisplay = integerDisplay.split(".", 1)[0] + "."
64 fractionalDisplay = fractionalDisplay.rsplit(".", 1)[-1]
66 return integerDisplay, fractionalDisplay
69 class Gonvert(object):
72 os.path.join(os.path.dirname(__file__), "gonvert.glade"),
73 os.path.join(os.path.dirname(__file__), "../data/gonvert.glade"),
74 os.path.join(os.path.dirname(__file__), "../lib/gonvert.glade"),
75 '/usr/share/gonvert/gonvert.glade',
76 '/usr/lib/gonvert/gonvert.glade',
83 UNITS_FRACTION_IDX = 4
86 self._unitDataInCategory = None
87 self._unit_sort_direction = False
88 self._value_sort_direction = False
89 self._units_sort_direction = False
90 self._isFullScreen = False
91 self._clipboard = gtk.clipboard_get()
93 self._find_result = [] # empty find result list
94 self._findIndex = 0 # default to find result number zero
96 self._selectedCategoryName = '' # preset to no selected category
97 self._defaultUnitForCategory = {} # empty dictionary for later use
99 #check to see if glade file is in current directory (user must be
100 # running from download untar directory)
101 for gladePath in self._glade_files:
102 if os.path.isfile(gladePath):
103 homepath = os.path.dirname(gladePath)
104 pixmapspath = "/".join((homepath, "pixmaps"))
105 widgets = gtk.glade.XML(gladePath)
108 _moduleLogger.error("UI Descriptor not found!")
112 self._mainWindow = widgets.get_widget('mainWindow')
113 self._app = hildonize.get_app_class()()
114 self._mainWindow = hildonize.hildonize_window(self._app, self._mainWindow)
116 change_menu_label(widgets, 'fileMenuItem', _('File'))
117 change_menu_label(widgets, 'exitMenuItem', _('Exit'))
118 change_menu_label(widgets, 'helpMenuItem', _('Help'))
119 change_menu_label(widgets, 'aboutMenuItem', _('About'))
120 change_menu_label(widgets, 'findButton', _('Find'))
122 self._categorySelectionButton = widgets.get_widget("categorySelectionButton")
123 self._categoryView = widgets.get_widget('categoryView')
125 self._unitsView = widgets.get_widget('unitsView')
126 self._unitsView.set_property('rules_hint', 1)
127 self._unitsView_selection = self._unitsView.get_selection()
129 self._unitName = widgets.get_widget('unitName')
130 self._unitValue = widgets.get_widget('unitValue')
131 self._previousUnitName = widgets.get_widget('previousUnitName')
132 self._previousUnitValue = widgets.get_widget('previousUnitValue')
134 self._unitSymbol = widgets.get_widget('unitSymbol')
135 self._previousUnitSymbol = widgets.get_widget('previousUnitSymbol')
137 self._unitDescription = widgets.get_widget('unitDescription')
139 self._searchLayout = widgets.get_widget('searchLayout')
140 self._searchLayout.hide()
141 self._findEntry = widgets.get_widget('findEntry')
142 self._findLabel = widgets.get_widget('findLabel')
143 self._findButton = widgets.get_widget('findButton')
145 self._unitsNameRenderer = gtk.CellRendererText()
146 self._unitsNameRenderer.set_property("scale", 0.75)
147 if FORCE_HILDON_LIKE:
148 self._unitsNameRenderer.set_property("ellipsize", pango.ELLIPSIZE_END)
149 self._unitsNameRenderer.set_property("width-chars", 5)
150 self._unitNameColumn = gtk.TreeViewColumn(_('Name'), self._unitsNameRenderer)
151 self._unitNameColumn.set_property('resizable', True)
152 self._unitNameColumn.add_attribute(self._unitsNameRenderer, 'text', self.UNITS_NAME_IDX)
153 self._unitNameColumn.set_clickable(True)
154 self._unitNameColumn.connect("clicked", self._on_click_unit_column)
155 self._unitsView.append_column(self._unitNameColumn)
157 renderer = gtk.CellRendererText()
158 renderer.set_property("xalign", 1.0)
159 renderer.set_property("alignment", pango.ALIGN_RIGHT)
160 hildonize.set_cell_thumb_selectable(renderer)
161 self._unitIntegerColumn = gtk.TreeViewColumn(_('Value'), renderer)
162 self._unitIntegerColumn.set_property('resizable', True)
163 self._unitIntegerColumn.add_attribute(renderer, 'text', self.UNITS_INTEGER_IDX)
164 self._unitIntegerColumn.set_clickable(True)
165 self._unitIntegerColumn.connect("clicked", self._on_click_unit_column)
166 self._unitsView.append_column(self._unitIntegerColumn)
168 renderer = gtk.CellRendererText()
169 renderer.set_property("xalign", 0.0)
170 renderer.set_property("alignment", pango.ALIGN_LEFT)
171 renderer.set_property("scale", 0.75)
172 self._unitFractionalColumn = gtk.TreeViewColumn(_(''), renderer)
173 self._unitFractionalColumn.set_property('resizable', True)
174 self._unitFractionalColumn.add_attribute(renderer, 'text', self.UNITS_FRACTION_IDX)
175 self._unitFractionalColumn.set_clickable(True)
176 self._unitFractionalColumn.connect("clicked", self._on_click_unit_column)
177 self._unitsView.append_column(self._unitFractionalColumn)
179 renderer = gtk.CellRendererText()
180 renderer.set_property("ellipsize", pango.ELLIPSIZE_END)
181 #renderer.set_property("scale", 0.5)
182 self._unitSymbolColumn = gtk.TreeViewColumn(_('Units'), renderer)
183 self._unitSymbolColumn.set_property('resizable', True)
184 self._unitSymbolColumn.add_attribute(renderer, 'text', self.UNITS_SYMBOL_IDX)
185 self._unitSymbolColumn.set_clickable(True)
186 self._unitSymbolColumn.connect("clicked", self._on_click_unit_column)
187 self._unitsView.append_column(self._unitSymbolColumn)
189 self._unitModel = gtk.ListStore(
190 gobject.TYPE_STRING, # UNITS_NAME_IDX
191 gobject.TYPE_STRING, # UNITS_VALUE_IDX
192 gobject.TYPE_STRING, # UNITS_SYMBOL_IDX
193 gobject.TYPE_STRING, # UNITS_INTEGER_IDX
194 gobject.TYPE_STRING, # UNITS_FRACTION_IDX
196 self._sortedUnitModel = gtk.TreeModelSort(self._unitModel)
197 columns = self._get_column_sort_stuff()
198 for columnIndex, (column, sortDirection, col_cmp) in enumerate(columns):
199 self._sortedUnitModel.set_sort_func(columnIndex, col_cmp)
200 self._unitsView.set_model(self._sortedUnitModel)
202 #Insert a column into the category list even though the heading will not be seen
203 renderer = gtk.CellRendererText()
204 self._categoryColumn = gtk.TreeViewColumn('Title', renderer)
205 self._categoryColumn.set_property('resizable', 1)
206 self._categoryColumn.add_attribute(renderer, 'text', 0)
207 self._categoryView.append_column(self._categoryColumn)
209 self._categoryModel = gtk.ListStore(gobject.TYPE_STRING)
210 self._categoryView.set_model(self._categoryModel)
211 #colourize each row differently for easier reading
212 self._categoryView.set_property('rules_hint', 1)
214 #Populate the catagories list
215 for key in unit_data.UNIT_CATEGORIES:
217 self._categoryModel.append(row)
219 #--------- connections to GUI ----------------
220 self._mainWindow.connect("delete-event", self._on_user_exit)
221 self._mainWindow.connect("key-press-event", self._on_key_press)
222 self._mainWindow.connect("window-state-event", self._on_window_state_change)
223 self._categorySelectionButton.connect("clicked", self._on_category_selector_clicked)
224 self._categoryView.connect("cursor-changed", self._on_click_category)
225 self._findButton.connect("clicked", self._on_find_activate)
226 self._findEntry.connect("activate", self._on_find_activate)
227 self._findEntry.connect("changed", self._on_findEntry_changed)
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("exitMenuItem").connect("activate", self._on_user_exit)
237 for scrollingWidgetName in (
238 "unitsViewScrolledWindow",
240 scrollingWidget = widgets.get_widget(scrollingWidgetName)
241 assert scrollingWidget is not None, scrollingWidgetName
242 hildonize.hildonize_scrollwindow_with_viewport(scrollingWidget)
244 if hildonize.IS_HILDON_SUPPORTED or FORCE_HILDON_LIKE:
245 self._categoryView.get_parent().hide()
246 self._unitsView.set_headers_visible(False)
247 self._previousUnitName.get_parent().hide()
248 self._unitDescription.get_parent().get_parent().hide()
250 self._categorySelectionButton.hide()
252 replacementButtons = []
253 menu = hildonize.hildonize_menu(
255 widgets.get_widget("mainMenuBar"),
259 if not hildonize.IS_HILDON_SUPPORTED:
260 _moduleLogger.info("No hildonization support")
262 hildonize.set_application_title(
263 self._mainWindow, "%s - Unit Conversion Utility" % constants.__pretty_app_name__
265 iconPath = pixmapspath + '/gonvert.png'
266 if os.path.exists(iconPath):
267 self._mainWindow.set_icon(gtk.gdk.pixbuf_new_from_file(iconPath))
269 _moduleLogger.warn("Error: Could not find gonvert icon: %s" % iconPath)
271 self._load_settings()
272 self._mainWindow.show()
274 def _load_settings(self):
275 #Restore window size from previously saved settings if it exists and is valid.
276 windowDatPath = "/".join((constants._data_path_, "window.dat"))
277 if os.path.exists(windowDatPath):
278 saved_window = pickle.load(open(windowDatPath, "r"))
280 a, b = saved_window['size']
284 self._mainWindow.resize(a, b)
286 #Restore selections from previously saved settings if it exists and is valid.
288 selectedCategoryName = unit_data.UNIT_CATEGORIES[0]
289 selectionsDatPath = "/".join((constants._data_path_, "selections.dat"))
290 if os.path.exists(selectionsDatPath):
291 selections = pickle.load(open(selectionsDatPath, 'r'))
293 self._defaultUnitForCategory = selections['selected_units']
298 selectedCategoryName = selections['selected_category']
303 categoryIndex = unit_data.UNIT_CATEGORIES.index(selectedCategoryName)
305 _moduleLogger.warn("Unknown category: %s" % selectedCategoryName)
307 self._categorySelectionButton.get_child().set_markup("<big>%s</big>" % selectedCategoryName)
308 self._categoryView.set_cursor(categoryIndex, self._categoryColumn, False)
309 self._categoryView.grab_focus()
311 self._select_default_unit()
313 def _save_settings(self):
315 This routine saves the selections to a file, and
316 should therefore only be called when exiting the program.
318 Update selections dictionary which consists of the following keys:
319 'self._selectedCategoryName': full name of selected category
320 'self._defaultUnitForCategory': self._defaultUnitForCategory dictionary which contains:
321 [categoryname: #1 displayed unit, #2 displayed unit]
323 #Determine the contents of the selected category row
324 selected, iter = self._categoryView.get_selection().get_selected()
325 self._selectedCategoryName = self._categoryModel.get_value(iter, 0)
328 'selected_category': self._selectedCategoryName,
329 'selected_units': self._defaultUnitForCategory
331 selectionsDatPath = "/".join((constants._data_path_, "selections.dat"))
332 pickle.dump(selections, open(selectionsDatPath, 'w'))
334 #Get last size of app and save it
336 'size': self._mainWindow.get_size()
338 windowDatPath = "/".join((constants._data_path_, "window.dat"))
339 pickle.dump(window_settings, open(windowDatPath, 'w'))
341 def _refresh_columns(self):
342 self._unitsView.remove_column(self._unitNameColumn)
343 self._unitsView.remove_column(self._unitIntegerColumn)
344 self._unitsView.remove_column(self._unitFractionalColumn)
345 self._unitsView.remove_column(self._unitSymbolColumn)
347 self._unitsView.append_column(self._unitNameColumn)
348 self._unitsView.append_column(self._unitIntegerColumn)
349 self._unitsView.append_column(self._unitFractionalColumn)
350 self._unitsView.append_column(self._unitSymbolColumn)
352 def _clear_find(self):
353 # switch to "new find" state
354 self._find_result = []
357 # Clear our user message
358 self._findLabel.set_text('')
360 def _find_first(self):
361 assert len(self._find_result) == 0
362 assert self._findIndex == 0
363 findString = self._findEntry.get_text().strip().lower()
367 # Gather info on all the matching units from all categories
368 for catIndex, category in enumerate(unit_data.UNIT_CATEGORIES):
369 units = unit_data.get_units(category)
370 for unitIndex, unit in enumerate(units):
371 loweredUnit = unit.lower()
372 if loweredUnit in findString or findString in loweredUnit:
373 self._find_result.append((category, unit, catIndex, unitIndex))
375 def _update_find_selection(self):
376 assert 0 < len(self._find_result)
378 #check if next find is in a new category (prevent category changes when unnecessary
379 searchCategoryName = self._find_result[self._findIndex][0]
380 if self._selectedCategoryName != searchCategoryName:
381 self._categorySelectionButton.get_child().set_markup("<big>%s</big>" % searchCategoryName)
382 self._categoryView.set_cursor(
383 self._find_result[self._findIndex][2], self._categoryColumn, False
386 self._unitsView.set_cursor(
387 self._find_result[self._findIndex][3], self._unitNameColumn, True
390 def _find_next(self):
391 if len(self._find_result) == 0:
394 if self._findIndex == len(self._find_result)-1:
399 if not self._find_result:
400 self._findLabel.set_text('Text not found')
402 self._update_find_selection()
403 resultsLeft = len(self._find_result) - self._findIndex - 1
404 self._findLabel.set_text(
405 '%s result(s) left' % (resultsLeft, )
408 def _find_previous(self):
409 if len(self._find_result) == 0:
412 if self._findIndex == 0:
413 self._findIndex = len(self._find_result)-1
417 if not self._find_result:
418 self._findLabel.set_text('Text not found')
420 self._update_find_selection()
421 resultsLeft = len(self._find_result) - self._findIndex - 1
422 self._findLabel.set_text(
423 '%s result(s) left' % (resultsLeft, )
426 def _toggle_find(self):
427 if self._searchLayout.get_property("visible"):
428 self._searchLayout.hide()
429 self._unitsView.grab_focus()
431 self._searchLayout.show()
432 self._findEntry.grab_focus()
434 def _unit_model_cmp(self, sortedModel, leftItr, rightItr):
435 leftUnitText = self._unitModel.get_value(leftItr, self.UNITS_NAME_IDX)
436 rightUnitText = self._unitModel.get_value(rightItr, self.UNITS_NAME_IDX)
437 return cmp(leftUnitText, rightUnitText)
439 def _symbol_model_cmp(self, sortedModel, leftItr, rightItr):
440 leftSymbolText = self._unitModel.get_value(leftItr, self.UNITS_SYMBOL_IDX)
441 rightSymbolText = self._unitModel.get_value(rightItr, self.UNITS_SYMBOL_IDX)
442 return cmp(leftSymbolText, rightSymbolText)
444 def _value_model_cmp(self, sortedModel, leftItr, rightItr):
445 #special sorting exceptions for ascii values (instead of float values)
446 if self._selectedCategoryName == "Computer Numbers":
447 leftValue = self._unitModel.get_value(leftItr, self.UNITS_VALUE_IDX)
448 rightValue = self._unitModel.get_value(rightItr, self.UNITS_VALUE_IDX)
450 leftValueText = self._unitModel.get_value(leftItr, self.UNITS_VALUE_IDX)
451 leftValue = float(leftValueText) if leftValueText else 0.0
453 rightValueText = self._unitModel.get_value(rightItr, self.UNITS_VALUE_IDX)
454 rightValue = float(rightValueText) if rightValueText else 0.0
455 return cmp(leftValue, rightValue)
457 def _get_column_sort_stuff(self):
459 (self._unitNameColumn, "_unit_sort_direction", self._unit_model_cmp),
460 (self._unitIntegerColumn, "_value_sort_direction", self._value_model_cmp),
461 (self._unitFractionalColumn, "_value_sort_direction", self._value_model_cmp),
462 (self._unitSymbolColumn, "_units_sort_direction", self._symbol_model_cmp),
466 def _switch_category(self, category):
467 self._selectedCategoryName = category
468 self._unitDataInCategory = unit_data.UNIT_DESCRIPTIONS[self._selectedCategoryName]
470 #Fill up the units descriptions and clear the value cells
471 self._clear_visible_unit_data()
473 for key in unit_data.get_units(self._selectedCategoryName):
474 row = key, '0.0', self._unitDataInCategory[key][1], '0.', '0'
475 self._unitModel.append(row)
476 nameLength = max(nameLength, len(key))
477 self._sortedUnitModel.sort_column_changed()
479 if FORCE_HILDON_LIKE:
480 maxCatCharWidth = int(nameLength * 0.75)
481 maxCharWidth = int(len("nibble | hexit | quadbit") * 0.75)
482 charWidth = min(maxCatCharWidth, maxCharWidth)
483 self._unitsNameRenderer.set_property("width-chars", charWidth)
485 self._select_default_unit()
487 def _clear_visible_unit_data(self):
488 self._unitDescription.get_buffer().set_text("")
489 self._unitName.set_text('')
490 self._unitValue.set_text('')
491 self._unitSymbol.set_text('')
493 self._previousUnitName.set_text('')
494 self._previousUnitValue.set_text('')
495 self._previousUnitSymbol.set_text('')
497 self._unitModel.clear()
499 def _select_default_unit(self):
500 # Restore the previous historical settings of previously selected units
501 # in this newly selected category
502 defaultPrimary = unit_data.get_base_unit(self._selectedCategoryName)
503 defaultSecondary = ""
504 if self._selectedCategoryName in self._defaultUnitForCategory:
505 if self._defaultUnitForCategory[self._selectedCategoryName][0]:
506 defaultPrimary = self._defaultUnitForCategory[self._selectedCategoryName][0]
507 if self._defaultUnitForCategory[self._selectedCategoryName][1]:
508 defaultSecondary = self._defaultUnitForCategory[self._selectedCategoryName][1]
510 units = unit_data.get_units(self._selectedCategoryName)
512 #Restore oldest selection first.
515 unitIndex = units.index(defaultPrimary)
518 self._unitsView.set_cursor(unitIndex, self._unitNameColumn, True)
520 #Restore newest selection second.
523 unitIndex = units.index(defaultSecondary)
526 self._unitsView.set_cursor(unitIndex, self._unitNameColumn, True)
528 # select the text so user can start typing right away
529 self._unitValue.grab_focus()
530 self._unitValue.select_region(0, -1)
532 def _sanitize_value(self, userEntry):
533 if self._selectedCategoryName == "Computer Numbers":
542 value = float(userEntry)
545 def _on_key_press(self, widget, event, *args):
547 @note Hildon specific
549 RETURN_TYPES = (gtk.keysyms.Return, gtk.keysyms.ISO_Enter, gtk.keysyms.KP_Enter)
552 event.keyval == gtk.keysyms.F6 or
553 event.keyval in RETURN_TYPES and event.get_state() & gtk.gdk.CONTROL_MASK
555 if self._isFullScreen:
556 self._mainWindow.unfullscreen()
558 self._mainWindow.fullscreen()
559 elif event.keyval == gtk.keysyms.f and event.get_state() & gtk.gdk.CONTROL_MASK:
561 elif event.keyval == gtk.keysyms.p and event.get_state() & gtk.gdk.CONTROL_MASK:
562 self._find_previous()
563 elif event.keyval == gtk.keysyms.n and event.get_state() & gtk.gdk.CONTROL_MASK:
565 elif event.keyval == ord("l") and event.get_state() & gtk.gdk.CONTROL_MASK:
566 with open(constants._user_logpath_, "r") as f:
567 logLines = f.xreadlines()
568 log = "".join(logLines)
569 self._clipboard.set_text(str(log))
571 _moduleLogger.exception("_on_key_press")
573 def _on_browse_key_press(self, widget, event, *args):
575 if event.keyval == gtk.keysyms.uparrow or event.keyval == gtk.keysyms.Up:
576 index, column = self._unitsView.get_cursor()
577 newIndex = max(index[0]-1, 0)
578 self._unitsView.set_cursor((newIndex, ), column, True)
579 return True # override default behavior
580 elif event.keyval == gtk.keysyms.downarrow or event.keyval == gtk.keysyms.Down:
581 index, column = self._unitsView.get_cursor()
582 newIndex = min(index[0]+1, len(self._unitModel)-1)
583 self._unitsView.set_cursor((newIndex, ), column, True)
584 return True # override default behavior
586 _moduleLogger.exception("_on_key_press")
588 def _on_window_state_change(self, widget, event, *args):
590 @note Hildon specific
593 if event.new_window_state & gtk.gdk.WINDOW_STATE_FULLSCREEN:
594 self._isFullScreen = True
596 self._isFullScreen = False
598 _moduleLogger.exception("_on_window_state_change")
600 def _on_findEntry_changed(self, *args):
602 Clear out find results since the user wants to look for something new
607 _moduleLogger.exception("_on_findEntry_changed")
609 def _on_find_activate(self, *args):
612 self._findButton.grab_focus()
614 _moduleLogger.exception("_on_find_activate")
616 def _on_click_unit_column(self, col):
618 Sort the contents of the col when the user clicks on the title.
621 #Determine which column requires sorting
622 columns = self._get_column_sort_stuff()
623 for columnIndex, (maybeCol, directionName, col_cmp) in enumerate(columns):
625 direction = getattr(self, directionName)
626 gtkDirection = gtk.SORT_ASCENDING if direction else gtk.SORT_DESCENDING
629 self._sortedUnitModel.set_sort_column_id(columnIndex, gtkDirection)
631 # set the visual for sorting
632 col.set_sort_indicator(True)
633 col.set_sort_order(not direction)
635 setattr(self, directionName, not direction)
638 maybeCol.set_sort_indicator(False)
640 assert False, "Unknown column: %s" % (col.get_title(), )
642 _moduleLogger.exception("_on_click_unit_column")
644 def _on_category_selector_clicked(self, *args):
646 currenntIndex = unit_data.UNIT_CATEGORIES.index(self._selectedCategoryName)
647 newIndex = hildonize.touch_selector(
650 unit_data.UNIT_CATEGORIES,
654 selectedCategoryName = unit_data.UNIT_CATEGORIES[newIndex]
655 self._categorySelectionButton.get_child().set_markup("<big>%s</big>" % selectedCategoryName)
656 self._categoryView.set_cursor(newIndex, self._categoryColumn, False)
657 self._categoryView.grab_focus()
659 _moduleLogger.exception("_on_category_selector_clicked")
661 def _on_click_category(self, *args):
663 selected, iter = self._categoryView.get_selection().get_selected()
665 # User is typing in an invalid string, not selecting any category
667 selectedCategory = self._categoryModel.get_value(iter, 0)
668 self._switch_category(selectedCategory)
670 _moduleLogger.exception("_on_click_category")
672 def _on_click_unit(self, *args):
674 selected, iter = self._unitsView.get_selection().get_selected()
675 selected_unit = selected.get_value(iter, self.UNITS_NAME_IDX)
676 unit_spec = self._unitDataInCategory[selected_unit]
680 if self._unitName.get_text() != selected_unit:
681 self._previousUnitName.set_text(self._unitName.get_text())
682 self._previousUnitValue.set_text(self._unitValue.get_text())
683 self._previousUnitSymbol.set_text(self._unitSymbol.get_text())
684 if self._unitSymbol.get_text():
687 self._unitName.set_text(selected_unit)
688 self._unitValue.set_text(selected.get_value(iter, self.UNITS_VALUE_IDX))
689 buffer = self._unitDescription.get_buffer()
690 buffer.set_text(unit_spec[2])
691 self._unitSymbol.set_text(unit_spec[1]) # put units into label text
698 self._unitSymbol.show()
699 self._previousUnitSymbol.show()
701 self._unitSymbol.hide()
702 self._previousUnitSymbol.hide()
704 if self._unitValue.get_text() == '':
705 if self._selectedCategoryName == "Computer Numbers":
706 self._unitValue.set_text("0")
708 self._unitValue.set_text("0.0")
710 self._defaultUnitForCategory[self._selectedCategoryName] = [
711 self._unitName.get_text(), self._previousUnitName.get_text()
714 # select the text so user can start typing right away
715 self._unitValue.grab_focus()
716 self._unitValue.select_region(0, -1)
718 _moduleLogger.exception("_on_click_unit")
720 def _on_unit_value_changed(self, *args):
722 if self._unitName.get_text() == '':
724 if not self._unitValue.is_focus():
727 #retrieve the conversion function and value from the selected unit
728 value = self._sanitize_value(self._unitValue.get_text())
729 func, arg = self._unitDataInCategory[self._unitName.get_text()][0]
730 base = func.to_base(value, arg)
732 #point to the first row
733 for row in self._unitModel:
734 func, arg = self._unitDataInCategory[row[self.UNITS_NAME_IDX]][0]
735 newValue = func.from_base(base, arg)
737 newValueDisplay = str(newValue)
738 integerDisplay, fractionalDisplay = split_number(newValue)
740 row[self.UNITS_VALUE_IDX] = newValueDisplay
741 row[self.UNITS_INTEGER_IDX] = integerDisplay
742 row[self.UNITS_FRACTION_IDX] = fractionalDisplay
744 # Update the secondary unit entry
745 if self._previousUnitName.get_text() != '':
746 func, arg = self._unitDataInCategory[self._previousUnitName.get_text()][0]
747 self._previousUnitValue.set_text(str(func.from_base(base, arg, )))
749 self._sortedUnitModel.sort_column_changed()
750 self._refresh_columns()
752 _moduleLogger.exception("_on_unit_value_changed")
754 def _on_previous_unit_value_changed(self, *args):
756 if self._previousUnitName.get_text() == '':
758 if not self._previousUnitValue.is_focus():
761 #retrieve the conversion function and value from the selected unit
762 value = self._sanitize_value(self._previousUnitValue.get_text())
763 func, arg = self._unitDataInCategory[self._previousUnitName.get_text()][0]
764 base = func.to_base(value, arg)
766 #point to the first row
767 for row in self._unitModel:
768 func, arg = self._unitDataInCategory[row[self.UNITS_NAME_IDX]][0]
769 newValue = func.from_base(base, arg)
771 newValueDisplay = str(newValue)
772 integerDisplay, fractionalDisplay = split_number(newValue)
774 row[self.UNITS_VALUE_IDX] = newValueDisplay
775 row[self.UNITS_INTEGER_IDX] = integerDisplay
776 row[self.UNITS_FRACTION_IDX] = fractionalDisplay
778 # Update the primary unit entry
779 func, arg = self._unitDataInCategory[self._unitName.get_text()][0]
780 self._unitValue.set_text(str(func.from_base(base, arg, )))
782 self._sortedUnitModel.sort_column_changed()
783 self._refresh_columns()
785 _moduleLogger.exception("_on_previous_unit_value_changed")
787 def _on_about_clicked(self, a):
788 dlg = gtk.AboutDialog()
789 dlg.set_name(constants.__pretty_app_name__)
790 dlg.set_version("%s-%d" % (constants.__version__, constants.__build__))
791 dlg.set_copyright("Copyright 2009 - GPL")
793 dlg.set_website("http://unihedron.com/projects/gonvert/gonvert.php")
794 dlg.set_authors(["Anthony Tekatch <anthony@unihedron.com>", "Ed Page <eopage@byu.net> (Blame him for the most recent bugs)"])
798 def _on_user_exit(self, *args):
800 self._save_settings()
802 _moduleLogger.exception("_on_user_exit")
808 gtk.gdk.threads_init()
809 if hildonize.IS_HILDON_SUPPORTED:
810 gtk.set_application_name(constants.__pretty_app_name__)
812 if not PROFILE_STARTUP:
816 if __name__ == "__main__":
817 logging.basicConfig(level = logging.DEBUG)
819 os.makedirs(constants._data_path_)