• Skip to content
• Skip to link menu

KDE 4.2 API Reference

• KDE API Reference
• kdepim

• Sitemap
• Contact Us

 

ktimetracker

taskview.cpp

Go to the documentation of this file.

/*
 *     Copyright (C) 2003 by Scott Monachello <smonach@cox.net>
 *
 *   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; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   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.
 *      51 Franklin Street, Fifth Floor
 *      Boston, MA  02110-1301  USA.
 *
 */

#include "taskview.h"

#include <cassert>

#include <QFile>
#include <QStyledItemDelegate>
#include <QMenu>
#include <QPainter>
#include <QString>
#include <QTimer>
#include <QMouseEvent>
#include <QList>
#include <QClipboard>

#include <KApplication>       // kapp
#include <KDebug>
#include <KFileDialog>
#include <KLocale>            // i18n
#include <KMessageBox>
#include <KUrlRequester>

#include "csvexportdialog.h"
#include "desktoptracker.h"
#include "edittaskdialog.h"
#include "idletimedetector.h"
#include "plannerparser.h"
#include "preferences.h"
#include "ktimetracker.h"
#include "task.h"
#include "timekard.h"
#include "treeviewheadercontextmenu.h"
#include "focusdetector.h"
#include "focusdetectornotifier.h"
#include "storageadaptor.h"

#define T_LINESIZE 1023

class DesktopTracker;

//BEGIN TaskViewDelegate (custom painting of the progress column)
class TaskViewDelegate : public QStyledItemDelegate {
public:
  TaskViewDelegate( QObject *parent = 0 ) : QStyledItemDelegate( parent ) {}

  void paint( QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index ) const {
    if (index.column () == 6) {
      QApplication::style()->drawControl( QStyle::CE_ItemViewItem, &option, painter );
      int rX = option.rect.x() + 2;
      int rY = option.rect.y() + 2;
      int rWidth = option.rect.width() - 4;
      int rHeight = option.rect.height() - 4;

      int value = index.model()->data( index ).toInt();
      int newWidth = (int)(rWidth * (value / 100.));

      if(QApplication::isLeftToRight())
      {
         int mid = rY + rHeight / 2;
         int width = rWidth / 2;
         QLinearGradient gradient1( rX, mid, rX + width, mid);
         gradient1.setColorAt( 0, Qt::red );
         gradient1.setColorAt( 1, Qt::yellow );
         painter->fillRect( rX, rY, (newWidth < width) ? newWidth : width, rHeight, gradient1 );

         if (newWidth > width) {
            QLinearGradient gradient2( rX + width, mid, rX + 2 * width, mid);
            gradient2.setColorAt( 0, Qt::yellow );
            gradient2.setColorAt( 1, Qt::green );
            painter->fillRect( rX + width, rY, newWidth - width, rHeight, gradient2 );
         }

         painter->setPen( option.state & QStyle::State_Selected ? option.palette.highlight().color() : option.palette.background().color() );
         for (int x = rHeight; x < newWidth; x += rHeight) {
            painter->drawLine( rX + x, rY, rX + x, rY + rHeight - 1 );
         }
      }
      else
      {
         int mid = option.rect.height() - rHeight / 2;
         int width = rWidth / 2;
         QLinearGradient gradient1( rX, mid, rX + width, mid);
         gradient1.setColorAt( 0, Qt::red );
         gradient1.setColorAt( 1, Qt::yellow );
         painter->fillRect( option.rect.height(), rY, (newWidth < width) ? newWidth : width, rHeight, gradient1 );

         if (newWidth > width) {
            QLinearGradient gradient2( rX + width, mid, rX + 2 * width, mid);
            gradient2.setColorAt( 0, Qt::yellow );
            gradient2.setColorAt( 1, Qt::green );
            painter->fillRect( rX + width, rY, newWidth - width, rHeight, gradient2 );
         }

         painter->setPen( option.state & QStyle::State_Selected ? option.palette.highlight().color() : option.palette.background().color() );
         for (int x = rWidth- rHeight; x > newWidth; x -= rHeight) {
            painter->drawLine( rWidth - x, rY, rWidth - x, rY + rHeight - 1 );
         }

      }
      painter->setPen( Qt::black );
      painter->drawText( option.rect, Qt::AlignCenter | Qt::AlignVCenter, QString::number(value) + " %" );
    } else {
      QStyledItemDelegate::paint( painter, option, index );
    }
  }
};
//END

