Subversion Repositories public

/***************************************************************************

 *   Copyright (C) 2007, 2008 by Andreas Theofilu                          *

 *   andreas@theosys.at                                                    *

 *                                                                         *

 *   This program is free software; you can redistribute it and/or modify  *

 *   it under the terms of the GNU General Public License as published by  *

 *   the Free Software Foundation version 3 of the License.                *

 *                                                                         *

 *   This program is distributed in the hope that it will be useful,       *

 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *

 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *

 *   GNU General Public License for more details.                          *

 *                                                                         *

 *   You should have received a copy of the GNU General Public License     *

 *   along with this program; if not, write to the                         *

 *   Free Software Foundation, Inc.,                                       *

 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *

 ***************************************************************************/

#include "progresswidget.h"

#include <kapplication.h>

#include <kprogress.h>

#include <kmessagebox.h>

#include <ksimpleconfig.h>

#include <klocale.h>

#include <qlabel.h>

#include "garmin.h"

#include <iostream>

using std::cout;

using std::endl;

extern KApplication *mapp;

progressWidget *me;

progressWidget::progressWidget ( QWidget* parent, const char* name, bool modal, WFlags fl )

		: progressWidgetBase ( parent,name, modal,fl )

{

	step = 0;

	psteps = 7;

	me = this;

}

progressWidget::~progressWidget()

{

	me = 0;

}

/*

 * This function is called from the Garmin library libgarmin.a during

 * reading data from a GPS device.

 */

void progressWidget::CallBack(char *str)

{

	if (me)

	   me->IncrementBar();

}

void progressWidget::IncrementBar()

{

	step++;

	if (psteps <= step)

	{

	   psteps += 2;

	   barProgress->setTotalSteps(psteps);

	}

	barProgress->setProgress(step);

}

/*$SPECIALIZATION$*/

/*

 * The following function reads out all data from a GPS device. It uses

 * the library libgarmin.a, who is basicly the "garmintools-0.5", written by

 * Dave Bailey (thanks Dave!).

 */

bool progressWidget::Download()

