More implementation and thoughts

1 files changed, 190 insertions, 9 deletions

diff --git a/libopie/big-screen/omodalhelper.h b/libopie/big-screen/omodalhelper.h
index 32d921d..c483403 100644
--- a/libopie/big-screen/omodalhelper.h
+++ b/libopie/big-screen/omodalhelper.h
@@ -8,132 +8,313 @@
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This library 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
 ..}^=.=       =       ;      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.
 
 */
 
 #ifndef HAZE_OMODAL_HELPER_H
 #define HAZE_OMODAL_HELPER_H
 
+#include <qdialog.h>
 #include <qwidget.h>
 #include <qvaluelist.h>
 #include <qmap.h>
 
 typedef int TransactionID;
 
 class OModalHelperControler;
 class OModalHelperSignal;
 class QDialog;
 
 struct OModalHelperBase  {
-    virtual void done( TransactionID id, QWidget* ) = 0;
-    virtual void next( TransactionID, OModalHelperControler * );
-    virtual void prev( TransactionID, OModalHelperControler * );
+    virtual void done( 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.
  * This class helps you to work like with modality and help
  * 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.
  * 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
  * for each item or it can queue them depending on your usage. But it is
  * so smart that if only one item is shown that the queue bar is not shown
  * See the example for simple usage.
  *
  * @short helps to life without modaility
  * @author hOlgAr
  * @version 0.01
  */
-template<class Dialog, class Record, typename Id = QString>
+template<class Dialog, class Record, typename Id = int>
 class OModalHelper : private OModalHelperBase{
     friend class OModalHelperSignal;
     friend class OModalHelperControler;
 public:
     typedef QValueList<Record> RecordList;
     typedef QMap<Id, Record> IdMap;
     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;
 
     void cancel();
     void cancel( TransactionID );
 
-    void connect( QObject* rec, const char* slot );
+    void connectDone( QObject* rec, const char* slot );
+    void connectAccepted( QObject* rec, const char* slot );
+    void connectRejected( QObject* rec, const char* slot );
 
-    TransactionID handle( const Record& rec = Record() );
+    TransactionID handle( Id id, const Record& rec = Record() );
 
     void edited( TransactionID, int what, const QString& data );
 
     Record record( TransactionID )const;
     RecordList done()const;
 private:
+    virtual void done( TransactionID, QDialog* );
+    virtual void next( TransactionID, OModalHelperControler * );
+    virtual void prev( TransactionID, OModalHelperControler * );
+
+    Record nextRecord( TransactionID, int * )const;
+    Record prevRecord( TransactionID, int * )const;
+
+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
+    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
 };
 
 
 
 /* ### FIXME use namespace with Qt3 */
 
 /*
  * A note on flow. The Signal is used for QT Signals when
  * a record is done.
  * There is either one controler and this controler slot will
  * be connected to a dialog signal.
  * In Queue we get the next and prev signals and call the Helper.
  * this then changes the Record of the dialog and sets the transactionId
  * of the controler.
  * For the new mode
  *
  */
 
 class OModalHelperSignal : public QObject {
     Q_OBJECT
 public:
-    OModalHelperSignal();
+    OModalHelperSignal(OModalHelperBase* base,  QObject* parent);
 
 signals:
     done( int status,  TransactionID transaction );
-    accpeted( TransactionID transaction );
+    accepted( TransactionID transaction );
     rejected( TransactionID transaction );
+
+private:
+    OModalHelperBase* m_base;
 };
 
 
 class OModalHelperControler : public QObject {
     Q_OBJECT
 public:
-    OModalHelperControler( TransactionID id );
+    OModalHelperControler( OModalHelperBase* , QObject* parent);
     virtual TransactionID transactionID()const;
     void setTransactionID( TransactionID id );
     QDialog* dialog()const;
 
 public slots:
     virtual done(int result );
 private:
     QDialog *m_dia;
     TransactionID m_id;
+    OModalHelperBase *m_base;
+}
+
+class OModalQueueBar;
+class OModalQueuedDialog : public QDialog {
+    Q_OBJECT
+public:
+    OModalQueuedDialog(QWidget *mainWidget);
+    ~OModalQueuedDialog();
+
+    QDialog* centerDialog()const;
+
+    void setQueueBarEnabled( bool = true );
+    void setRecord( int record, int count );
+private:
+    OModalQueueBar *m_bar;
+};
+
+
+/*
+ * Tcpp Template Implementation
+ */
+
+/**
+ * This is the simple Template c'tor. It takes the mode
+ * this helper should operate in and the parent object.
+ * 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_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
+ *
+ * @return true if the record is currenlty edited otherwise false
+ *
+ * @param Id The id which might be handled
+ */
+template<class Dialog, class Record, typename Id>
+bool OModalHelper<Dialog, Record, Id>::handles( 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.
+ */
+template<class Dialog, class Record, typename Id>
+void OModalHelper<Dialog, Record, Id>::cancel() {
+    m_ids.clear();
+    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 );
+
+
+}
+
+
+/**
+ * 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>
+void OModalHelper::cancel( TransactionID tid ) {
+    /* wrong tid */
+    if (!m_transactions.contains( tid ) && !m_done.contains( tid) )
+        return;
+
+    if (m_mode == New )
+        /* 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() );
+        }
+    }
+    /* now remove from the various maps */
+    m_ids.remove( m_transactions.contains( tid ) ? m_transactions[tid] : m_done[tid ]  );
+
+    m_done.remove( tid );
+    m_transactions.remove( tid );
+}
+
+/**
+ * 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
+ */
+template<class Dialog, class Record, typename Id>
+void OModalHelper<Dialog, Record, Id>::connectDone( QObject* rec, const char* slot ) {
+    QObject::connect(m_signal, SIGNAL(done(int, TransactionID) ),
+                     rec, slot );
+}
+
+/**
+ * Connect to the accepted 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
+ */
+template<class Dialog, class Record, typename Id>
+void OModalHelper<Dialog, Record, Id>::( QObject* rec, const char* slot ) {
+
+}
+
+
+template<class Dialog, class Record, typename Id>
+void OModalHelper<Dialog, Record, Id>::( QObject* rec, const char* slot ) {
+
+}
 #endif