//BEGIN Private Data
//@cond PRIVATE
class TaskView::Private {
  public:
    Private() : 
      mStorage( new KarmStorage() ), 
      mFocusTrackingActive( false ) {}

    ~Private() {
      delete mStorage; 
    }
    KarmStorage *mStorage;
    bool mFocusTrackingActive;
    Task* mLastTaskWithFocus;
    QList<Task*> mActiveTasks;

    QMenu *mPopupPercentageMenu;
    QMap<QAction*, int> mPercentage;
    QMenu *mPopupPriorityMenu;
    QMap<QAction*, int> mPriority;
};
//@endcond
//END

TaskView::TaskView( QWidget *parent ) : QTreeWidget(parent), d( new Private() )
{
  _preferences = Preferences::instance();
    new StorageAdaptor( this );
    QDBusConnection::sessionBus().registerObject( "/ktimetrackerstorage", this );

  connect( this, SIGNAL(itemExpanded(QTreeWidgetItem*)),
           this, SLOT(itemStateChanged(QTreeWidgetItem*)) );
  connect( this, SIGNAL(itemCollapsed(QTreeWidgetItem*)),
           this, SLOT(itemStateChanged(QTreeWidgetItem*)) );
  connect( this, SIGNAL(itemDoubleClicked(QTreeWidgetItem*, int)),
           this, SLOT(slotItemDoubleClicked(QTreeWidgetItem*, int)) );
  connect( FocusDetectorNotifier::instance()->focusDetector(), 
           SIGNAL( newFocus( const QString & ) ), 
           this, SLOT( newFocusWindowDetected ( const QString & ) ) ); 

  QStringList labels;
  setWindowFlags( windowFlags() | Qt::WindowContextHelpButtonHint );
  labels << i18n( "Task Name" ) << i18n( "Session Time" ) << i18n( "Time" ) 
         << i18n( "Total Session Time" ) << i18n( "Total Time" ) 
         << i18n( "Priority" ) << i18n( "Percent Complete" );
  setHeaderLabels( labels );
  headerItem()->setWhatsThis(0,"The task name is how you call the task, it can be chosen freely.");
  headerItem()->setWhatsThis(1,"The session time is the time since you last chose \"start new session.\"");
  headerItem()->setWhatsThis(3,"The total session time is the session time of this task and all its subtasks.");
  headerItem()->setWhatsThis(4,"The total time is the time of this task and all its subtasks.");
  setAllColumnsShowFocus( true );
  setSortingEnabled( true );
  setAlternatingRowColors( true );
  setDragDropMode( QAbstractItemView::InternalMove );
  setItemDelegateForColumn( 6, new TaskViewDelegate(this) );

  // set up the minuteTimer
  _minuteTimer = new QTimer(this);
  connect( _minuteTimer, SIGNAL( timeout() ), this, SLOT( minuteUpdate() ));
  _minuteTimer->start(1000 * secsPerMinute);

  // Set up the idle detection.
  _idleTimeDetector = new IdleTimeDetector( KTimeTrackerSettings::period() );
  connect( _idleTimeDetector, SIGNAL( extractTime(int) ),
           this, SLOT( extractTime(int) ));
  connect( _idleTimeDetector, SIGNAL( stopAllTimers(QDateTime) ),
           this, SLOT( stopAllTimers(QDateTime) ));
  if (!_idleTimeDetector->isIdleDetectionPossible())
    KTimeTrackerSettings::setEnabled( false );

  // Setup auto save timer
  _autoSaveTimer = new QTimer(this);
  connect( _autoSaveTimer, SIGNAL( timeout() ), this, SLOT( save() ));

  // Setup manual save timer (to save changes a little while after they happen)
  _manualSaveTimer = new QTimer(this);
  _manualSaveTimer->setSingleShot( true );
  connect( _manualSaveTimer, SIGNAL( timeout() ), this, SLOT( save() ));

  // Connect desktop tracker events to task starting/stopping
  _desktopTracker = new DesktopTracker();
  connect( _desktopTracker, SIGNAL( reachedActiveDesktop( Task* ) ),
           this, SLOT( startTimerFor(Task*) ));
  connect( _desktopTracker, SIGNAL( leftActiveDesktop( Task* ) ),
           this, SLOT( stopTimerFor(Task*) ));

  // Header context menu
  TreeViewHeaderContextMenu *headerContextMenu = new TreeViewHeaderContextMenu( this, this, TreeViewHeaderContextMenu::AlwaysCheckBox, QVector<int>() << 0 );
  connect( headerContextMenu, SIGNAL(columnToggled(int)), this, SLOT(slotColumnToggled(int)) );

  // Context Menu
  d->mPopupPercentageMenu = new QMenu( this );
  for ( int i = 0; i <= 100; i += 10 )
  {
    QString label = i18n( "%1 %" , i );
    d->mPercentage[ d->mPopupPercentageMenu->addAction( label ) ] = i;
  }
  connect( d->mPopupPercentageMenu, SIGNAL( triggered( QAction * ) ),
           this, SLOT( slotSetPercentage( QAction * ) ) );

  d->mPopupPriorityMenu = new QMenu( this );
  for ( int i = 0; i <= 9; ++i ) {
    QString label;
    switch ( i ) {
      case 0:
        label = i18n( "unspecified" );
        break;
      case 1:
        label = i18nc( "combox entry for highest priority", "1 (highest)" );
        break;
      case 5:
        label = i18nc( "combox entry for medium priority", "5 (medium)" );
        break;
      case 9:
        label = i18nc( "combox entry for lowest priority", "9 (lowest)" );
        break;
      default:
        label = QString( "%1" ).arg( i );
        break;
    }
    d->mPriority[ d->mPopupPriorityMenu->addAction( label ) ] = i;
  }
  connect( d->mPopupPriorityMenu, SIGNAL( triggered( QAction * ) ),
           this, SLOT( slotSetPriority( QAction * ) ) );

  setContextMenuPolicy( Qt::CustomContextMenu );
  connect( this, SIGNAL( customContextMenuRequested( const QPoint & ) ),
           this, SLOT( slotCustomContextMenuRequested( const QPoint & ) ) );

  reconfigure();
  sortByColumn( 0, Qt::AscendingOrder );
  for (int i=0; i<=columnCount(); i++) resizeColumnToContents(i);
}

