From 14db240e82c6208277946c6a76fe1d41615d6804 Mon Sep 17 00:00:00 2001 From: zecke Date: Fri, 12 Sep 2003 19:58:28 +0000 Subject: Add the implementation for non template objects And only 10 and 1/2 methods to implement --- (limited to 'libopie/big-screen') diff --git a/libopie/big-screen/omodalhelper.cpp b/libopie/big-screen/omodalhelper.cpp new file mode 100644 index 0000000..e3d1c70 --- a/dev/null +++ b/libopie/big-screen/omodalhelper.cpp @@ -0,0 +1,160 @@ +/* +               =. This file is part of the OPIE Project +             .=l. Copyright (c) 2003 hOlgAr +           .>+-= + _;:,     .>    :=|. This library is free software; you can +.> <`_,   >  .   <= redistribute it and/or modify it under +:`=1 )Y*s>-.--   : the terms of the GNU Library General Public +.="- .-=="i,     .._ License as published by the Free Software + - .   .-<_>     .<> Foundation; either version 2 of the License, +     ._= =}       : or (at your option) any later version. +    .%`+i>       _;_. +    .i_,=:_.      -`: PARTICULAR PURPOSE. See the GNU +..}^=.=       =       ; Library General Public License for more +++=   -.     .`     .: details. + :     =  ...= . :.=- + -.   .:....=;==+<; You should have received a copy of the GNU +  -_. . .   )=.  = Library General Public License along with +    --        :-=` this library; see the file COPYING.LIB. + If not, write to the Free Software Foundation, + Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. + +*/ + +#include +#include +#include +#include + +#include "omodalhelper.h" + + +/* SIgnal handling */ +OModalHelperSignal::OModalHelperSignal( OModalHelperBase* base, QObject* parent ) + : QObject( parent, "OModal Helper Signal" ), m_base( base ) { +} + +OModalHelperSignal::~OModalHelperSignal() { + /* special the ancestor deletes its creator */ + delete m_base; +} + + +/* Helper Controler */ +/* + * the dialogs signal will be slotted here + * and we will call into m_base + */ +OModalHelperControler::OModalHelperControler( OModalHelperBase* base, QObject* parent ) + : QObject(parent, "OModal Helper Controler" ), m_base( base ), m_dia( 0 ), m_id( -1 ) +{ +} + +TransactionID OModalHelperControler::transactionID()const { + return m_id; +} + +void OModalHelperControler::setTransactionID( TransactionID id ) { + m_dia = 0; + m_id = id; +} + +QDialog* OModalHelperControler::dialog()const { + return m_dia; +} + +/* + * If we're in the New mode we will map the QDialog + * to the TransactionID + */ +void OModalHelperControler::done( int result ) { + if ( sender() && !sender()->isA("OModalQueuedDialog") ) + m_dia = static_cast( sender() ); + + m_base->done( m_id ); +} + +void OModalHelperControler::next() { + m_base->next( m_id ); +} + +void OModalHelperControler::prev() { + m_base->prev( m_id ); +} + +/* The Queued Dialog inclusive QueuedBar */ +struct OModalQueueBar : public QHBox { + QPushButton* next; + QPushButton* prev; + QLabel * label; + + OModalQueueBar( QWidget* parent ); + void setText( const QString& str ); +}; + +OModalQueueBar::OModalQueueBar( QWidget* parent ) + : QWidget( parent, "OModal Queue Bar" ) { + prev = new QPushButton( this ); + prev->setText( OModalQueuedDialog::tr("Prev") ); + + label = new QLabel(this); + + next = new QPushButton( this ); + next->setText( OModalQueuedDialog::tr("Next") ); +} + +void OModalQueueBar::setText( const QString& str ) { + label->setText( str ); +} + + +OModalQueuedDialog::OModalQueuedDialog( QDialog* mainWidget ) + : QDialog(0, "OModal Queued Dialog" ) +{ + QVBoxLayout *lay = new QVBoxLayout( this ); + + m_bar = new OModalQueueBar( this ); + lay->addWidget( m_bar ); + + m_center = mainWidget; + m_center->reparent(this, 0, QPoint(0, 0) ); + lay->addWidget( m_center ); + + + connect(m_bar->next, SIGNAL(clicked() ), this, + SIGNAL(next() ) ); + connect(m_bar->prev, SIGNAL(clicked() ), this, + SIGNAL(prev() ) ); + +} + +OModalQueuedDialog::~OModalQueuedDialog() { +} + +QDialog* OModalQueuedDialog::centerDialog()const { + return m_center; +} + +void OModalQueuedDialog::setQueueBarEnabled( bool b) { + /* in Qt3 use setEnabled( bool ) */ + if (b) + m_bar->show(); + else + m_bar->hide(); +} + +void OModalQueuedDialog::setRecord( int record, int count ) { + if (!record && !count ) { + hide(); + return; + }else + show(); + + m_bar->setText( tr("Editing record %1 out of %2", + "Shows the current edited record out of an array of records").arg( record ). arg( count ) ); +} diff --git a/libopie/big-screen/omodalhelper.h b/libopie/big-screen/omodalhelper.h index c483403..bc20d10 100644 --- a/libopie/big-screen/omodalhelper.h +++ b/libopie/big-screen/omodalhelper.h @@ -54,7 +54,10 @@ struct OModalHelperBase { * you to keep things in sync * It's a template class but it sends signals once one Item is ready * the signals contains the status and id of the item and then you - * can fetch it. + * need fetch it. + * Handled Records will stay available until the first call to retrieve + * either the record via the TransactionID or via the QValueList. Note + * that most functions do not take handled records into account. * Also if you edit an record external you can tell this class and it'll * call the merge() function of your widget to maybe merge in these changes. * It also supports multiple modes. Either it can create new dialogs @@ -79,6 +82,7 @@ public: OModalHelper(enum Mode mode, QObject* parnet ); bool handles( Id id)const; + TransactionID transactionID( Id id)const; void cancel(); void cancel( TransactionID ); @@ -94,9 +98,9 @@ public: Record record( TransactionID )const; RecordList done()const; private: - virtual void done( TransactionID, QDialog* ); - virtual void next( TransactionID, OModalHelperControler * ); - virtual void prev( TransactionID, OModalHelperControler * ); + virtual void done( TransactionID ); + virtual void next( TransactionID ); + virtual void prev( TransactionID ); Record nextRecord( TransactionID, int * )const; Record prevRecord( TransactionID, int * )const; @@ -107,6 +111,7 @@ private: OModalHelperSignal *m_signal; // our signal OModalHelperControler *m_controler; IdMap m_ids; // maps ids (uids) to a record + IdMap m_doneIds; TransactionMap m_transactions; // activate transactions TransactionMap m_done; // done and waiting for getting picked DialogMap m_editing; // only used for New Mode @@ -133,6 +138,7 @@ class OModalHelperSignal : public QObject { Q_OBJECT public: OModalHelperSignal(OModalHelperBase* base, QObject* parent); + ~OModalHelperSignal(); signals: done( int status, TransactionID transaction ); @@ -153,26 +159,34 @@ public: QDialog* dialog()const; public slots: - virtual done(int result ); + virtual void done(int result ); + virtual void next(); + virtual void prev(); private: QDialog *m_dia; TransactionID m_id; OModalHelperBase *m_base; } -class OModalQueueBar; +struct OModalQueueBar; class OModalQueuedDialog : public QDialog { Q_OBJECT public: - OModalQueuedDialog(QWidget *mainWidget); + OModalQueuedDialog(QDialog *mainWidget); ~OModalQueuedDialog(); QDialog* centerDialog()const; void setQueueBarEnabled( bool = true ); void setRecord( int record, int count ); + +signals: + void next(); + void prev(); + private: OModalQueueBar *m_bar; + QDialog *m_center; }; @@ -194,14 +208,14 @@ OModalHelper::OModalHelper( enum Mode mode, QObject* parent m_mode = mode; m_signal = new OModalHelperSignal( this, parent ); m_controler = new OModalHelperControler( this, m_signal ); + } /** * This functions looks for your record and sees if it is - * handled with this helper. Note that done and edited records - * will not be returned. But if you edit an already edited record - * the done record will be used + * handled with this helper. Note that done records + * will not be returned. * * @return true if the record is currenlty edited otherwise false * @@ -220,13 +234,32 @@ bool OModalHelper::handles( Id id )const { return false; } + +/** + * just like handles( Id ) but returns the TransactionId + */ +template +TransactionID OModalHelper::transactionID( Id id)const { + if ( m_transactions.isEmpty() ) + return false; + + TransactionMap::ConstIterator it = m_transactions.begin(); + for ( ; it != m_transactions.end(); ++it ) + if ( it.data() == id ) + return true; + + return false; +} + /** * Cancel will cancel all current operations and clear the list * of done operations as well. + * This also clears all done operations you did not popped */ template void OModalHelper::cancel() { m_ids.clear(); + m_doneIds.clear(); m_done.clear(); m_transactions.clear(); @@ -239,7 +272,7 @@ void OModalHelper::cancel() { }else if (m_dialog ) queuedDialog()->setRecord( 0, 0 ); - + m_controler->setTransactionID( -1 ); } @@ -278,10 +311,15 @@ void OModalHelper::cancel( TransactionID tid ) { Record rec = prevRecord( tid, &pos ); static_cast( queuedDialog()->centerDialog() )->setRecord( rec ); queuedDialog()->setRecord( pos, m_transactions.count() ); + m_controler->setTransactionID( tid ); } } - /* now remove from the various maps */ - m_ids.remove( m_transactions.contains( tid ) ? m_transactions[tid] : m_done[tid ] ); + /* now remove from the various maps done and currently editing map*/ + if (m_transactions.contains( tid ) ) + m_ids.remove( m_transactions[tid] ); + if (m_done.contains( tid ) ) + m_doneIds.remove( m_done[tid ] ); + m_done.remove( tid ); m_transactions.remove( tid ); @@ -301,20 +339,67 @@ void OModalHelper::connectDone( QObject* rec, const char* sl } /** - * Connect to the accepted Signal. SIGNAL( done(int, TransactionID ) ) - * This signal gets emitted whenever a Record was accepted or rejected + * Connect to the accepted Signal. SIGNAL( accepted(TransactionID ) ) + * This signal gets emitted whenever a Record was accepted * * @param rec The object where the slot belongs to * @param slot The slot which should be called. See the needed parameter above */ template -void OModalHelper::( QObject* rec, const char* slot ) { - +void OModalHelper::connectAccepted( QObject* rec, const char* slot ) { + QObject::connect(m_signal, SIGNAL(accepted(TransactionID) ), + rec, slot ); } +/** + * Same as the accepted method but this one gets emitted if the dialog + * got rejected. + * SIGNAL( rejected(TransactionID) ) + * + * @param rec The QObject of the slot + * @param slot The slot make sure the signature is correct + */ +template +void OModalHelper::connectRejected( QObject* rec, const char* slot ) { + QObject::connect(m_signal, SIGNAL(rejected(TransactionID) ), + rec, slot ); +} +/** + * Tell the helper to handle a record. If the record is currently handled + * it will be made active. + * Already handled record which are waiting getting popped are not taken into account + * Otherwise this helpers make the record editable. + * The record supplied needs to have a valid copy operator and constructor. + * In the case where the record is already present the parameter gets discarded. + * If you want the new record to be taken you need to cancel the Transaction first + * + * @param id The Identification of the Record. For PIM it would uid() + * @param rec The record we want to be edited + * + * @returns This functions returns the TransactionId assigned to the record + * + */ template -void OModalHelper::( QObject* rec, const char* slot ) { +TransactionID OModalHelper::handle( Id id, const Record& rec ) { + static TransactionID t_id = 0; + t_id++; + /* + *this method consists out of two parts divided each into New and Queued Mode. + * Either we have the dialog already, in this case we need to highlight the widget + * Or we need to add it. + */ + TransactionID tid = 0; + /* we already have the record lets see if it was done or not */ + if ( m_ids.contains( id ) ) { + } + + /* fall through if the record is in the done list */ + tid = t_id; + + + return; } + #endif -- cgit v0.9.0.2