WebSVN – public – Diff – /sportwatcher/trunk/src/sportwatcherwidget.cpp

 #include <ksimpleconfig.h>
 #include <klocale.h>
 #include <klistview.h>
 #include <kaboutdialog.h>
 #include <kaboutdata.h>
+#include <kinputdialog.h>
 #include <kglobalsettings.h>
+#include <kcombobox.h>
 #include <qapplication.h>
 #include <qstring.h>
 #include <qdatetime.h>
 #include <qtoolbutton.h>
 #include <qcursor.h>
    #include <gdal/ogrsf_frmts.h>
    #include <gdal/gdalwarper.h>
    #include <gdal/ogrsf_frmts.h>
 #endif
+#include "garmin.h"
 #include "copy.h"
 #include "transform.h"
 #include "import.h"
 // #define DEBUG	1
 	destroy();
 	liActivities->clear();
 	liActivities->setRootIsDecorated(true);
 	liActivities->setSortColumn(-1);
+	liActivities->addColumn(QString("Path"), 0);
+	liActivities->hideColumn(1);
 	other = new KListViewItem(liActivities, i18n("Others"));
 	biking = new KListViewItem(liActivities, i18n("Biking"));
 	running = new KListViewItem(liActivities, i18n("Running"));
 	other->setPixmap(0, QPixmap::fromMimeSource(QString("history.png")));
 	   switch (rn->run->sport_type)
+	   {
 	      case D1000_running:
 		 el = new KListViewItem(running, idx);
+		 el->setText(1, *strfl);
 		 el->setPixmap(0, QPixmap::fromMimeSource(QString("run.png")));
 		 running->insertItem(el);
 	      break;
 	      case D1000_biking:
 		 el = new KListViewItem(biking, idx);
+		 el->setText(1, *strfl);
 		 el->setPixmap(0, QPixmap::fromMimeSource(QString("bike.png")));
 		 biking->insertItem(el);
 	      break;
 	      case D1000_other:
 		 el = new KListViewItem(other, idx);
+		 el->setText(1, *strfl);
 		 el->setPixmap(0, QPixmap::fromMimeSource(QString("other.png")));
 		 other->insertItem(el);
 	      break;
 	      default:
 		 el = new KListViewItem(other, idx);
+		 el->setText(1, *strfl);
 		 el->setPixmap(0, QPixmap::fromMimeSource(QString("other.png")));
 		 other->insertItem(el);
+	   }
 	   delete qt;
 INDEX *akt;
 	if (!item)
 	   return;
-	akt = index;
+//	akt = index;
-	while (akt)
+//	while (akt)
-	{
+//	{
-	   if (akt->activ == item->text(0))
+//	   if (akt->activ == item->text(0))
-	   {
+//	   {
 	      spw.destroy();
-              if (spw.setFileName(akt->path.ascii()) == -1)
+//	      if (spw.setFileName(akt->path.ascii()) == -1)
+	      if (spw.setFileName(item->text(1).ascii()) == -1)
 		 return;
 	      if (gmn)
 		 garmin_free_data (gmn);
 	      gmn = spw.readFile();
 	      zfactor = 0;
 	      showLaps();
 	      showTrack();
 	      showCurves();
-	      return;
+//	      return;
-	   }
+//	   }
-	   akt = akt->next;
+//	   akt = akt->next;
-	}
+//	}
+}
 void sportwatcherWidget::helpAbout()