void TaskView::newFocusWindowDetected( const QString &taskName )
{
  QString newTaskName = taskName;
  newTaskName.replace( "\n", "" );

  if ( d->mFocusTrackingActive ) {
    bool found = false;  // has taskName been found in our tasks
    stopTimerFor( d->mLastTaskWithFocus );
    int i = 0;
    for ( Task* task = itemAt( i ); task; task = itemAt( ++i ) ) {
      if ( task->name() == newTaskName ) {
         found = true;
         startTimerFor( task );
         d->mLastTaskWithFocus = task;
      }
    }
    if ( !found ) {
      QString taskuid = addTask( newTaskName );
      if ( taskuid.isNull() ) {
        KMessageBox::error( 0, i18n(
        "Error storing new task. Your changes were not saved. Make sure you can edit your iCalendar file. Also quit all applications using this file and remove any lock file related to its name from ~/.kde/share/apps/kabc/lock/ " ) );
      }
      i = 0;
      for ( Task* task = itemAt( i ); task; task = itemAt( ++i ) ) {
        if (task->name() == newTaskName) {
          startTimerFor( task );
          d->mLastTaskWithFocus = task;
        }
      }
    }
    emit updateButtons();
  } // focustrackingactive
}

void TaskView::mouseMoveEvent( QMouseEvent *event ) 
{
  QModelIndex index = indexAt( event->pos() );

  if (index.isValid() && index.column() == 6) 
  {
    int newValue = (int)((event->pos().x() - visualRect(index).x()) / (double)(visualRect(index).width()) * 100);

    if ( event->modifiers() & Qt::ShiftModifier ) {
      int delta = newValue % 10;
      if ( delta >= 5 ) {
        newValue += (10 - delta);
      } else {
        newValue -= delta;
      }
    }

    QTreeWidgetItem *item = itemFromIndex( index );
    if (item && item->isSelected()) 
    {
      Task *task = static_cast<Task*>(item);
      if (task) 
      {
        task->setPercentComplete( newValue, d->mStorage );

        emit updateButtons();
      }
    }
  } 
  else 
  {
    QTreeWidget::mouseMoveEvent( event );
  }
}

