2 files changed, 346 insertions, 38 deletions

diff --git a/libopie/big-screen/omodalhelper.cpp b/libopie/big-screen/omodalhelper.cpp
index e3d1c70..c5a47b3 100644
--- a/libopie/big-screen/omodalhelper.cpp
+++ b/libopie/big-screen/omodalhelper.cpp
@@ -71,17 +71,17 @@ QDialog* OModalHelperControler::dialog()const {
 /*
  * 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<QDialog*>( sender() );
 
-    m_base->done( m_id );
+    m_base->done( result, m_id );
 }
 
 void OModalHelperControler::next() {
     m_base->next( m_id );
 }
 
 void OModalHelperControler::prev() {
     m_base->prev( m_id );
@@ -150,11 +150,16 @@ void OModalQueuedDialog::setQueueBarEnabled( bool b) {
 
 void OModalQueuedDialog::setRecord( int record, int count ) {
     if (!record && !count ) {
         hide();
         return;
     }else
         show();
 
+    if ( count > 1 )
+        m_bar->show();
+    else
+        m_bar->hide();
+
     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 bc20d10..78a2ac9 100644
--- a/libopie/big-screen/omodalhelper.h
+++ b/libopie/big-screen/omodalhelper.h
@@ -28,25 +28,26 @@
 
 #ifndef HAZE_OMODAL_HELPER_H
 #define HAZE_OMODAL_HELPER_H
 
 #include <qdialog.h>
 #include <qwidget.h>
 #include <qvaluelist.h>
 #include <qmap.h>
+#include <qvariant.h>
 
 typedef int TransactionID;
 
 class OModalHelperControler;
 class OModalHelperSignal;
 class QDialog;
 
 struct OModalHelperBase  {
-    virtual void done( TransactionID ) = 0;
+    virtual void done( int status, TransactionID ) = 0;
     virtual void next( TransactionID ) = 0;
     virtual void prev( TransactionID ) = 0;
 };
 
 /**
  * Modality sucks! ;) But it is easy to work with
  * do exec() on a dialog and you know everything is funky.
  * You only need to have one Dialog loaded and so on.
@@ -79,48 +80,53 @@ public:
     typedef QMap<TransactionID, Id> TransactionMap;
     typedef QMap<QDialog*, TransactionID> DialogMap
     enum Mode { Queue, New };
     OModalHelper(enum Mode mode, QObject* parnet );
 
     bool handles( Id id)const;
     TransactionID transactionID( Id id)const;
 
+    void suspend( bool = true );
+
     void cancel();
     void cancel( TransactionID );
 
     void connectDone( QObject* rec, const char* slot );
     void connectAccepted( QObject* rec, const char* slot );
     void connectRejected( QObject* rec, const char* slot );
 
     TransactionID handle( Id id, const Record& rec = Record() );
 
-    void edited( TransactionID, int what, const QString& data );
+    void edited( Id, int what, const QVariant& data );
 
     Record record( TransactionID )const;
-    RecordList done()const;
+    RecordList recordsDone()const;
 private:
-    virtual void done( TransactionID );
+    virtual void done( int, TransactionID );
     virtual void next( TransactionID );
     virtual void prev( TransactionID );
 
-    Record nextRecord( TransactionID, int * )const;
-    Record prevRecord( TransactionID, int * )const;
+    Record nextRecord( TransactionID &, int & )const;
+    Record prevRecord( TransactionID &, int & )const;
+    int pos( TransactionID )const;
+    Dialog* newDialogRecord( const Record& );
 
 private:
     OModalHelperDialog     *queuedDialog()const; // generate or recycle
     OModalHelperDialog     *m_dialog;
     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
     enum Mode              m_mode; // the mode we're in
+    bool                   m_disabled :1;
 };
 
 
 
 /* ### FIXME use namespace with Qt3 */
 
 /*
  * A note on flow. The Signal is used for QT Signals when
@@ -200,20 +206,20 @@ private:
  * This helper will be deleted when the parent gets deleted
  * or you delete it yourself.
  *
  * @param mode The mode this dialog should be in
  * @param parent The parent QObject of this helper.
  */
 template<class Dialog, class Record, typename Id>
 OModalHelper<Dialog, Record, Id>::OModalHelper( enum Mode mode, QObject* parent ) {
+    m_disabled = false;
     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 records
  * will not be returned.
  *
@@ -235,25 +241,44 @@ bool OModalHelper<Dialog, Record, Id>::handles( Id id )const {
 }
 
 
 /**
  * just like handles( Id ) but returns the TransactionId
  */
 template<class Dialog, class Record, typename Id>
 TransactionID OModalHelper<Dialog, Record, Id>::transactionID( Id id)const {
-    if ( m_transactions.isEmpty() )
-        return false;
+    if ( m_transactions.isEmpty() || !m_ids.contains( id ) )
+        return 0;
 
     TransactionMap::ConstIterator it = m_transactions.begin();
     for ( ; it != m_transactions.end(); ++it )
         if ( it.data() == id )
-            return true;
+            return it.key();
 
-    return false;
+    return 0;
+}
+
+/**
+ * If you're requested to flush your data and you do not want
+ * to call cancel with this method you can disable and enabled
+ * all dialogs.
+ * The state gets saved so if you want to handle a new record the dialog
+ * will be disabled as well.
+ *
+ * @param sus If true setDisabled(TRUE) will be called otherwise FALSE
+ */
+template<class Dialog, class Record, typename Id>
+void OModalHelper<Dialog, Record, Id>::suspend(bool sus) {
+    m_disabled = sus;
+    if (m_mode == New )
+        for (DialogMap::Iterator it = m_editing.begin(); it != m_editing.end(); ++it )
+            it.key()->setDisabled( sus );
+    else if (m_dialog )
+        queuedDialog()->setDisabled( sus );
 }
 
 /**
  * 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<class Dialog, class Record, typename Id>
@@ -263,21 +288,22 @@ void OModalHelper<Dialog, Record, Id>::cancel() {
     m_done.clear();
     m_transactions.clear();
 
     /* we also need to remove the QDialogs */
     /* and hide the queue dialog if present */
     if (m_mode == New && !m_editing.isEmpty() ) {
         for (DialogMap::Iterator it = m_editing.begin(); it != m_editing.end(); ++it )
             delete it.key();
+
         m_editing.clear();
     }else if (m_dialog )
         queuedDialog()->setRecord( 0, 0 );
 
-    m_controler->setTransactionID( -1 );
+    m_controler->setTransactionID( 0 );
 }
 
 
 /**
  * This cancels editing of the record behind the Transaction Number
  * Note that if editing is already done it will also be removed from this list
  */
 template<class Dialog, class Record, typename Id>
@@ -290,44 +316,26 @@ void OModalHelper::cancel( TransactionID tid ) {
         /* reverse map eek */
         for (DialogMap::Iterator it = m_editing.begin(); it != m_editing.end(); ++it )
             if ( it.data() == tid ) {
                 it.key()->hide();
                 delete it.key();
                 it = m_editing.remove( it );
                 break;
             }
-     else if ( m_transactions.contains( tid ) ) {
-        /* need to stop editing from the queue block */
-        /* if we're currently editing actiavte the previous */
-#if 0
-        if (tid == m_controler->transactionID() ) {
 
-        }
-#endif
-        /* now either activate the previous again or hide  */
-        if (!  m_transactions.count() -1 )
-            queuedDialog()->setRecord( 0, 0 );
-        else {
-            int pos;
-            Record rec = prevRecord( tid, &pos );
-            static_cast<Dialog*>( queuedDialog()->centerDialog() )->setRecord( rec );
-            queuedDialog()->setRecord( pos, m_transactions.count() );
-            m_controler->setTransactionID( 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 );
+
+    next( 0 );
 }
 
 /**
  * Connect to the done Signal. SIGNAL( done(int, TransactionID ) )
  * This signal gets emitted whenever a Record was accepted or rejected
  *
  * @param rec  The object where the slot belongs to
  * @param slot The slot which should be called. See the needed parameter above
@@ -378,28 +386,323 @@ void OModalHelper<Dialog, Record, Id>::connectRejected( QObject* rec, const char
  * @param rec The record we want to be edited
  *
  * @returns This functions returns the TransactionId assigned to the record
  *
  */
 template<class Dialog, class Record, typename Id>
 TransactionID OModalHelper<Dialog, Record, Id>::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 ) ) {
+    if ( !(tid = transactionID( id ) ) ) {
+        if (m_mode == New ) {
+            /* lets find the dialog and show it need to reverse map*/
+            for (DialogMap::Iterator it = m_editing.begin(); it != m_editing.end(); ++it )
+                if ( it.data() == tid )
+                    it.key()->show();
+        }else if (m_controler->transactionID() != tid ) {
+            int po = pos( tid );
+            m_controler->setTransactionID( tid );
+            static_cast<Dialog*>( queuedDialog()->centerDialog() )->setRecord( m_ids[ m_transactions[tid] ] );
+            queuedDialog()->setRecord( po, m_transactions.count() );
+        }
+    }else {
+        tid = ++t_id;
+        m_transactions.insert( tid, id );
+        m_ids.insert( id, rec );
+
+        if (m_mode == New )
+            m_editing.insert( newDialogRecord( rec ), tid );
+        else{
+            m_controler->setTransactionID( tid );
+            static_cast<Dialog*>( queuedDialog()->centerDialog() )->setRecord( rec );
+            queuedDialog()->setRecord( m_transactions.count(), m_transactions.count() );
+        }
+    }
+    return tid;
+}
 
+/**
+ * The goal of this helper is to help you to create non blocking
+ * GUIs. In the example of the todolist you can have the edit dialog
+ * but still change the priority or completion inline even if you currently
+ * edit the record.
+ * Your Dialog needs to have a Method setData(int,const QVariant& ) which will be called
+ * in these cases.
+ * If you edit anything while a record is edited call this function to merge the
+ * change in. Note if the record is not handled here we will ignore the request
+ *
+ */
+template<class Dialog, class Record, typename Id>
+void OModalHelper<Dialog, Record, Id>::edited( Id id, int what, const QVariant& data ) {
+    int tid;
+    if (!( tid = transactionID( id ) ) )
+        return;
+
+    if (m_mode == New ) {
+        for (DialogMap::Iterator it= m_editing.begin(); it != m_editing.end(); ++it )
+            if ( it.data() == tid )
+                it.key()->setData( what, data );
+    }else{
+        int po = pos( tid );
+        Dialog* dia = static_cast<Dialog*>( queuedDialog()->centerDialog() );
+        dia->setRecord( m_ids[id] );
+        dia->setData( what, data );
+        queuedDialog()->setRecord( pos, m_transactions.count() );
+    }
+}
+
+/**
+ * This functions either returns the unedited record the done record
+ * or a new empty Record using Record().
+ * If a done record is retrieved all traces are removed inside this class. This
+ * is what was called popping a  record. This means when you call this function
+ * with the same TransactionID an Empty record is retrieved.
+ *
+ */
+template<class Dialog, class Record, typename Id>
+Record OModalHelper<Dialog, Record, Id>::record( TransactionID tid)const {
+    if (m_transactions.contains( tid ) )
+        return m_ids[ m_transactions[tid] ];
+    else if (m_done.contains( tid ) ) {
+        Record rec = m_doneIds[ m_done[ tid] ];
+        m_doneIds.remove( m_done[ tid ] );
+        m_done.remove( tid );
+        return rec;
+    }else
+        return Record();
+}
+
+/**
+ * Returns all done Records and removes all references to them internally. A 2nd call to this will
+ * only contain done record that where edited past the point
+ */
+template<class Dialog, class Record, typename Id>
+OModalHelper<Dialog,Record,Id>::RecordList OModalHelper<Dialog, Record, Id>::recordsDone()const {
+    RecordList list;
+
+    for (IdMap::ConstIterator it = m_doneIds.begin(); it != m_doneIds.end(); ++it )
+        list.append( it.data() );
+
+    /* clean up */
+    m_done.clear();
+    m_doneIds.clear();
+
+    return list;
+}
+
+
+/**
+ * @internal
+ */
+template<class Dialog, class Record, typename Id>
+void OModalHelper<Dialog, Record, Id>::done( int status, TransactionID tid) {
+/* If we're in New mode the transaction Id does not count */
+    Record rec;
+
+    if (m_mode == New ) {
+        Dialog *dia = static_cast<Dialog*>( m_controler->dialog() );
+        m_controler->setTransactionID( 0 ); // set the internal dialog to 0l again
+        tid = m_editing[ dia ];
+        m_editing.remove( dia );
+        rec = dia->record();
+        delete dia;
+    }else
+        rec = queuedDialog()->record();
+
+    Id id = m_transactions[ tid ];
+    if (result == QDialog::Accept ) {
+        m_doneIds.insert( is, rec  );
+        m_done.insert( tid, id );
     }
 
-    /* fall through if the record is in the done list */
-    tid = t_id;
+    m_transactions.remove( tid );
+    m_ids.remove( id );
+
 
+    if (status == QDialog::Accept )
+        emit m_signal->accepted( tid );
+    else
+        emit m_signal->rejected( tid );
 
-    return;
+    emit m_signal->done( result, tid );
+
+    next( 0 );
+}
+
+/**
+ * @internal
+ */
+template<class Dialog, class Record, typename Id>
+void OModalHelper<Dialog, Record, Id>::next( TransactionID tid) {
+    if (m_mode == New )
+        return;
+
+    if (! (m_transactions.count() ) ) {
+        m_controler->setTransactionID( 0 );
+        queuedDialog()->setRecord( 0, 0 );
+        return;
+    }
+
+    int next;
+    Record rec;
+
+    /* save the maybe edited record before switching */
+    Dialog *dia = static_cast<Dialog*>( queuedDialog()->centerDialog() );
+    rec = dia->record();
+    m_ids.replace( m_transactions[tid], rec );
+
+    rec = nextRecord( tid, next );
+    queuedDialog()->setRecord( next, m_transactions.count() );
+    dia->setRecord( rec );
+
+    m_controler->setTransactionID( tid ); // was changed during the next call
+}
+
+/**
+ * @internal
+ */
+/*
+ * code duplication should create a template fcuntion
+ * which takes a pointer to a function ( next, prev ) function
+ */
+template<class Dialog, class Record, typename Id>
+void OModalHelper<Dialog, Record, Id>::prev( TransactionID tid ) {
+    if (m_mode == New )
+        return;
+
+    if (! (m_transactions.count()) ) {
+        m_controler->setTransactionID( 0 );
+        queuedDialog()->setRecord( 0, 0 );
+        return;
+    }
+
+    int prev;
+    Record rec;
+
+    /* save the maybe edited record before switching */
+    Dialog *dia = static_cast<Dialog*>( queuedDialog()->centerDialog() );
+    rec = dia->record();
+    m_ids.replace( m_transactions[tid], rec );
+
+    rec = prevRecord( tid, prev );
+    queuedDialog()->setRecord( prev, m_transactions.count() );
+    dia->setRecord( rec );
+
+    m_controler->setTransactionID( tid ); // was changed during the next call
+}
+
+/**
+ * @internal
+ */
+template<class Dialog, class Record, typename Id>
+Record  OModalHelper<Dialog, Record, Id>::nextRecord( TransactionID &tid, int &po ) {
+    /* if tid is == 0 we will take the first one */
+    /* pos starts at 1 here */
+    /* we know we're only called if there are records */
+    Record rec;
+    TransactionMap::Iterator it;
+    if (!tid ) {
+        po = 1;
+        TransactionMap::Iterator it = m_transactions.begin();
+    }else{
+        po = pos( tid );
+        /* if it is the last take the first as next */
+        if ( po == m_transactions.count() ) {
+            po = 1;
+            it = m_transactions.begin();
+        }else {
+            /* we know we're not the last and there is one after us */
+            it = m_transactions.find( tid );
+            ++it; ++po;
+        }
+    }
+
+    tid = it.key();
+    rec = m_ids[ tid ];
+    return rec;
+}
+
+/**
+ * @internal
+ */
+template<class Dialog, class Record, typename Id>
+Record OModalHelper<Dialog, Record, Id>::prevRecord( TransactionID& tid, int& pos ) {
+    /* if tid is == 0 we will take the first one */
+    /* pos starts at 1 here */
+    /* we know we're only called if there are records */
+    Record rec;
+    TransactionMap::Iterator it;
+    if (!tid ) {
+        po = 1;
+        TransactionMap::Iterator it = m_transactions.begin();
+    }else{
+        po = pos( tid );
+        /* if it is the last take the first as next */
+        if ( po == 1 ) {
+            po = m_transactions.count();
+            it = m_transactions.end();
+            --it;
+        }else {
+            /* we know we're not the first and there is one before us */
+            it = m_transactions.find( tid );
+            --it; --po;
+        }
+    }
+
+    tid = it.key();
+    rec = m_ids[ tid ];
+    return rec;
+}
+
+/**
+ * @internal
+ */
+template<class Dialog, class Record, typename Id>
+int OModalHelper<Dialog, Record, Id>::pos( TransactionID id)const {
+    int i = 1;
+    for ( TransactionMap::ConstIterator it = m_transactions.begin(); it != m_transactions.end(); ++it, i++ )
+        if ( it.key() == id )
+            return i;
+
+
+    return 0;
+}
+
+/**
+ * @internal
+ */
+template<class Dialog, class Record, typename Id>
+Dialog* OModalHelper<Dialog, Record, Id>::newDialogRecord( const Record& rec ) {
+    Dialog* dia = new Dialog;
+    dia->setRecord( rec );
+    dia->setDisabled( m_disabled );
+
+    QObject::connect(dia, SIGNAL(done(int) ),
+                     m_controler, SLOT(done(int) ) );
+
+    /* FIXME big screen QPEApplication needs fixed*/
+    dia->show();
+}
+
+template<class Record, class Dialog, typename Id>
+OModalHelperDialog* OModalHelper<Record, Dialog, Id>::queuedDialog()const{
+    if (!m_dialog ) {
+        m_dialog = new OModalHelperDialog;
+        m_dialog->setEnabled( m_disabled );
+
+        QObject::connect(m_dialog, SIGNAL(done(int) ),
+                         m_controler, SLOT(done(int) ) );
+        QObject::connect(m_dialog, SIGNAL(next() ),
+                         m_controler, SLOT(next() ) );
+        QObject::connect(m_dialog, SIGNAL(prev() ),
+                         m_controler, SLOT(prev() ) );
+    }
+    return m_dialog;
 }
 
 #endif