{

QString Data, filepath, device;

garmin_unit         garmin;

garmin_data *       data;

garmin_data *       data0;

garmin_data *       data1;

garmin_data *       data2;

garmin_data *       rlaps;

garmin_data *       rtracks;

garmin_list *       runs   = NULL;

garmin_list *       laps   = NULL;

garmin_list *       tracks = NULL;

garmin_data *       rlist;

garmin_list_node *  n;

garmin_list_node *  m;

uint32              trk;

uint32              f_lap;

uint32              l_lap;

uint32              l_idx;

time_type           start;

time_t              start_time;

char                filename[BUFSIZ];

struct tm *         tbuf;

	// Find the data path in config file

	KSimpleConfig *cfg = new KSimpleConfig(QString("sportwatcher.rc"), true);

	cfg->setGroup(QString("SportWatcher"));

	Data = cfg->readEntry("Data");

	device = cfg->readEntry("Device");

	delete cfg;

	if (Data.isEmpty())

	{

	   KMessageBox::error(this, i18n("No data path was set in the settings!"));

//	   done(QDialog::Rejected);

	   return false;

	}

	if (!isVisible())

	   setShown(true);

	barProgress->setTotalSteps(psteps);

	step = 0;

	garmin_set_device(device.ascii());

	garmin_set_method(0);		// Setting to 1 doesn't work!! (reading over garmin_gps kernel module)

	// Initialize a callback function to have a real progress bar

	garmin_set_hook(&progressWidget::CallBack);

	lblInfo->setText(i18n("Looking for a Garmin GPS device..."));

	if (garmin_init(&garmin, 0) == 0)

	{

	   garmin_close(&garmin);

	   garmin_clear_hook();

	   return false;

	}

	barProgress->setProgress(++step);

	lblInfo->setText(i18n("Extracting data from Garmin <i>") + QString(garmin.product.product_description) + QString("</i>"));

	lblReading->setText(i18n("Please wait, this may take some time!"));

	mapp->processEvents();

	if ((data = garmin_get(&garmin, GET_RUNS)) != NULL )

	{

	   /*

	    * We should have a list with three elements:

	    *

	    * 1) The runs (which identify the track and lap indices)

	    * 2) The laps (which are related to the runs)

	    * 3) The tracks (which are related to the runs)

	    */

	   barProgress->setProgress(++step);

	   lblReading->setText(i18n("Sorting out runs ..."));

	   mapp->processEvents();

	   data0 = garmin_list_data(data, 0);

	   barProgress->setProgress(++step);

	   lblReading->setText(i18n("Sorting out laps ..."));

	   mapp->processEvents();

	   data1 = garmin_list_data(data, 1);

	   barProgress->setProgress(++step);

	   lblReading->setText(i18n("Sorting out tracks ..."));

	   mapp->processEvents();

	   data2 = garmin_list_data(data, 2);

	   barProgress->setProgress(++step);

	   lblReading->setText(i18n("Sorting out data blocks done."));

	   mapp->processEvents();

	   if ( data0 != NULL && (runs   = (garmin_list *)data0->data) != NULL &&

		data1 != NULL && (laps   = (garmin_list *)data1->data) != NULL &&

		data2 != NULL && (tracks = (garmin_list *)data2->data) != NULL )

	   {

	      /* For each run, get its laps and track points. */

	      /* But first see how much runs to set the progress bar */

	      for (n = runs->head; n != NULL; n = n->next)

		 psteps++;

	      barProgress->setTotalSteps(psteps);

	      mapp->processEvents();

	      for (n = runs->head; n != NULL; n = n->next)

	      {

		 barProgress->setProgress(++step);

		 mapp->processEvents();

		 if (get_run_track_lap_info(n->data, &trk, &f_lap, &l_lap) != 0)

		 {

		    lblReading->setText(i18n("Running: track ") + QString("%1, ").arg(trk) + i18n("laps ") + QString("%1:%1").arg(f_lap).arg(l_lap));

		    mapp->processEvents();

		    start = 0;

		    /* Get the laps. */

		    rlaps = garmin_alloc_data(data_Dlist);

		    for (m = laps->head; m != NULL; m = m->next)

		    {

		       if (get_lap_index(m->data, &l_idx) != 0)

		       {

			  if ( l_idx >= f_lap && l_idx <= l_lap )

			  {

			     garmin_list_append((garmin_list *)rlaps->data, m->data);

			     if ( l_idx == f_lap )

			        get_lap_start_time(m->data, &start);

			  }

		       }

		    }

		    /* Get the track points. */

		    rtracks = get_track(tracks,trk);

		    /* Now make a three-element list for this run. */

		    rlist = garmin_alloc_data(data_Dlist);

		    garmin_list_append((garmin_list *)rlist->data,n->data);

		    garmin_list_append((garmin_list *)rlist->data,rlaps);

		    garmin_list_append((garmin_list *)rlist->data,rtracks);

		    /*

		     * Determine the filename based on the start time of the first lap

		     */

		    if ((start_time = start) != 0)

		    {

		       tbuf = localtime(&start_time);

		       filepath.sprintf("%s/%d/%02d",

			  Data.ascii(), tbuf->tm_year+1900, tbuf->tm_mon + 1);

		       strftime(filename, sizeof(filename), "%Y%m%dT%H%M%S.gmn", tbuf);

		       /* Save rlist to the file. */

		       garmin_save(rlist, filename, filepath.ascii());

		       lblReading->setText(i18n("Saved file ") + QString(filename) + i18n(" successfully."));

		       mapp->processEvents();

		    }

	            else

		       KMessageBox::error(this, i18n("Start time of first lap not found!"));

		    /* Free the temporary lists we were using. */

		    if (rlaps != NULL)

		    {

		       garmin_free_list_only((garmin_list *)rlaps->data);

		       free(rlaps);

		    }

		    if (rtracks != NULL)

		    {

		       garmin_free_list_only((garmin_list *)rtracks->data);

		       free(rtracks);

		    }

		    if (rlist != NULL)

		    {

		       garmin_free_list_only((garmin_list *)rlist->data);

		       free(rlist);

		    }

		 }

	      }

	   }

	   else

	   {

              if (data0 == NULL)

		 KMessageBox::error(this, i18n("Toplevel data missing element 0 (runs)"));

	      else if (runs == NULL)

		 KMessageBox::error(this, i18n("No runs extracted!"));

	      if ( data1 == NULL )

		 KMessageBox::error(this, i18n("Toplevel data missing element 1 (laps)"));

	      else if (laps == NULL)

		 KMessageBox::error(this, i18n("No laps extracted!"));

	      if (data2 == NULL)

		 KMessageBox::error(this, i18n("Toplevel data missing element 2 (tracks)"));

	      else if (tracks == NULL)

		 KMessageBox::error(this, i18n("No tracks extracted!"));

	   }

	   garmin_free_data(data);

	}

	else

	   KMessageBox::error(this, i18n("Unable to extract any data!"));

	mapp->processEvents();

	garmin_close(&garmin);

	garmin_clear_hook();

	if (garmin_count_error() > 0)

	   return false;

	return true;

}