void TaskView::mousePressEvent( QMouseEvent *event )
{
  QModelIndex index = indexAt( event->pos() );

  // if the user toggles a task as complete/incomplete
  if (   index.isValid() 
      && index.column() == 0
      && visualRect( index ).x() <= event->pos().x()
      && event->pos().x() < visualRect( index ).x() + 19)
  {
    QTreeWidgetItem *item = itemFromIndex( index );
    if (item)
    {
      Task *task = static_cast<Task*>(item);
      if (task) 
      {
        if (task->isComplete()) task->setPercentComplete( 0, d->mStorage );
        else 
        {
          task->setPercentComplete( 100, d->mStorage );
        }
        
        emit updateButtons();
      }
    }
  }
  else
  {
    if ( KTimeTrackerSettings::configPDA() )
    // if you have a touchscreen, you cannot right-click. So, display context menu on any click.
    {
      QPoint newPos = viewport()->mapToGlobal( event->pos() );
      emit contextMenuRequested( newPos );
    }
    QTreeWidget::mousePressEvent( event );
  }
}

KarmStorage* TaskView::storage()
{
  return d->mStorage;
}

TaskView::~TaskView()
{
  FocusDetectorNotifier::instance()->detach( this );
  delete d;
  KTimeTrackerSettings::self()->writeConfig();
}

Task* TaskView::currentItem() const
{
  kDebug(5970) << "Entering function";
  return static_cast< Task* >( QTreeWidget::currentItem() );
}

Task* TaskView::itemAt(int i)
/* This procedure delivers the item at the position i in the KTreeWidget.
Every item is a task. The items are counted linearily. The uppermost item
has the number i=0. */
{
  if ( topLevelItemCount() == 0 ) return 0;
  
  QTreeWidgetItemIterator item( this );
  while( *item && i-- ) ++item;
  
  kDebug( 5970 ) << "Leaving TaskView::itemAt" << "returning " << (*item==0);
  if ( !( *item ) )
    return 0;
  else
    return (Task*)*item;
}

void TaskView::load( const QString &fileName )
{
  assert( !( fileName.isEmpty() ) );

  // if the program is used as an embedded plugin for konqueror, there may be a need
  // to load from a file without touching the preferences.
  kDebug(5970) << "Entering function";
  _isloading = true;
  QString err = d->mStorage->load(this, fileName);

  if (!err.isEmpty())
  {
    KMessageBox::error(this, err);
    _isloading = false;
    kDebug(5970) << "Leaving TaskView::load";
    return;
  }

  // Register tasks with desktop tracker
  int i = 0;
  for ( Task* t = itemAt(i); t; t = itemAt(++i) )
    _desktopTracker->registerForDesktops( t, t->desktops() );
  // till here
  // Start all tasks that have an event without endtime
  i = 0;
  for ( Task* t = itemAt(i); t; t = itemAt(++i) )
  {
    if ( !d->mStorage->allEventsHaveEndTiMe( t ) )
    {
      t->resumeRunning();
      d->mActiveTasks.append(t);
      emit updateButtons();
      if ( d->mActiveTasks.count() == 1 )
        emit timersActive();  
      emit tasksChanged( d->mActiveTasks );
    }
  }
  // till here

  if ( topLevelItemCount() > 0 )
  {
    restoreItemState();
    setCurrentItem(topLevelItem( 0 ));
    if ( !_desktopTracker->startTracking().isEmpty() )
      KMessageBox::error( 0, i18n( "Your virtual desktop number is too high, desktop tracking will not work" ) );
    _isloading = false;
    refresh();
  }
  for (int i=0; i<=columnCount(); i++) resizeColumnToContents(i);
  kDebug(5970) << "Leaving function";
}

