def on_calcdistance_clicked(self,widget):
logging.debug(">>")
try:
hour = self.rcd_hour.get_value_as_int()
min = self.rcd_min.get_value_as_int()
sec = self.rcd_second.get_value_as_int()
time = sec + (min*60) + (hour*3600)
time_in_hour = time/3600.0
# we need either pace or speed
try:
average = float(gtk_str(self.rcd_average.get_text()))
distance = average*time_in_hour
logging.debug("Time: %d seconds | Speed: %0.2f -> Distance: %0.3f km (mi)",
time, average, distance)
pace = self.parent.pace_from_float(60/average)
logging.debug("Setting pace: %s", pace)
self.rcd_pace.set_text(pace)
except:
pace_dec = self.parent.pace_to_float(gtk_str(self.rcd_pace.get_text()))
distance = time/(60.0*pace_dec)
logging.debug("Time: %d seconds | Pace_dec: %0.2f -> Distance: %0.3f km (mi)",
time, pace_dec, distance)
speed = distance/time_in_hour
logging.debug("Setting average speed: %0.2f", speed)
self.rcd_average.set_text("%0.2f" %speed)
self.set_distance(distance)
except:
logging.debug("Traceback: %s" % traceback.format_exc())
pass
logging.debug("<<")
def on_calctime_clicked(self,widget):
logging.debug(">>")
try:
distance = float(gtk_str(self.rcd_distance.get_text())) # distance is mandatory!
# we need either pace or speed
try:
average = float(gtk_str(self.rcd_average.get_text()))
time_in_hour = distance/average
logging.debug("Distance: %0.3f km (mi) | Speed: %0.2f -> Time: %.f hours",
distance, average, time_in_hour)
pace = self.parent.pace_from_float(60/average)
logging.debug("Setting pace: %s", pace)
self.rcd_pace.set_text(pace)
except:
pace_dec = self.parent.pace_to_float(gtk_str(self.rcd_pace.get_text()))
time_in_hour = pace_dec*distance/60.0
logging.debug("Distance: %0.3f km (mi) | Pace_dec: %0.2f -> Time: %.f hours",
distance, pace_dec, time_in_hour)
speed = distance/time_in_hour
logging.debug("Setting average speed: %0.2f", speed)
self.rcd_average.set_text("%0.2f" %speed)
self.set_recordtime(time_in_hour)
except:
logging.debug("Traceback: %s" % traceback.format_exc())
pass
logging.debug("<<")
def on_calctime_clicked(self,widget):
logging.debug(">>")
try:
distance = float(gtk_str(self.rcd_distance.get_text())) # distance is mandatory!
# we need either pace or speed
try:
average = float(gtk_str(self.rcd_average.get_text()))
time_in_hour = distance/average
logging.debug("Distance: %0.3f km (mi) | Speed: %0.2f -> Time: %.f hours",
distance, average, time_in_hour)
pace = self.parent.pace_from_float(60/average)
logging.debug("Setting pace: %s", pace)
self.rcd_pace.set_text(pace)
except:
pace_dec = self.parent.pace_to_float(gtk_str(self.rcd_pace.get_text()))
time_in_hour = pace_dec*distance/60.0
logging.debug("Distance: %0.3f km (mi) | Pace_dec: %0.2f -> Time: %.f hours",
distance, pace_dec, time_in_hour)
speed = distance/time_in_hour
logging.debug("Setting average speed: %0.2f", speed)
self.rcd_average.set_text("%0.2f" %speed)
self.set_recordtime(time_in_hour)
except:
logging.debug("Traceback: %s" % traceback.format_exc())
pass
logging.debug("<<")
def _confirm_add_equipment_clicked(self, widget):
#FIXME input validation for numeric fields
description = gtk_str(
self._builder.get_object(
"entryEquipmentAddDescription").get_text())
life_expectancy = gtk_str(
self._builder.get_object(
"entryEquipmentAddLifeExpectancy").get_text())
prior_usage = gtk_str(
self._builder.get_object("entryEquipmentAddPriorUsage").get_text())
active = self._builder.get_object(
"checkbuttonEquipmentAddActive").get_active()
notes_buffer = self._builder.get_object(
"textviewEquipmentAddNotes").get_buffer()
notes = gtk_str(
notes_buffer.get_text(notes_buffer.get_start_iter(),
notes_buffer.get_end_iter(), True))
new_equipment = Equipment()
new_equipment.description = description
new_equipment.active = bool(active)
new_equipment.life_expectancy = int(life_expectancy)
new_equipment.prior_usage = int(prior_usage)
new_equipment.notes = notes
self._equipment_store.add_equipment(new_equipment)
self.show_page_equipment_list()
def on_newsport_accept_clicked(self, widget):
sport = Sport()
sport.name = gtk_str(self.newsportentry.get_text())
sport.met = self._trim_to_null(gtk_str(self.newmetentry.get_text()))
sport.weight = self._float_or_zero(
gtk_str(self.newweightentry.get_text()))
sport.max_pace = self._trim_to_null(gtk_str(
self.newmaxpace.get_text()))
sport.color = self.stored_color
if sport.name.lower() in [
s.name.lower() for s in self._sport_service.get_all_sports()
]:
msg = "Sport '%s' already exists" % sport.name
logging.error(msg)
md = Gtk.MessageDialog(None, Gtk.DialogFlags.DESTROY_WITH_PARENT,
Gtk.MessageType.ERROR,
Gtk.ButtonsType.CLOSE, _(msg))
md.set_title(_("Sport Creation Error"))
md.run()
md.destroy()
return
self._sport_service.store_sport(sport)
self.pytrainer_main.refreshMainSportList()
self.on_switch_page(None, None, 2)
self.hidesportsteps()
self.buttonbox.set_sensitive(1)
self.sportlist.show()
def on_calcdistance_clicked(self,widget):
logging.debug(">>")
try:
hour = self.rcd_hour.get_value_as_int()
min = self.rcd_min.get_value_as_int()
sec = self.rcd_second.get_value_as_int()
time = sec + (min*60) + (hour*3600)
time_in_hour = time/3600.0
# we need either pace or speed
try:
average = float(gtk_str(self.rcd_average.get_text()))
distance = average*time_in_hour
logging.debug("Time: %d seconds | Speed: %0.2f -> Distance: %0.3f km (mi)",
time, average, distance)
pace = self.parent.pace_from_float(60/average)
logging.debug("Setting pace: %s", pace)
self.rcd_pace.set_text(pace)
except:
pace_dec = self.parent.pace_to_float(gtk_str(self.rcd_pace.get_text()))
distance = time/(60.0*pace_dec)
logging.debug("Time: %d seconds | Pace_dec: %0.2f -> Distance: %0.3f km (mi)",
time, pace_dec, distance)
speed = distance/time_in_hour
logging.debug("Setting average speed: %0.2f", speed)
self.rcd_average.set_text("%0.2f" %speed)
self.set_distance(distance)
except:
logging.debug("Traceback: %s" % traceback.format_exc())
pass
logging.debug("<<")
def on_options_ok_clicked(self, widget, response_id):
if not response_id == Gtk.ResponseType.ACCEPT:
return response_id
self.description = gtk_str(self.entryList[0].get_text())
if self.description == "":
logging.debug("A description is required - setting to default")
self.description = "Uploaded from pytrainer"
self.tags = gtk_str(self.entryList[1].get_text())
self.visibility = gtk_str(self.entryList[2].get_active_text())
self.makeanon = self.entryList[3].get_active()
logging.debug("Description: %s, tags: %s, visibility: %s, makeanon: %s" % ( self.description, self.tags, self.visibility, self.makeanon) )
def _confirm_edit_equipment_clicked(self, widget):
item = self._get_selected_equipment_item()
description_text = gtk_str(self._builder.get_object("entryEquipmentEditDescription").get_text())
item.description = description_text
item.life_expectancy = gtk_str(self._builder.get_object("entryEquipmentEditLifeExpectancy").get_text())
item.prior_usage = gtk_str(self._builder.get_object("entryEquipmentEditPriorUsage").get_text())
item.active = self._builder.get_object("checkbuttonEquipmentEditActive").get_active()
notes_buffer = self._builder.get_object("textviewEquipmentEditNotes").get_buffer()
notes_text = gtk_str(notes_buffer.get_text(notes_buffer.get_start_iter(),
notes_buffer.get_end_iter(), True))
item.notes = notes_text
self._equipment_store.edit_equipment(self._get_selected_equipment_path(), item)
self.show_page_equipment_list()
def on_treeviewEntries_row_activated(self, treeview, event):
'''
Callback to display details of different activity
'''
#Check for edited data in previous row
if self.active_row is not None:
#Check for edited data in comments
buffer = self.rcd_comments.get_buffer()
start,end = buffer.get_bounds()
comments = gtk_str(buffer.get_text(start,end, True))
self.activity_data[self.active_row]["rcd_comments"] = comments
#Advanced tab items
self.activity_data[self.active_row]["rcd_maxpace"] = gtk_str(self.rcd_maxpace.get_text())
self.activity_data[self.active_row]["rcd_pace"] = gtk_str(self.rcd_pace.get_text())
self.activity_data[self.active_row]["rcd_upositive"] = gtk_str(self.rcd_upositive.get_text())
self.activity_data[self.active_row]["rcd_unegative"] = gtk_str(self.rcd_unegative.get_text())
self.activity_data[self.active_row]["rcd_maxbeats"] = gtk_str(self.rcd_maxbeats.get_text())
self.activity_data[self.active_row]["rcd_beats"] = gtk_str(self.rcd_beats.get_text())
self.activity_data[self.active_row]["rcd_calories"] = gtk_str(self.rcd_calories.get_text())
#Get row that was selected
x = int(event.x)
y = int(event.y)
time = event.time
pthinfo = treeview.get_path_at_pos(x, y)
if pthinfo is not None:
path, col, cellx, celly = pthinfo
treeview.grab_focus()
treeview.set_cursor(path, col, 0)
while Gtk.events_pending(): # This allows the GUI to update
Gtk.main_iteration() # before completion of this entire action
self.show_treeviewEntries_row(path[0])
def on_treeviewEntries_row_activated(self, treeview, event):
'''
Callback to display details of different activity
'''
#Check for edited data in previous row
if self.active_row is not None:
#Check for edited data in comments
buffer = self.rcd_comments.get_buffer()
start,end = buffer.get_bounds()
comments = gtk_str(buffer.get_text(start,end, True))
self.activity_data[self.active_row]["rcd_comments"] = comments
#Advanced tab items
self.activity_data[self.active_row]["rcd_maxpace"] = gtk_str(self.rcd_maxpace.get_text())
self.activity_data[self.active_row]["rcd_pace"] = gtk_str(self.rcd_pace.get_text())
self.activity_data[self.active_row]["rcd_upositive"] = gtk_str(self.rcd_upositive.get_text())
self.activity_data[self.active_row]["rcd_unegative"] = gtk_str(self.rcd_unegative.get_text())
self.activity_data[self.active_row]["rcd_maxbeats"] = gtk_str(self.rcd_maxbeats.get_text())
self.activity_data[self.active_row]["rcd_beats"] = gtk_str(self.rcd_beats.get_text())
self.activity_data[self.active_row]["rcd_calories"] = gtk_str(self.rcd_calories.get_text())
#Get row that was selected
x = int(event.x)
y = int(event.y)
time = event.time
pthinfo = treeview.get_path_at_pos(x, y)
if pthinfo is not None:
path, col, cellx, celly = pthinfo
treeview.grab_focus()
treeview.set_cursor(path, col, 0)
while Gtk.events_pending(): # This allows the GUI to update
Gtk.main_iteration() # before completion of this entire action
self.show_treeviewEntries_row(path[0])
def on_editsport_accept_clicked(self,widget):
oldnamesport = gtk_str(self.sportnameedit.get_text())
sport = self._sport_service.get_sport_by_name(oldnamesport)
sport.name = gtk_str(self.editsportentry.get_text())
sport.weight = self._float_or_zero(gtk_str(self.editweightentry.get_text()))
sport.met = self._trim_to_null(gtk_str(self.editmetentry.get_text()))
sport.max_pace = self._trim_to_null(gtk_str(self.editmaxpace.get_text()))
sport.color = self.stored_color
self._sport_service.store_sport(sport)
self.pytrainer_main.refreshMainSportList()
self.on_switch_page(None,None,2)
self.hidesportsteps()
self.buttonbox.set_sensitive(1)
self.sportlist.show()
def on_calcavs_clicked(self,widget):
logging.debug(">>")
hour = self.rcd_hour.get_value_as_int()
min = self.rcd_min.get_value_as_int()
sec = self.rcd_second.get_value_as_int()
time = sec + (min*60) + (hour*3600)
if time<1:
logging.debug("Seems no time value (%s) has been entered, nothing to calculate.", time)
return False
distance = float(gtk_str(self.rcd_distance.get_text()))
if distance<1:
logging.debug("Seems no distance value (%s) has been entered, nothing to calculate.", distance)
return False
logging.debug("Time: %d seconds | Distance: %0.2f km (mi)", time, distance)
# Average speed
average_speed = distance*3600.0/time
logging.debug("Average speed: %0.2f", average_speed)
self.rcd_average.set_text("%0.2f" %average_speed)
# Average pace
dec_pace = 60/average_speed
#Transform pace to mm:ss
pace = self.parent.pace_from_float(dec_pace)
logging.debug("Average pace: %s", pace)
self.rcd_pace.set_text(pace)
logging.debug("<<")
def on_rcd_distance_changed(self, widget):
if self.mode == "multiple_activities" and self.active_row is not None:
distance = gtk_str(self.rcd_distance.get_text())
#Update distance in data store
self.activity_data[self.active_row]["rcd_distance"] = distance
#Update distance in treeview
self.store[self.active_row][2] = distance
def on_rcd_sport_changed(self, widget):
if self.mode == "multiple_activities" and self.active_row is not None:
sport = gtk_str(self.rcd_sport.get_active_text())
#Update sport in data store
self.activity_data[self.active_row]["rcd_sport"] = sport
#Update sport in treeview
self.store[self.active_row][4] = sport
def on_rcd_distance_changed(self, widget):
if self.mode == "multiple_activities" and self.active_row is not None:
distance = gtk_str(self.rcd_distance.get_text())
#Update distance in data store
self.activity_data[self.active_row]["rcd_distance"] = distance
#Update distance in treeview
self.store[self.active_row][2] = distance
def on_calcavs_clicked(self,widget):
logging.debug(">>")
hour = self.rcd_hour.get_value_as_int()
min = self.rcd_min.get_value_as_int()
sec = self.rcd_second.get_value_as_int()
time = sec + (min*60) + (hour*3600)
if time<1:
logging.debug("Seems no time value (%s) has been entered, nothing to calculate.", time)
return False
distance = float(gtk_str(self.rcd_distance.get_text()))
if distance<1:
logging.debug("Seems no distance value (%s) has been entered, nothing to calculate.", distance)
return False
logging.debug("Time: %d seconds | Distance: %0.2f km (mi)", time, distance)
# Average speed
average_speed = distance*3600.0/time
logging.debug("Average speed: %0.2f", average_speed)
self.rcd_average.set_text("%0.2f" %average_speed)
# Average pace
dec_pace = 60/average_speed
#Transform pace to mm:ss
pace = self.parent.pace_from_float(dec_pace)
logging.debug("Average pace: %s", pace)
self.rcd_pace.set_text(pace)
logging.debug("<<")
def on_rcd_sport_changed(self, widget):
if self.mode == "multiple_activities" and self.active_row is not None:
sport = gtk_str(self.rcd_sport.get_active_text())
#Update sport in data store
self.activity_data[self.active_row]["rcd_sport"] = sport
#Update sport in treeview
self.store[self.active_row][4] = sport
def on_editsport_accept_clicked(self, widget):
oldnamesport = gtk_str(self.sportnameedit.get_text())
sport = self._sport_service.get_sport_by_name(oldnamesport)
sport.name = gtk_str(self.editsportentry.get_text())
sport.weight = self._float_or_zero(
gtk_str(self.editweightentry.get_text()))
sport.met = self._trim_to_null(gtk_str(self.editmetentry.get_text()))
sport.max_pace = self._trim_to_null(
gtk_str(self.editmaxpace.get_text()))
sport.color = self.stored_color
self._sport_service.store_sport(sport)
self.pytrainer_main.refreshMainSportList()
self.on_switch_page(None, None, 2)
self.hidesportsteps()
self.buttonbox.set_sensitive(1)
self.sportlist.show()
def on_calculatemaxhr_clicked(self,widget=None):
import datetime
today = "%s"%datetime.date.today()
year1,month1,day1 = today.split("-")
year2,month2,day2 = gtk_str(self.prf_age.get_text()).split("-")
diff = datetime.datetime(int(year1), int(month1), int(day1),0,0,0) - datetime.datetime(int(year2), int(month2), int(day2),0,0,0)
self.prf_maxhr.set_text("%d" %(220-int(diff.days/365)))
def test_listsearch_sport(self):
self.parent.lsa_sport.set_active(3)
active = gtk_str(self.parent.lsa_sport.get_active_text())
by_sport = list(
self.main.record.getRecordListByCondition(
self.parent.listsearch.condition))
self.assertEqual(len(by_sport), 2)
self.assertEqual(by_sport[0].sport.name, active)
def _confirm_add_equipment_clicked(self, widget):
#FIXME input validation for numeric fields
description = gtk_str(self._builder.get_object("entryEquipmentAddDescription").get_text())
life_expectancy = gtk_str(self._builder.get_object("entryEquipmentAddLifeExpectancy").get_text())
prior_usage = gtk_str(self._builder.get_object("entryEquipmentAddPriorUsage").get_text())
active = self._builder.get_object("checkbuttonEquipmentAddActive").get_active()
notes_buffer = self._builder.get_object("textviewEquipmentAddNotes").get_buffer()
notes = gtk_str(notes_buffer.get_text(notes_buffer.get_start_iter(),
notes_buffer.get_end_iter(), True))
new_equipment = Equipment()
new_equipment.description = description
new_equipment.active = bool(active)
new_equipment.life_expectancy = int(life_expectancy)
new_equipment.prior_usage = int(prior_usage)
new_equipment.notes = notes
self._equipment_store.add_equipment(new_equipment)
self.show_page_equipment_list()
def populateMultiWindow(self, activities):
logging.debug(">>")
self.mode = "multiple_activities"
#activities (activity_id, start_time, distance, duration, sport, gpx_file, file_id)
self.activity_data = []
#Make treeview
self.store = self.build_tree_view()
#Add data
for activity in activities:
iter = self.store.append()
self.store.set(
iter,
0, activity[0],
1, activity[1],
2, activity[2],
3, activity[3],
4, activity[4],
5, activity[5]
)
details = {}
details["complete"] = False
details["rcd_distance"] = activity[2]
duration = activity[3]
if duration.count(":") == 2:
hours, mins, secs = duration.split(":")
else:
hours = mins = secs = 0
#details["rcd_hour"] = float(hours)
#details["rcd_min"] = float(mins)
#details["rcd_second"] = float(secs)
#details["rcd_time"] = (((float(hours) * 60) + float(mins)) * 60) + float(secs)
details["activity_id"] = activity[0]
details["rcd_time"] = (float(hours), float(mins), float(secs))
if activity[4] is not None:
details["rcd_sport"] = activity[4]
else:
# No sport was provided, preliminary set the current selection from window
details["rcd_sport"] = gtk_str(self.rcd_sport.get_active_text())
details["rcd_gpxfile"] = activity[5]
details["file_id"] = activity[6]
self.activity_data.append(details)
self.scrolledwindowEntries.show_all()
#Hide some of the buttons
self.button25.hide() #GPX file "Open" button
self.button24.hide() #GPX file "Calculate Values" button
self.button10.hide() #Distance "Calculate" button
self.button11.hide() #Duration "Calculate" button
#self.button12.hide() #Velocity "Calculate" button
self.button43.hide() #Pace "Calculate" button
#Make GPX file 'unsensitive'
self.rcd_gpxfile.set_sensitive(0)
while Gtk.events_pending(): # This allows the GUI to update
Gtk.main_iteration() # before completion of this entire action
#Select first row and display details
self.treeviewEntries.set_cursor(0)
self.show_treeviewEntries_row(0)
logging.debug("<<")
def populateMultiWindow(self, activities):
logging.debug(">>")
self.mode = "multiple_activities"
#activities (activity_id, start_time, distance, duration, sport, gpx_file, file_id)
self.activity_data = []
#Make treeview
self.store = self.build_tree_view()
#Add data
for activity in activities:
iter = self.store.append()
self.store.set(
iter,
0, activity[0],
1, activity[1],
2, activity[2],
3, activity[3],
4, activity[4],
5, activity[5]
)
details = {}
details["complete"] = False
details["rcd_distance"] = activity[2]
duration = activity[3]
if duration.count(":") == 2:
hours, mins, secs = duration.split(":")
else:
hours = mins = secs = 0
#details["rcd_hour"] = float(hours)
#details["rcd_min"] = float(mins)
#details["rcd_second"] = float(secs)
#details["rcd_time"] = (((float(hours) * 60) + float(mins)) * 60) + float(secs)
details["activity_id"] = activity[0]
details["rcd_time"] = (float(hours), float(mins), float(secs))
if activity[4] is not None:
details["rcd_sport"] = activity[4]
else:
# No sport was provided, preliminary set the current selection from window
details["rcd_sport"] = gtk_str(self.rcd_sport.get_active_text())
details["rcd_gpxfile"] = activity[5]
details["file_id"] = activity[6]
self.activity_data.append(details)
self.scrolledwindowEntries.show_all()
#Hide some of the buttons
self.button25.hide() #GPX file "Open" button
self.button24.hide() #GPX file "Calculate Values" button
self.button10.hide() #Distance "Calculate" button
self.button11.hide() #Duration "Calculate" button
#self.button12.hide() #Velocity "Calculate" button
self.button43.hide() #Pace "Calculate" button
#Make GPX file 'unsensitive'
self.rcd_gpxfile.set_sensitive(0)
while Gtk.events_pending(): # This allows the GUI to update
Gtk.main_iteration() # before completion of this entire action
#Select first row and display details
self.treeviewEntries.set_cursor(0)
self.show_treeviewEntries_row(0)
logging.debug("<<")
def on_deletesport_clicked(self,widget):
sport_name = gtk_str(self.sportnamedel.get_text())
sport = self._sport_service.get_sport_by_name(sport_name)
self._sport_service.remove_sport(sport)
self.pytrainer_main.refreshMainSportList()
self.on_switch_page(None,None,2)
self.hidesportsteps()
self.buttonbox.set_sensitive(1)
self.sportlist.show()
def on_calculatemaxhr_clicked(self, widget=None):
import datetime
today = "%s" % datetime.date.today()
year1, month1, day1 = today.split("-")
year2, month2, day2 = gtk_str(self.prf_age.get_text()).split("-")
diff = datetime.datetime(
int(year1), int(month1), int(day1), 0, 0, 0) - datetime.datetime(
int(year2), int(month2), int(day2), 0, 0, 0)
self.prf_maxhr.set_text("%d" % (220 - int(diff.days / 365)))
def on_deletesport_clicked(self, widget):
sport_name = gtk_str(self.sportnamedel.get_text())
sport = self._sport_service.get_sport_by_name(sport_name)
self._sport_service.remove_sport(sport)
self.pytrainer_main.refreshMainSportList()
self.on_switch_page(None, None, 2)
self.hidesportsteps()
self.buttonbox.set_sensitive(1)
self.sportlist.show()
def setup_lsa_distance(self):
liststore_lsa = self.parent.lsa_distance.get_model()
if self.parent.lsa_distance.get_active() > 0:
self.parent.lsa_distance.set_active(0)
firstEntry = gtk_str(self.parent.lsa_distance.get_active_text())
liststore_lsa.clear() #Delete all items
for i in self.listDistance:
liststore_lsa.append([i[0]])
self.parent.lsa_distance.set_active(0)
#Add handler manually, so above changes do not trigger recursive loop
self.parent.lsa_distance.connect("changed", self.parent.on_listareasearch_clicked)
def setup_lsa_distance(self):
liststore_lsa = self.parent.lsa_distance.get_model()
if self.parent.lsa_distance.get_active() > 0:
self.parent.lsa_distance.set_active(0)
firstEntry = gtk_str(self.parent.lsa_distance.get_active_text())
liststore_lsa.clear() #Delete all items
for i in self.listDistance:
liststore_lsa.append([i[0]])
self.parent.lsa_distance.set_active(0)
#Add handler manually, so above changes do not trigger recursive loop
self.parent.lsa_distance.connect("changed",
self.parent.on_listareasearch_clicked)
def on_newsport_accept_clicked(self,widget):
sport = Sport()
sport.name = gtk_str(self.newsportentry.get_text())
sport.met = self._trim_to_null(gtk_str(self.newmetentry.get_text()))
sport.weight = self._float_or_zero(gtk_str(self.newweightentry.get_text()))
sport.max_pace = self._trim_to_null(gtk_str(self.newmaxpace.get_text()))
sport.color = self.stored_color
if sport.name.lower() in [s.name.lower() for s in self._sport_service.get_all_sports()]:
msg = "Sport '%s' already exists" % sport.name
logging.error(msg)
md = Gtk.MessageDialog(None, Gtk.DialogFlags.DESTROY_WITH_PARENT, Gtk.MessageType.ERROR, Gtk.ButtonsType.CLOSE, _(msg))
md.set_title(_("Sport Creation Error"))
md.run()
md.destroy()
return
self._sport_service.store_sport(sport)
self.pytrainer_main.refreshMainSportList()
self.on_switch_page(None,None,2)
self.hidesportsteps()
self.buttonbox.set_sensitive(1)
self.sportlist.show()
def setup_lsa_sport(self):
liststore_lsa = self.parent.lsa_sport.get_model()
if self.parent.lsa_sport.get_active() is not 0:
self.parent.lsa_sport.set_active(0) #Set first item active if isnt
firstEntry = gtk_str(self.parent.lsa_sport.get_active_text())
liststore_lsa.clear() #Delete all items
#Re-add "All Sports"
liststore_lsa.append([firstEntry])
#Re-add all sports in listSport
for sport in self.listSport:
liststore_lsa.append([sport.name])
self.parent.lsa_sport.set_active(0)
#Add handler manually, so above changes do not trigger recursive loop
self.parent.lsa_sport.connect("changed", self.parent.on_listareasearch_clicked)
def _confirm_edit_equipment_clicked(self, widget):
item = self._get_selected_equipment_item()
description_text = gtk_str(
self._builder.get_object(
"entryEquipmentEditDescription").get_text())
item.description = description_text
item.life_expectancy = gtk_str(
self._builder.get_object(
"entryEquipmentEditLifeExpectancy").get_text())
item.prior_usage = gtk_str(
self._builder.get_object(
"entryEquipmentEditPriorUsage").get_text())
item.active = self._builder.get_object(
"checkbuttonEquipmentEditActive").get_active()
notes_buffer = self._builder.get_object(
"textviewEquipmentEditNotes").get_buffer()
notes_text = gtk_str(
notes_buffer.get_text(notes_buffer.get_start_iter(),
notes_buffer.get_end_iter(), True))
item.notes = notes_text
self._equipment_store.edit_equipment(
self._get_selected_equipment_path(), item)
self.show_page_equipment_list()
def saveOptions(self):
logging.debug(">>")
list_options = {}
logging.debug(self.conf_options)
for i in self.conf_options.keys():
if i == "default_viewer":
if self.radiobuttonDefaultOSM.get_active():
list_options[i] = "1"
else:
list_options[i] = "0"
elif i == "prf_startscreen":
ss_selected = "current_day"
if self.radioButtonStartScreenLastEntry.get_active():
ss_selected = "last_entry"
list_options[i] = ss_selected
else:
try:
var = getattr(self,i)
except AttributeError as e:
continue
if i == "prf_hrzones_karvonen" or i == "prf_us_system":
if var.get_active():
list_options[i] = "True"
else:
list_options[i] = "False"
elif i == "prf_gender":
list_options[i] = self.gender_options[var.get_active()]
elif i == "prf_ddbb":
list_options[i] = gtk_str(var.get_active_text())
else:
list_options[i] = gtk_str(var.get_text())
logging.info("Saving %s as %s" % (i, list_options[i]))
logging.info("Updating profile...")
self.parent.setProfile(list_options)
self.parent.saveProfile()
logging.debug("<<")
def saveOptions(self):
logging.debug(">>")
list_options = {}
logging.debug(self.conf_options)
for i in self.conf_options.keys():
if i == "default_viewer":
if self.radiobuttonDefaultOSM.get_active():
list_options[i] = "1"
else:
list_options[i] = "0"
elif i == "prf_startscreen":
ss_selected = "current_day"
if self.radioButtonStartScreenLastEntry.get_active():
ss_selected = "last_entry"
list_options[i] = ss_selected
else:
try:
var = getattr(self, i)
except AttributeError as e:
continue
if i == "prf_hrzones_karvonen" or i == "prf_us_system":
if var.get_active():
list_options[i] = "True"
else:
list_options[i] = "False"
elif i == "prf_gender":
list_options[i] = self.gender_options[var.get_active()]
elif i == "prf_ddbb":
list_options[i] = gtk_str(var.get_active_text())
else:
list_options[i] = gtk_str(var.get_text())
logging.info("Saving %s as %s" % (i, list_options[i]))
logging.info("Updating profile...")
self.parent.setProfile(list_options)
self.parent.saveProfile()
logging.debug("<<")
def setup_lsa_sport(self):
liststore_lsa = self.parent.lsa_sport.get_model()
if self.parent.lsa_sport.get_active() is not 0:
self.parent.lsa_sport.set_active(0) #Set first item active if isnt
firstEntry = gtk_str(self.parent.lsa_sport.get_active_text())
liststore_lsa.clear() #Delete all items
#Re-add "All Sports"
liststore_lsa.append([firstEntry])
#Re-add all sports in listSport
for sport in self.listSport:
liststore_lsa.append([sport.name])
self.parent.lsa_sport.set_active(0)
#Add handler manually, so above changes do not trigger recursive loop
self.parent.lsa_sport.connect("changed",
self.parent.on_listareasearch_clicked)
def on_acceptSettings_clicked(self, widget, widget2):
selected,iter = self.extensionsTree.get_selection().get_selected()
prefs = self.parent.getExtensionConfParams(selected.get_value(iter,0))
savedOptions = []
i = 0
for key in prefs.keys():
try:
savedOptions.append((key, gtk_str(self.entryList[i].get_text())))
except:
combobox = self.entryList[i]
index = combobox.get_active()
savedOptions.append((key,"%s" %index))
i+=1
self.prefwindow.hide()
self.prefwindow = None
self.parent.setExtensionConfParams(selected.get_value(iter,0),savedOptions)
self.on_extensionsTree_clicked(None,None)
def on_acceptSettings_clicked(self, widget, widget2):
selected,iter = self.pluginsTreeview.get_selection().get_selected()
prefs = self.parent.getPluginConfParams(selected.get_value(iter,0))
savedOptions = []
i = 0
for pref in prefs:
try:
savedOptions.append((pref[0], gtk_str(self.entryList[i].get_text())))
except:
combobox = self.entryList[i]
index = combobox.get_active()
savedOptions.append((pref[0],"%s" %index))
i+=1
self.prefwindow.hide()
self.prefwindow = None
self.parent.setPluginConfParams(selected.get_value(iter,0),savedOptions)
self.on_pluginsTree_clicked(None,None)
def on_calculatemaxhr_clicked(self, widget=None):
import datetime
today = "%s" % datetime.date.today()
year1, month1, day1 = today.split("-")
# tell user that we can't calculate heart rate if age is not supplied
try:
year2, month2, day2 = gtk_str(self.prf_age.get_text()).split("-")
date1 = datetime.datetime(int(year1), int(month1), int(day1), 0, 0,
0)
date2 = datetime.datetime(int(year2), int(month2), int(day2), 0, 0,
0)
except ValueError:
msg = ("Unable to calculate max heart rate, please configure age "
"in the <i>Athlete</i> tab.")
logging.error(msg)
warning_dialog(text=_(msg),
title=_("Heart Rate Calculation Error"))
return
diff = date1 - date2
self.prf_maxhr.set_text("%d" % (220 - int(diff.days / 365)))
def on_pluginAcceptSettings_clicked(self, widget, pluginClass):
'''
Duplicate of plugin settings accept handler
'''
logging.debug('>>')
prefs = self.plugins.getPluginConfParams(pluginClass)
savedOptions = []
i = 0
for pref in prefs:
try:
savedOptions.append(
(pref[0], gtk_str(self.entryList[i].get_text())))
except:
combobox = self.entryList[i]
index = combobox.get_active()
savedOptions.append((pref[0], "%s" % index))
i += 1
self.prefwindow.hide()
self.prefwindow = None
self.plugins.setPluginConfParams(pluginClass, savedOptions)
self.init_plugins_tab()
logging.debug('<<')
def on_calccalories_clicked(self,widget):
sport = gtk_str(self.rcd_sport.get_active_text())
hour = self.rcd_hour.get_value_as_int()
min = self.rcd_min.get_value_as_int()
sec = self.rcd_second.get_value_as_int()
hour += float(min)/60.0 + float(sec)/(60.0*60.0)
weight = self.pytrainer_main.profile.getValue("pytraining","prf_weight")
try:
weight = float(weight)
except:
weight = 0.0
try:
met = float(self.parent.getSportMet(sport))
except:
met = None
try:
extraweight = self.parent.getSportWeight(sport)
extraweight = float(extraweight)
except:
extraweight = 0.0
if met is not None:
calories = met*(weight+extraweight)*hour
self.rcd_calories.set_text(str(calories))
def on_calccalories_clicked(self,widget):
sport = gtk_str(self.rcd_sport.get_active_text())
hour = self.rcd_hour.get_value_as_int()
min = self.rcd_min.get_value_as_int()
sec = self.rcd_second.get_value_as_int()
hour += float(min)/60.0 + float(sec)/(60.0*60.0)
weight = self.pytrainer_main.profile.getValue("pytraining","prf_weight")
try:
weight = float(weight)
except:
weight = 0.0
try:
met = float(self.parent.getSportMet(sport))
except:
met = None
try:
extraweight = self.parent.getSportWeight(sport)
extraweight = float(extraweight)
except:
extraweight = 0.0
if met is not None:
calories = met*(weight+extraweight)*hour
self.rcd_calories.set_text(str(calories))
def on_accept_clicked(self,widget):
logging.debug(">>")
if self.mode == "multiple_activities":
logging.debug("multiple_activities")
#Check for edited data in comments
if self.active_row is not None:
buffer = self.rcd_comments.get_buffer()
start,end = buffer.get_bounds()
comments = gtk_str(buffer.get_text(start,end, True))
self.activity_data[self.active_row]["rcd_comments"] = comments
#Advanced tab items
self.activity_data[self.active_row]["rcd_maxpace"] = gtk_str(self.rcd_maxpace.get_text())
self.activity_data[self.active_row]["rcd_pace"] = gtk_str(self.rcd_pace.get_text())
self.activity_data[self.active_row]["rcd_upositive"] = gtk_str(self.rcd_upositive.get_text())
self.activity_data[self.active_row]["rcd_unegative"] = gtk_str(self.rcd_unegative.get_text())
self.activity_data[self.active_row]["rcd_maxbeats"] = gtk_str(self.rcd_maxbeats.get_text())
self.activity_data[self.active_row]["rcd_beats"] = gtk_str(self.rcd_beats.get_text())
self.activity_data[self.active_row]["rcd_calories"] = gtk_str(self.rcd_calories.get_text())
row = 0
for activity in self.activity_data:
index = self.activity_data.index(activity)
if activity["complete"] is False:
#Did not view or modify this record - need to get all the details
logging.debug("Activity incomplete.. %s", activity["rcd_gpxfile"])
self.update_activity_data(row, activity["rcd_gpxfile"], activity["rcd_sport"])
activity["rcd_title"] = activity["rcd_title"].replace("\"","'")
#Add activity to DB etc
laps = activity.pop("laps", ())
selected_equipment_ids = self._get_selected_equipment_ids()
self.activity_data[index]["db_id"] = self.parent.insertRecord(activity, laps, equipment=selected_equipment_ids)
row += 1
logging.debug("Processed %d rows of activity data", row)
else:
logging.debug("Single activity")
list_options = {}
trackSummary = {}
list_options["rcd_date"] = gtk_str(self.rcd_date.get_text())
list_options["rcd_sport"] = gtk_str(self.rcd_sport.get_active_text())
list_options["rcd_distance"] = self.uc.usr2sys_str('distance',
gtk_str(self.rcd_distance.get_text()))
list_options["rcd_beats"] = gtk_str(self.rcd_beats.get_text())
list_options["rcd_average"] = self.uc.usr2sys_str('speed',
gtk_str(self.rcd_average.get_text()))
list_options["rcd_calories"] = gtk_str(self.rcd_calories.get_text())
list_options["rcd_title"] = gtk_str(self.rcd_title.get_text())
list_options["rcd_gpxfile"] = gtk_str(self.rcd_gpxfile.get_text())
list_options["rcd_upositive"] = self.uc.usr2sys_str('height',
gtk_str(self.rcd_upositive.get_text()))
list_options["rcd_unegative"] = self.uc.usr2sys_str('height',
gtk_str(self.rcd_unegative.get_text()))
list_options["rcd_maxbeats"] = gtk_str(self.rcd_maxbeats.get_text())
# 2011.11.05 - dgranda
# Pace is shown to user in mm:ss format
# But pace in database is stored in a mixed way: 4.30 for 4:30 (4.5 in 'decimal'). This needs to be changed!!
list_options["rcd_pace"] = self.uc.usr2sys_str('pace', gtk_str(self.rcd_pace.get_text()).replace(":","."))
list_options["rcd_maxpace"] = self.uc.usr2sys_str('pace', gtk_str(self.rcd_maxpace.get_text()).replace(":","."))
list_options["rcd_maxvel"] = self.uc.usr2sys_str('speed', gtk_str(self.rcd_maxvel.get_text()))
list_options["rcd_time"] = [self.rcd_hour.get_value_as_int(),self.rcd_min.get_value_as_int(),self.rcd_second.get_value_as_int()]
buffer = self.rcd_comments.get_buffer()
start,end = buffer.get_bounds()
comment = gtk_str(buffer.get_text(start,end, True))
list_options["rcd_comments"] = comment
selected_equipment_ids = self._get_selected_equipment_ids()
# Added to change start time, only activities without GPX+ source file - dgranda 2011/06/10
record_time = gtk_str(self.rcd_starttime.get_text())
record_date = gtk_str(self.rcd_date.get_text())
localtz = getLocalTZ()
date = dateutil.parser.parse(record_date+" "+record_time+" "+localtz)
local_date = str(date)
utc_date = date.astimezone(tzutc()).strftime("%Y-%m-%dT%H:%M:%SZ")
list_options["date_time_utc"] = utc_date
list_options["date_time_local"] = local_date
if self.mode == "newrecord":
logging.debug('Track data: %s', list_options)
if list_options["rcd_gpxfile"] != "":
logging.info('Adding new activity based on GPX file')
self.parent.insertRecord(list_options, None, selected_equipment_ids)
else:
logging.info('Adding new activity based on provided data')
#Manual entry, calculate time info
record_time = gtk_str(self.rcd_starttime.get_text())
record_date = gtk_str(self.rcd_date.get_text())
localtz = getLocalTZ()
date = dateutil.parser.parse(record_date+" "+record_time+" "+localtz)
local_date = str(date)
utc_date = date.astimezone(tzutc()).strftime("%Y-%m-%dT%H:%M:%SZ")
list_options["date_time_utc"] = utc_date
list_options["date_time_local"] = local_date
self.parent.insertRecord(list_options, equipment=selected_equipment_ids)
elif self.mode == "editrecord":
self.parent.updateRecord(list_options, self.id_record, equipment=selected_equipment_ids)
logging.debug("<<")
self.close_window()
def on_calculatevalues_clicked(self,widget):
gpxfile = gtk_str(self.rcd_gpxfile.get_text())
if os.path.isfile(gpxfile):
self.frameGeneral.set_sensitive(0)
self.frameVelocity.set_sensitive(0)
self.parent.actualize_fromgpx(gpxfile)
def on_calendar_clicked(self,widget):
calendardialog = WindowCalendar(self.data_path,self, date=gtk_str(self.rcd_date.get_text()))
calendardialog.run()
def on_rcd_title_changed(self, widget):
if self.mode == "multiple_activities" and self.active_row is not None:
self.activity_data[self.active_row]["rcd_title"] = gtk_str(self.rcd_title.get_text())
def on_rcd_starttime_changed(self, widget):
if self.mode == "multiple_activities" and self.active_row is not None:
#Update start time in data store
self.activity_data[self.active_row]["rcd_starttime"] = gtk_str(self.rcd_starttime.get_text())
def on_buttonCSVImport_clicked(self, widget):
logging.debug('>>')
#Determine values
dateCol = self.cbCSVDate.get_active()
distanceCol = self.cbCSVDistance.get_active()
durationCol = self.cbCSVDuration.get_active()
titleCol = self.cbCSVTitle.get_active()
sportCol = self.cbCSVSport.get_active()
avgspeedCol = self.cbCSVAvgSpeed.get_active()
maxspeedCol = self.cbCSVMaxSpeed.get_active()
calCol = self.cbCSVCal.get_active()
accCol = self.cbCSVAccent.get_active()
desCol = self.cbCSVDescent.get_active()
hrCol = self.cbCSVHR.get_active()
maxHRCol = self.cbCSVMaxHR.get_active()
paceCol = self.cbCSVPace.get_active()
maxPaceCol = self.cbCSVMaxPace.get_active()
commentsCol = self.cbCSVComments.get_active()
if dateCol == 0:
#Error need to have at least a date
self.updateStatusbar(
self.statusbarCSVImport,
_("ERROR: Must define at least a date column"))
return
#Import...
#Get selected file
if not os.path.isfile(self.CSVfilename):
return
#Read as delimited file
csvfile = open(self.CSVfilename, 'rb')
reader = csv.reader(csvfile, delimiter=self.delimiter)
#Process File
for i, row in enumerate(reader):
if self.has_header and i == 0:
#Ignore first row
continue
if not row:
continue
data = Activity()
#Determine dates
_date = getDateTime(row[dateCol - 1])
#year, month, day = date.split("-")
date = _date[1].strftime("%Y-%m-%d")
zuluDateTime = _date[0].strftime("%Y-%m-%dT%H:%M:%SZ")
localDateTime = str(_date[1])
data.date = _date[1].date()
data.date_time_utc = zuluDateTime
data.date_time_local = localDateTime
if distanceCol:
try:
data.distance = locale.atof(row[distanceCol - 1])
except:
data.distance = 0
else:
data.distance = 0
if durationCol:
#calculate duration in sec...
try:
_duration = row[durationCol - 1]
except:
_duration = 0
if _duration.count(':') == 2:
#Have 00:00:00 duration
h, m, s = _duration.split(':')
try:
durationSec = int(h) * 3600 + int(m) * 60 + int(s)
except:
logging.debug("Error calculating duration for '%s'" %
_duration)
durationSec = None
else:
try:
durationSec = locale.atoi(_duration)
except:
#Unknown duration
logging.debug("Could not determine duration for '%s'" %
_duration)
durationSec = None
if durationSec is not None:
data.duration = durationSec
data.time = str(durationSec)
if titleCol:
try:
data.title = row[titleCol - 1]
except:
pass
if self.checkbCSVForceSport.get_active():
sport = self.pytrainer_main.record.getSport(gtk_str(
self.comboCSVForceSport.get_active_text()),
add=True)
data.sport = sport
elif sportCol:
#retrieving sport id (adding sport if it doesn't exist yet)
sport = self.pytrainer_main.record.getSport(row[sportCol - 1],
add=True)
data.sport = sport
else:
self.comboCSVForceSport.set_active(0)
sport = self.pytrainer_main.record.getSport(gtk_str(
self.comboCSVForceSport.get_active_text()),
add=True)
data.sport = sport
if avgspeedCol:
#
try:
data.average = locale.atof(row[avgspeedCol - 1])
except:
pass
if maxspeedCol:
try:
data.maxspeed = locale.atof(row[maxspeedCol - 1])
except:
pass
if calCol:
try:
data.calories = locale.atoi(row[calCol - 1])
except:
pass
if accCol:
try:
data.upositive = locale.atof(row[accCol - 1])
except:
pass
if desCol:
try:
data.unegative = locale.atof(row[desCol - 1])
except:
pass
if hrCol:
try:
data.beats = locale.atof(row[hrCol - 1])
except:
pass
if maxHRCol:
try:
data.maxbeats = locale.atof(row[maxHRCol - 1])
except:
pass
if paceCol:
try:
data.pace = locale.atof(row[paceCol - 1])
except:
pass
if maxPaceCol:
try:
data.maxpace = locale.atof(row[maxPaceCol - 1])
except:
pass
if commentsCol:
try:
data.comments = row[commentsCol - -1]
except:
pass
#Insert into DB
self.pytrainer_main.ddbb.session.add(data)
self.pytrainer_main.ddbb.session.commit()
#Display message....
self.updateStatusbar(self.statusbarCSVImport,
_("Import completed. %d rows processed") % i)
#Disable import button
self.buttonCSVImport.set_sensitive(0)
logging.debug('<<')
def on_prf_ddbb_changed(self, widget):
i = gtk_str(self.prf_ddbb.get_active_text())
if i == "sqlite":
self._ddbb_value_deactive()
else:
self._ddbb_value_active()
def on_rcd_title_changed(self, widget):
if self.mode == "multiple_activities" and self.active_row is not None:
self.activity_data[self.active_row]["rcd_title"] = gtk_str(self.rcd_title.get_text())
def on_calendar_clicked(self,widget):
calendardialog = WindowCalendar(self.data_path,self, date=gtk_str(self.rcd_date.get_text()))
calendardialog.run()
def on_accept_clicked(self,widget):
logging.debug(">>")
if self.mode == "multiple_activities":
logging.debug("multiple_activities")
#Check for edited data in comments
if self.active_row is not None:
buffer = self.rcd_comments.get_buffer()
start,end = buffer.get_bounds()
comments = gtk_str(buffer.get_text(start,end, True))
self.activity_data[self.active_row]["rcd_comments"] = comments
#Advanced tab items
self.activity_data[self.active_row]["rcd_maxpace"] = gtk_str(self.rcd_maxpace.get_text())
self.activity_data[self.active_row]["rcd_pace"] = gtk_str(self.rcd_pace.get_text())
self.activity_data[self.active_row]["rcd_upositive"] = gtk_str(self.rcd_upositive.get_text())
self.activity_data[self.active_row]["rcd_unegative"] = gtk_str(self.rcd_unegative.get_text())
self.activity_data[self.active_row]["rcd_maxbeats"] = gtk_str(self.rcd_maxbeats.get_text())
self.activity_data[self.active_row]["rcd_beats"] = gtk_str(self.rcd_beats.get_text())
self.activity_data[self.active_row]["rcd_calories"] = gtk_str(self.rcd_calories.get_text())
row = 0
for activity in self.activity_data:
index = self.activity_data.index(activity)
if activity["complete"] is False:
#Did not view or modify this record - need to get all the details
logging.debug("Activity incomplete.. %s", activity["rcd_gpxfile"])
self.update_activity_data(row, activity["rcd_gpxfile"], activity["rcd_sport"])
activity["rcd_title"] = activity["rcd_title"].replace("\"","'")
#Add activity to DB etc
laps = activity.pop("laps", ())
selected_equipment_ids = self._get_selected_equipment_ids()
self.activity_data[index]["db_id"] = self.parent.insertRecord(activity, laps, equipment=selected_equipment_ids)
row += 1
logging.debug("Processed %d rows of activity data", row)
else:
logging.debug("Single activity")
list_options = {}
trackSummary = {}
list_options["rcd_date"] = gtk_str(self.rcd_date.get_text())
list_options["rcd_sport"] = gtk_str(self.rcd_sport.get_active_text())
list_options["rcd_distance"] = self.uc.usr2sys_str('distance',
gtk_str(self.rcd_distance.get_text()))
list_options["rcd_beats"] = gtk_str(self.rcd_beats.get_text())
list_options["rcd_average"] = self.uc.usr2sys_str('speed',
gtk_str(self.rcd_average.get_text()))
list_options["rcd_calories"] = gtk_str(self.rcd_calories.get_text())
list_options["rcd_title"] = gtk_str(self.rcd_title.get_text())
list_options["rcd_gpxfile"] = gtk_str(self.rcd_gpxfile.get_text())
list_options["rcd_upositive"] = self.uc.usr2sys_str('height',
gtk_str(self.rcd_upositive.get_text()))
list_options["rcd_unegative"] = self.uc.usr2sys_str('height',
gtk_str(self.rcd_unegative.get_text()))
list_options["rcd_maxbeats"] = gtk_str(self.rcd_maxbeats.get_text())
# 2011.11.05 - dgranda
# Pace is shown to user in mm:ss format
# But pace in database is stored in a mixed way: 4.30 for 4:30 (4.5 in 'decimal'). This needs to be changed!!
list_options["rcd_pace"] = self.uc.usr2sys_str('pace', gtk_str(self.rcd_pace.get_text()).replace(":","."))
list_options["rcd_maxpace"] = self.uc.usr2sys_str('pace', gtk_str(self.rcd_maxpace.get_text()).replace(":","."))
list_options["rcd_maxvel"] = self.uc.usr2sys_str('speed', gtk_str(self.rcd_maxvel.get_text()))
list_options["rcd_time"] = [self.rcd_hour.get_value_as_int(),self.rcd_min.get_value_as_int(),self.rcd_second.get_value_as_int()]
buffer = self.rcd_comments.get_buffer()
start,end = buffer.get_bounds()
comment = gtk_str(buffer.get_text(start,end, True))
list_options["rcd_comments"] = comment
selected_equipment_ids = self._get_selected_equipment_ids()
# Added to change start time, only activities without GPX+ source file - dgranda 2011/06/10
record_time = gtk_str(self.rcd_starttime.get_text())
record_date = gtk_str(self.rcd_date.get_text())
localtz = getLocalTZ()
date = dateutil.parser.parse(record_date+" "+record_time+" "+localtz)
local_date = str(date)
utc_date = date.astimezone(tzutc()).strftime("%Y-%m-%dT%H:%M:%SZ")
list_options["date_time_utc"] = utc_date
list_options["date_time_local"] = local_date
if self.mode == "newrecord":
logging.debug('Track data: %s', list_options)
if list_options["rcd_gpxfile"] != "":
logging.info('Adding new activity based on GPX file')
self.parent.insertRecord(list_options, None, selected_equipment_ids)
else:
logging.info('Adding new activity based on provided data')
#Manual entry, calculate time info
record_time = gtk_str(self.rcd_starttime.get_text())
record_date = gtk_str(self.rcd_date.get_text())
localtz = getLocalTZ()
date = dateutil.parser.parse(record_date+" "+record_time+" "+localtz)
local_date = str(date)
utc_date = date.astimezone(tzutc()).strftime("%Y-%m-%dT%H:%M:%SZ")
list_options["date_time_utc"] = utc_date
list_options["date_time_local"] = local_date
try:
self.parent.insertRecord(
list_options,
equipment=selected_equipment_ids)
except ValueError:
msg = ("Unable to add an activity record without any "
"sports, please add a sport in preferences' "
"<i>Sports</i> tab.")
logging.error(msg)
warning_dialog(title=_("Error Adding Activity Record"), text=_(msg))
elif self.mode == "editrecord":
self.parent.updateRecord(list_options, self.id_record, equipment=selected_equipment_ids)
logging.debug("<<")
self.close_window()
def on_prf_ddbb_changed(self,widget):
i = gtk_str(self.prf_ddbb.get_active_text())
if i == "sqlite":
self._ddbb_value_deactive()
else:
self._ddbb_value_active()
def on_rcd_starttime_changed(self, widget):
if self.mode == "multiple_activities" and self.active_row is not None:
#Update start time in data store
self.activity_data[self.active_row]["rcd_starttime"] = gtk_str(self.rcd_starttime.get_text())
def on_calculatevalues_clicked(self,widget):
gpxfile = gtk_str(self.rcd_gpxfile.get_text())
if os.path.isfile(gpxfile):
self.frameGeneral.set_sensitive(0)
self.frameVelocity.set_sensitive(0)
self.parent.actualize_fromgpx(gpxfile)
def on_buttonCSVProcess_clicked(self, widget):
logging.debug('>>')
#Get selected file
self.CSVfilename = self.filechooserCSVImport.get_filename()
if not os.path.isfile(self.CSVfilename):
return
#Determine delimiter
if self.rbCSVTab.get_active():
self.delimiter = "\t"
elif self.rbCSVComma.get_active():
self.delimiter = ","
elif self.rbCSVOther.get_active():
self.delimiter = gtk_str(self.entryCSVOther.get_text())
else:
self.delimiter = " "
#Read as delimited file
csvfile = open(self.CSVfilename, 'rb')
#See if file has header row
self.has_header = csv.Sniffer().has_header(csvfile.read(1024))
csvfile.seek(0)
reader = csv.DictReader(csvfile, delimiter=self.delimiter)
#Read file to determine fields (must be a better way of doing this)
for row in reader:
pass
#Build array of column names
if self.has_header:
#If the file has a header row, use the actual column names
columns = reader.fieldnames
else:
#Otherwise just label them with numbers
logging.debug(len(reader.fieldnames))
columns = [
_("Column %d") % x for x in range(0, len(reader.fieldnames))
]
for column in columns:
self.cbCSVDate.append_text(column)
self.cbCSVDistance.append_text(column)
self.cbCSVDuration.append_text(column)
self.cbCSVTitle.append_text(column)
self.cbCSVSport.append_text(column)
self.cbCSVAvgSpeed.append_text(column)
self.cbCSVMaxSpeed.append_text(column)
self.cbCSVCal.append_text(column)
self.cbCSVAccent.append_text(column)
self.cbCSVDescent.append_text(column)
self.cbCSVHR.append_text(column)
self.cbCSVMaxHR.append_text(column)
self.cbCSVPace.append_text(column)
self.cbCSVMaxPace.append_text(column)
self.cbCSVComments.append_text(column)
self.cbCSVDate.set_active(0)
self.cbCSVDistance.set_active(0)
self.cbCSVDuration.set_active(0)
self.cbCSVTitle.set_active(0)
self.cbCSVSport.set_active(0)
self.cbCSVAvgSpeed.set_active(0)
self.cbCSVMaxSpeed.set_active(0)
self.cbCSVCal.set_active(0)
self.cbCSVAccent.set_active(0)
self.cbCSVDescent.set_active(0)
self.cbCSVHR.set_active(0)
self.cbCSVMaxHR.set_active(0)
self.cbCSVPace.set_active(0)
self.cbCSVMaxPace.set_active(0)
self.cbCSVComments.set_active(0)
logging.debug('<<')
