import gtk
import cairo
+import pygst
+pygst.require("0.10")
+import gst
+
import hildondesktop
import hildon
PATH = "/apps/pedometerhomewidget"
MODE = PATH + "/mode"
HEIGHT = PATH + "/height"
+WEIGHT = PATH + "/weight"
UNIT = PATH + "/unit"
ASPECT = PATH + "/aspect"
SECONDVIEW = PATH + "/secondview"
NOIDLETIME = PATH + "/noidletime"
LOGGING = PATH + "/logging"
+ALARM_PATH = PATH + "/alarm"
+ALARM_ENABLE = ALARM_PATH + "/enable"
+ALARM_FNAME = ALARM_PATH + "/fname"
+ALARM_TYPE = ALARM_PATH + "/type"
+ALARM_INTERVAL = ALARM_PATH + "/interval"
+
ICONSPATH = "/opt/pedometerhomewidget/"
unit = 0
self.steps = steps
self.calories = calories
self.dist = dist
- self.unit = unit
def __add__(self, other):
return PedoValues(self.time + other.time,
self.dist + other.dist,
self.calories + other.calories)
+ def __sub__(self, other):
+ return PedoValues(self.time - other.time,
+ self.steps - other.steps,
+ self.dist - other.dist,
+ self.calories - other.calories)
+
def get_print_time(self):
tdelta = self.time
hours = int(tdelta / 3600)
return strtime
def get_print_distance(self):
+ global unit
if self.dist > 1000:
- if self.unit == 0:
+ if unit == 0:
return "%.2f km" % (self.dist / 1000)
else:
return "%.2f mi" % (self.dist / 1609.344)
else:
- if self.unit == 0:
+ if unit == 0:
return "%d m" % self.dist
else:
return "%d ft" % int(self.dist * 3.2808)
def get_avg_speed(self):
+ global unit
conv = 0
- if self.unit:
+ if unit:
conv = 2.23693629
else:
conv = 3.6
return speed * conv
def get_print_avg_speed(self):
+ global unit
suffix = ""
conv = 0
- if self.unit:
+ if unit:
suffix = "mi/h"
conv = 2.23693629
else:
return str(self.steps)
def get_print_calories(self):
- return str(self.calories)
+ return "%.2f" % self.calories
class PedoRepository(Singleton):
values = {}
def get_values(self):
return self.values
- def add_values(self, values, when=date.today()):
+ def add_values(self, values, when=None):
+ if when is None:
+ when = date.today()
"""add PedoValues values to repository """
try:
self.values[when] = self.values[when] + values
except Exception, e:
logger.error("Error while saving data to xml file: %s" % e)
-
class PedoRepositoryPickle(PedoRepository):
DIR = os.path.join(os.path.expanduser("~"), ".pedometer")
FILE = os.path.join(DIR, "pickle.log")
last_time = 0
is_running = False
- graph_controller = None
+
+ observers = []
+
+ midnight_set = False
+ midnight_source_id = None
def __init__(self):
self.pedometer = PedoCounter(self.steps_detected)
self.repository = PedoRepositoryXML()
self.repository.load()
- self.graph_controller = GraphController()
self.load_values()
+ if not self.midnight_set:
+ self.update_at_midnight()
+ self.midnight_set = True
+
+ def update_at_midnight(self):
+ next_day = date.today() + timedelta(days=1)
+ diff = time.mktime(next_day.timetuple()) - time.time()
+ diff = int(diff+5)
+ self.midnight_source_id = gobject.timeout_add_seconds(diff, self.midnight_callback, True)
+
+ def stop_midnight_callback(self):
+ if self.midnight_source_id is not None:
+ gobject.source_remove(self.midnight_source_id)
+
+ def midnight_callback(self, first=False):
+ self.load_values()
+ self.notify()
+ if first:
+ self.midnight_source_id = gobject.timeout_add_seconds(24*3600, self.midnight_callback)
+ return False
+ else:
+ return True
+
def load_values(self):
if self.second_view == 0:
self.v[1] = self.repository.get_alltime_values()
self.last_time = time.time()
self.is_running = True
self.pedometer.start()
- self.notify_UI(True)
+ self.notify(True)
+
+ def reset_all_values(self):
+ self.repository.reset_values()
+ self.v[0] = PedoValues()
+ self.v[1] = PedoValues()
+ self.notify()
def stop_pedometer(self):
self.is_running = False
else:
self.v[0].steps += cnt
self.v[0].dist += self.get_distance(cnt)
- self.v[0].calories += self.get_distance(cnt)
+ self.v[0].calories += self.get_calories(self.get_distance(cnt))
self.v[0].time += time.time() - self.last_time
if last_steps:
self.save_values()
- self.notify_UI()
+ self.notify()
else:
- self.notify_UI(True)
+ self.notify(True)
self.last_time = time.time()
+ def get_calories(self, distance):
+ """calculate lost calories for the distance and weight given as parameters
+ """
+ #different coefficient for running and walking
+ if self.mode == 0:
+ coef = 0.53
+ else:
+ coef = 0.75
+
+ #convert distance from meters to miles
+ distance *= 0.000621371192
+
+ weight = self.weight
+ #convert weight from kg to pounds
+ if self.unit == 0:
+ weight *= 2.20462262
+ return weight * distance * coef
+
def set_mode(self, mode):
self.mode = mode
self.set_height(self.height_interval)
- self.notify_UI()
+ self.pedometerInterval.set_mode(self.mode)
+ self.notify()
def set_unit(self, new_unit):
self.unit = new_unit
+ global unit
unit = new_unit
+ self.notify()
+
+ def get_str_weight_unit(self):
+ if self.unit == 0:
+ return "kg"
+ else:
+ return "lb"
+
+ def set_weight(self, value):
+ self.weight = value
+ self.notify()
+
+ def get_weight(self):
+ return self.weight
def set_second_view(self, second_view):
self.second_view = second_view
self.load_values()
- self.notify_UI()
+ self.notify()
def set_callback_ui(self, func):
self.callback_update_ui = func
#increase step length if RUNNING
if self.mode == 1:
self.STEP_LENGTH *= 1.45
- self.notify_UI()
+ self.notify()
def set_no_idle_time(self, value):
self.no_idle_time = value
steps = self.counter
return self.STEP_LENGTH * steps;
- def get_calories(self, steps):
- return steps
+ def add_observer(self, func):
+ try:
+ self.observers.index(func)
+ except:
+ self.observers.append(func)
+
+ def remove_observer(self, func):
+ self.observers.remove(func)
- def notify_UI(self, optional=False):
+ def notify(self, optional=False):
if self.callback_update_ui is not None:
self.callback_update_ui()
- self.graph_controller.update_ui(optional)
+
+ for func in self.observers:
+ func(optional)
+
+class AlarmController(Singleton):
+ enable = False
+ fname = "/home/user/MyDocs/.sounds/Ringtones/Bicycle.aac"
+ interval = 5
+ type = 0
+
+ player = None
+ is_playing = False
+ pedo_controller = None
+
+ def __init__(self):
+ self.client = gconf.client_get_default()
+
+ self.enable = self.client.get_bool(ALARM_ENABLE)
+ self.fname = self.client.get_string(ALARM_FNAME)
+ self.interval = self.client.get_int(ALARM_INTERVAL)
+ self.type = self.client.get_int(ALARM_TYPE)
+
+ self.pedo_controller = PedoController()
+ if self.enable:
+ self.init_player()
+ self.pedo_controller.add_observer(self.update)
+ self.start_value = self.pedo_controller.get_first()
+
+ def init_player(self):
+ self.player = gst.element_factory_make("playbin2", "player")
+ fakesink = gst.element_factory_make("fakesink", "fakesink")
+ self.player.set_property("video-sink", fakesink)
+
+ bus = self.player.get_bus()
+ bus.add_signal_watch()
+ bus.connect("message", self.on_message)
+
+ def on_message(self, bus, message):
+ t = message.type
+ if t == gst.MESSAGE_EOS:
+ self.player.set_state(gst.STATE_NULL)
+ self.is_playing = False
+ elif t == gst.MESSAGE_ERROR:
+ self.player.set_state(gst.STATE_NULL)
+ self.is_playing = False
+ err, debug = message.parse_error()
+ logger.error("ERROR: %s, %s" % (err, debug) )
+
+ def update(self, optional):
+ diff = self.pedo_controller.get_first() - self.start_value
+ if self.type == 0 and diff.time >= self.interval * 60 or \
+ self.type == 1 and diff.steps >= self.interval or \
+ self.type == 2 and diff.dist >= self.interval or \
+ self.type == 3 and diff.calories >= self.interval:
+ self.play()
+ #get new instance of current values
+ self.start_value = PedoValues() + self.pedo_controller.get_first()
+ logger.info("Alarm!")
+
+ def play(self):
+ if self.player is None:
+ self.init_player()
+ if self.is_playing:
+ self.player.set_state(gst.STATE_NULL)
+ self.is_playing = False
+ else:
+ self.player.set_property("uri", "file://" + self.fname)
+ self.player.set_state(gst.STATE_PLAYING)
+ self.is_playing = True
+
+ def stop(self):
+ self.player.set_state(gst.STATE_NULL)
+
+ def set_enable(self, value):
+ self.enable = value
+ self.client.set_bool(ALARM_ENABLE, value)
+ if self.enable:
+ self.init_player()
+ self.pedo_controller.add_observer(self.update)
+ self.start_value = self.pedo_controller.get_first()
+ else:
+ self.stop()
+ self.player = None
+ self.pedo_controller.remove_observer(self.update)
+
+ def get_enable(self):
+ return self.enable
+
+ def set_alarm_file(self, fname):
+ self.fname = fname
+ self.client.set_string(ALARM_FNAME, fname)
+
+ def get_alarm_file(self):
+ if self.fname == None:
+ return ""
+ return self.fname
+
+ def set_interval(self, interval):
+ self.interval = interval
+ self.client.set_int(ALARM_INTERVAL, interval)
+
+ def get_interval(self):
+ return self.interval
+
+ def set_type(self, type):
+ self.type = type
+ self.client.set_int(ALARM_TYPE, type)
+
+ def get_type(self):
+ return self.type
class PedoCounter(Singleton):
COORD_FNAME = "/sys/class/i2c-adapter/i2c-3/3-001d/coord"
COORD_FNAME_SDK = "/home/andrei/pedometer-widget-0.1/date.txt"
LOGFILE = "/home/user/log_pedometer"
#time in ms between two accelerometer data reads
- COORD_GET_INTERVAL = 10
+ COORD_GET_INTERVAL = 25
COUNT_INTERVAL = 5
def __init__(self):
self.repository = PedoRepositoryXML()
self.last_update = 0
+ PedoController().add_observer(self.update_ui)
def set_graph(self, widget):
self.widget = widget
second_view_labels = ["All-time", "Today", "This week"]
controller = None
- pedometer = None
- pedometerInterval = None
graph_controller = None
mode = 0
height = 0
+ weight = 70
unit = 0
aspect = 0
second_view = 0
gobject.type_register(GraphWidget)
self.client = gconf.client_get_default()
- try:
- self.mode = self.client.get_int(MODE)
- self.height = self.client.get_int(HEIGHT)
- self.unit = self.client.get_int(UNIT)
- self.aspect = self.client.get_int(ASPECT)
- self.second_view = self.client.get_int(SECONDVIEW)
- self.graph_view = self.client.get_int(GRAPHVIEW)
- self.no_idle_time = self.client.get_bool(NOIDLETIME)
- self.logging = self.client.get_bool(LOGGING)
- except:
- self.client.set_int(MODE, 0)
- self.client.set_int(HEIGHT, 0)
- self.client.set_int(UNIT, 0)
- self.client.set_int(ASPECT, 0)
- self.client.set_int(SECONDVIEW, 0)
- self.client.set_int(GRAPHVIEW, 0)
- self.client.set_bool(NOIDLETIME, False)
- self.client.set_bool(LOGGING, False)
+ self.mode = self.client.get_int(MODE)
+ self.height = self.client.get_int(HEIGHT)
+ self.weight = self.client.get_int(WEIGHT)
+ self.unit = self.client.get_int(UNIT)
+ self.aspect = self.client.get_int(ASPECT)
+ self.second_view = self.client.get_int(SECONDVIEW)
+ self.graph_view = self.client.get_int(GRAPHVIEW)
+ self.no_idle_time = self.client.get_bool(NOIDLETIME)
+ self.logging = self.client.get_bool(LOGGING)
self.controller = PedoController()
self.controller.set_height(self.height)
+ self.controller.set_weight(self.weight)
self.controller.set_mode(self.mode)
self.controller.set_unit(self.unit)
self.controller.set_second_view(self.second_view)
self.graph_controller = GraphController()
self.graph_controller.set_current_view(self.graph_view)
+ self.alarm_controller = AlarmController()
+
self.button = CustomButton(ICONSPATH + "play.png")
self.button.connect("clicked", self.button_clicked)
eventBox.connect("button-press-event", self.eventBox_clicked)
eventBox.connect("button-release-event", self.eventBox_clicked_release)
-
mainHBox.add(buttonVBox)
mainHBox.add(descVBox)
mainHBox.add(currentVBox)
self.graph = graph
eventBoxGraph.connect("button-press-event", self.eventBoxGraph_clicked)
eventBoxGraph.connect("button-release-event", self.eventBoxGraph_clicked_release)
+ self.graphBox = eventBoxGraph
self.mainvbox = gtk.VBox()
new_labels[label] = l
def update_aspect(self):
- if self.aspect == 0:
+
+ if self.aspect > 0:
+ self.graphBox.hide_all()
+ else:
+ self.graphBox.show_all()
+
+ if self.aspect == 0 or self.aspect == 1:
self.currentBox.show_all()
self.totalBox.show_all()
- elif self.aspect == 1:
+ elif self.aspect == 2:
self.currentBox.show_all()
self.totalBox.hide_all()
else:
self.currentBox.hide_all()
self.totalBox.show_all()
+ x,y = self.size_request()
+ self.resize(x,y)
+
def update_ui_values(self, labels, values):
labels["timer"].set_label(values.get_print_time())
labels["count"].set_label(values.get_print_steps())
def update_total(self):
self.update_ui_values(self.labelsT, self.controller.get_second())
+ def show_alarm_settings(self, main_button):
+ def choose_file(widget):
+ file = hildon.FileChooserDialog(self, gtk.FILE_CHOOSER_ACTION_OPEN, hildon.FileSystemModel() )
+ file.show()
+ if ( file.run() == gtk.RESPONSE_OK):
+ fname = file.get_filename()
+ widget.set_value(fname)
+ self.alarm_controller.set_alarm_file(fname)
+ file.destroy()
+
+ def test_sound(button):
+ try:
+ self.alarm_controller.play()
+ except Exception, e:
+ logger.error("Could not play alarm sound: %s" % e)
+ hildon.hildon_banner_show_information(self, "None", "Could not play alarm sound")
+
+ def enableButton_changed(button):
+ value = button.get_active()
+ self.alarm_controller.set_enable(value)
+ if value:
+ main_button.set_value("Enabled")
+ else:
+ main_button.set_value("Disabled")
+
+ def selectorType_changed(selector, data, labelEntry2):
+ self.alarm_controller.set_type(selector.get_active(0))
+ labelEntry2.set_label(suffix[self.alarm_controller.get_type()])
+
+ dialog = gtk.Dialog()
+ dialog.set_title("Alarm settings")
+ dialog.add_button("OK", gtk.RESPONSE_OK)
+
+ enableButton = hildon.CheckButton(gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT)
+ enableButton.set_label("Enable alarm")
+ enableButton.set_active(self.alarm_controller.get_enable())
+ enableButton.connect("toggled", enableButton_changed)
+
+ testButton = hildon.Button(gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT, hildon.BUTTON_ARRANGEMENT_VERTICAL)
+ testButton.set_alignment(0, 0.8, 1, 1)
+ testButton.set_title("Test sound")
+ testButton.connect("pressed", test_sound)
+
+ fileButton = hildon.Button(gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT, hildon.BUTTON_ARRANGEMENT_VERTICAL)
+ fileButton.set_alignment(0, 0.8, 1, 1)
+ fileButton.set_title("Alarm sound")
+ fileButton.set_value(self.alarm_controller.get_alarm_file())
+ fileButton.connect("pressed", choose_file)
+
+ labelEntry = gtk.Label("Notify every:")
+ suffix = ["mins", "steps", "m/ft", "calories"]
+ labelEntry2 = gtk.Label(suffix[self.alarm_controller.get_type()])
+ intervalEntry = hildon.Entry(gtk.HILDON_SIZE_AUTO_WIDTH)
+ intervalEntry.set_text(str(self.alarm_controller.get_interval()))
+
+ selectorType = hildon.TouchSelector(text=True)
+ selectorType.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_SINGLE)
+ selectorType.append_text("Time")
+ selectorType.append_text("Steps")
+ selectorType.append_text("Distance")
+ selectorType.append_text("Calories")
+ selectorType.connect("changed", selectorType_changed, labelEntry2)
+
+ typePicker = hildon.PickerButton(gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT, hildon.BUTTON_ARRANGEMENT_VERTICAL)
+ typePicker.set_alignment(0.0, 0.5, 1.0, 1.0)
+ typePicker.set_title("Alarm type")
+ typePicker.set_selector(selectorType)
+ typePicker.set_active(self.alarm_controller.get_type())
+
+ hbox = gtk.HBox()
+ hbox.add(labelEntry)
+ hbox.add(intervalEntry)
+ hbox.add(labelEntry2)
+
+ dialog.vbox.add(enableButton)
+ dialog.vbox.add(fileButton)
+ dialog.vbox.add(testButton)
+ dialog.vbox.add(typePicker)
+ dialog.vbox.add(hbox)
+ dialog.show_all()
+ while 1:
+ response = dialog.run()
+ if response != gtk.RESPONSE_OK:
+ break
+ try:
+ value = int(intervalEntry.get_text())
+ self.alarm_controller.set_interval(value)
+ break
+ except:
+ hildon.hildon_banner_show_information(self, "None", "Invalid interval")
+
+ dialog.destroy()
+
def show_settings(self, widget):
def reset_total_counter(arg):
- widget.totalCounter = 0
- widget.totalTime = 0
- widget.update_total()
- hildon.hildon_banner_show_information(self, "None", "Total counter was resetted")
+ note = hildon.hildon_note_new_confirmation(self.dialog, "Are you sure you want to delete all your pedometer history?")
+ ret = note.run()
+ if ret == gtk.RESPONSE_OK:
+ self.controller.reset_all_values()
+ hildon.hildon_banner_show_information(self, "None", "All history was deleted")
+ note.destroy()
+
+ def alarmButton_pressed(widget):
+ self.show_alarm_settings(widget)
def selector_changed(selector, data):
widget.mode = selector.get_active(0)
widget.controller.set_mode(widget.mode)
def selectorH_changed(selector, data):
- widget.height = selectorH.get_active(0)
+ widget.height = selector.get_active(0)
widget.client.set_int(HEIGHT, widget.height)
widget.controller.set_height(widget.height)
-
def selectorUnit_changed(selector, data):
- widget.unit = selectorUnit.get_active(0)
+ widget.unit = selector.get_active(0)
widget.client.set_int(UNIT, widget.unit)
widget.controller.set_unit(widget.unit)
+ if widget.unit == 0:
+ self.heightPicker.set_active(widget.height)
+ self.heightPicker.show()
+ self.heightPicker_English.hide()
+ else:
+ self.heightPicker_English.set_active(widget.height)
+ self.heightPicker_English.show()
+ self.heightPicker.hide()
+
+ update_weight_button()
+
def selectorUI_changed(selector, data):
widget.aspect = selectorUI.get_active(0)
widget.client.set_int(ASPECT, widget.aspect)
widget.client.set_bool(NOIDLETIME, widget.no_idle_time)
widget.controller.set_no_idle_time(widget.no_idle_time)
+ def update_weight_button():
+ weightButton.set_value(str(self.controller.get_weight()) + \
+ " " + self.controller.get_str_weight_unit() )
+
+ def weight_dialog(button):
+ dialog = gtk.Dialog("Weight", self.dialog)
+ dialog.add_button("OK", gtk.RESPONSE_OK)
+
+ label = gtk.Label("Weight:")
+ entry = gtk.Entry()
+ entry.set_text(str(self.controller.get_weight()))
+
+ suffixLabel = gtk.Label(self.controller.get_str_weight_unit())
+
+ hbox = gtk.HBox()
+ hbox.add(label)
+ hbox.add(entry)
+ hbox.add(suffixLabel)
+
+ dialog.vbox.add(hbox)
+ dialog.show_all()
+ while 1:
+ response = dialog.run()
+ if response != gtk.RESPONSE_OK:
+ break
+ try:
+ value = int(entry.get_text())
+ if value <= 0:
+ raise ValueError
+ self.controller.set_weight(value)
+ self.client.set_int(WEIGHT, value)
+ update_weight_button()
+ break
+ except:
+ hildon.hildon_banner_show_information(self, "None", "Invalid weight")
+ dialog.destroy()
+
dialog = gtk.Dialog()
dialog.set_title("Settings")
dialog.add_button("OK", gtk.RESPONSE_OK)
+ self.dialog = dialog
+ resetButton = hildon.Button(gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT, hildon.BUTTON_ARRANGEMENT_VERTICAL)
+ resetButton.set_title("Reset total counter")
+ resetButton.set_alignment(0, 0.8, 1, 1)
+ resetButton.connect("clicked", reset_total_counter)
- button = hildon.Button(gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT, hildon.BUTTON_ARRANGEMENT_VERTICAL)
- button.set_title("Reset total counter")
- button.set_alignment(0, 0.8, 1, 1)
- button.connect("clicked", reset_total_counter)
+ alarmButton = hildon.Button(gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT, hildon.BUTTON_ARRANGEMENT_VERTICAL)
+ alarmButton.set_title("Alarm")
+ if self.alarm_controller.get_enable():
+ alarmButton.set_value("Enabled")
+ else:
+ alarmButton.set_value("Disabled")
+ alarmButton.set_alignment(0, 0.8, 1, 1)
+ alarmButton.connect("clicked", alarmButton_pressed)
selector = hildon.TouchSelector(text=True)
selector.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_SINGLE)
modePicker = hildon.PickerButton(gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT, hildon.BUTTON_ARRANGEMENT_VERTICAL)
modePicker.set_alignment(0.0, 0.5, 1.0, 1.0)
- modePicker.set_title("Select mode")
+ modePicker.set_title("Mode")
modePicker.set_selector(selector)
modePicker.set_active(widget.mode)
selectorH.append_text(" > 1.95 m")
selectorH.connect("changed", selectorH_changed)
+ selectorH_English = hildon.TouchSelector(text=True)
+ selectorH_English.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_SINGLE)
+ selectorH_English.append_text("< 5 ft")
+ selectorH_English.append_text("5 - 5.5 ft")
+ selectorH_English.append_text("5.5 - 6 ft")
+ selectorH_English.append_text("6 - 6.5 ft")
+ selectorH_English.append_text("> 6.5 ft")
+ selectorH_English.connect("changed", selectorH_changed)
+
heightPicker = hildon.PickerButton(gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT, hildon.BUTTON_ARRANGEMENT_VERTICAL)
heightPicker.set_alignment(0.0, 0.5, 1.0, 1.0)
- heightPicker.set_title("Select height")
+ heightPicker.set_title("Height")
heightPicker.set_selector(selectorH)
heightPicker.set_active(widget.height)
+ heightPicker_English = hildon.PickerButton(gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT, hildon.BUTTON_ARRANGEMENT_VERTICAL)
+ heightPicker_English.set_alignment(0.0, 0.5, 1.0, 1.0)
+ heightPicker_English.set_title("Height")
+ heightPicker_English.set_selector(selectorH_English)
+ heightPicker_English.set_active(widget.height)
+
+ self.heightPicker = heightPicker
+ self.heightPicker_English = heightPicker_English
+
+ weightButton = hildon.Button(gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT, hildon.BUTTON_ARRANGEMENT_VERTICAL)
+ weightButton.set_title("Weight")
+ weightButton.set_alignment(0, 0.8, 1, 1)
+ weightButton.set_value(str(self.controller.get_weight()) + " " + self.controller.get_str_weight_unit() )
+ weightButton.connect("clicked", weight_dialog)
+
selectorUnit = hildon.TouchSelector(text=True)
selectorUnit.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_SINGLE)
selectorUnit.append_text("Metric (km)")
unitPicker = hildon.PickerButton(gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT, hildon.BUTTON_ARRANGEMENT_VERTICAL)
unitPicker.set_alignment(0.0, 0.5, 1.0, 1.0)
- unitPicker.set_title("Units")
+ unitPicker.set_title("Unit")
unitPicker.set_selector(selectorUnit)
unitPicker.set_active(widget.unit)
selectorUI = hildon.TouchSelector(text=True)
selectorUI = hildon.TouchSelector(text=True)
selectorUI.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_SINGLE)
+ selectorUI.append_text("Show current + total + graph")
selectorUI.append_text("Show current + total")
selectorUI.append_text("Show only current")
selectorUI.append_text("Show only total")
pan_area = hildon.PannableArea()
vbox = gtk.VBox()
- vbox.add(button)
+ vbox.add(alarmButton)
vbox.add(modePicker)
vbox.add(heightPicker)
+ vbox.add(heightPicker_English)
+ vbox.add(weightButton)
vbox.add(unitPicker)
vbox.add(UIPicker)
vbox.add(idleButton)
+ vbox.add(resetButton)
#vbox.add(logButton)
pan_area.add_with_viewport(vbox)
dialog.vbox.add(pan_area)
dialog.show_all()
+
+ if widget.unit == 0:
+ self.heightPicker_English.hide()
+ else:
+ self.heightPicker.hide()
+
response = dialog.run()
#hildon.hildon_banner_show_information(self, "None", "You have to Stop/Start the counter to apply the new settings")
dialog.destroy()
def close_requested(self, widget):
- if self.pedometer is None:
- return
-
- self.pedometer.request_stop()
+ if self.controller.is_running:
+ self.controller.stop_pedometer()
+ self.controller.stop_midnight_callback()
def update_values(self):
#TODO: do not update if the widget is not on the active desktop
else:
self.controller.start_pedometer()
self.button.set_icon(ICONSPATH + "stop.png")
+ hildon.hildon_banner_show_information(self, "None", "Keep the N900 in a pocket close to your hip for best results")
def do_expose_event(self, event):
cr = self.window.cairo_create()
hd_plugin_type = PedometerHomePlugin
-# The code below is just for testing purposes.
-# It allows to run the widget as a standalone process.
-if __name__ == "__main__":
- import gobject
- gobject.type_register(hd_plugin_type)
- obj = gobject.new(hd_plugin_type, plugin_id="plugin_id")
- obj.show_all()
- gtk.main()
-
-############### old pedometer.py ###
import math
import logging
ch.setFormatter(formatter)
logger.addHandler(ch)
+# The code below is just for testing purposes.
+# It allows to run the widget as a standalone process.
+if __name__ == "__main__":
+ import gobject
+ gobject.type_register(hd_plugin_type)
+ obj = gobject.new(hd_plugin_type, plugin_id="plugin_id")
+ obj.show_all()
+ gtk.main()
projects / pedometerwidget / blobdiff