void TaskView::restoreItemState()
/* Restores the item state of every item. An item is a task in the list.
Its state is whether it is expanded or not. If a task shall be expanded
is stored in the _preferences object. */
{
  kDebug(5970) << "Entering function";
  
  if ( topLevelItemCount() > 0 ) {
    QTreeWidgetItemIterator item( this );
    while( *item ) 
    {
      Task *t = (Task *) *item;
      t->setExpanded( _preferences->readBoolEntry( t->uid() ) );
      ++item;
    }
  }
  kDebug(5970) << "Leaving function";
}

void TaskView::itemStateChanged( QTreeWidgetItem *item )
{
  kDebug() << "Entering function";
  if ( !item || _isloading ) return;
  Task *t = (Task *)item;
  kDebug(5970) <<"TaskView::itemStateChanged()" <<" uid=" << t->uid() <<" state=" << t->isExpanded();
  if( _preferences ) _preferences->writeEntry( t->uid(), t->isExpanded() );
}

void TaskView::closeStorage() { d->mStorage->closeStorage(); }

bool TaskView::allEventsHaveEndTiMe()
{
  return d->mStorage->allEventsHaveEndTiMe();
}

void TaskView::iCalFileModified(ResourceCalendar *rc)
{
  kDebug(5970) << "entering function";
  kDebug(5970) << rc->infoText();
  rc->dump();
  d->mStorage->buildTaskView(rc,this);
  kDebug(5970) << "exiting iCalFileModified";
}

void TaskView::refresh()
{
  kDebug(5970) << "entering function";
  int i = 0;
  for ( Task* t = itemAt(i); t; t = itemAt(++i) )
  {
    t->setPixmapProgress();
    t->update();  // maybe there was a change in the times's format
  }

  // remove root decoration if there is no more child.
  i = 0;
  while ( itemAt( ++i ) && ( itemAt( i )->depth() == 0 ) ){};
  //setRootIsDecorated( itemAt( i ) && ( itemAt( i )->depth() != 0 ) );
  // FIXME workaround? seems that the QItemDelegate for the procent column only
  // works properly if rootIsDecorated == true.
  setRootIsDecorated( true );

  emit updateButtons();
  kDebug(5970) << "exiting TaskView::refresh()";
}

QString TaskView::reFreshTimes()
{
  kDebug(5970) << "Entering function";
  QString err;

  // re-calculate the time for every task based on events in the history

  KCal::Event::List eventList = storage()->rawevents(); // get all events (!= tasks)
  int n=-1;
  resetTimeForAllTasks();
  emit reSetTimes();
  while (itemAt(++n)) // loop over all tasks
  {
    for( KCal::Event::List::iterator i = eventList.begin(); i != eventList.end(); ++i ) // loop over all events
    {
      if ( (*i)->relatedToUid() == itemAt(n)->uid() ) // if event i belongs to task n
      {
        KDateTime kdatetimestart = (*i)->dtStart();
        KDateTime kdatetimeend = (*i)->dtEnd();
        KDateTime eventstart = KDateTime::fromString(kdatetimestart.toString().replace("Z",""));
        KDateTime eventend = KDateTime::fromString(kdatetimeend.toString().replace("Z",""));
        int duration=eventstart.secsTo( eventend )/60;
        itemAt(n)->addTime( duration );
        emit totalTimesChanged( 0, duration );
        kDebug(5970) << "duration is " << duration;

        if ( itemAt(n)->sessionStartTiMe().isValid() )
        {
        // if there is a session
          if ((itemAt(n)->sessionStartTiMe().secsTo( eventstart )>0) &&        
              (itemAt(n)->sessionStartTiMe().secsTo( eventend )>0))
          // if the event is after the session start
          {
            int sessionTime=eventstart.secsTo( eventend )/60;
            itemAt(n)->setSessionTime( itemAt(n)->sessionTime()+sessionTime );
          }
        }
    else 
    // so there is no session at all
        {
          itemAt(n)->addSessionTime( duration );
          emit totalTimesChanged( duration, 0 );
        };
      }
    }
  }
  refresh();
  kDebug(5970) << "Leaving TaskView::reFreshTimes()";
  return err;
}