+{
 KAboutData about("SportWatcher", "SportWatcher", VERSION);
 	showLaps();
 	showTrack();
 	showCurves();
+}
+/*
+ * Display a small dialog to rename the currently loaded session.
+ */
+void sportwatcherWidget::editRename()
+{
+bool ok;
+QString name, inhalt;
+QPtrList<QListViewItem> item;
+QListViewItem *lvItem;
+QFileInfo datei;
+RUN_NODE *rn;
+LAP *lap;
+garmin_list *list;
+D1009 *n;
+	if (!gmn)
+	{
+	   KMessageBox::error(this, i18n("There is no session selected!"));
+	   return;
+	}
+	rn = ds.getRunNode();
+	item = liActivities->selectedItems (false);
+	lvItem = item.first();
+	if (!isdigit(rn->run->workout.name[0]))
+	   inhalt = lvItem->text(0);
+	else
+	   inhalt = QString::null;
+	name = KInputDialog::getText(i18n("Rename session"), i18n("Session name"),
+		inhalt, &ok, this, "dialogRename", 0,
+		QString("Nxxxxxxxxxxxxxx"));
+	if (!ok)
+	   return;
+	if (name.length() <= 1)
+	{
+	   lap = ds.getLap(rn->run->first_lap_index);
+	   const QDateTime *qt = garmin_dtime (lap->start_time);
+	   QString idx = qt->toString("dd.MM.yyyy hh:mm.ss");
+	   lvItem->setText (0, idx);
+	   datei.setFile (lvItem->text(1));
+	   garmin_save_all (gmn, datei.fileName().ascii(), datei.dirPath(true).ascii(), 1);
+	   delete qt;
+	   return;
+	}
+	strncpy (rn->run->workout.name, name.ascii(), 16);
+	if (gmn->type != data_Dlist)
+	{
+	   KMessageBox::error(this, i18n("editRename: Unexpected structure type %1 found!").arg(gmn->type));
+	   return;
+	}
+	list = (garmin_list *)gmn->data;
+	if (list->head->data->type != data_D1009)	// This should be the run node
+	{
+	   KMessageBox::error(this, i18n("editRename: The run node was not found!"));
+	   return;
+	}
+	n = (D1009 *)list->head->data->data;
+	strcpy (n->workout.name, rn->run->workout.name);
+	lvItem->setText (0, name);
+	datei.setFile (lvItem->text(1));
+	garmin_save_all (gmn, datei.fileName().ascii(), datei.dirPath(true).ascii(), 1);
+}
 void sportwatcherWidget::fileNew()
+{
 progressWidget *dlg = new progressWidget(this, "progressWidgetBase");
 	dlg->show();
+	}
 	ds.destroy();
 	min_hr = max_hr = 0;
 	min_height = max_height = 0.0;
+	min_speed = max_speed = 0.0;
 	liLaps->clear();
 	liLaps->setAllColumnsShowFocus(true);
 	ds.garmin_print_data(gmn);
 	rn = ds.getRunNode();
 	rakt = rn;
 			  old_dsc = alt_dsc;
+		    }
 		    else
 		       alt_dsc = alt_asc = 0;
+		    POINT *oldPoint = 0;
+		    double sc, dist, speed;
 		    while (point)
