| -rw-r--r-- | korganizer/kotodoview.cpp | 1028 |
1 files changed, 1028 insertions, 0 deletions
diff --git a/korganizer/kotodoview.cpp b/korganizer/kotodoview.cpp new file mode 100644 index 0000000..0708a69 --- a/dev/null +++ b/korganizer/kotodoview.cpp @@ -0,0 +1,1028 @@ +/* + This file is part of KOrganizer. + Copyright (c) 2000,2001 Cornelius Schumacher <schumacher@kde.org> + + 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + + As a special exception, permission is given to link this program + with any edition of Qt, and distribute the resulting executable, + without including the source code for Qt in the source distribution. +*/ + +#include <qlayout.h> +#include <qheader.h> +#include <qcursor.h> + +#include <qvbox.h> +#include <kdebug.h> +#include "koprefs.h" +#include <klocale.h> +#include <kglobal.h> +#include <kiconloader.h> +#include <kmessagebox.h> + +#include <libkcal/icaldrag.h> +#include <libkcal/vcaldrag.h> +#include <libkcal/calfilter.h> +#include <libkcal/dndfactory.h> +#include <libkcal/calendarresources.h> +#include <libkcal/resourcecalendar.h> +#include <kresources/resourceselectdialog.h> +#ifndef DESKTOP_VERSION +#include <qpe/qpeapplication.h> +#else +#include <qapplication.h> +#endif +#ifndef KORG_NOPRINTER +#include "calprinter.h" +#endif +#include "docprefs.h" + +#include "kotodoview.h" +using namespace KOrg; +#include "kotodoview.moc" + +KOTodoListView::KOTodoListView(Calendar *calendar,QWidget *parent, + const char *name) : + KListView(parent,name) +{ + mCalendar = calendar; +#ifndef DESKTOP_VERSION + QPEApplication::setStylusOperation(viewport(), QPEApplication::RightOnHold ); +#endif + mOldCurrent = 0; + mMousePressed = false; + + setAcceptDrops(true); + viewport()->setAcceptDrops(true); + int size = 16; + if (qApp->desktop()->width() < 300 ) + size = 12; + setTreeStepSize( size + 6 ); + +} + +void KOTodoListView::contentsDragEnterEvent(QDragEnterEvent *e) +{ +#ifndef KORG_NODND +// kdDebug() << "KOTodoListView::contentsDragEnterEvent" << endl; + if ( !ICalDrag::canDecode( e ) && !VCalDrag::canDecode( e ) && + !QTextDrag::canDecode( e ) ) { + e->ignore(); + return; + } + + mOldCurrent = currentItem(); +#endif +} + + +void KOTodoListView::contentsDragMoveEvent(QDragMoveEvent *e) +{ +#ifndef KORG_NODND +// kdDebug() << "KOTodoListView::contentsDragMoveEvent" << endl; + + if ( !ICalDrag::canDecode( e ) && !VCalDrag::canDecode( e ) && + !QTextDrag::canDecode( e ) ) { + e->ignore(); + return; + } + + e->accept(); +#endif +} + +void KOTodoListView::contentsDragLeaveEvent(QDragLeaveEvent *) +{ +#ifndef KORG_NODND +// kdDebug() << "KOTodoListView::contentsDragLeaveEvent" << endl; + + setCurrentItem(mOldCurrent); + setSelected(mOldCurrent,true); +#endif +} + +void KOTodoListView::contentsDropEvent(QDropEvent *e) +{ +#ifndef KORG_NODND +// kdDebug() << "KOTodoListView::contentsDropEvent" << endl; + + if ( !ICalDrag::canDecode( e ) && !VCalDrag::canDecode( e ) && + !QTextDrag::canDecode( e ) ) { + e->ignore(); + return; + } + + DndFactory factory( mCalendar ); + Todo *todo = factory.createDropTodo(e); + + if (todo) { + e->acceptAction(); + + KOTodoViewItem *destination = + (KOTodoViewItem *)itemAt(contentsToViewport(e->pos())); + Todo *destinationEvent = 0; + if (destination) destinationEvent = destination->todo(); + + Todo *existingTodo = mCalendar->todo(todo->uid()); + + if(existingTodo) { +// kdDebug() << "Drop existing Todo" << endl; + Incidence *to = destinationEvent; + while(to) { + if (to->uid() == todo->uid()) { + KMessageBox::sorry(this, + i18n("Cannot move To-Do to itself or a child of itself"), + i18n("Drop To-Do")); + delete todo; + return; + } + to = to->relatedTo(); + } + existingTodo->setRelatedTo(destinationEvent); + emit todoDropped(todo); + delete todo; + } else { +// kdDebug() << "Drop new Todo" << endl; + todo->setRelatedTo(destinationEvent); + mCalendar->addTodo(todo); + + emit todoDropped(todo); + } + } + else { + QString text; + if (QTextDrag::decode(e,text)) { + //QListViewItem *qlvi = itemAt( contentsToViewport(e->pos()) ); + KOTodoViewItem *todoi = static_cast<KOTodoViewItem *>(itemAt( contentsToViewport(e->pos()) )); + kdDebug() << "Dropped : " << text << endl; + QStringList emails = QStringList::split(",",text); + for(QStringList::ConstIterator it = emails.begin();it!=emails.end();++it) { + kdDebug() << " Email: " << (*it) << endl; + int pos = (*it).find("<"); + QString name = (*it).left(pos); + QString email = (*it).mid(pos); + if (!email.isEmpty() && todoi) { + todoi->todo()->addAttendee(new Attendee(name,email)); + } + } + } + else { + kdDebug() << "KOTodoListView::contentsDropEvent(): Todo from drop not decodable" << endl; + e->ignore(); + } + } +#endif +} + +void KOTodoListView::contentsMousePressEvent(QMouseEvent* e) +{ + QListView::contentsMousePressEvent(e); +#ifndef KORG_NODND + QPoint p(contentsToViewport(e->pos())); + QListViewItem *i = itemAt(p); + if (i) { + // if the user clicked into the root decoration of the item, don't + // try to start a drag! + if (p.x() > header()->sectionPos(header()->mapToIndex(0)) + + treeStepSize() * (i->depth() + (rootIsDecorated() ? 1 : 0)) + + itemMargin() || + p.x() < header()->sectionPos(header()->mapToIndex(0))) { + if (e->button()==Qt::LeftButton) { + mPressPos = e->pos(); + mMousePressed = true; + } + } + } +#endif +} + +void KOTodoListView::contentsMouseMoveEvent(QMouseEvent* e) +{ +#ifndef KORG_NODND +// kdDebug() << "KOTodoListView::contentsMouseMoveEvent()" << endl; + QListView::contentsMouseMoveEvent(e); + if (mMousePressed && (mPressPos - e->pos()).manhattanLength() > + QApplication::startDragDistance()) { + mMousePressed = false; + QListViewItem *item = itemAt(contentsToViewport(mPressPos)); + if (item) { +// kdDebug() << "Start Drag for item " << item->text(0) << endl; + DndFactory factory( mCalendar ); + ICalDrag *vd = factory.createDragTodo( + ((KOTodoViewItem *)item)->todo(),viewport()); + if (vd->drag()) { + kdDebug() << "KOTodoListView::contentsMouseMoveEvent(): Delete drag source" << endl; + } +/* + QString source = fullPath(item); + if ( QFile::exists(source) ) { + QUriDrag* ud = new QUriDrag(viewport()); + ud->setFilenames( source ); + if ( ud->drag() ) + QMessageBox::information( this, "Drag source", + QString("Delete ")+source, "Not implemented" ); +*/ + } + } +#endif +} +void KOTodoListView::keyPressEvent ( QKeyEvent * e ) +{ + + QListViewItem* cn; + if ( e->key() == Qt::Key_Return || e->key() == Qt::Key_Enter ) { + cn = currentItem(); + if ( cn ) { + KOTodoViewItem* ci = (KOTodoViewItem*)( cn ); + if ( ci ){ + if ( e->state() == ShiftButton ) + ci->setOn( false ); + else + ci->setOn( true ); + cn = cn->nextSibling(); + if ( cn ) { + setCurrentItem ( cn ); + ensureItemVisible ( cn ); + } + + } + } + + return; + } + + // qDebug("KOTodoListView::keyPressEvent "); + if ( e->state() == Qt::ControlButton || e->state() == Qt::ShiftButton || ( height() > 150 && width() > 200 ) ) { + switch ( e->key() ) { + case Qt::Key_Down: + case Qt::Key_Up: + QListView::keyPressEvent ( e ); + break; + default: + e->ignore(); + break; + } + return; + } + e->ignore(); +} +void KOTodoListView::contentsMouseReleaseEvent(QMouseEvent *e) +{ + QListView::contentsMouseReleaseEvent(e); + mMousePressed = false; +} + +void KOTodoListView::contentsMouseDoubleClickEvent(QMouseEvent *e) +{ + if (!e) return; + + QPoint vp = contentsToViewport(e->pos()); + + QListViewItem *item = itemAt(vp); + + emit double_Clicked(item); + if (!item) return; + + emit doubleClicked(item,vp,0); +} + +///////////////////////////////////////////////////////////////////////////// + +KOQuickTodo::KOQuickTodo(QWidget *parent) : + QLineEdit(parent) +{ + setText(i18n("Click to add a new Todo")); +} + +void KOQuickTodo::focusInEvent(QFocusEvent *ev) +{ + if ( text()==i18n("Click to add a new Todo") ) + setText(""); + QLineEdit::focusInEvent(ev); +} + +void KOQuickTodo::focusOutEvent(QFocusEvent *ev) +{ + setText(i18n("Click to add a new Todo")); + QLineEdit::focusOutEvent(ev); +} + +///////////////////////////////////////////////////////////////////////////// + +KOTodoView::KOTodoView(Calendar *calendar,QWidget* parent,const char* name) : + KOrg::BaseView(calendar,parent,name) +{ + QBoxLayout *topLayout = new QVBoxLayout(this); + mName = QString ( name ); + mBlockUpdate = false; + mQuickAdd = new KOQuickTodo(this); + topLayout->addWidget(mQuickAdd); + + if ( !KOPrefs::instance()->mEnableQuickTodo ) mQuickAdd->hide(); + + mTodoListView = new KOTodoListView(calendar,this); + topLayout->addWidget(mTodoListView); + //mTodoListView->header()->setMaximumHeight(30); + mTodoListView->setRootIsDecorated(true); + mTodoListView->setAllColumnsShowFocus(true); + + mTodoListView->setShowSortIndicator(true); + + mTodoListView->addColumn(i18n("Todo")); + mTodoListView->addColumn(i18n("Prio")); + mTodoListView->setColumnAlignment(1,AlignHCenter); + mTodoListView->addColumn(i18n("Complete")); + mTodoListView->setColumnAlignment(2,AlignHCenter); + mTodoListView->addColumn(i18n("Due Date")); + mTodoListView->setColumnAlignment(3,AlignLeft); + mTodoListView->addColumn(i18n("Due Time")); + mTodoListView->setColumnAlignment(4,AlignHCenter); + mTodoListView->addColumn(i18n("Cancelled")); + mTodoListView->addColumn(i18n("Categories")); +#if 0 + mTodoListView->addColumn(i18n("Sort Id")); + mTodoListView->setColumnAlignment(4,AlignHCenter); +#endif + + mTodoListView->setMinimumHeight( 60 ); + mTodoListView->setItemsRenameable( true ); + mTodoListView->setRenameable( 0 ); + mTodoListView->setColumnWidth( 0, 120 ); + mTodoListView->setColumnWidthMode(0, QListView::Manual); + mTodoListView->setColumnWidthMode(1, QListView::Manual); + mTodoListView->setColumnWidthMode(2, QListView::Manual); + mTodoListView->setColumnWidthMode(3, QListView::Manual); + mTodoListView->setColumnWidthMode(4, QListView::Manual); + mTodoListView->setColumnWidthMode(5, QListView::Manual); + mTodoListView->setColumnAlignment( 2, AlignCenter ); +#if 0 + mTodoListView->setColumnWidthMode(6, QListView::Manual); +#endif + + mPriorityPopupMenu = new QPopupMenu(this); + for (int i = 1; i <= 5; i++) { + QString label = QString ("%1").arg (i); + mPriority[mPriorityPopupMenu->insertItem (label)] = i; + } + connect (mPriorityPopupMenu, SIGNAL(activated (int)), SLOT (setNewPriority(int))); + + mPercentageCompletedPopupMenu = new QPopupMenu(this); + for (int i = 0; i <= 100; i+=20) { + QString label = QString ("%1 %").arg (i); + mPercentage[mPercentageCompletedPopupMenu->insertItem (label)] = i; + } + connect (mPercentageCompletedPopupMenu, SIGNAL (activated (int)), SLOT (setNewPercentage (int))); + + + + mItemPopupMenu = new QPopupMenu(this); + mItemPopupMenu->insertItem(i18n("Show..."), this, + SLOT (showTodo())); + mItemPopupMenu->insertItem(i18n("Edit..."), this, + SLOT (editTodo())); + mItemPopupMenu->insertItem( i18n("Delete"), this, + SLOT (deleteTodo())); + mItemPopupMenu->insertItem( i18n("Clone..."), this, + SLOT (cloneTodo())); + mItemPopupMenu->insertItem( i18n("Move..."), this, + SLOT (moveTodo())); + mItemPopupMenu->insertItem( i18n("Beam..."), this, + SLOT (beamTodo())); + mItemPopupMenu->insertItem( i18n("Toggle Cancel"), this, + SLOT (cancelTodo())); + mItemPopupMenu->insertSeparator(); + + mItemPopupMenu->insertItem( i18n("New Todo..."), this, + SLOT (newTodo())); + mItemPopupMenu->insertItem(i18n("New Sub-Todo..."), this, + SLOT (newSubTodo())); + mItemPopupMenu->insertItem(i18n("Unparent Todo"), this, + SLOT (unparentTodo())); + mItemPopupMenu->insertSeparator(); + mItemPopupMenu->insertItem(i18n("Delete completed To-Dos","Purge Completed"), + this, SLOT( purgeCompleted() ) ); + mItemPopupMenu->insertItem(i18n("toggle completed To-Dos","Show Completed"), + this, SLOT( toggleCompleted() ),0, 33 ); + mItemPopupMenu->insertItem(i18n("toggle quick todo","Show Quick Todo"), + this, SLOT( toggleQuickTodo() ),0, 34 ); + + mPopupMenu = new QPopupMenu(this); + mPopupMenu->insertItem(SmallIconSet("todo"), i18n("New Todo..."), this, + SLOT (newTodo()),0,1); + mPopupMenu->insertItem(i18n("delete completed To-Dos","Purge Completed"), + this, SLOT(purgeCompleted()),0,2); + mPopupMenu->insertItem(i18n("Show Completed"), + this, SLOT( toggleCompleted() ),0,3 ); + mPopupMenu->insertItem(i18n("toggle quick todo","Show Quick Todo"), + this, SLOT( toggleQuickTodo() ),0,4 ); + mDocPrefs = new DocPrefs( name ); + + mPopupMenu->setCheckable( true ); + mItemPopupMenu->setCheckable( true ); + // Double clicking conflicts with opening/closing the subtree + connect( mTodoListView, SIGNAL( doubleClicked( QListViewItem *) ), + SLOT( editItem( QListViewItem *) ) ); + connect( mTodoListView, SIGNAL( rightButtonClicked ( QListViewItem *, + const QPoint &,int ) ), + SLOT( popupMenu( QListViewItem *, const QPoint & ,int) ) ); + connect( mTodoListView, SIGNAL( clicked( QListViewItem * ) ), + SLOT( itemClicked( QListViewItem * ) ) ); + connect( mTodoListView, SIGNAL( double_Clicked( QListViewItem * ) ), + SLOT( itemDoubleClicked( QListViewItem * ) ) ); + connect( mTodoListView, SIGNAL( todoDropped( Todo * ) ), + SLOT( updateView() ) ); + connect( mTodoListView, SIGNAL( expanded( QListViewItem * ) ), + SLOT( itemStateChanged( QListViewItem * ) ) ); + connect( mTodoListView, SIGNAL( collapsed( QListViewItem * ) ), + SLOT( itemStateChanged( QListViewItem * ) ) ); + +#if 0 + connect(mTodoListView,SIGNAL(selectionChanged(QListViewItem *)), + SLOT(selectionChanged(QListViewItem *))); + connect(mTodoListView,SIGNAL(clicked(QListViewItem *)), + SLOT(selectionChanged(QListViewItem *))); + connect(mTodoListView,SIGNAL(pressed(QListViewItem *)), + SLOT(selectionChanged(QListViewItem *))); +#endif + connect( mTodoListView, SIGNAL(selectionChanged() ), + SLOT( processSelectionChange() ) ); + connect( mQuickAdd, SIGNAL( returnPressed () ), + SLOT( addQuickTodo() ) ); +// if ( QApplication::desktop()->width() < 480 ) { +// setNarrow(); + // mTodoListView->setColumnWidth( 0, 100 ); + + // } + +} + +KOTodoView::~KOTodoView() +{ + delete mDocPrefs; +} + +void KOTodoView::jumpToDate () +{ + // if (mActiveItem) { +// mActiveItem->todo()); +// if ( mActiveItem->todo()->hasDueDate() ) +// emit mActiveItem->todo()jumpToTime( mTodo->dtDue().date() ); +} + +void KOTodoView::setNarrow() +{ + //mTodoListView->setColumnWidth( 0, 120 ); + mTodoListView->setColumnWidth( 1, 35 ); + mTodoListView->setColumnWidth( 2, 40 ); + mTodoListView->setColumnWidth( 3, 80 ); + mTodoListView->setColumnWidth( 4, 40 ); + mTodoListView->setColumnWidth( 5, 90 ); + +} +void KOTodoView::updateView() +{ +// kdDebug() << "KOTodoView::updateView()" << endl; + QFont fo = KOPrefs::instance()->mTodoViewFont; + mTodoListView->clear(); + if ( mName == "todolistsmall" ) { + if ( KOPrefs::instance()->mTodoViewUsesSmallFont ) { + int ps = fo.pointSize() -2; + if ( ps > 12 ) + ps -= 2; + fo.setPointSize( ps ); + } + } + + mTodoListView->setFont( fo ); + // QFontMetrics fm ( KOPrefs::instance()->mTodoViewFont ); + //mTodoListView->header()->setMaximumHeight(fm.height()); + QPtrList<Todo> todoList = calendar()->todos(); + +/* + kdDebug() << "KOTodoView::updateView(): Todo List:" << endl; + Event *t; + for(t = todoList.first(); t; t = todoList.next()) { + kdDebug() << " " << t->getSummary() << endl; + + if (t->getRelatedTo()) { + kdDebug() << " (related to " << t->getRelatedTo()->getSummary() << ")" << endl; + } + + QPtrList<Event> l = t->getRelations(); + Event *c; + for(c=l.first();c;c=l.next()) { + kdDebug() << " - relation: " << c->getSummary() << endl; + } + } +*/ + + // Put for each Event a KOTodoViewItem in the list view. Don't rely on a + // specific order of events. That means that we have to generate parent items + // recursively for proper hierarchical display of Todos. + mTodoMap.clear(); + Todo *todo; + todo = todoList.first();// todo; todo = todoList.next()) { + while ( todo ) { + bool next = true; + // qDebug("todo %s ", todo->summary().latin1()); + Incidence *incidence = todo->relatedTo(); + while ( incidence ) { + if ( incidence->type() == "Todo") { + //qDebug("related %s ",incidence->summary().latin1() ); + if ( !(todoList.contains ( ((Todo* )incidence ) ) )) { + //qDebug("related not found "); + todoList.remove( ); + todo = todoList.current(); + next = false; + incidence = 0; + + } else { + //qDebug("related found "); + incidence = incidence->relatedTo(); + } + } else + incidence = 0; + } + if ( next ) + todo = todoList.next(); + } +// qDebug("again .... "); +// for(todo = todoList.first(); todo; todo = todoList.next()) { + +// qDebug("yytodo %s ", todo->summary().latin1()); +// } + //qDebug("for "); + for(todo = todoList.first(); todo; todo = todoList.next()) { + if (!mTodoMap.contains(todo) && ( KOPrefs::instance()->mShowCompletedTodo || !todo->isCompleted() ) ) + { + insertTodoItem(todo); + } + } + //qDebug("for end "); + // Restore opened/closed state + mTodoListView->blockSignals( true ); + if( mDocPrefs ) restoreItemState( mTodoListView->firstChild() ); + mTodoListView->blockSignals( false ); + mTodoListView->setFocus(); + processSelectionChange(); +} + +void KOTodoView::restoreItemState( QListViewItem *item ) +{ + while( item ) { + KOTodoViewItem *todoItem = (KOTodoViewItem *)item; + todoItem->setOpen( mDocPrefs->readBoolEntry( todoItem->todo()->uid() ) ); + if( item->childCount() > 0 ) restoreItemState( item->firstChild() ); + item = item->nextSibling(); + } +} + + +QMap<Todo *,KOTodoViewItem *>::ConstIterator + KOTodoView::insertTodoItem(Todo *todo) +{ +// kdDebug() << "KOTodoView::insertTodoItem(): " << todo->getSummary() << endl; + // TODO: Check, if dynmaic cast is necessary + + + Incidence *incidence = todo->relatedTo(); + if (incidence && incidence->type() == "Todo") { + Todo *relatedTodo = static_cast<Todo *>(incidence); + +// kdDebug() << " has Related" << endl; + QMap<Todo *,KOTodoViewItem *>::ConstIterator itemIterator; + itemIterator = mTodoMap.find(relatedTodo); + if (itemIterator == mTodoMap.end()) { +// kdDebug() << " related not yet in list" << endl; + itemIterator = insertTodoItem (relatedTodo); + } + // isn't this pretty stupid? We give one Todo to the KOTodoViewItem + // and one into the map. Sure finding is more easy but why? -zecke + KOTodoViewItem *todoItem = new KOTodoViewItem(*itemIterator,todo,this); + return mTodoMap.insert(todo,todoItem); + } else { +// kdDebug() << " no Related" << endl; + // see above -zecke + KOTodoViewItem *todoItem = new KOTodoViewItem(mTodoListView,todo,this); + return mTodoMap.insert(todo,todoItem); + } +} + + +void KOTodoView::updateConfig() +{ + updateView(); + mTodoListView->repaintContents(); +} + +QPtrList<Incidence> KOTodoView::selectedIncidences() +{ + QPtrList<Incidence> selected; + + KOTodoViewItem *item = (KOTodoViewItem *)(mTodoListView->selectedItem()); +// if (!item) item = mActiveItem; + if (item) selected.append(item->todo()); + + return selected; +} + +QPtrList<Todo> KOTodoView::selectedTodos() +{ + QPtrList<Todo> selected; + + KOTodoViewItem *item = (KOTodoViewItem *)(mTodoListView->selectedItem()); +// if (!item) item = mActiveItem; + if (item) selected.append(item->todo()); + + return selected; +} + +void KOTodoView::changeEventDisplay(Event *, int) +{ + updateView(); +} + +void KOTodoView::showDates(const QDate &, const QDate &) +{ +} + +void KOTodoView::showEvents(QPtrList<Event>) +{ + kdDebug() << "KOTodoView::selectEvents(): not yet implemented" << endl; +} + +void KOTodoView::printPreview(CalPrinter *calPrinter, const QDate &fd, + const QDate &td) +{ +#ifndef KORG_NOPRINTER + calPrinter->preview(CalPrinter::Todolist, fd, td); +#endif +} + +void KOTodoView::editItem(QListViewItem *item ) +{ + // qDebug("editItem(QListViewItem *item ) "); + emit editTodoSignal(((KOTodoViewItem *)item)->todo()); +} + +void KOTodoView::showItem(QListViewItem *item,const QPoint &,int) +{ + emit showTodoSignal(((KOTodoViewItem *)item)->todo()); +} + +void KOTodoView::popupMenu(QListViewItem *item,const QPoint &,int column) +{ + + mActiveItem = (KOTodoViewItem *)item; + if (item) { + switch (column){ + case 1: + mPriorityPopupMenu->popup(QCursor::pos ()); break; + case 2: + mPercentageCompletedPopupMenu->popup(QCursor::pos ()); break; + case 3: + moveTodo(); + break; + case 6: + getCategoryPopupMenu((KOTodoViewItem *)item)->popup(QCursor::pos ()); break; + default: + mItemPopupMenu->popup(QCursor::pos()); + } + } else mPopupMenu->popup(QCursor::pos()); +} +void KOTodoView::newTodo() +{ + emit newTodoSignal(); +} + +void KOTodoView::newSubTodo() +{ + if (mActiveItem) { + emit newSubTodoSignal(mActiveItem->todo()); + } +} +void KOTodoView::unparentTodo() +{ + if (mActiveItem) { + emit unparentTodoSignal(mActiveItem->todo()); + } +} +void KOTodoView::editTodo() +{ + if (mActiveItem) { + emit editTodoSignal(mActiveItem->todo()); + } +} +void KOTodoView::cloneTodo() +{ + if (mActiveItem) { + emit cloneTodoSignal((Incidence*)mActiveItem->todo()); + } +} +void KOTodoView::cancelTodo() +{ + if (mActiveItem) { + emit cancelTodoSignal((Incidence*)mActiveItem->todo()); + } +} +void KOTodoView::moveTodo() +{ + if (mActiveItem) { + emit moveTodoSignal((Incidence*)mActiveItem->todo()); + } +} +void KOTodoView::beamTodo() +{ + if (mActiveItem) { + emit beamTodoSignal((Incidence*)mActiveItem->todo()); + } +} + + +void KOTodoView::showTodo() +{ + if (mActiveItem) { + emit showTodoSignal(mActiveItem->todo()); + } +} + +void KOTodoView::deleteTodo() +{ + if (mActiveItem) { + if (mActiveItem->childCount()) { + KMessageBox::sorry(this,i18n("Cannot delete To-Do which has children."), + i18n("Delete To-Do")); + } else { + emit deleteTodoSignal(mActiveItem->todo()); + } + } +} + +void KOTodoView::setNewPriority(int index) +{ + if (mActiveItem && !mActiveItem->todo()->isReadOnly ()) { + mActiveItem->todo()->setPriority(mPriority[index]); + mActiveItem->construct(); + todoModified (mActiveItem->todo(), KOGlobals::PRIORITY_MODIFIED); + mActiveItem->todo()->setRevision( mActiveItem->todo()->revision()+1 ); + } +} + +void KOTodoView::setNewPercentage(int index) +{ + if (mActiveItem && !mActiveItem->todo()->isReadOnly ()) { + if (mPercentage[index] == 100) { + mActiveItem->todo()->setCompleted(QDateTime::currentDateTime()); + } else { + mActiveItem->todo()->setCompleted(false); + } + mActiveItem->todo()->setPercentComplete(mPercentage[index]); + mActiveItem->construct(); + todoModified (mActiveItem->todo (), KOGlobals::COMPLETION_MODIFIED); + mActiveItem->todo()->setRevision( mActiveItem->todo()->revision()+1 ); + } +} + + +QPopupMenu * KOTodoView::getCategoryPopupMenu (KOTodoViewItem *todoItem) +{ + QPopupMenu* tempMenu = new QPopupMenu (this); + QStringList checkedCategories = todoItem->todo()->categories (); + + tempMenu->setCheckable (true); + for (QStringList::Iterator it = KOPrefs::instance()->mCustomCategories.begin (); + it != KOPrefs::instance()->mCustomCategories.end (); + ++it) { + int index = tempMenu->insertItem (*it); + mCategory[index] = *it; + if (checkedCategories.find (*it) != checkedCategories.end ()) tempMenu->setItemChecked (index, true); + } + + connect (tempMenu, SIGNAL (activated (int)), SLOT (changedCategories (int))); + return tempMenu; + + +} +void KOTodoView::changedCategories(int index) +{ + if (mActiveItem && !mActiveItem->todo()->isReadOnly ()) { + QStringList categories = mActiveItem->todo()->categories (); + if (categories.find (mCategory[index]) != categories.end ()) + categories.remove (mCategory[index]); + else + categories.insert (categories.end(), mCategory[index]); + categories.sort (); + mActiveItem->todo()->setCategories (categories); + mActiveItem->construct(); + mActiveItem->todo()->setRevision( mActiveItem->todo()->revision()+1 ); + todoModified (mActiveItem->todo (), KOGlobals::CATEGORY_MODIFIED); + } +} +void KOTodoView::itemDoubleClicked(QListViewItem *item) +{ + if (!item) { + newTodo(); + return; + } + if ( KOPrefs::instance()->mEditOnDoubleClick ) + editItem( item ); + else + showItem( item , QPoint(), 0 ); +} +void KOTodoView::itemClicked(QListViewItem *item) +{ + if (!item) { + return; + } + + KOTodoViewItem *todoItem = (KOTodoViewItem *)item; + int completed = todoItem->todo()->isCompleted(); // Completed or not? + + if (todoItem->isOn()) { + if (!completed) { + todoItem->todo()->setCompleted(QDateTime::currentDateTime()); + } + } else { + if (completed) { + todoItem->todo()->setCompleted(false); + } + } +} + +void KOTodoView::setDocumentId( const QString &id ) +{ + kdDebug() << "KOTodoView::setDocumentId()" << endl; + + mDocPrefs->setDoc( id ); +} + +void KOTodoView::itemStateChanged( QListViewItem *item ) +{ + if (!item) return; + + KOTodoViewItem *todoItem = (KOTodoViewItem *)item; + +// kdDebug() << "KOTodoView::itemStateChanged(): " << todoItem->todo()->summary() << endl; + + if( mDocPrefs ) mDocPrefs->writeEntry( todoItem->todo()->uid(), todoItem->isOpen() ); +} + +void KOTodoView::saveLayout(KConfig *config, const QString &group) const +{ + mTodoListView->saveLayout(config,group); +} + +void KOTodoView::restoreLayout(KConfig *config, const QString &group) +{ + mTodoListView->restoreLayout(config,group); +} + +void KOTodoView::processSelectionChange() +{ +// kdDebug() << "KOTodoView::processSelectionChange()" << endl; + + KOTodoViewItem *item = + static_cast<KOTodoViewItem *>( mTodoListView->selectedItem() ); + + if ( !item ) { + emit incidenceSelected( 0 ); + } else { + emit incidenceSelected( item->todo() ); + } +} + +void KOTodoView::modified(bool b) +{ + emit isModified(b); +} +void KOTodoView::setTodoModified( Todo* todo ) +{ + todoModified( todo, KOGlobals::UNKNOWN_MODIFIED ); +} +void KOTodoView::clearSelection() +{ + mTodoListView->selectAll( false ); +} + +void KOTodoView::purgeCompleted() +{ + emit purgeCompletedSignal(); +} +void KOTodoView::toggleQuickTodo() +{ + if ( mQuickAdd->isVisible() ) { + mQuickAdd->hide(); + KOPrefs::instance()->mEnableQuickTodo = false; + } + else { + mQuickAdd->show(); + KOPrefs::instance()->mEnableQuickTodo = true; + } + mPopupMenu->setItemChecked(4,KOPrefs::instance()->mEnableQuickTodo); + mItemPopupMenu->setItemChecked( 34 , KOPrefs::instance()->mEnableQuickTodo ); +} +void KOTodoView::toggleCompleted() +{ + KOPrefs::instance()->mShowCompletedTodo = !KOPrefs::instance()->mShowCompletedTodo; + mPopupMenu->setItemChecked( 3,KOPrefs::instance()->mShowCompletedTodo ); + mItemPopupMenu->setItemChecked( 33 , KOPrefs::instance()->mShowCompletedTodo ); + updateView(); +} + +void KOTodoView::addQuickTodo() +{ + Todo *todo = new Todo(); + todo->setSummary(mQuickAdd->text()); + todo->setOrganizer(KOPrefs::instance()->email()); + CalFilter * cf = mCalendar->filter(); + if ( cf ) { + if ( cf->isEnabled()&& cf->showCategories()) { + todo->setCategories(cf->categoryList()); + } + if ( cf->isEnabled() ) + todo->setSecrecy( cf->getSecrecy()); + } + mCalendar->addTodo(todo); + mQuickAdd->setText(""); + todoModified (todo, KOGlobals::EVENTADDED ); + updateView(); +} +void KOTodoView::keyPressEvent ( QKeyEvent * e ) +{ + // e->ignore(); + //return; + switch ( e->key() ) { + case Qt::Key_Down: + QWidget::keyPressEvent ( e ); + break; + + case Qt::Key_Up: + QWidget::keyPressEvent ( e ); + break; + case Qt::Key_Q: + toggleQuickTodo(); + break; + + default: + e->ignore(); + } + + if ( e->state() == Qt::ControlButton || e->state() == Qt::ShiftButton || ( height() > 150 && width() > 200 ) ) { + if ( e->key() == Qt::Key_I ) { + KOTodoViewItem*cn = (KOTodoViewItem*)mTodoListView->currentItem(); + if ( cn ) { + mActiveItem = cn; + KOTodoViewItem* ci = (KOTodoViewItem*)( cn ); + if ( ci ){ + showTodo(); + cn = (KOTodoViewItem*)cn->itemBelow(); + if ( cn ) { + mTodoListView->setCurrentItem ( cn ); + mTodoListView->ensureItemVisible ( cn ); + } + + } + } + e->accept(); + + } + + } + +} +void KOTodoView::updateTodo( Todo * t, int type ) +{ + if ( mBlockUpdate) + return; + + QMap<Todo *,KOTodoViewItem *>::ConstIterator itemIterator; + itemIterator = mTodoMap.find(t); + if (itemIterator != mTodoMap.end()) { + (*itemIterator)->construct(); + } else { + if ( type == KOGlobals::EVENTADDED ) { + insertTodoItem( t ); + } + } + +} + +void KOTodoView::todoModified(Todo * t , int p ) +{ + mBlockUpdate = true; + emit todoModifiedSignal ( t, p ); + mBlockUpdate = false; +} |