void TaskView::importPlanner( const QString &fileName )
{
  kDebug( 5970 ) << "entering importPlanner";
  PlannerParser *handler = new PlannerParser( this );
  QString lFileName = fileName;
  if ( lFileName.isEmpty() ) 
    lFileName = KFileDialog::getOpenFileName( QString(), QString(), 0 );
  QFile xmlFile( lFileName );
  QXmlInputSource source( &xmlFile );
  QXmlSimpleReader reader;
  reader.setContentHandler( handler );
  reader.parse( source );
  refresh();
}

QString TaskView::report( const ReportCriteria& rc )
{
  return d->mStorage->report( this, rc );
}

void TaskView::exportcsvFile()
{
  kDebug(5970) << "TaskView::exportcsvFile()";

  CSVExportDialog dialog( ReportCriteria::CSVTotalsExport, this );
  if ( currentItem() && currentItem()->isRoot() )
    dialog.enableTasksToExportQuestion();
  dialog.urlExportTo->KUrlRequester::setMode(KFile::File);
  if ( dialog.exec() ) {
    QString err = d->mStorage->report( this, dialog.reportCriteria() );
    if ( !err.isEmpty() ) KMessageBox::error( this, i18n(err.toAscii()) );
  }
}

QString TaskView::exportcsvHistory()
{
  kDebug(5970) << "TaskView::exportcsvHistory()";
  QString err;
  
  CSVExportDialog dialog( ReportCriteria::CSVHistoryExport, this );
  if ( currentItem() && currentItem()->isRoot() )
    dialog.enableTasksToExportQuestion();
  dialog.urlExportTo->KUrlRequester::setMode(KFile::File);
  if ( dialog.exec() ) {
    err = d->mStorage->report( this, dialog.reportCriteria() );
  }
  return err;
}

long TaskView::count()
{
  long n = 0;
  for (Task* t = itemAt(n); t; t=itemAt(++n)){};
  return n;
}

QStringList TaskView::tasks()
{
  QStringList result;
  int i=0;
  while ( itemAt(i) ) 
  {
    result << itemAt(i)->name();
    ++i;
  }
  return result;
}

Task* TaskView::task( const QString& taskId )
{
  Task* result=0;
  int i=-1;
  while ( itemAt(++i) ) 
    if ( itemAt( i ) ) 
      if ( itemAt( i )->uid() == taskId ) result=itemAt( i );
  return result;
}

void TaskView::scheduleSave()
{
    _manualSaveTimer->start( 10 );
}

QString TaskView::save()
{
  kDebug(5970) <<"Entering TaskView::save()";
  QString err=d->mStorage->save(this);

  if (err.isNull()) emit setStatusBarText( i18n("Successfully saved file ").append( d->mStorage->icalfile() ));
  else
    if (err==QString("Could not save. Could not lock file.")) emit setStatusBarText( i18n("Could not save. Disk full ?") );
    else emit setStatusBarText( i18n("Could not save.") );
  return err;
}

void TaskView::startCurrentTimer()
{
  startTimerFor( currentItem() );
}

