Changeset 52 in projects for punch-card/punch-card-editor/src/qpunchcard/card.h

Timestamp:

Dec 16, 2009, 2:47:25 AM (10 years ago)

Author:

sven

Message:

Punch Card Editor: Code reordering and class renaming, rewriting.
Now using the namespace QPunchCard everywhere.

Parted the whole application into 5 parts/directories:

• app: The application core with MainWindow and main() function
• qpunchcard: Everything directly binary card related (no interpretation): modeling, input/output, view. Most important classes are Card, Deck, FileFormat, Widget
• text: Everything related to text interpretation of Cards/Card Decks. Having the abstract Codec classes and the Text::Editor, Text::EditorDock
• deckviewer: Application components like binary card editing central widget (CardEditor) and Navigator (Model View Controller classes)
• driver: Basis for the driver framework, must be written soon.

Deck now hides the complete Storage to implement frontend methods that
implement versioning (Undo framework). All code was cleaned up, but doesn't
compile right now (still quite some non heavy errors).

-- Sven @ workstation

Location:

punch-card/punch-card-editor

Files:

• . (modified) (1 prop)
• src/qpunchcard/card.h (modified) (6 diffs)

punch-card/punch-card-editor/src/qpunchcard/card.h

@@ -14 +14 @@
 
 namespace QPunchCard {
-        class Column; class Card; class Deck; class DeckIndex;
+        class Column; class Deck; class DeckIndex;
 };
-
-#include "format.h"
-//#include "codec.h"
 
 namespace QPunchCard {
@@ -29 +26 @@
         Column() : QBitArray(13) {}
 
+        // TODO: int-Casting komplett entfernen. Das ist nicht Sinn
+        //       der Sache bei der *Modellierung*, sondern eben eher
+        //       beim Import/Export. Natuerlich *kann* man hier Methoden
+        //       fuer sowas bereitstellen.
         Column(int value) : QBitArray(13) {
                 // TODO: range check, throw exception if bad
@@ -36 +37 @@
                 }
         }
-
 
         operator int() const {
@@ -49 +49 @@
  * This is a punch card.
  **/
-class Card : public QObject {
-        Q_OBJECT // must be qobject for signals/slots and QPointer usage
+class Card {
 
 public:
@@ -78 +77 @@
 
         ~Card() {};
-
-signals:
-        // auf das level will echt keiner runter!
-        void dataChanged(int left_index, int right_index);
-        // wenn signal: klasse muss QObject sein =>
-        //              kein copy constructor möglich =>
-        //              File = QVector<Card*>
 };
 
-
-/**
- * File uses the strategy pattern to switch between different
- * I/O formats (using the FileFormat class).
- **/
-class Deck : public QObject, public QList< QPointer<Card> > {
-        Q_OBJECT
-
-        QSharedPointer<const FileFormat> created_format;
-        void init();
-
-public:
-        typedef QList< QPointer<Card> >::iterator iterator;
-        QPointer<QUndoStack> undo;
-
-        // Creation and I/O handling ===================
-        /// Create empty
-        Deck() : QList< QPointer<Card> >() { init(); }
-        ~Deck() {};
-        /// Create from file/stream/etc., that is, calls format->read()
-        Deck(const FileFormat* format) : QList< QPointer<Card> >(), created_format(format) { init(); }
-        /// Save with same device/format as created
-        bool save(QFile& file) { return save(created_format.data(), file); }
-        /// Save
-        bool save(const FileFormat* format, QFile& file);
-        bool read(QFile& file) { return read(created_format.data(), file); }
-        bool read(const FileFormat* format, QFile& file);
-
-        bool canSave() const { return created_format; }
-        void setFormat(const FileFormat* format);
-        //File* getFile() { if(created_format && created_format->file) return created_format->file; }
-
-        bool isModified() const { return !undo->isClean(); }
-
-        // index handling ======================
-        inline bool isValid(int i);
-        inline DeckIndex createIndex(int i);
-
-        // Bearbeitungsfunktionen
-        bool insert(DeckIndex after); // neue Karte hinzufuegen
-        bool insertTimes(DeckIndex after, int times = 1);
-        bool move(DeckIndex from, DeckIndex to);
-        bool erase(DeckIndex from, DeckIndex to);
-
-        // Quick & dirty
-        inline void emitChanged(DeckIndex lower, DeckIndex upper);
-signals:
-        void cardCountChanged(int newCardCount); // wer braucht das?
-
-        // das hier ist das FAVORISIERTE FORMAT:
-        void contentsChanged(DeckIndex lowerCard, DeckIndex upperCard);
-
-
-        void modified(bool modified);
-        //void redoAvailable(bool available);
-        //void undoAvailable(bool available);
-        //void undoCommandAdded();
-
-public slots:
-        //void redo() {}
-        //void undo() {}
-        //void setModified(bool modified) {}
-};
-
-// Java-style iterator
-typedef QListIterator< QPointer<Card> > DeckIterator;
-
-
-/**
- * CardIndex feels like an int (normalized)
- **/
-class DeckIndex {
-private:
-        QPointer<Deck> deck;
-        int i;
-public:
-        // behaves like int, copy constructor and operator= will be created automatically
-        DeckIndex(int i = 0) : i(i) {}
-        operator int() const { return normalized(); }
-        int asInt() const { return normalized(); }
-
-        DeckIndex(Deck* d, int i) : deck(d), i(i) { if(!deck) qDebug() << "NULL DECK!"; }
-        bool isValid() const { return deck ? (i >= 0 && i < deck->count()) : false; }
-
-        // "normalisierung" = in Deck Bounds
-        int normalized() const { if(!deck) return i; if(i < 0) return 0; else if(i >= deck->count()) return deck->count()-1; else return i; }
-        void normalize() { i = normalized(); }
-        bool canNormalize() const { return deck; }
-
-        // special positions
-        bool isTop() const { return i < 0; }
-        bool isEnd() const { return i >= deck->count(); }
-        bool isFirst() const { return i == 0; }
-        bool isLast() const { return i == deck->count(); }
-
-        const QPointer<Deck> getDeck() const { return deck; }
-        void setDeck(Deck* deck) { this->deck = deck; }
-        bool assertDeck(Deck* fallback) { if(!deck) deck=fallback; return deck == fallback; }
-        bool hasDeck() const { return deck; }
-
-        // ein paar abkuerzungen
-        /// @returns null wenn nicht normalisierbar (also letztlich kein Deck da ist)
-        QPointer<Card> getCard() const { return canNormalize() ? deck->at(normalized()) : NULL; }
-
-        DeckIndex& operator++() { i++; return *this; }
-        DeckIndex& operator+=(int x) { i+= x; return *this; }
-};
 
 /****************************************************************************
@@ -199 +84 @@
  ***************************************************************************/
 
- QDebug operator<<(QDebug dbg, const Column &c);
- QDebug operator<<(QDebug dbg, const Card &c);
- QDebug operator<<(QDebug dbg, const Deck &c);
- QDebug operator<<(QDebug dbg, const DeckIndex &c);
+QDebug operator<<(QDebug dbg, const Column &c);
+QDebug operator<<(QDebug dbg, const Card &c);
 
-
-/****************************************************************************
-  inline functions
- ***************************************************************************/
-
-inline bool Deck::isValid(int i) { return createIndex(i).isValid(); }
-inline DeckIndex Deck::createIndex(int i) { return DeckIndex(this, i); }
-inline void Deck::emitChanged(DeckIndex lower, DeckIndex upper) {
-        emit contentsChanged(lower, upper);
-}
 
 }; // Namespace