+		    {
 		       if (point->time > (lap->start_time + (lap->total_time / 100)))
 			 break;
+		       if (!oldPoint)
+			  oldPoint = point;
 		       if (point->alt > alt_asc && point->alt < 20000)
+		       {
 			  alt_asc = point->alt;
 			  if (alt_dsc == 0)
 			  max_height = point->alt;
 		       if (point->alt < 20000 && (min_height == 0.0 || min_height > point->alt))
 			  min_height = point->alt;
+		       // Calculate speed of current track
+		       sc = point->time - oldPoint->time;
+		       dist = point->distance - oldPoint->distance;
+		       if (sc > 0.0)
+			  speed = (dist / sc) * 3.6;
+		       else
+			  speed = 0.0;
+		       if (Units == 1)
+			  speed /= 1.609344;
+		       if (speed > 0.0 && speed < 400.0 && max_speed < speed)
+			  max_speed = speed;
+		       if (speed > 0.0 && (min_speed == 0.0 || min_speed > speed))
+			  min_speed = speed;
 		       if (point->heart_rate > 0)
+		       {
 			  avg_hr += point->heart_rate;
 			  men++;
+		       }
+		       oldPoint = point;
 		       point = ds.getPoint(point->time + 1);
+		    }
 		    if (old_asc < alt_asc)
 		       sum_asc += (alt_asc - old_asc);
 void sportwatcherWidget::showCurves(LAP *lap)
+{
 QPainter paint;
 int width, height;
-int i, secs;
+int i, secs, cuType;
 int lineHeight, margin_left, margin_right, margin_bottom;
 int x1, y1, x2, y2;		// Coordinates
 bool meter;
-double maxHeight, minHeight;
+double maxHeight, minHeight, maxSpeed, minSpeed;
 int maxHr, minHr, rh;
 POINT *point;
 RUN_NODE *rn;
 LAP *lp;
 double w_tick, h_tick;		// Number of pixels one "tick" has;
 	// values detected in the function showLap(). In case
 	// all values are 0, we exit here.
 	if (min_hr == 0 && max_hr == 0 && min_height == 0.0 && max_height == 0.0)
 	   return;
+	// Look up, what curves we should draw
+	cuType = kcbCurveTypes->currentItem();
+	// Get the dimensions of the available draw area
 	width = imgProfile->width() - 2;
 	height = imgProfile->height();
 	pmProfile.resize(width, height);
 	paint.begin(&pmProfile);
 	   if (minHeight < 0.0)		// make sure, we are not too deep
 	      minHeight = 0.0;
+	}
+	if (max_speed > 0.0)
+	{
+	double add = (max_speed - min_speed) / 100.0 * 5.0;	// Percent
+	   maxSpeed = max_speed + add;
+	   minSpeed = min_speed - add;
+	   if (minSpeed < 0.0)		// make sure, we are not too deep
+	      minSpeed = 0.0;
+	}
 	if (max_hr > 0)
+	{
 	   maxHr = max_hr + 10;
 	   minHr = min_hr - 10;
 	lineHeight = 10;
 	rh = height - margin_bottom - 1;
 	w_tick = (double)(width - (margin_left + margin_right)) / max_time;	// 1 tick = 1 second
-	if ((maxHeight - minHeight) > (double)(maxHr - minHr))
+	if (cuType == 1)	// Speed?
+	{
+	   if ((maxSpeed - minSpeed) > (double)(maxHr - minHr))
+	   {
-	   h_tick = (double)rh / (maxHeight - minHeight);		// 1 tick = 1 meter
+	      h_tick = (double)rh / (maxSpeed - minSpeed);		// 1 tick = 1 meter
-	   meter = true;
+	      meter = true;
+	   }
+	   else
+	   {
+	      h_tick = (double)rh / ((double)maxHr - (double)minHr);	// 1 tick = 1 bpm
+	      meter = false;
+	   }
+	}
-	else
+	else	// Altitude
+	{
+	   if ((maxHeight - minHeight) > (double)(maxHr - minHr))
+	   {
+	      h_tick = (double)rh / (maxHeight - minHeight);		// 1 tick = 1 meter
+	      meter = true;
+	   }
+	   else
+	   {
-	   h_tick = (double)rh / ((double)maxHr - (double)minHr);	// 1 tick = 1 bpm
+	      h_tick = (double)rh / ((double)maxHr - (double)minHr);	// 1 tick = 1 bpm
-	   meter = false;
+	      meter = false;
+	   }
+	}
 	// Fill background with background colors
 	paint.fillRect(0, 0, width + 4, height + 4, background);
 	// Draw a grid with markers at every 10 minutes
 	paint.setPen(QPen(frame, 1, QPen::SolidLine));
 	// Bottom border line
 	paint.setFont(fntNormal);
 	paint.drawText(margin_left - 20, height - lineHeight, 40, lineHeight, Qt::AlignCenter, QString("00:00"));
 	paint.save();
 	paint.rotate(270);
 	paint.setPen(QPen(barcol, 1, QPen::SolidLine));
+	if (cuType == 0)
-	paint.drawText((height + 4) * -1, 3, height - 2, lineHeight, Qt::AlignCenter, i18n((Units == 1) ? "Elevation (ft)" : "Elevation (m)"));
+	   paint.drawText((height + 4) * -1, 3, height - 2, lineHeight, Qt::AlignCenter, i18n((Units == 1) ? "Elevation (ft)" : "Elevation (m)"));
+	else if (cuType == 1)
+	   paint.drawText((height + 4) * -1, 3, height - 2, lineHeight, Qt::AlignCenter, i18n((Units == 1) ? "Speed (mph)" : "Speed (km/h)"));
+	else
+	   paint.drawText((height + 4) * -1, 3, height - 2, lineHeight, Qt::AlignCenter, i18n((Units == 1) ? "Elevation (ft)" : "Elevation (m)"));
 	paint.setPen(QPen(blue, 1, QPen::SolidLine));
+	if (cuType < 2)
-	paint.drawText((height + 4) * -1, width - 1 - lineHeight, height - 2, lineHeight, Qt::AlignCenter, i18n("Heart Rate (bpm)"));
+	   paint.drawText((height + 4) * -1, width - 1 - lineHeight, height - 2, lineHeight, Qt::AlignCenter, i18n("Heart Rate (bpm)"));
+	else
+	   paint.drawText((height + 4) * -1, width - 1 - lineHeight, height - 2, lineHeight, Qt::AlignCenter, i18n((Units == 1) ? "Speed (mph)" : "Speed (km/h)"));
 	paint.restore();
 	paint.setPen(QPen(mark, 1, QPen::SolidLine));
 	// Draw the time scale
 	for (i = 0; (unsigned int)i < max_time; i++)
+	{
 	QString qs;
 	tm = tm.addSecs(max_time);
 	paint.setPen(QPen(frame, 1, QPen::SolidLine));
 	paint.drawText(width - margin_right - 25, height - lineHeight, 50, lineHeight, Qt::AlignCenter, tm.toString((max_time >= 3600) ? "hh:mm:ss" : "mm:ss"));
-	if (max_height > 0.0)
+	if (max_height > 0.0 || max_speed > 0.0)
+	{
 	   paint.setPen(QPen(barcol, 1, QPen::SolidLine));
+	   if (cuType == 1)
+	      paint.drawText(12, height - margin_bottom - lineHeight / 2, margin_left - 14, lineHeight, Qt::AlignRight, qs.sprintf("%.0f", minSpeed));
+	   else
-	   paint.drawText(12, height - margin_bottom - lineHeight / 2, margin_left - 14, lineHeight, Qt::AlignRight, qs.sprintf("%.0f", (Units == 1) ? minHeight / 0.304 : minHeight));
+	      paint.drawText(12, height - margin_bottom - lineHeight / 2, margin_left - 14, lineHeight, Qt::AlignRight, qs.sprintf("%.0f", (Units == 1) ? minHeight / 0.304 : minHeight));
+	}
 	if (max_hr > 0)
+	{
 	   paint.setPen(QPen(blue, 1, QPen::SolidLine));
+	}
 	paint.setPen(QPen(mark, 1, QPen::SolidLine));
 	// Grid horizontal
+	int factor = 0;
+	int target = 0;
+	if (cuType == 1)
+	{
+	   factor = (meter) ? (maxSpeed - minSpeed) / (rh / 12) : (maxHr - minHr) / (rh / 12);
+	   target = (meter) ? (int)(maxSpeed - minSpeed) : (maxHr - minHr);
+	}
+	else
+	{
-	int factor = (meter) ? (maxHeight - minHeight) / (rh / 12) : (maxHr - minHr) / (rh / 12);
+	   factor = (meter) ? (maxHeight - minHeight) / (rh / 12) : (maxHr - minHr) / (rh / 12);
-	int target = (meter) ? (int)(maxHeight - minHeight) : (maxHr - minHr);
+	   target = (meter) ? (int)(maxHeight - minHeight) : (maxHr - minHr);
+	}
 	int oldy = height;
 	for (i = 0; i < target; i++)
+	{
 	   if (i > 0 && !(i % factor))
 	      if (y1 < (oldy - lineHeight))
+	      {
 		 if (meter)
+		 {
 		    paint.setPen(QPen(barcol, 1, QPen::SolidLine));
+		    if (cuType == 1)
+		       paint.drawText(12, y1 - lineHeight / 2, margin_left - 14, lineHeight, Qt::AlignRight, qs.sprintf("%.0f", minSpeed + i));
+		    else
-		    paint.drawText(12, y1 - lineHeight / 2, margin_left - 14, lineHeight, Qt::AlignRight, qs.sprintf("%.0f", (Units == 1) ? (minHeight + i) / 0.304 : minHeight + i));
+		       paint.drawText(12, y1 - lineHeight / 2, margin_left - 14, lineHeight, Qt::AlignRight, qs.sprintf("%.0f", (Units == 1) ? (minHeight + i) / 0.304 : minHeight + i));
 		    if (maxHr > 0)
+		    {
 		       double hrscale = (double)(maxHr - minHr) / (double)target;
 		       paint.setPen(QPen(blue, 1, QPen::SolidLine));
 		 else
+		 {
 		    paint.setPen(QPen(blue, 1, QPen::SolidLine));
 		    paint.drawText(width - margin_right + 2, y1 - lineHeight / 2, margin_right - 14, lineHeight, Qt::AlignLeft, qs.sprintf("%d", minHr + i));
-		    if (max_height > 0)
+		    if (cuType == 0 && max_height > 0)
+		    {
 		       double hrscale = (maxHeight - minHeight) / (double)target;
 		       paint.setPen(QPen(barcol, 1, QPen::SolidLine));
 		       paint.drawText(12, y1 - lineHeight / 2, margin_left - 14, lineHeight, Qt::AlignRight, qs.sprintf("%.0f", minHeight + hrscale * (double)i));
+		    }
+		    else if (max_speed > 0)
+		    {
+		       double hrscale = (maxSpeed - minSpeed) / (double)target;
+		       paint.setPen(QPen(barcol, 1, QPen::SolidLine));
+		       paint.drawText(12, y1 - lineHeight / 2, margin_left - 14, lineHeight, Qt::AlignRight, qs.sprintf("%.0f", minSpeed + hrscale * (double)i));
+		    }
+		}
 		 paint.setPen(QPen(mark, 1, QPen::SolidLine));
 		 oldy = y1;
+	      }
 	hy1 = hy2 = hx1 = hx2 = 0;
 	int hEc = 0;
 	i = 0;
 	AVGHEIGHT *avgHakt, *avgHfirst, *avgHlast, *avgHeight = 0;
 	avgHfirst = avgHlast = 0;
 	// To even the surface lines, we store every altitude in the
 	// memory, by building a chain. Then, if the user has set in the
 	// settings (Contour == true), we will even the line by calculating
 	// the average of 10 messure points and setting every value to the
 	// average, who is up or down more than 2 meters from the average.
 	   i++;
+	}
 	avgHlast = avgHeight;
 	// If wanted, even the lines
-	if (Contour && hEc > 0)
+	if (Contour && hEc > 0 && cuType != 0)
+	{
 	double alt[100], avg, avg1, avg2, avg3, avg4;
 	int a, pos;
 	   for (i = 0; i < (hEc + 100); i += 100)
+		 }
+	      }
+	   }
+	}
-	// plot the altitude
+	// plot the altitude or speed. Depends on <cuType>)
 	i = 0;
 	int j = 0;
+	POINT *oldPoint = 0;
+	double speed = 0.0;
 	while ((point = ds.getPoint(i)) != 0)
+	{
+	   if (!oldPoint)
+	      oldPoint = point;
 	   // calculate the y position based on the time
 	   qt = garmin_dtime(point->time);
 	   secs = zeit.secsTo(qt->time());
 	   delete qt;
 	   x2 = secs * w_tick + margin_left + 1;
 	      x1 = x2;
 	   if (hx1 == 0)
 	      hx1 = hx2;
-	   if (point->alt < 20000.0 && point->alt > -1000.0)
+	   if (cuType == 1)
+	   {
-	   double alt = getAvgAlt(avgHfirst, j);
+	      double dist;
+	      double sc;
-	      j++;
-	      if (meter)
-		 y2 = (double)rh - (alt - minHeight) * h_tick;
+	      if (point->distance >= 1 && point->distance < 1.0e24)
-	      else
+	      {
-		 double hrscale = rh / (maxHeight - minHeight);
+		 dist = point->distance - oldPoint->distance;
-		 y2 = (double)rh - (alt - minHeight) * hrscale;
+		 sc = point->time - oldPoint->time;
+		 speed = (dist / sc) * 3.6;
+		 if (Units == 1)
+		    speed /= 1.609344;
+		 if (speed < 0.0 || speed > 400.0)
-	      }
+		    speed = 0.0;
+		 if (meter)
+		    y2 = (double)rh - (speed - minSpeed) * h_tick;
+		 else
+		 {
+		    double hrscale = rh / (maxSpeed - minSpeed);
+		    y2 = (double)rh - (speed - minSpeed) * hrscale;
+		 }
-	      if (y1 == 0)
+		 if (y1 == 0)
+		    y1 = y2;
+		 paint.setPen(QPen(barcol, 1, QPen::SolidLine));
+		 paint.drawLine(x1, y1, x2, y2);
 		 y1 = y2;
+		 x1 = x2;
+	      }
+	   }
+	   else
+	   {
+	      if (point->alt < 20000.0 && point->alt > -1000.0)
+	      {
+	      double alt = getAvgAlt(avgHfirst, j);
+		 j++;
+		 if (meter)
+		    y2 = (double)rh - (alt - minHeight) * h_tick;
+		 else
+		 {
+		    double hrscale = rh / (maxHeight - minHeight);
+		    y2 = (double)rh - (alt - minHeight) * hrscale;
+		 }
+		 if (y1 == 0)
+		    y1 = y2;
-	      paint.setPen(QPen(barcol, 1, QPen::SolidLine));
+		 paint.setPen(QPen(barcol, 1, QPen::SolidLine));
-	      paint.drawLine(x1, y1, x2, y2);
+		 paint.drawLine(x1, y1, x2, y2);
-	      y1 = y2;
+		 y1 = y2;
-	      x1 = x2;
+		 x1 = x2;
+	      }
+	   }
 	   if (point->heart_rate > 0)
+	   {
 	      if (meter)
 	      hy1 = hy2;
 	      hx1 = hx2;
+	   }
 	   i++;
+	   oldPoint = point;
+	}
 	paint.end();
 	imgProfile->setPixmap(pmProfile);

Subversion Repositories public

(root)/sportwatcher/trunk/src/sportwatcherwidget.cpp – Rev 217 → 218