void TaskView::startTimerFor( Task* task, const QDateTime &startTime )
{
  kDebug(5970) << "Entering function";
  if (task != 0 && d->mActiveTasks.indexOf(task) == -1) 
  {
    if (!task->isComplete())
    {
      if ( KTimeTrackerSettings::uniTasking() ) stopAllTimers();
      _idleTimeDetector->startIdleDetection();
      task->setRunning(true, d->mStorage, startTime);
      d->mActiveTasks.append(task);
      emit updateButtons();
      if ( d->mActiveTasks.count() == 1 )
          emit timersActive();
      emit tasksChanged( d->mActiveTasks );
    }
  }
}

void TaskView::clearActiveTasks()
{
  d->mActiveTasks.clear(); 
}

void TaskView::stopAllTimers( const QDateTime &when )
{
  kDebug(5970) << "Entering function";
  foreach ( Task *task, d->mActiveTasks )
    task->setRunning( false, d->mStorage, when );

  _idleTimeDetector->stopIdleDetection();
  FocusDetectorNotifier::instance()->detach( this );
  d->mActiveTasks.clear();
  emit updateButtons();
  emit timersInactive();
  emit tasksChanged( d->mActiveTasks );
}

void TaskView::toggleFocusTracking()
{
  d->mFocusTrackingActive = !d->mFocusTrackingActive;

  if ( d->mFocusTrackingActive ) 
  {
    FocusDetectorNotifier::instance()->attach( this );
  } 
  else  
  {
    stopTimerFor( d->mLastTaskWithFocus );
    FocusDetectorNotifier::instance()->detach( this );
  }

  emit updateButtons();
}

void TaskView::startNewSession()
/* This procedure starts a new session. We speak of session times, 
overalltimes (comprising all sessions) and total times (comprising all subtasks).
That is why there is also a total session time. */
{
  kDebug(5970) <<"Entering TaskView::startNewSession";
  QTreeWidgetItemIterator item( this );
  while ( *item )
  {
    Task * task = (Task *) *item;
    task->startNewSession();
    ++item;
  }
  kDebug(5970) << "Leaving TaskView::startNewSession";
}

void TaskView::resetTimeForAllTasks()
/* This procedure resets all times (session and overall) for all tasks and subtasks. */
{
  kDebug(5970) << "Entering TaskView::resetTimeForAllTasks";
  QTreeWidgetItemIterator item( this );
  while ( *item ) 
  {
    Task * task = (Task *) *item;
    task->resetTimes();
    ++item;
  }
  kDebug(5970) << "Leaving TaskView::resetTimeForAllTasks";
}

void TaskView::stopTimerFor(Task* task)
{
  kDebug(5970) << "Entering function";
  if ( task != 0 && d->mActiveTasks.indexOf(task) != -1 ) 
  {
    d->mActiveTasks.removeAll(task);
    task->setRunning(false, d->mStorage);
    if ( d->mActiveTasks.count() == 0 ) 
    {
      _idleTimeDetector->stopIdleDetection();
      emit timersInactive();
    }
    emit updateButtons();
  }
  emit tasksChanged( d->mActiveTasks );
}

void TaskView::stopCurrentTimer()
{
  stopTimerFor( currentItem() );
  if ( d->mFocusTrackingActive && d->mLastTaskWithFocus == currentItem() ) 
  {
    toggleFocusTracking();
  }
}

void TaskView::minuteUpdate()
{
  addTimeToActiveTasks(1, false);
}

void TaskView::addTimeToActiveTasks(int minutes, bool save_data)
{
  foreach ( Task *task, d->mActiveTasks )
    task->changeTime( minutes, ( save_data ? d->mStorage : 0 ) );
}

void TaskView::newTask()
{
  newTask(i18n("New Task"), 0);
}