int progressWidget::get_run_track_lap_info ( garmin_data * run,

			 uint32 *      track_index,

			 uint32 *      first_lap_index,

			 uint32 *      last_lap_index )

{

  D1000 * d1000;

  D1009 * d1009;

  D1010 * d1010;

  int ok = 1;

  switch ( run->type ) {

  case data_D1000:

    d1000            = (D1000 *)run->data;

    *track_index     = d1000->track_index;

    *first_lap_index = d1000->first_lap_index;

    *last_lap_index  = d1000->last_lap_index;

    break;

  case data_D1009:

    d1009            = (D1009 *)run->data;

    *track_index     = d1009->track_index;

    *first_lap_index = d1009->first_lap_index;

    *last_lap_index  = d1009->last_lap_index;

    break;

  case data_D1010:

    d1010            = (D1010 *)run->data;

    *track_index     = d1010->track_index;

    *first_lap_index = d1010->first_lap_index;

    *last_lap_index  = d1010->last_lap_index;

    break;

  default:

    fprintf(stderr, "get_run_track_lap_info: run type %d invalid!\n",run->type);

    ok = 0;

    break;

  }

  return ok;

}

int progressWidget::get_lap_index ( garmin_data * lap, uint32 * lap_index )

{

  D1001 * d1001;

  D1011 * d1011;

  D1015 * d1015;

  int ok = 1;

  switch ( lap->type ) {

  case data_D1001:

    d1001      = (D1001 *)lap->data;

    *lap_index = d1001->index;

    break;

  case data_D1011:

    d1011      = (D1011 *)lap->data;

    *lap_index = d1011->index;

    break;

  case data_D1015:

    d1015      = (D1015 *)lap->data;

    *lap_index = d1015->index;

    break;

  default:

    fprintf(stderr, "get_lap_index: lap type %d invalid!\n",lap->type);

    ok = 0;

    break;

  }

  return ok;

}

int progressWidget::get_lap_start_time (garmin_data *lap, time_type *start_time)

{

  D1001 * d1001;

  D1011 * d1011;

  D1015 * d1015;

  int ok = 1;

  switch ( lap->type ) {

  case data_D1001:

    d1001       = (D1001 *)lap->data;

    *start_time = d1001->start_time + TIME_OFFSET;

    break;

  case data_D1011:

    d1011       = (D1011 *)lap->data;

    *start_time = d1011->start_time + TIME_OFFSET;

    break;

  case data_D1015:

    d1015       = (D1015 *)lap->data;

    *start_time = d1015->start_time + TIME_OFFSET;

    break;

  default:

    fprintf(stderr, "get_lap_start_time: lap type %d invalid!\n",lap->type);

    ok = 0;

    break;

  }

  return ok;

}

garmin_data *progressWidget::get_track(garmin_list *points, uint32 trk_index)

{

  garmin_list_node * n;

  garmin_data *      track = NULL;

  D311 *             d311;

  int                done = 0;

  /* Look for a data_D311 with an index that matches. */

  for ( n = points->head; n != NULL; n = n->next ) {    

    if ( n->data != NULL ) {

      switch ( n->data->type ) {

      case data_D311:

	if ( track == NULL ) {

	  d311 = (D311 *)n->data->data;

	  if ( d311->index == trk_index ) {

	    track = garmin_alloc_data(data_Dlist);

	    garmin_list_append((garmin_list *)track->data,n->data);

	  }

	} else {

	  /* We've reached the end of the track */

	  done = 1;

	}

	break;

      case data_D300:

      case data_D301:

      case data_D302:

      case data_D303:

      case data_D304:

	if ( track != NULL ) {

	  garmin_list_append((garmin_list *)track->data,n->data);

	}

	break;

      default:

	fprintf(stderr, "get_track: point type %d invalid!\n",n->data->type);

	break;

      }

    }

    if ( done != 0 ) break;

  }

  return track;

}

#include "progresswidget.moc"