def create_remote_selector(win):
global remote_sources
global google_new_btn
global google_item_picker
global remote_selector
remote_selector = hildon.TouchSelector()
remote_sources = gtk.ListStore(str, str)
renderer = gtk.CellRendererText()
column = remote_selector.append_column(remote_sources, renderer, text=1)
column.set_property("text-column", 1)
google_item_picker = hildon.PickerButton(gtk.HILDON_SIZE_AUTO | \
gtk.HILDON_SIZE_FINGER_HEIGHT, \
hildon.BUTTON_ARRANGEMENT_VERTICAL)
google_item_picker.set_title("Remote Source")
google_item_picker.set_selector(remote_selector)
google_item_picker.set_sensitive(False)
google_new_btn = hildon.Button(gtk.HILDON_SIZE_AUTO_WIDTH | \
gtk.HILDON_SIZE_FINGER_HEIGHT, \
hildon.BUTTON_ARRANGEMENT_HORIZONTAL)
google_new_btn.set_label("New...")
google_new_btn.connect("clicked", new_remote_source, "hint")
google_new_btn.set_sensitive(False)
hbox = gtk.HBox()
hbox.pack_start(google_item_picker)
hbox.pack_start(google_new_btn, False, False, 30)
return hbox
def create_local_selector(win):
global local_source_list
global local_selector
local_selector = hildon.TouchSelector()
local_source_list = gtk.ListStore(int, str)
renderer = gtk.CellRendererText()
column = local_selector.append_column(local_source_list, renderer, text=1)
column.set_property("text-column", 1)
picker = hildon.PickerButton(gtk.HILDON_SIZE_AUTO | \
gtk.HILDON_SIZE_FINGER_HEIGHT,
hildon.BUTTON_ARRANGEMENT_VERTICAL)
picker.set_title("Local Source")
picker.set_selector(local_selector)
new_btn = hildon.Button(gtk.HILDON_SIZE_AUTO_WIDTH | \
gtk.HILDON_SIZE_FINGER_HEIGHT, \
hildon.BUTTON_ARRANGEMENT_HORIZONTAL)
new_btn.set_label("New...")
new_btn.connect("clicked", new_local_source, "hint")
hbox = gtk.HBox()
hbox.pack_start(picker)
hbox.pack_start(new_btn, False, False, 30)
return hbox
def getVerticalPickerButton(self, title=""):
import gtk
import hildon
pb = hildon.PickerButton(
gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT,
hildon.BUTTON_ARRANGEMENT_VERTICAL)
pb.set_title(title)
return pb
def getHorizontalPickerButton(self, title=""):
import gtk
import hildon
pb = hildon.PickerButton(
gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT,
hildon.BUTTON_ARRANGEMENT_HORIZONTAL)
pb.set_title(title)
return pb
def _getRotationPickerButton(self, title=None):
"""get a picker button with an associated touch selector,
also load the last used value on startup"""
import gtk
import hildon
pb = hildon.PickerButton(
gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT,
hildon.BUTTON_ARRANGEMENT_HORIZONTAL)
if title:
pb.set_title(title)
modes = self._getRotationModes()
lastUsedValue = self.mieru.get('rotationMode',
self._getDefaultRotationMode())
selector = self.getSelector(modes, lastUsedValue)
pb.set_selector(selector)
pb.connect('value-changed', self._applyRotationCB)
return pb
def _getFittingPickerButton(self, title=None, arrangement=None):
"""get a picker button with an associated touch selector,
also load the last used value on startup"""
import gtk
import hildon
if arrangement is None:
arrangement = hildon.BUTTON_ARRANGEMENT_HORIZONTAL
fitPickerButton = hildon.PickerButton(
gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT,
arrangement)
if title:
fitPickerButton.set_title(title)
selector = self._getFittingSelector()
fitPickerButton.set_selector(selector)
fitPickerButton.connect('value-changed', self._applyFittingModeCB)
return fitPickerButton
def create_type_selector():
selector = hildon.TouchSelector()
type_list = gtk.ListStore(int, str)
type_list.append([consts.SYNC_TYPE_CAL, "Calendar"])
renderer = gtk.CellRendererText()
column = selector.append_column(type_list, renderer, text=1)
column.set_property("text-column", 1)
picker = hildon.PickerButton(gtk.HILDON_SIZE_AUTO | \
gtk.HILDON_SIZE_FINGER_HEIGHT,
hildon.BUTTON_ARRANGEMENT_HORIZONTAL)
picker.set_title("Synchronization item")
picker.set_selector(selector)
# default on Calendar
picker.set_active(0)
return picker
def create_source_selector():
source_selector = hildon.TouchSelector()
type_list = gtk.ListStore(int, str)
type_list.append([consts.DATASOURCE_BUILTIN, "Built-in"])
renderer = gtk.CellRendererText()
column = source_selector.append_column(type_list, renderer, text=1)
column.set_property("text-column", 1)
source_selector.connect("changed", source_selector_changed)
picker = hildon.PickerButton(gtk.HILDON_SIZE_AUTO | \
gtk.HILDON_SIZE_FINGER_HEIGHT,
hildon.BUTTON_ARRANGEMENT_HORIZONTAL)
picker.set_title("Local Data Source")
picker.set_selector(source_selector)
# default on Built-In
picker.set_active(0)
return picker
def __init__(self, parent, coherence):
super(SelectMRDialog,
self).__init__(parent=parent,
buttons=(gtk.STOCK_APPLY, gtk.RESPONSE_ACCEPT))
self.set_title(_("Select a MediaRenderer"))
self.mrs = []
self.mediarenderer_picker = hildon.PickerButton(
gtk.HILDON_SIZE_FINGER_HEIGHT, hildon.BUTTON_ARRANGEMENT_VERTICAL)
selector = hildon.TouchSelectorEntry(text=True)
self.mediarenderer_picker.set_title(_('Mediarenderer:'))
for device in coherence.devices:
if device.get_friendly_device_type().lower() == "mediarenderer":
self.mrs.append(device)
selector.append_text(device.get_friendly_name())
self.mediarenderer_picker.set_selector(selector)
if self.mrs:
self.mediarenderer_picker.set_active(0)
self.vbox.add(self.mediarenderer_picker)
self.vbox.show_all()
def _show_tile_select_dialog(self, zoom_steps):
sel_zoom = hildon.TouchSelector(text=True)
current_zoom = self.map.get_zoom()
for zoom, size, count in zoom_steps:
sel_zoom.append_text(
'Zoom %d (Current+%d) ~%s' %
(zoom, zoom - current_zoom, self.core.format_file_size(size)))
sel_zoom.set_column_selection_mode(
hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)
pick_zoom = hildon.PickerButton(
gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT,
hildon.BUTTON_ARRANGEMENT_HORIZONTAL)
pick_zoom.set_selector(sel_zoom)
pick_zoom.set_title("Select Zoom Levels")
def print_func(widget):
size = sum(zoom_steps[x][1]
for x, in sel_zoom.get_selected_rows(0))
pick_zoom.set_value('~' + self.core.format_file_size(size))
pick_zoom.connect('value-changed', print_func)
pick_zoom.connect('realize', print_func)
dialog = gtk.Dialog("Download Map Tiles", self.window,
gtk.DIALOG_DESTROY_WITH_PARENT,
(gtk.STOCK_OK, gtk.RESPONSE_ACCEPT))
dialog.vbox.pack_start(pick_zoom)
dialog.show_all()
res = dialog.run()
dialog.hide()
if res != gtk.RESPONSE_ACCEPT:
return []
steps = [zoom_steps[x] for x, in sel_zoom.get_selected_rows(0)]
return steps
def create_direction_selector():
global direction_selector
direction_selector = hildon.TouchSelector()
type_list = gtk.ListStore(int, str)
type_list.append([consts.DIRECTION_BOTH, "Both"])
type_list.append([consts.DIRECTION_FROM_GOOGLE_ONLY, "From Google Only"])
type_list.append([consts.DIRECTION_TO_GOOGLE_ONLY, "To Google Only"])
renderer = gtk.CellRendererText()
column = direction_selector.append_column(type_list, renderer, text=1)
column.set_property("text-column", 1)
picker = hildon.PickerButton(gtk.HILDON_SIZE_AUTO | \
gtk.HILDON_SIZE_FINGER_HEIGHT,
hildon.BUTTON_ARRANGEMENT_HORIZONTAL)
picker.set_title("Synchronization direction")
picker.set_selector(direction_selector)
# default on Built-In
picker.set_active(0)
return picker
def create_account_selector():
global account_selector
global account_list
account_selector = hildon.TouchSelector()
account_list = gtk.ListStore(int, str)
renderer = gtk.CellRendererText()
column = account_selector.append_column(account_list, renderer, text=1)
column.set_property("text-column", 1)
account_selector.connect("changed", account_selector_changed)
picker = hildon.PickerButton(gtk.HILDON_SIZE_AUTO | \
gtk.HILDON_SIZE_FINGER_HEIGHT,
hildon.BUTTON_ARRANGEMENT_HORIZONTAL)
picker.set_title("Google Account")
picker.set_selector(account_selector)
for id, acct in google_accounts.get_registered_accounts():
account_list.append([int(id), acct])
return picker
def __init__(self, weboob):
self.touch_selector_entry_filled = False
self.refresh_in_progress = False
self.connected = False
self.weboob = weboob
try:
self.connection = conic.Connection()
self.connection.connect("connection-event", self.connect_event)
self.connection.set_property("automatic-connection-events", True)
self.connection.request_connection(conic.CONNECT_FLAG_NONE)
except NotImplementedError:
pass
horizontal_box = gtk.HBox()
self.main_window = toolkit.Window()
try:
self.refresh_button = toolkit.Button(
gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT,
hildon.BUTTON_ARRANGEMENT_HORIZONTAL, "Actualiser")
self.retour_button = hildon.Button(
gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT,
hildon.BUTTON_ARRANGEMENT_HORIZONTAL, "Retour")
self.combo_source = hildon.TouchSelectorEntry(text=True)
self.combo_dest = hildon.TouchSelectorEntry(text=True)
self.picker_button_source = hildon.PickerButton(
gtk.HILDON_SIZE_AUTO, hildon.BUTTON_ARRANGEMENT_VERTICAL)
self.picker_button_dest = hildon.PickerButton(
gtk.HILDON_SIZE_AUTO, hildon.BUTTON_ARRANGEMENT_VERTICAL)
self.picker_button_source.set_sensitive(False)
self.picker_button_dest.set_sensitive(False)
self.picker_button_source.set_title("Gare de Depart")
self.picker_button_dest.set_title("Gare d'arrivee")
self.picker_button_source.set_selector(self.combo_source)
self.picker_button_dest.set_selector(self.combo_dest)
horizontal_box.pack_start(self.picker_button_source)
horizontal_box.pack_start(self.picker_button_dest)
except AttributeError:
self.refresh_button = gtk.Button("Actualiser")
self.retour_button = gtk.Button("Retour")
self.combo_source = gtk.combo_box_entry_new_text()
self.combo_dest = gtk.combo_box_entry_new_text()
horizontal_box.pack_start(self.combo_source)
horizontal_box.pack_start(self.combo_dest)
self.main_window.set_title("Horaires des Prochains Trains")
self.main_window.connect("destroy", self.on_main_window_destroy)
self.refresh_button.connect("clicked", self.on_refresh_button_clicked)
self.retour_button.set_sensitive(False)
self.retour_button.connect("clicked", self.on_retour_button_clicked)
self.treestore = gtk.TreeStore(str, str, str, str, str)
treeview = gtk.TreeView(self.treestore)
treeview.append_column(
gtk.TreeViewColumn('Train', gtk.CellRendererText(), text=0))
treeview.append_column(
gtk.TreeViewColumn('Horaire', gtk.CellRendererText(), text=1))
treeview.append_column(
gtk.TreeViewColumn('Destination', gtk.CellRendererText(), text=2))
treeview.append_column(
gtk.TreeViewColumn('Voie', gtk.CellRendererText(), text=3))
treeview.append_column(
gtk.TreeViewColumn('Information', gtk.CellRendererText(), text=4))
vertical_box = gtk.VBox()
vertical_box.pack_start(horizontal_box)
horizontal_box.pack_start(self.retour_button)
vertical_box.pack_start(treeview)
vertical_box.pack_start(self.refresh_button)
self.main_window.add(vertical_box)
self.main_window.show_all()
self.fill_touch_selector_entry()
if toolkit != gtk:
self.picker_button_source.connect("value-changed",
self.check_station_input,
self.picker_button_source)
self.picker_button_dest.connect("value-changed",
self.check_station_input,
self.picker_button_dest)
def _on_show_search(self, widget, data):
name = hildon.Entry(gtk.HILDON_SIZE_AUTO_WIDTH
| gtk.HILDON_SIZE_FINGER_HEIGHT)
name.set_placeholder("search for name...")
name_hbox = hildon.Caption(None, "Name", name, None,
hildon.CAPTION_OPTIONAL)
sel_dist_type = hildon.TouchSelector(text=True)
sel_dist_type.append_text('anywhere')
sel_dist_type.append_text('around my position')
sel_dist_type.append_text('around the current map center')
pick_dist_type = hildon.PickerButton(
gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT,
hildon.BUTTON_ARRANGEMENT_HORIZONTAL)
pick_dist_type.set_selector(sel_dist_type)
pick_dist_type.set_title("Search")
sel_dist_type.select_iter(0,
sel_dist_type.get_model(0).get_iter(1),
False)
list_dist_radius = (1, 5, 10, 20, 50, 100, 200)
sel_dist_radius = hildon.TouchSelector(text=True)
for x in list_dist_radius:
sel_dist_radius.append_text('%d km' % x)
pick_dist_radius = hildon.PickerButton(
gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT,
hildon.BUTTON_ARRANGEMENT_HORIZONTAL)
pick_dist_radius.set_selector(sel_dist_radius)
pick_dist_radius.set_title("Radius")
pick_dist_type.connect(
'value-changed', lambda caller: pick_dist_radius.set_sensitive(
sel_dist_type.get_selected_rows(0)[0][0] != 0))
sel_dist_radius.select_iter(0,
sel_dist_radius.get_model(0).get_iter(1),
False)
sel_size = hildon.TouchSelector(text=True)
sel_size.append_text('micro')
sel_size.append_text('small')
sel_size.append_text('regular')
sel_size.append_text('huge')
sel_size.append_text('other')
sel_size.set_column_selection_mode(
hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)
pick_size = hildon.PickerButton(
gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT,
hildon.BUTTON_ARRANGEMENT_HORIZONTAL)
pick_size.set_selector(sel_size)
pick_size.set_title("Select Size(s)")
for i in xrange(5):
sel_size.select_iter(0, sel_size.get_model(0).get_iter(i), False)
sel_type = hildon.TouchSelector(text=True)
sel_type.append_text('traditional')
sel_type.append_text('multi-stage')
sel_type.append_text('virtual')
sel_type.append_text('earth')
sel_type.append_text('event')
sel_type.append_text('mystery')
sel_type.append_text('all')
sel_type.set_column_selection_mode(
hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)
pick_type = hildon.PickerButton(
gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT,
hildon.BUTTON_ARRANGEMENT_HORIZONTAL)
pick_type.set_selector(sel_type)
pick_type.set_title("Select Type(s)")
sel_type.unselect_all(0)
sel_type.select_iter(0, sel_type.get_model(0).get_iter(6), False)
sel_status = hildon.TouchSelector(text=True)
sel_status.append_text('any')
sel_status.append_text("Geocaches I haven't found")
sel_status.append_text("Geocaches I have found")
sel_status.append_text("Marked Geocaches")
sel_status.append_text("Marked Geocaches I haven't found")
pick_status = hildon.PickerButton(
gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT,
hildon.BUTTON_ARRANGEMENT_HORIZONTAL)
pick_status.set_selector(sel_status)
pick_status.set_title("Select Status")
sel_status.unselect_all(0)
sel_status.select_iter(0, sel_status.get_model(0).get_iter(0), False)
sel_diff = hildon.TouchSelector(text=True)
sel_diff.append_text('1..2.5')
sel_diff.append_text('3..4')
sel_diff.append_text('4.5..5')
sel_diff.set_column_selection_mode(
hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)
pick_diff = hildon.PickerButton(
gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT,
hildon.BUTTON_ARRANGEMENT_HORIZONTAL)
pick_diff.set_selector(sel_diff)
pick_diff.set_title("Select Difficulty")
for i in xrange(3):
sel_diff.select_iter(0, sel_diff.get_model(0).get_iter(i), False)
sel_terr = hildon.TouchSelector(text=True)
sel_terr.append_text('1..2.5')
sel_terr.append_text('3..4')
sel_terr.append_text('4.5..5')
sel_terr.set_column_selection_mode(
hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)
pick_terr = hildon.PickerButton(
gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT,
hildon.BUTTON_ARRANGEMENT_HORIZONTAL)
pick_terr.set_selector(sel_terr)
pick_terr.set_title("Select Terrain")
for i in xrange(3):
sel_terr.select_iter(0, sel_terr.get_model(0).get_iter(i), False)
RESPONSE_SHOW_LIST, RESPONSE_RESET, RESPONSE_LAST_RESULTS = range(3)
dialog = gtk.Dialog("Search", self.window,
gtk.DIALOG_DESTROY_WITH_PARENT,
("OK", RESPONSE_SHOW_LIST))
dialog.add_button("Filter Map", gtk.RESPONSE_ACCEPT)
if self.map_filter_active:
dialog.add_button("Reset Filter", RESPONSE_RESET)
if self.old_search_window != None:
dialog.add_button("Last Results", RESPONSE_LAST_RESULTS)
dialog.set_size_request(800, 800)
pan = hildon.PannableArea()
options = gtk.VBox()
pan.add_with_viewport(options)
dialog.vbox.pack_start(pan)
options.pack_start(gtk.Label("Search Geocaches"))
options.pack_start(name_hbox)
options.pack_start(pick_dist_type)
options.pack_start(pick_dist_radius)
options.pack_start(pick_type)
options.pack_start(pick_status)
options.pack_start(gtk.Label("Details..."))
w = gtk.Label(
"If you select something here, only geocaches for which details were downloaded will be shown in the result."
)
w.set_line_wrap(True)
w.set_alignment(0, 0.5)
options.pack_start(w)
options.pack_start(pick_size)
options.pack_start(pick_diff)
options.pack_start(pick_terr)
while True:
dialog.show_all()
response = dialog.run()
dialog.hide()
if response == RESPONSE_RESET:
self.core.reset_filter()
self.map_filter_active = False
self.show_success("Showing all geocaches.")
return
elif response == RESPONSE_LAST_RESULTS:
if self.old_search_window == None:
return
hildon.WindowStack.get_default().push_1(self.old_search_window)
return
name_search = name.get_text().strip().lower()
sizes = [x + 1 for x, in sel_size.get_selected_rows(0)]
if sizes == [1, 2, 3, 4, 5]:
sizes = None
typelist = [
geocaching.GeocacheCoordinate.TYPE_REGULAR,
geocaching.GeocacheCoordinate.TYPE_MULTI,
geocaching.GeocacheCoordinate.TYPE_VIRTUAL,
geocaching.GeocacheCoordinate.TYPE_EARTH,
geocaching.GeocacheCoordinate.TYPE_EVENT,
geocaching.GeocacheCoordinate.TYPE_MYSTERY,
geocaching.GeocacheCoordinate.TYPE_UNKNOWN
]
types = [typelist[x] for x, in sel_type.get_selected_rows(0)]
if geocaching.GeocacheCoordinate.TYPE_UNKNOWN in types:
types = None
# found, marked
statuslist = [
(None, None),
(False, None),
(True, None),
(None, True),
(False, True),
]
found, marked = statuslist[sel_status.get_selected_rows(0)[0][0]]
numberlist = [[1, 1.5, 2, 2.5], [3, 3.5, 4], [4.5, 5]]
difficulties = []
count = 0
for x, in sel_diff.get_selected_rows(0):
difficulties += numberlist[x]
count += 1
if count == len(numberlist):
difficulties = None
terrains = []
count = 0
for x, in sel_terr.get_selected_rows(0):
terrains += numberlist[x]
count += 1
if count == len(numberlist):
terrains = None
center = None
dist_type = sel_dist_type.get_selected_rows(0)[0][0]
if dist_type == 1:
try:
center = self.gps_last_good_fix.position
except AttributeError:
logger.debug("No current Fix.")
pass
elif dist_type == 2:
center = self.map.get_center()
if center != None:
radius = list_dist_radius[sel_dist_radius.get_selected_rows(0)
[0][0]]
sqrt_2 = 1.41421356
c1 = center.transform(-45, radius * 1000 * sqrt_2)
c2 = center.transform(-45 + 180, radius * 1000 * sqrt_2)
location = (c1, c2)
else:
location = None
if response == RESPONSE_SHOW_LIST:
points, truncated = self.core.get_points_filter(
found=found,
name_search=name_search,
size=sizes,
terrain=terrains,
diff=difficulties,
ctype=types,
marked=marked,
location=location)
if len(points) > 0:
self._display_results(points, truncated)
break
else:
self.show_error(
"Search returned no geocaches. Please remember that search works only within the downloaded geocaches."
)
elif response == gtk.RESPONSE_ACCEPT:
self.core.set_filter(found=found,
name_search=name_search,
size=sizes,
terrain=terrains,
diff=difficulties,
ctype=types,
marked=marked)
self.show_success(
"Filter for map activated, ignoring distance restrictions."
)
self.map_filter_active = True
break
else:
break
def _on_show_log_fieldnote_dialog(self, widget, data):
from time import gmtime
from time import localtime
from time import strftime
if self.current_cache == None:
return
sel_type = hildon.TouchSelector(text=True)
sel_type.append_text('Post as Log')
sel_type.append_text('Upload as Fieldnote')
#sel_type.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_MULTIPLE)
pick_type = hildon.PickerButton(
gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT,
hildon.BUTTON_ARRANGEMENT_HORIZONTAL)
pick_type.set_selector(sel_size)
pick_type.set_title("Select Type")
selected = cache.upload_as if (cache.upload_as != Null) else 0
sel_type.select_iter(0,
sel_type.get_model(0).get_iter(selected), False)
statuses = [("Don't upload", geocaching.GeocacheCoordinate.LOG_NO_LOG),
("Found it", geocaching.GeocacheCoordinate.LOG_AS_FOUND),
("Did not find it",
geocaching.GeocacheCoordinate.LOG_AS_NOTFOUND),
("Post a note", geocaching.GeocacheCoordinate.LOG_AS_NOTE)]
cache = self.current_cache
dialog = gtk.Dialog("Write Log/Fieldnote", self.window,
gtk.DIALOG_DESTROY_WITH_PARENT,
(gtk.STOCK_OK, gtk.RESPONSE_ACCEPT))
if cache.logdate == '':
try:
text = strftime(self.settings['options_default_log_text'],
localtime()) % {
'machine': 'N900'
}
except ValueError:
text = self.settings['options_default_log_text']
else:
text = cache.fieldnotes
fieldnotes = gtk.TextView()
#fieldnotes.set_placeholder("Your fieldnote text...")
fieldnotes.get_buffer().set_text(text)
fieldnotes_log_as_selector = hildon.TouchSelector(text=True)
for text, status in statuses:
fieldnotes_log_as_selector.append_text(text)
i = 0
for text, status in statuses:
if cache.logas == status:
fieldnotes_log_as_selector.select_iter(
0,
fieldnotes_log_as_selector.get_model(0).get_iter(i), False)
i += 1
fieldnotes_log_as = hildon.PickerButton(
gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT,
hildon.BUTTON_ARRANGEMENT_HORIZONTAL)
fieldnotes_log_as.set_title('Log Type')
fieldnotes_log_as.set_selector(fieldnotes_log_as_selector)
dialog.vbox.pack_start(sel_type, False)
dialog.vbox.pack_start(fieldnotes_log_as, False)
dialog.vbox.pack_start(fieldnotes, True)
#dialog.vbox.pack_start(hildon.Caption(None, "Text", fieldnotes, None, hildon.CAPTION_OPTIONAL))
dialog.show_all()
result = dialog.run()
dialog.hide()
if result != gtk.RESPONSE_ACCEPT:
logger.debug('Not logging this fieldnote')
return
cache.upload_as = sel_type.get_selected_rows(0)[0][0]
cache.logas = statuses[fieldnotes_log_as_selector.get_selected_rows(0)
[0][0]][1]
cache.logdate = strftime('%Y-%m-%d', gmtime())
cache.fieldnotes = fieldnotes.get_buffer().get_text(
fieldnotes.get_buffer().get_start_iter(),
fieldnotes.get_buffer().get_end_iter())
self.core.save_fieldnote(cache)
def __init__(self, parent, mirabeau_section, media_server_enabled):
super(SettingsDialog,
self).__init__(parent=parent,
buttons=(gtk.STOCK_SAVE, gtk.RESPONSE_ACCEPT))
self.set_title(_("Settings"))
self.accounts = []
bus = dbus.SessionBus()
# account
conf_account = mirabeau_section.get("account")
index = -1
accounts = connect.gabble_accounts()
self.account_picker = hildon.PickerButton(
gtk.HILDON_SIZE_FINGER_HEIGHT, hildon.BUTTON_ARRANGEMENT_VERTICAL)
selector = hildon.TouchSelectorEntry(text=True)
self.account_picker.set_title(_('Account:'))
for account_obj_path in accounts:
account_obj = bus.get_object(ACCOUNT_MANAGER, account_obj_path)
norm_name = account_obj.Get(ACCOUNT, 'NormalizedName')
nick_name = account_obj.Get(ACCOUNT, 'Nickname')
parameters = account_obj.Get(ACCOUNT, 'Parameters')
if "" in (nick_name, norm_name):
label = parameters["account"]
else:
label = "%s - %s" % (nick_name, norm_name)
selector.append_text(label)
self.accounts.append((account_obj_path, nick_name))
if account_obj_path == conf_account:
index = accounts.index(account_obj_path)
self.account_picker.set_selector(selector)
if index > -1:
self.account_picker.set_active(index)
self.vbox.pack_start(self.account_picker, expand=False)
# conf server
self.conf_server_label = gtk.Label(_("Conference Server"))
self.conf_server_entry = hildon.Entry(gtk.HILDON_SIZE_FINGER_HEIGHT)
self.conf_server_entry.set_text(
mirabeau_section.get("conference-server", ""))
self.conf_server_hbox = gtk.HBox()
self.conf_server_hbox.pack_start(self.conf_server_label, expand=False)
self.conf_server_hbox.pack_start(self.conf_server_entry, expand=True)
self.vbox.pack_start(self.conf_server_hbox, expand=False)
# chatroom name
self.chatroom_label = gtk.Label(_("Chatroom"))
self.chatroom_entry = hildon.Entry(gtk.HILDON_SIZE_FINGER_HEIGHT)
self.chatroom_entry.set_text(mirabeau_section.get("chatroom", ""))
self.chatroom_hbox = gtk.HBox()
self.chatroom_hbox.pack_start(self.chatroom_label, expand=False)
self.chatroom_hbox.pack_start(self.chatroom_entry, expand=True)
self.vbox.pack_start(self.chatroom_hbox, expand=False)
# MS toggle
self.ms_toggle = hildon.CheckButton(gtk.HILDON_SIZE_FINGER_HEIGHT)
self.ms_toggle.set_label(_("Share the media files of this device"))
self.ms_toggle.set_active(media_server_enabled)
self.vbox.pack_start(self.ms_toggle, expand=False)
self.vbox.show_all()
def __init__(self, spawner):
""" Create and display the Configuration dialog. """
self.config = fMMSconf.fMMS_config()
self.window = spawner
dialog = gtk.Dialog()
dialog.set_transient_for(self.window)
dialog.set_title(
gettext.ldgettext('rtcom-messaging-ui',
"messaging_me_main_settings"))
allVBox = gtk.VBox()
labelwidth = 18
apnHBox = gtk.HBox()
apn_label = gtk.Label(
gettext.ldgettext('osso-connectivity-ui', "conn_mngr_me_int_conn"))
apn_label.set_width_chars(labelwidth)
apn_label.set_alignment(0, 0.5)
apn_button = hildon.Button(gtk.HILDON_SIZE_FINGER_HEIGHT,
hildon.BUTTON_ARRANGEMENT_HORIZONTAL)
apn_button.set_label(
gettext.ldgettext('rtcom-messaging-ui',
"messaging_me_main_settings"))
apn_button.connect('clicked', self.show_apn_config, dialog)
apnHBox.pack_start(apn_label, False, True, 0)
apnHBox.pack_start(apn_button, True, True, 0)
imgwidthHBox = gtk.HBox()
imgwidth_label = gtk.Label(
gettext.ldgettext('osso-imageviewer-ui',
"imag_bd_resize_percentage_button"))
imgwidth_label.set_width_chars(labelwidth)
imgwidth_label.set_alignment(0, 0.5)
self.imgmodes = [(_('Small'), '240'), (_('Medium'), '320'),
(_('Large'), '640'), (_('Original'), '0')]
self.active_imgselector_index = 0
self.imgselector = self.create_img_selector()
self.imgwidth = hildon.PickerButton(
gtk.HILDON_SIZE_FINGER_HEIGHT,
hildon.BUTTON_ARRANGEMENT_HORIZONTAL)
self.imgwidth.set_selector(self.imgselector)
self.imgwidth.set_active(self.active_imgselector_index)
imgwidthHBox.pack_start(imgwidth_label, False, True, 0)
imgwidthHBox.pack_start(self.imgwidth, True, True, 0)
expHBox = gtk.HBox()
exp_label = gtk.Label(
gettext.ldgettext('osso-connectivity-ui',
"conn_set_iap_fi_wlan_ap_mode"))
exp_label.set_width_chars(labelwidth)
exp_label.set_line_wrap(True)
exp_label.set_alignment(0, 0.5)
hbox = gtk.HButtonBox()
hbox.set_property("name", "GtkHBox")
self.havocbutton = hildon.GtkToggleButton(
gtk.HILDON_SIZE_FINGER_HEIGHT)
self.havocbutton.set_label(_("Havoc"))
self.havocsignal = self.havocbutton.connect('toggled',
self.conn_mode_toggled)
self.rudebutton = hildon.GtkToggleButton(gtk.HILDON_SIZE_FINGER_HEIGHT)
self.rudebutton.set_label(_("Rude"))
self.rudesignal = self.rudebutton.connect('toggled',
self.conn_mode_toggled)
self.icdbutton = hildon.GtkToggleButton(gtk.HILDON_SIZE_FINGER_HEIGHT)
self.icdbutton.set_label(_("Polite"))
self.icdsignal = self.icdbutton.connect('toggled',
self.conn_mode_toggled)
expRBox = gtk.HBox()
exp_label2 = gtk.Label("Roaming Mode")
exp_label2.set_width_chars(labelwidth)
exp_label2.set_line_wrap(True)
exp_label2.set_alignment(0, 0.5)
rbox = gtk.HButtonBox()
rbox.set_property("name", "GtkHBox2")
self.promptbutton = hildon.GtkToggleButton(
gtk.HILDON_SIZE_FINGER_HEIGHT)
self.promptbutton.set_label(_("Prompt"))
self.promptsignal = self.promptbutton.connect('toggled',
self.roam_mode_toggled)
self.ignorebutton = hildon.GtkToggleButton(
gtk.HILDON_SIZE_FINGER_HEIGHT)
self.ignorebutton.set_label(_("Ignore"))
self.ignoresignal = self.ignorebutton.connect('toggled',
self.roam_mode_toggled)
# Set the correct button to be active
self.connmode_setactive()
hbox.pack_start(self.icdbutton, True, False, 0)
hbox.pack_start(self.rudebutton, True, False, 0)
hbox.pack_start(self.havocbutton, True, False, 0)
alignment = gtk.Alignment(0.5, 0.5, 0, 0)
alignment.add(hbox)
expHBox.pack_start(exp_label, False, True, 0)
expHBox.pack_start(alignment, False, True, 0)
# Set the correct button to be active
self.roammode_setactive()
rbox.pack_start(self.promptbutton, True, False, 0)
rbox.pack_start(self.ignorebutton, True, False, 0)
alignment = gtk.Alignment(0.5, 0.5, 0, 0)
alignment.add(rbox)
expRBox.pack_start(exp_label2, False, True, 0)
expRBox.pack_start(alignment, False, True, 0)
allVBox.pack_start(apnHBox, False, False, 2)
#allVBox.pack_start(numberHBox, False, False, 2)
allVBox.pack_start(imgwidthHBox, False, False, 2)
allVBox.pack_end(expRBox, False, False, 2)
allVBox.pack_end(expHBox, False, False, 2)
allVBox.show_all()
dialog.vbox.add(allVBox)
dialog.add_button(gtk.STOCK_SAVE, 1)
ret = dialog.run()
self.config_menu_button_clicked(ret)
dialog.destroy()