void TaskView::newTask( const QString &caption, Task *parent )
{
  EditTaskDialog *dialog = new EditTaskDialog( this, caption, false );
  long total, totalDiff, session, sessionDiff;
  DesktopList desktopList;

  int result = dialog->exec();
  if ( result == QDialog::Accepted ) 
  {
    QString taskName = i18n( "Unnamed Task" );
    if ( !dialog->taskName().isEmpty()) taskName = dialog->taskName();

    total = totalDiff = session = sessionDiff = 0;
    dialog->status( &total, &totalDiff, &session, &sessionDiff, &desktopList );

    // If all available desktops are checked, disable auto tracking,
    // since it makes no sense to track for every desktop.
    if ( desktopList.size() ==  _desktopTracker->desktopCount() )
      desktopList.clear();

    QString uid = addTask( taskName, total, session, desktopList, parent );
    if ( uid.isNull() )
    {
      KMessageBox::error( 0, i18n(
            "Error storing new task. Your changes were not saved. Make sure you can edit your iCalendar file. Also quit all applications using this file and remove any lock file related to its name from ~/.kde/share/apps/kabc/lock/ " ) );
    }
  }
  emit updateButtons();
}

QString TaskView::addTask
( const QString& taskname, long total, long session, 
  const DesktopList& desktops, Task* parent )
{
  kDebug(5970) << "Entering function; taskname =" << taskname;
  setSortingEnabled(false);
  Task *task;
  if ( parent ) task = new Task( taskname, total, session, desktops, parent );
  else          task = new Task( taskname, total, session, desktops, this );

  task->setUid( d->mStorage->addTask( task, parent ) );
  QString taskuid=task->uid();
  if ( ! taskuid.isNull() )
  {
    _desktopTracker->registerForDesktops( task, desktops );
    setCurrentItem( task );
    task->setSelected( true );
    task->setPixmapProgress();
    save();
  }
  else
  {
    delete task;
  }
  setSortingEnabled(true);
  return taskuid;
}

void TaskView::newSubTask()
{
  Task* task = currentItem();
  if(!task)
    return;
  newTask(i18n("New Sub Task"), task);
  task->setExpanded(true);
  refresh();
}

void TaskView::editTask()
{
  kDebug(5970) <<"Entering editTask";
  Task *task = currentItem();
  if (!task)
    return;

  DesktopList desktopList = task->desktops();
  DesktopList oldDeskTopList = desktopList;
  EditTaskDialog *dialog = new EditTaskDialog( this, i18n("Edit Task"), true, &desktopList );
  dialog->setTask( task->name(),
                   task->time(),
                   task->sessionTime() );
  int result = dialog->exec();
  if (result == QDialog::Accepted) 
  {
    QString taskName = i18n("Unnamed Task");
    if (!dialog->taskName().isEmpty()) 
    {
      taskName = dialog->taskName();
    }
    // setName only does something if the new name is different
    task->setName(taskName, d->mStorage);

    // update session time as well if the time was changed
    long total, session, totalDiff, sessionDiff;
    total = totalDiff = session = sessionDiff = 0;
    DesktopList desktopList;
    dialog->status( &total, &totalDiff, &session, &sessionDiff, &desktopList);

    if( totalDiff != 0 || sessionDiff != 0)
      task->changeTimes( sessionDiff, totalDiff, d->mStorage );

    // If all available desktops are checked, disable auto tracking,
    // since it makes no sense to track for every desktop.
    if (desktopList.size() == _desktopTracker->desktopCount())
      desktopList.clear();
    // only do something for autotracking if the new setting is different
    if ( oldDeskTopList != desktopList )
    { 
      task->setDesktopList(desktopList);
      _desktopTracker->registerForDesktops( task, desktopList );
    }
    emit updateButtons();
  }
}

void TaskView::reinstateTask(int completion)
{
  Task* task = currentItem();
  if (task == 0) {
    KMessageBox::information(0,i18n("No task selected."));
    return;
  }

  if (completion<0) completion=0;
  if (completion<100)
  {
    task->setPercentComplete(completion, d->mStorage);
    task->setPixmapProgress();
    save();
    emit