Changeset 47 in projects


Ignore:
Timestamp:
Dec 9, 2009, 2:56:54 AM (10 years ago)
Author:
sven
Message:

Continued implementation:

  • removed bugs
  • improved features

Programming continues, but quite slow since I've got few time... unfortunately

Location:
punch-card/punch-card-editor/src
Files:
16 edited

Legend:

Unmodified
Added
Removed
  • punch-card/punch-card-editor/src/app/cardeditor.cc

    r44 r47  
    22
    33CardEditor::CardEditor(EditorWindow* win) : QScrollArea(win), main(win) {
    4         //QScrollArea(parent);
    54        view = new CardWidget(this);
    65        setWidget(view);
    7         view->setCard(0);
     6        view->unsetCard();
    87}
    98
    10 void CardEditor::setCard(int i) {
    11         if(main->deck && main->deck->isValid(i))
    12                 view->setCard( main->deck->at(i) );
    13         this->current_card = i;
     9void CardEditor::setCard(DeckIndex i) {
     10        if(i.assertDeck(main->deck) && i.isValid()) {
     11                view->setCard( i.getCard() );
     12        } else {
     13                qDebug("DeckIndex has not the same deck as we use or is not valid.");
     14                qDebug() << i;
     15        }
     16        this->current_index = i;
    1417        view->update();
     18        setStatusTip( QString("Click to Edit card %1").arg(current_index));
    1519}
    1620
    17 void CardEditor::contentsChanged(int lowerCard, int upperCard) {
    18         if(current_card >= lowerCard && current_card <= upperCard) {
     21void CardEditor::contentsChanged(DeckIndex lowerCard, DeckIndex upperCard) {
     22        if(current_index >= lowerCard && current_index <= upperCard) {
    1923                view->update();
     24        } else {
     25                qDebug("contentsChanged: Index was out of bound:");
     26                qDebug() << "lower: " << lowerCard << "upper: " << upperCard;
    2027        }
    2128}
    2229
    23 void CardEditor::createToolbar() {
    24         next_card_action = new QAction(tr("&Next Card"), this);
    25         next_card_action->setStatusTip(tr("Go to next Card"));
    26         connect(next_card_action, SIGNAL(triggered()), main, SLOT(nextCard()));
     30void CardEditor::fileOpened(bool opened) {
     31        // in jedem Fall: Karte entfernen und neuzeichnen
     32        view->unsetCard();
     33        view->update();
     34        // wenn opened == true => setCard(0) wird schon kommen
     35        // ansonsten ist CardWidget schlau genug, nicht den Nullpointer
     36        // anzusprechen.
     37}
    2738
    28         prev_card_action = new QAction(tr("&Previous Card"), this);
    29         prev_card_action->setStatusTip(tr("Go to previous Card"));
    30         connect(prev_card_action, SIGNAL(triggered()), main, SLOT(prevCard()));
    31 
    32         navi_bar = main->addToolBar(tr("Navigation"));
    33         navi_bar->addAction(prev_card_action);
    34         navi_bar->addAction(next_card_action);
     39void CardEditor::enterEvent(QEvent*) {
     40        // aeh... wird vielleicht spaeter gebraucht :)
    3541}
  • punch-card/punch-card-editor/src/app/cardeditor.h

    r44 r47  
    99
    1010#include <QScrollArea>
     11#include <QEvent>
    1112
     13using namespace QPunchCard;
    1214
    1315class CardEditor : public QScrollArea {
     
    1517
    1618        QPointer<EditorWindow> main; // und damit die offene Datei
    17         QPointer< QPunchCard::CardWidget > view;
    18         int current_card;
     19        QPointer<CardWidget> view;
     20        DeckIndex current_index;
    1921
    2022public:
    2123        CardEditor(EditorWindow* win);
    2224
    23         void createToolbar();
    24 
    25         // Naviactions
    26         QAction* next_card_action;
    27         QAction* prev_card_action;
    28 
    29         QToolBar* navi_bar;
    30 
    3125public slots:
    32         void setCard(int i);
    33         void contentsChanged(int lowerCard, int upperCard);
     26        void setCard(DeckIndex i);
     27        void contentsChanged(DeckIndex lower, DeckIndex upper);
     28        void fileOpened(bool opened);
    3429
    3530signals:
    36         void cardSelected(int i); // hmmm....
    3731        // und ja, das hier soll ein EDITOR werden (hmja, echt)
    3832        // also wird hier auch bald mal ein Signal emitiert...
     33
     34protected:
     35        void enterEvent(QEvent* event);
    3936
    4037};
  • punch-card/punch-card-editor/src/app/decktexteditor.cc

    r44 r47  
    1111
    1212        // - Codec erstellen oder kriegen
    13 
    14         editor = new DeckTextEditor(this);
     13        editor = new DeckTextEditor(main);
     14
     15        // Signal weiterleiten
     16        connect(editor, SIGNAL(cursorRowChanged(DeckIndex)), this, SIGNAL(cardSelected(DeckIndex)));
     17        connect(main, SIGNAL(contentsChanged(DeckIndex,DeckIndex)), editor, SLOT(contentsChanged(DeckIndex,DeckIndex)));
    1518
    1619        // spaeter: oben (in Titelleiste oder drunter) Codeauswahl,
     
    2023}
    2124
    22 DeckTextEditor::DeckTextEditor(QWidget* parent) : QPlainTextEdit(parent) {
     25void TextEditorDock::setCard(DeckIndex i) {
     26        editor->highlightRow(i);
     27}
     28
     29void DeckTextEditor::contentsChanged(DeckIndex lower_card, DeckIndex upper_card) {
     30        // translate indices to text rows and load new text
     31        qDebug("Loading new text between [%d, %d]", (int)lower_card, (int)upper_card);
     32        for(int i = lower_card; i < upper_card; i++) {
     33                DeckIndex index(main->deck, i);
     34                if(!index.isValid()) {
     35                        qDebug("text update: skipping invalid %d", i);
     36                        continue;
     37                }
     38
     39                // Ganzen Block markieren und ueberschreiben
     40                QTextCursor cursor( this->document()->findBlockByNumber(i) );
     41                cursor.movePosition(QTextCursor::EndOfBlock, QTextCursor::KeepAnchor);
     42                // an dieser Stelle: Ungueltige Zeichen maskieren (per anderem QTextCharFormat)!
     43                cursor.insertText(QString("Zeile %d von Lochkarte").arg(i));
     44        }
     45}
     46
     47DeckTextEditor::DeckTextEditor(EditorWindow* main) : QPlainTextEdit(main), main(main) {
    2348        row_area = new NumberArea(this);
    2449        col_area = new NumberArea(this);
     
    106131}
    107132
    108 void DeckTextEditor::highlightRow(int i) {
     133void DeckTextEditor::highlightRow(DeckIndex i) {
    109134        // externe eingabe: Highlighted_row machen und so...
    110135        highlighted_row = i;
  • punch-card/punch-card-editor/src/app/decktexteditor.h

    r44 r47  
    1717        EditorWindow* main;
    1818        QPunchCard::Codec* codec;
    19 
     19        DeckTextEditor* editor;
    2020public:
    21         // das hier ist auch irgendwie *kacke*:
    22         DeckTextEditor* editor;
    2321        TextEditorDock(EditorWindow* parent);
    2422
    25 /*public slots:
    26         void setCard(int i) { editor->cursorRowChanged(i); }
     23public slots:
     24        void setCard(DeckIndex i);
    2725
    2826signals:
    29         void cardSelected(int i);
    30         */
     27        void cardSelected(DeckIndex i);
    3128};
    3229
     
    3431class DeckTextEditor : public QPlainTextEdit {
    3532        Q_OBJECT
     33
     34        EditorWindow* main;
    3635
    3736public:
     
    5049        };
    5150
    52         DeckTextEditor(QWidget* parent = 0);
     51        DeckTextEditor(EditorWindow* main);
    5352
    5453        void numberAreaPaintEvent(NumberArea* area, QPaintEvent* event);
     
    5756public slots:
    5857        // wird Markierung entfernen, wenn ausser gueltigem Blockbereich
    59         void highlightRow(int i);
     58        void highlightRow(DeckIndex i);
     59        void contentsChanged(DeckIndex lower_card_index, DeckIndex upper_card_index);
    6060
    6161signals:
    6262        // die aktive Karte des Benutzers
    63         void cursorRowChanged(int row);
     63        void cursorRowChanged(DeckIndex row);
    6464
    6565private:
  • punch-card/punch-card-editor/src/app/editorwindow.cc

    r44 r47  
    2222
    2323        // etwas kartenmaterial besorgen
    24         /*
    2524        Card* foo = new Card;
    2625        foo->column[0] = 12;
     
    3736                deck->push_back(c);
    3837        }
    39         */
    40 
    41         deck = new Deck();
    42 
    43         graphical_editor = new CardEditor(this);
    44         graphical_editor->createToolbar();
    45         setCentralWidget(graphical_editor);
    46         // signale und so:
    47         connect(graphical_editor, SIGNAL(cardSelected(int)), this, SLOT(setCard(int)));
    48         connect(this, SIGNAL(cardSelected(int)), graphical_editor, SLOT(setCard(int)));
    49 
     38
     39        //deck = new Deck();
     40
     41        createGraphicalEditor();
    5042        createActions();
    5143        createMenus();
     
    5850        // und jetzt:
    5951
    60         emit fileOpened(true);
     52        notifyFileOpened();
     53}
     54
     55void EditorWindow::createGraphicalEditor() {
     56        graphical_editor = new CardEditor(this);
     57        setCentralWidget(graphical_editor);
     58        // signale und so:
     59        connect(this, SIGNAL(cardSelected(DeckIndex)), graphical_editor, SLOT(setCard(DeckIndex)));
     60        connect(this, SIGNAL(fileOpened(bool)), graphical_editor, SLOT(fileOpened(bool)));
     61        connect(this, SIGNAL(contentsChanged(DeckIndex, DeckIndex)), graphical_editor, SLOT(contentsChanged(DeckIndex, DeckIndex)));
     62
    6163}
    6264
    6365void EditorWindow::window_update_on_file_state(bool opened) {
     66        // * Window Title setzen
     67        // * contentsChanged-Signal broadcasten
    6468        if(opened) {
    6569                // titel setzen
     
    7074                // Modified-Stern ([*]) verbinden
    7175                connect(deck, SIGNAL(modified(bool)), this, SLOT(setWindowModified(bool)));
     76
     77                // Broadcasting von "Edited" verbinden
     78                connect(deck, SIGNAL(contentsChanged(DeckIndex, DeckIndex)), this, SIGNAL(contentsChanged(DeckIndex,DeckIndex)));
    7279        } else {
    7380                setWindowTitle(tr("Punch Card Editor"));
    7481                // passiert folgendes nicht sowieso automatisch?
    7582                disconnect(this, SLOT(setWindowModified(bool)));
     83                // urhm, den broadcaster... nicht die slots freisetzen, waere bloed.
    7684        }
    7785}
     
    101109
    102110void EditorWindow::closeDeck() {
    103         qDebug() << "Emitting closing file...";
    104         emit fileOpened(false);
    105111        qDebug() << "Deleting deck.";
    106         delete deck; // jaha! :-)
     112        delete deck;
     113        emit fileOpened(deck); // also false
    107114}
    108115
     
    123130        deck = new_deck;
    124131        this->file.setFileName( file.fileName() );
    125         emit fileOpened(true);
    126         emit setCard(0);
     132        notifyFileOpened();
     133}
     134
     135void EditorWindow::notifyFileOpened() {
     136        if(deck) {
     137                emit fileOpened(deck);
     138                if(deck->count() > 0)
     139                        emit setCard( deck->createIndex(0) );
     140                else {
     141                        // naja, das Deck ist *leer*. gibt also nix.
     142                }
     143        } else
     144                qDebug("notifyFileOpened is supposed to be called when a file was *opened*");
    127145}
    128146
     
    134152                closeDeck();
    135153                deck = new Deck();
    136                 emit fileOpened(true);
    137                 emit setCard(0);
     154                notifyFileOpened();
    138155        }
    139156}
     
    232249
    233250        // Signale anschalten:
    234         connect(editor->editor, SIGNAL(cursorRowChanged(int)), this, SLOT(setCard(int)));
    235         connect(this, SIGNAL(cardSelected(int)), editor->editor, SLOT(highlightRow(int)));
     251        connect(editor, SIGNAL(cardSelected(DeckIndex)), this, SLOT(setCard(DeckIndex)));
     252        connect(this, SIGNAL(cardSelected(DeckIndex)), editor, SLOT(setCard(DeckIndex)));
    236253        connect(this, SIGNAL(fileOpened(bool)), editor, SLOT(setVisible(bool)));
    237254        // TODO: klaeren, wer den Texteditor irgendwann mal killt
     
    240257
    241258void EditorWindow::nextCard() {
    242         setCard( getCurrentCard() + 1);
     259        setCard( getCurrentIndex() + 1);
    243260}
    244261
    245262void EditorWindow::prevCard() {
    246         setCard( getCurrentCard() - 1);
    247 }
    248 
    249 void EditorWindow::setCard(int i) {
     263        setCard( getCurrentIndex() - 1);
     264}
     265
     266void EditorWindow::setCard(DeckIndex i) {
    250267        // wenn keine Datei offen und so
    251         if(!deck) return;
    252         if(i < 0) i = 0;
    253         if(i >= deck->count()) i = deck->count() - 1;
    254 
    255         // neue current Card setzen:
    256         current_card = i;
     268        if(!deck) {
     269                qDebug("No card open, skipping setCard broadcasting");
     270                return;
     271        }
     272        if(! i.assertDeck(deck)) {
     273                qDebug() << "Index i has wrong deck: " << i;
     274                return;
     275        }
     276        i.normalize();
     277
     278        // neuen index setzen
     279        current_index = i;
    257280
    258281        // Signal weitergeben:
    259282        emit cardSelected(i);
     283}
     284
     285void EditorWindow::newCard() {
     286        // append new Card behind current card
     287        if(!deck) return;
     288        if(deck->insert(current_index)) {
     289                setCard( current_index+1 );
     290        }
     291
     292        /*
     293        int new_card_index = current_card + 1;
     294        if(! deck->isValid(current_card))
     295                new_card_index = 0; // insert card at beginning of deck
     296        deck->insert( current_card + 1, new Card);
     297        // ob das hier geht...
     298        emit deck->contentsChanged(current_card, deck->count());
     299        setCard( current_card + 1 );
     300        */
     301}
     302
     303void EditorWindow::moveCardForwards() {
     304        if(!deck) return;
     305        if(deck->move(current_index, current_index+1)) {
     306                setCard( current_index+1 );
     307        }
     308        /*
     309        //DeckIndex new_index(deck, current_index + 1);
     310        if(!deck->isValid(current_card) || !deck->isValid(new_card_index)) {
     311                qDebug() << "Invalid indices for moveCardForwards";
     312                return;
     313        }
     314        deck->move(current_card, new_card_index);
     315        setCard( new_card_index );
     316        */
     317}
     318
     319void EditorWindow::moveCardBackwards() {
     320        if(!deck) return;
     321        if(deck->move(current_index, current_index-1)) {
     322                setCard( current_index-1 );
     323        }
     324        /*
     325        int new_card_index = current_card - 1;
     326        if(!deck->isValid(current_card) || !deck->isValid(new_card_index)) {
     327                qDebug() << "Invalid indices for moveCardBackwards";
     328                return;
     329        }
     330        deck->move(current_card, new_card_index);
     331        setCard( new_card_index );
     332        */
    260333}
    261334
     
    311384        new_text_editor_action = new QAction(tr("Open new &Text editor"), this);
    312385        new_text_editor_action->setStatusTip(tr("Display another text editor for editing the dock using a card code"));
     386        connect(new_text_editor_action, SIGNAL(triggered()), this, SLOT(newTextEditor()));
    313387
    314388        undo_action = new QAction(tr("&Undo"), this);
     
    316390        undo_action->setStatusTip(tr("Undo latest changes"));
    317391        redo_action->setStatusTip(tr("Redo latest changes"));
     392
     393        next_card_action = new QAction(tr("&Next Card"), this);
     394        next_card_action->setStatusTip(tr("Go to next Card"));
     395        connect(next_card_action, SIGNAL(triggered()), this, SLOT(nextCard()));
     396
     397        prev_card_action = new QAction(tr("&Previous Card"), this);
     398        prev_card_action->setStatusTip(tr("Go to previous Card"));
     399        connect(prev_card_action, SIGNAL(triggered()), this, SLOT(prevCard()));
     400
     401        new_card_action = new QAction(tr("Insert &new Card"), this);
     402        new_card_action->setStatusTip(tr("Insert new blanco card after current card"));
     403        connect(new_card_action, SIGNAL(triggered()), this, SLOT(newCard()));
     404
     405        move_forwards_action = new QAction(tr("Move forwards"), this);
     406        move_forwards_action->setStatusTip(tr("Move current card forwards"));
     407        connect(move_forwards_action, SIGNAL(triggered()), this, SLOT(moveCardForwards()));
     408
     409        move_backwards_action = new QAction(tr("Move backwards"), this);
     410        move_backwards_action->setStatusTip(tr("Move current card backwards"));
     411        connect(move_backwards_action, SIGNAL(triggered()), this, SLOT(moveCardBackwards()));
     412
    318413        // mehr Signale erst beim oeffnen/schliessen einer Datei
    319414}
     
    364459void EditorWindow::createToolBars() {
    365460        // ja ne... waere momentan noch das gleiche wie die Menus, also
    366         // schon irgendwie iditisch.
    367 
    368 
    369 
     461        // schon irgendwie iditisch. Egal:
     462
     463        navi_bar = addToolBar(tr("Navigation"));
     464        navi_bar->addAction(prev_card_action);
     465        navi_bar->addAction(next_card_action);
     466        navi_bar->addAction(new_card_action);
     467        navi_bar->addAction(this->move_backwards_action);
     468        navi_bar->addAction(this->move_forwards_action);
    370469}
    371470
     
    379478        addDockWidget(Qt::LeftDockWidgetArea, navigator);
    380479        view_menu->addAction(navigator->toggleViewAction());
    381         // Beim Klick auf Karte alle Views aktualisieren
    382         connect(navigator, SIGNAL(cardSelected(int)), this, SLOT(setCard(int)));
    383         connect(this, SIGNAL(cardSelected(int)), navigator, SLOT(setCard(int)));
    384         connect(this, SIGNAL(fileOpened(bool)), navigator, SLOT(setVisible(bool)));
    385 }
     480        // Signale werden natuerlich dort gemacht und so.
     481}
  • punch-card/punch-card-editor/src/app/editorwindow.h

    r44 r47  
    2222#include "decktexteditor.h"
    2323
     24using namespace QPunchCard;
     25
    2426class EditorWindow : public QMainWindow {
    2527        Q_OBJECT
    26         int current_card;
     28        DeckIndex current_index;
    2729
    2830public:
     
    3941
    4042        bool hasFileOpened() const { return deck; }
    41         int getCurrentCard() const { return current_card; }
     43        QPointer< QPunchCard::Deck > getDeck() const { return deck; }
     44        DeckIndex getCurrentIndex() const { return current_index; }
    4245
    4346        /// speichert die Datei wenn noetig, auf Benutzeranfrage
     
    6972        void newTextEditor();
    7073
     74        void newCard();
     75        void moveCardForwards();
     76        void moveCardBackwards();
     77
    7178        // durchreichen an alle Kindobjekte
    7279        void nextCard();
    7380        void prevCard();
    74         void setCard(int i);
     81        void setCard(DeckIndex i);
    7582
    7683signals:
    77         void cardSelected(int i);
     84        void cardSelected(DeckIndex i);
     85
     86        // broadcasting from deck
     87        void contentsChanged(DeckIndex lower_index, DeckIndex upper_index);
    7888
    7989        void fileOpened(bool opened);
     
    8393
    8494private:
     95        void createGraphicalEditor();
    8596        void createActions();
    8697        void createMenus();
     
    8899        void createStatusBar();
    89100        void createDockWindows();
     101
     102        void notifyFileOpened();
    90103
    91104        QMenu* file_menu;
     
    116129        QAction* new_text_editor_action;
    117130
     131        // Naviactions
     132        QAction* next_card_action;
     133        QAction* prev_card_action;
     134        QAction* new_card_action;
     135        QAction* move_forwards_action;
     136        QAction* move_backwards_action;
     137
    118138protected:
    119139        void closeEvent(QCloseEvent* event);
  • punch-card/punch-card-editor/src/app/navigator.cc

    r44 r47  
    22
    33Navigator::Navigator(EditorWindow* parent) : QDockWidget("Cards", parent), main(parent) {
    4         view = new QListView(this);
    5         model = new DeckModel(this);
    6 
    7         model->setDeck(main->deck);
     4        model = new DeckModel(main); // ja, das ist bloed.
     5        view = new DeckListView(this);
     6        // mach das model selbst:
     7        //model->setDeck(main->deck);
     8        // darf die view nicht selbst machen (erst nach model erstellt wird!)
    89        view->setModel(model);
    9 
    10         // view einrichten
    11         view->setViewMode(QListView::IconMode);
    12         view->setIconSize( model->getIconSize() );
    13         view->setSpacing(20);
    14         view->setSelectionMode(QAbstractItemView::ContiguousSelection);
    15         view->setDragEnabled(true);
    16         view->setAcceptDrops(true);
    17         view->setDropIndicatorShown(true);
    18         view->setMovement(QListView::Snap);
    19         view->setWrapping(false);
    20         view->setFlow(QListView::TopToBottom);
    2110
    2211        setWidget(view);
     
    2615        connect(view, SIGNAL(activated(QModelIndex)), this, SLOT(cardSelected_translator(QModelIndex)));
    2716        connect(this, SIGNAL(dockLocationChanged(Qt::DockWidgetArea)), this, SLOT(setFlowOnLocationChange(Qt::DockWidgetArea)));
     17        connect(main, SIGNAL(contentsChanged(DeckIndex,DeckIndex)), model, SLOT(contentsChanged(DeckIndex,DeckIndex)));
     18
     19        // Beim Klick auf Karte alle Views aktualisieren
     20        connect(this, SIGNAL(cardSelected(DeckIndex)), main, SLOT(setCard(DeckIndex)));
     21        connect(main, SIGNAL(cardSelected(DeckIndex)), this, SLOT(setCard(DeckIndex)));
     22
     23        // Beim Laden/Entladen eines Decks Model und View an/ausschalten
     24        connect(main, SIGNAL(fileOpened(bool)), this, SLOT(setVisible(bool)));
     25        connect(main, SIGNAL(fileOpened(bool)), model, SLOT(setDeck(bool)));
     26}
     27
     28DeckListView::DeckListView(Navigator* nav) : QListView(nav), navigator(nav) {
     29        Q_ASSERT( navigator->model != 0);
     30        setModel( navigator->model );
     31
     32        // view einrichten
     33        setViewMode(QListView::IconMode);
     34        setIconSize( navigator->model->getIconSize() );
     35        setSpacing(20);
     36        //setSelectionMode(QAbstractItemView::ContiguousSelection);
     37        setSelectionMode(QAbstractItemView::SingleSelection);
     38        setDragEnabled(true);
     39        setAcceptDrops(true);
     40        setDropIndicatorShown(true);
     41        setMovement(QListView::Snap);
     42        setWrapping(false);
     43        setFlow(QListView::TopToBottom);
    2844}
    2945
     
    4157                        break;
    4258        }
     59        // in jedem Fall Icon-Groesse neu berechnen (etwas quick & dirty)
     60        resizeEvent(0);
    4361}
    4462
    45 void Navigator::setCard(int i) {
    46         view->scrollTo( model->index(i), QAbstractItemView::PositionAtCenter);
     63void Navigator::setCard(DeckIndex i) {
     64        if(i.isValid())
     65                view->scrollTo( model->index(i), QAbstractItemView::PositionAtCenter);
     66        else
     67                qDebug("Navigator invalid scroll to %d", (int)i);
    4768}
    4869
    49 void Navigator::resizeEvent(QResizeEvent* event) {
    50         qDebug("Alte size: %d, %d, neue: %d, %d", event->oldSize().width(), event->oldSize().height(),
    51                 event->size().width(), event->size().height());
    52         qDebug("Icon size war: %d, %d", view->iconSize().width(), view->iconSize().height());
    53         qDebug("Icon size war: %d, %d", model->getIconSize().width(), model->getIconSize().height());
    54         view->setIconSize(
    55                 model->getIconSize() *
    56                 ( (float)event->size().width() / (float)event->oldSize().width() )
     70void Navigator::resizeEvent(QResizeEvent*) {
     71        if(view->flow() == QListView::TopToBottom) {
     72                model->setIconSizeByWidth( view->viewport()->contentsRect().width() - 40 );
     73                view->setIconSize( model->getIconSize() );
     74        } else if(view->flow() == QListView::LeftToRight) {
     75                // bei Hoehe ist halt noch das Label irgendwie dabei -- schwierig zu berechnen
     76                model->setIconSizeByHeight( view->viewport()->contentsRect().height() - 80);
     77                view->setIconSize( model->getIconSize() );
     78        }
     79}
     80
     81void DeckListView::dragEnterEvent(QDragEnterEvent *event) {
     82        if(event->mimeData()->hasFormat("binary/x-punch-card"))
     83                event->accept();
     84        else
     85                event->ignore();
     86}
     87
     88void DeckListView::dragMoveEvent(QDragMoveEvent* event) {
     89        if(event->mimeData()->hasFormat("binary/x-punch-card")) {
     90                event->setDropAction(Qt::MoveAction);
     91                event->accept();
     92        } else {
     93                event->ignore();
     94        }
     95}
     96
     97void DeckListView::dropEvent(QDropEvent* event) {
     98        /*
     99        if(event->mimeData()->hasFormat("binary/x-punch-card")) {
     100                QByteArray piece = event->mimeData()->data("binary/x-punch-card");
     101                QDataStream dataStream(&piece, QIODevice::ReadOnly);
     102                Card card;
     103                dataStream >> card;
     104
     105         QByteArray pieceData = event->mimeData()->data("image/x-puzzle-piece");
     106         QDataStream dataStream(&pieceData, QIODevice::ReadOnly);
     107         QPixmap pixmap;
     108         QPoint location;
     109         dataStream >> pixmap >> location;
     110
     111         addPiece(pixmap, location);
     112
     113         event->setDropAction(Qt::MoveAction);
     114         event->accept();
     115     } else
     116         event->ignore();
     117         */
     118        event->ignore();
     119 }
     120
     121void DeckListView::startDrag(Qt::DropActions /* supportedActions */) {
     122        qDebug("Started Drag and Drop handler");
     123        Q_ASSERT(navigator->main != 0);
     124        Q_ASSERT(navigator->main->deck != 0);
     125        DeckIndex i = navigator->main->deck->createIndex(
     126                currentIndex().row()
    57127        );
    58         model->setIconSize( ( (float)event->size().width() / (float)event->oldSize().width() ) );
    59         qDebug("Icon size ist: %d, %d", view->iconSize().width(), view->iconSize().height());
     128
     129        if(!i.isValid()) {
     130                qDebug() << "Invalid index for drag&drop start: " << i;
     131                return;
     132        }
     133
     134        QPixmap pixmap = currentIndex().data(Qt::DecorationRole).value<QPixmap>();
     135
     136        QByteArray itemData;
     137        // todo: Lochkarte praepareieren in verschiedenen Formaten
     138
     139        QMimeData *mimeData = new QMimeData;
     140        mimeData->setData("binary/x-punch-card", itemData);
     141
     142        QDrag *drag = new QDrag(this);
     143        drag->setMimeData(mimeData);
     144        drag->setHotSpot(QPoint( navigator->model->getIconSize().width()/2,
     145                                 navigator->model->getIconSize().height()/2));
     146        drag->setPixmap(pixmap);
     147
     148        if(drag->exec(Qt::MoveAction) == Qt::MoveAction) {
     149                qDebug() << "Karte wurde verschoben von Index " << i;
     150                // teil hier loeschen und so.
     151        }
     152
     153        /*
     154     QListWidgetItem *item = currentItem();
     155
     156     QByteArray itemData;
     157     QDataStream dataStream(&itemData, QIODevice::WriteOnly);
     158     QPixmap pixmap = qVariantValue<QPixmap>(item->data(Qt::UserRole));
     159     QPoint location = item->data(Qt::UserRole+1).toPoint();
     160
     161     dataStream << pixmap << location;
     162
     163     QMimeData *mimeData = new QMimeData;
     164     mimeData->setData("image/x-puzzle-piece", itemData);
     165
     166     QDrag *drag = new QDrag(this);
     167     drag->setMimeData(mimeData);
     168     drag->setHotSpot(QPoint(pixmap.width()/2, pixmap.height()/2));
     169     drag->setPixmap(pixmap);
     170
     171     if (drag->exec(Qt::MoveAction) == Qt::MoveAction)
     172         delete takeItem(row(item));
     173*/
    60174}
  • punch-card/punch-card-editor/src/app/navigator.h

    r44 r47  
    44#include <QDockWidget>
    55#include <QListView>
     6#include <QAbstractListModel>
     7#include <QVariant>
     8#include <QList>
     9#include <QSize>
    610
    711class Navigator;
     12class DeckListView;
    813
    914#include "qpunchcard/deckmodel.h"
    1015#include "editorwindow.h"
    11 #include "qpunchcard/deckmodel.h"
    1216#include <QResizeEvent>
     17#include <QDragEnterEvent>
     18#include <QDragLeaveEvent>
     19#include <QDropEvent>
    1320
    1421using namespace QPunchCard;
     
    2330
    2431        EditorWindow* main;
    25         QListView* view;
     32        DeckListView* view;
    2633        DeckModel* model;
     34        friend class DeckModel;
     35        friend class DeckListView;
    2736
    2837public:
     
    3039
    3140public slots:
    32         void setCard(int i);
     41        void setCard(DeckIndex i);
    3342
    3443signals:
    35         void cardSelected(int i);
     44        void cardSelected(DeckIndex i);
    3645
    3746private slots:
     
    4554protected:
    4655        void resizeEvent(QResizeEvent* event);
     56};
    4757
     58class DeckListView : public QListView {
     59        Q_OBJECT
     60
     61        Navigator* navigator;
     62public:
     63        //static const QString item_mime_type = "binary/x-punch-card";
     64
     65        DeckListView(Navigator* navigator);
     66protected:
     67        void dragEnterEvent(QDragEnterEvent *event);
     68        void dragMoveEvent(QDragMoveEvent *event);
     69        void dropEvent(QDropEvent *event);
     70        void startDrag(Qt::DropActions supportedActions);
    4871};
    4972
  • punch-card/punch-card-editor/src/qpunchcard/card.cc

    r44 r47  
    1010}
    1111
    12 bool QPunchCard::Deck::save(FileFormat* format, QFile& file) {
     12bool Deck::save(FileFormat* format, QFile& file) {
    1313        if(!format) return false;
    1414        return format->write(file);
     15}
     16
     17bool Deck::insert(DeckIndex after) {
     18        // TODO: Undo Redo Framework
     19        if(!after.assertDeck(this))
     20                return false;
     21        DeckIndex new_index = createIndex(after + 1);
     22        qDebug("Inserting card at %i", (int)new_index.normalized());
     23        QList< QPointer<Card> >::insert( new_index.normalized(), new Card);
     24        qDebug() << "Deck is now:" << *this;
     25        emit contentsChanged(after, createIndex(count()) );
     26        return true;
     27}
     28
     29bool Deck::move(DeckIndex before, DeckIndex after) {
     30        // asdasdas
     31        return true;
    1532}
    1633
     
    4865        dbg.nospace() << "QPunchCard::File object with [" << c.size() << "] cards:\n\n";
    4966        for(int i = 0; i < c.size(); i++) {
    50                 dbg.nospace() << "Card no. #" << i << "\n";
    51                 dbg.nospace() << c.at(i);
     67                dbg.nospace() << "Card no. #" << i << " (" << c[i] << ")\n";
     68                dbg.nospace() << *c.at(i);
    5269                dbg.nospace() << '\n';
    5370        }
    5471        return dbg.nospace();
    5572}
     73
     74QDebug QPunchCard::operator<<(QDebug dbg, const DeckIndex &c) {
     75        dbg.nospace() << "QPunchCard::DeckIndex: i=" << c.asInt() << ". Has deck: " << c.hasDeck() << "\n";
     76        return dbg.nospace();
     77}
  • punch-card/punch-card-editor/src/qpunchcard/card.h

    r44 r47  
    44#include <QBitArray>
    55#include <QHash>
    6 #include <QVector>
     6#include <QList>
    77#include <QPointer>
    88#include <QDebug>
     
    1010#include <QFile>
    1111
     12#include <QModelIndex>
     13
    1214namespace QPunchCard {
    13         class Column; class Card; class Deck;
     15        class Column; class Card; class Deck; class DeckIndex;
    1416};
    1517
     
    5860                return column[x];
    5961        }
     62        const Column& get(int x) const {
     63                if(x < 0 || x > 80)
     64                        throw "Out of range exception";
     65                return column[x];
     66        }
    6067        Column& operator[](int x) { return get(x); }
    6168        const Column& operator[](int x) const { return column[x]; }
     69        int length() const { return 80; } // aja...
    6270
    6371        /*Card& operator=(const Card& other) {
     
    8290 * I/O formats (using the FileFormat class).
    8391 **/
    84 class Deck : public QObject, public QVector< QPointer<Card> > {
     92class Deck : public QObject, public QList< QPointer<Card> > {
    8593        Q_OBJECT
    8694
     
    8997
    9098public:
    91         typedef QVector< QPointer<Card> >::iterator iterator;
     99        typedef QList< QPointer<Card> >::iterator iterator;
    92100        QPointer<QUndoStack> undo;
    93101
     102        // Creation and I/O handling ===================
    94103        /// Create empty
    95         Deck() : QVector< QPointer<Card> >() { init(); }
     104        Deck() : QList< QPointer<Card> >() { init(); }
    96105        ~Deck() {};
    97106        /// Create from file/stream/etc., that is, calls format->read()
    98         Deck(FileFormat* format) : QVector< QPointer<Card> >(), created_format(format) { init(); }
     107        Deck(FileFormat* format) : QList< QPointer<Card> >(), created_format(format) { init(); }
    99108        /// Save with same device/format as created
    100109        bool save(QFile& file) { return save(created_format, file); }
     
    102111        bool save(FileFormat* format, QFile& file);
    103112
    104 
    105113        bool canSave() const { return created_format; }
    106114        void setFormat(FileFormat* format) { created_format = format; } // TODO: was ist mit altem format?
     
    109117        bool isModified() const { return !undo->isClean(); }
    110118
    111         /// checks whether position is valid
    112         bool isValid(int i) const { return i >= 0 && i < count(); }
     119        // index handling ======================
     120        inline bool isValid(int i);
     121        inline DeckIndex createIndex(int i);
     122
     123        // Bearbeitungsfunktionen
     124        bool insert(DeckIndex after); // neue Karte hinzufuegen
     125        bool move(DeckIndex from, DeckIndex to);
    113126
    114127signals:
     
    116129
    117130        // das hier ist das FAVORISIERTE FORMAT:
    118         void contentsChanged(int lowerCard, int upperCard);
     131        void contentsChanged(DeckIndex lowerCard, DeckIndex upperCard);
    119132
    120133
     
    125138
    126139public slots:
    127         // changeCard soll so nicht genutzt werden -- direkt auf den Daten arbeiten
    128         // und dann contentsChanged() abfeuern oder so
    129         //void changeCard(int card, const Column& new_value);
    130 
    131140        //void redo() {}
    132141        //void undo() {}
     
    134143};
    135144
    136 
     145// Java-style iterator
     146typedef QListIterator< QPointer<Card> > DeckIterator;
     147
     148
     149/**
     150 * CardIndex feels like an int (normalized)
     151 **/
     152class DeckIndex {
     153private:
     154        QPointer<Deck> deck;
     155        int i;
     156public:
     157        // behaves like int, copy constructor and operator= will be created automatically
     158        DeckIndex(int i = 0) : i(i) {}
     159        operator int() const { return normalized(); }
     160        int asInt() const { return normalized(); }
     161
     162        DeckIndex(Deck* d, int i) : deck(d), i(i) { if(!deck) qDebug() << "NULL DECK!"; }
     163        bool isValid() const { return deck ? (i >= 0 && i < deck->count()) : false; }
     164
     165        // "normalisierung" = in Deck Bounds
     166        int normalized() const { if(!deck) return i; if(i < 0) return 0; else if(i >= deck->count()) return deck->count()-1; else return i; }
     167        void normalize() { i = normalized(); }
     168        bool canNormalize() const { return deck; }
     169
     170        // special positions
     171        bool isTop() const { return i < 0; }
     172        bool isEnd() const { return i >= deck->count(); }
     173        bool isFirst() const { return i == 0; }
     174        bool isLast() const { return i == deck->count(); }
     175
     176        const QPointer<Deck> getDeck() const { return deck; }
     177        void setDeck(Deck* deck) { this->deck = deck; }
     178        bool assertDeck(Deck* fallback) { if(!deck) deck=fallback; return deck == fallback; }
     179        bool hasDeck() const { return deck; }
     180
     181        // ein paar abkuerzungen
     182        /// @returns null wenn nicht normalisierbar (also letztlich kein Deck da ist)
     183        QPointer<Card> getCard() const { return canNormalize() ? deck->at(normalized()) : NULL; }
     184};
    137185
    138186/****************************************************************************
     
    143191 QDebug operator<<(QDebug dbg, const Card &c);
    144192 QDebug operator<<(QDebug dbg, const Deck &c);
     193 QDebug operator<<(QDebug dbg, const DeckIndex &c);
    145194
    146195
     
    149198 ***************************************************************************/
    150199
     200inline bool Deck::isValid(int i) { return createIndex(i).isValid(); }
     201inline DeckIndex Deck::createIndex(int i) { return DeckIndex(this, i); }
    151202
    152203
  • punch-card/punch-card-editor/src/qpunchcard/codec.cc

    r44 r47  
     1#include <QDebug>
     2#include <QHash>
     3#include <QMap>
     4#include <QSharedPointer>
     5
    16#include "codec.h"
    2 
    37#include "cardcodes.h"
    48
    59using namespace QPunchCard;
    610
    7 Codec::Codec(const CodeTable* table, char illegal_character) : table(table), illegal_character(illegal_character) {
    8         create_inverse();
     11int Codec::countIllegalColumns(const Card* card) const {
     12        int fail;
     13        for(int x = 0; x < card->length(); x++) {
     14                if( !canEncode(card->get(x)) )
     15                        fail++;
     16        }
     17        return fail;
    918}
    1019
    11 void Codec::create_inverse() {
     20int Codec::countIllegalColumns(const Deck* deck) const {
     21        int fail;
     22        for(int x = 0; x < deck->count(); x++) {
     23                fail += countIllegalColumns(deck->at(x));
     24        }
     25        return fail;
     26}
     27
     28CharArrayCodec::CharArrayCodec(const int* table, char illegal) : Codec(illegal), table(table) {
    1229        // Inverse Tabelle (ASCII -> Column-Tabelle) erstellen
    13         int i;
    14 
    1530        if(!table) {
    1631                // uhh... miserable failure. Sehr schlecht.
    17                 // notbehelf:
    18 //              this->table = o29_code;
     32                qDebug() << "CharArrayCodec: Table is NULL! This will *CRASH* application!";
     33                //this->table = o29_code;
    1934        }
    2035
    21         for(i = 0; i < 4096; i++) {
     36        for(int i = 0; i < 4096; i++) {
    2237                // Illegal characters setzen
    23                 inverse_table[i] = illegal_character;
     38                inverse_table[i] = illegal;
    2439        }
    2540
    26         for(i = ' '; i < '`'; i++) {
    27                 inverse_table[ table[i] ] = i;
     41        for(char c = ' '; c < '`'; c++) {
     42                inverse_table[ this->table[c] ] = c;
    2843        }
    2944}
    3045
    31 Codec::Codec(const char* name, char illegal_character) : illegal_character(illegal_character) {
    32         if(strcmp(name, "o29_code"))
    33                 table = o29_code;
    34         else if(strcmp(name, "o26_ftn_code"))
    35                 table = o26_ftn_code;
    36         else if(strcmp(name, "o26_comm_code"))
    37                 table = o26_comm_code;
    38         // else => Exception schmeissen :-)
     46QList<QString> CodecFactory::availableCodecs() {
     47        QList<QString> list;
     48        list << "o29_code" << "o29_ftn_code" << "o26_comm_code";
     49        return list;
     50}
    3951
    40         create_inverse();
     52const Codec* CodecFactory::createCodec(const QString& name, char illegal) {
     53        if("o29_code" == name)
     54                return new CharArrayCodec(o29_code, illegal);
     55        else if("o26_ftn_code" == name)
     56                return new CharArrayCodec(o26_ftn_code, illegal);
     57        else if("o26_comm_code" == name)
     58                return new CharArrayCodec(o26_comm_code, illegal);
     59        else {
     60                qDebug() << QString("Codec '%s' not supported!").arg(name);
     61                return NULL;
     62        }
    4163}
     64
     65static const QString autoDetectCodec(const Card* card) {
     66        QMap<int, QString> bad_chars;
     67
     68        // alle moeglichen Codec-Namen kriegen
     69        QList<QString> codec_names = CodecFactory::availableCodecs();
     70        // ueber alle Codecnamen iterieren
     71        for(QList<QString>::iterator name = codec_names.begin(); name != codec_names.end(); ++name) {
     72                // dieser Pointer loescht das Objekt nach dem Scope:
     73                QSharedPointer<const Codec> codec( CodecFactory::createCodec(*name) );
     74
     75                // Anzahl Bad chars in Map (=> sortiert) speichern
     76                bad_chars.insertMulti(codec->countIllegalColumns( card ), *name );
     77        }
     78
     79        // den erstbesten Codec nehmen (da Map nach anzahl schlechter Zeichen sortiert)
     80        QString best_code = bad_chars.begin().value();
     81        return best_code;
     82}
     83
     84const QString autoDetectCodec(const Deck* deck) {
     85        QHash<QString, int> best_codec_counter;
     86
     87        // alle karten itereieren und hochzaehlen, welcher codec am besten abschnitt
     88        for(int x = 0; x < deck->count(); x++) {
     89                // INEFFIZIENZ: bei autoDetectCodec wird *jeder* Codec *neu* erstellt.
     90                // Loesung: Codec-Caching in der CodecFactory
     91                best_codec_counter[ autoDetectCodec(deck->at(x)) ]++;
     92        }
     93
     94        // besten Wert kriegen
     95        QHashIterator<QString, int> i(best_codec_counter);
     96        QString min_failes_name;
     97        int min_failes = 0;
     98        while(i.hasNext()) {
     99                i.next();
     100                if(i.value() < min_failes) {
     101                        min_failes = i.value();
     102                        min_failes_name = i.key();
     103                }
     104        }
     105
     106        // der ist es
     107        return min_failes_name;
     108}
  • punch-card/punch-card-editor/src/qpunchcard/codec.h

    r44 r47  
    1313// this is just to typify these `int Foo[]` arrays in method calls.
    1414// Thus `int Foo[]` is just the type `CodeTable*`
    15 typedef int CodeTable;
     15//typedef int CodeTable;
    1616class Codec;
    1717
    1818/**
    19  * Codec (Coder, Decoder), der mithilfe von hardgecodeten Codetabellen
     19 * Abstracte Codec-Klasse. Implementierungen muessen toAscii/fromAscii
     20 * implementieren und sollten canEncode() implementieren. Fuer Namenszuordnung
     21 * und fortgeschrittene Erstellung ist CodecFactory zustaendig.
     22 **/
     23class Codec {
     24public:
     25        // soll const sein, weil Codec unveraenderbar *immer* das gleiche
     26        // Ergebnis liefern soll, nach Erzeugung. Das ist auch noetig fuer
     27        // CharArrayCodec.
     28        const char illegal;
     29        /// @param illegal_character Zeichen fuer nicht existente Zahlen
     30        Codec(char illegal_character = '~') : illegal(illegal_character) { }
     31        virtual ~Codec() {}
     32        virtual char toAscii(const Column* col) const = 0;
     33        virtual Column fromAscii(char ch) const = 0;
     34        virtual bool canEncode(const Column* col) const { return toAscii(col) != illegal; }
     35        virtual bool canEncode(char ch) const = 0;
     36
     37        int countIllegalColumns(const Card* card) const;
     38        int countIllegalColumns(const Deck* deck) const;
     39};
     40
     41/**
     42 * Codec-Implementierung, der mithilfe von hardgecodeten Codetabellen
    2043 * (von Douglas Jones uebernommen) eine Umwandlung char->Column und andersrum
    2144 * durchfuehren kann. Letzteres geht genauso perfomant dank 4kb grosser
    2245 * inverser Tabelle, die bei Objektkonstruktion angelegt wird.
    23  *
    24  *
    2546 **/
    26 class Codec {
    27         const CodeTable* table;
     47class CharArrayCodec : public Codec {
     48        const int* table;
    2849        char inverse_table[4096];
    29         char illegal_character;
    3050
    3151public:
    32         /// @param illegal_character Zeichen fuer nicht existente Zahlen
    33         Codec(const CodeTable* table, char illegal_character = '~');
    34         Codec(const char* name, char illegal_character = '~');
    35 
    36         char toAscii(Column* col) const { return inverse_table[*col]; }
     52        CharArrayCodec(const int* table, char illegal = '~');// : Codec(illegal), table(table) {}
     53        char toAscii(const Column* col) const { return inverse_table[*col]; }
    3754        Column fromAscii(char ch) const { return Column(table[ch]); }
    3855
    39         bool canEncode(Column* col) const { return inverse_table[*col] != illegal_character; }
     56        bool canEncode(const Column* col) const { return inverse_table[*col] != illegal; }
    4057        bool canEncode(char ch) const { return table[ch] != ERROR; }
     58};
    4159
    42         static QList<QString> availableCodecs() {
    43                 QList<QString> list;
    44                 list << "o29_code" << "o29_ftn_code" << "o26_comm_code";
    45                 return list;
    46         }
     60/**
     61 * Factory-Klasse, die alle bekannten Codecs zurueckgeben kann. Wesentliches
     62 * Merkmal ist die Faehigkeit, mit Namen (QStrings) von Codecs umgehen zu
     63 * koennen und Codecs aus Namen erstellen zu koennen. Ausserdem gibt es
     64 * Algorithmen zum Finden des bestmoeglichen Codecs zu einer Card/einem Deck,
     65 * die mit Codec:countIllegalColumns() arbeitet.
     66 **/
     67class CodecFactory {
     68public:
     69        // TODO: Codec-Caching (Codec-Constructor privatisieren, dafuer hier caching
     70        // betreiben) weil einige codecs recht teuer zu erstellen sind (CharArrayCodec)
     71        static QList<QString> availableCodecs();
     72        static const Codec* createCodec(const QString& name, char illegal_character = '~');
     73        static const QString autoDetectCodec(const Card* card);
     74        static const QString autoDetectCodec(const Deck* deck);
     75};
    4776
    48 private:
    49         void create_inverse();
    50 };
    5177
    5278}; // Namespace
  • punch-card/punch-card-editor/src/qpunchcard/deckmodel.cc

    r44 r47  
    55using namespace QPunchCard;
    66
    7 DeckModel::DeckModel(QObject* parent) : QAbstractListModel(parent) {
    8         icon_size = QSize(73, 32) * 3;
     7DeckModel::DeckModel(EditorWindow* parent) : QAbstractListModel(parent), main(parent) {
     8        // allgemeines widget einrichten
     9        card_widget = new CardWidget();
     10        //card_widget->setParent(this);
     11        card_widget->setQuality( CardWidget::ThumbnailQuality );
     12        setIconSizeByWidth(73);
    913}
    1014
    11 void DeckModel::setDeck(Deck* f) {
    12         this->deck = f;
    13         cardwidgets.clear();
    14         if(deck) {
    15                 // Widgets fuer alle Karten erstellen
    16                 QVectorIterator< QPointer<Card> > i(*deck);
     15void DeckModel::setIconSizeByWidth(int width) {
     16        icon_size = QSize(width, qRound( ((double)width / 7375) * 3250 ) );
     17        card_widget->setGeometry( QRect(QPoint(), icon_size) );
     18}
     19
     20void DeckModel::setIconSizeByHeight(int height) {
     21        icon_size = QSize( qRound( ((double)height / 3250) * 7375 ), height);
     22        card_widget->setGeometry( QRect(QPoint(), icon_size) );
     23}
     24
     25void DeckModel::setDeck(bool) {
     26        if(!main) return; // das waere sowieso haesslich
     27        this->deck = main->getDeck();
     28        //cardwidgets.clear();
     29        // werden neu angelegt von data() -> DecorationRole
     30        /*if(opened) {
     31                DeckIterator i(*deck);
    1732                while(i.hasNext()) {
    1833                        CardWidget* w = new CardWidget; // wird nicht kompilieren => dann 0 setzen.
     
    2237                        cardwidgets.append(w);
    2338                }
    24         }
     39        }*/
    2540}
     41
    2642
    2743QVariant DeckModel::data(const QModelIndex &index, int role) const {
     
    3248                // hm... will ne Deko kriegen und so
    3349                int i = index.row();
    34                 if(i <= cardwidgets.count())
    35                         //qDebug("Zeichne Karte %d von %d (%d)", i, cardwidgets.count(), deck->count());
    36                         return QPixmap::grabWidget( cardwidgets[i], QRect(QPoint(), icon_size));
     50
     51                Q_ASSERT(main != 0);
     52                Q_ASSERT(main->deck != 0);
     53
     54                DeckIndex card_index(main->deck, i);
     55                if(!card_index.isValid()) {
     56                        qDebug("DeckModel: ungueltige Karte %d gefragt", i);
     57                        return QVariant();
     58                }
     59                /*
     60                if(i >= cardwidgets.count()) {
     61                        qDebug("Erstelle Kartenwidget %d", i);
     62                        QPointer<CardWidget> w( new CardWidget );
     63                        w->setCard( card_index.getCard() );
     64                        w->setQuality( CardWidget::ThumbnailQuality );
     65                        w->setGeometry( QRect(QPoint(), icon_size) );
     66                        cardwidgets.insert(i, w);
     67                }*/
     68                card_widget->setCard( main->deck->at(i) );
     69
     70                qDebug("Zeichne Karte %d von %d", i, deck->count());
     71                QPixmap ret = QPixmap::grabWidget( card_widget /* cardwidgets[i] */, QRect(QPoint(), icon_size));
     72                // sicherheitshalber
     73                card_widget->unsetCard();
     74                return ret;
     75
    3776        } else if(role == Qt::DisplayRole) {
    3877                return tr("Card %1").arg(index.row());
     
    5897}
    5998
    60 void DeckModel::contentsChanged(int left, int right) {
    61         emit dataChanged( index(left), index(right));
     99
     100void DeckModel::contentsChanged(DeckIndex left, DeckIndex right) {
     101        // Ist halt ein casting DeckIndex -> int -> ModelIndex hier noetig,
     102        // daher kann man nicht einfach SIGNAL => SIGNAL patchen
     103
     104        // mit dem folgenden sind Laengenaenderungen nicht abgedeckt:
     105        //emit dataChanged( index(left), index(right));
     106        // dummy damit compiler nicht weint:
     107        { left + right; }
     108        reset();
    62109}
  • punch-card/punch-card-editor/src/qpunchcard/deckmodel.h

    r44 r47  
    22#define DECKMODEL_H
    33
    4 #include <QAbstractListModel>
    5 #include <QVariant>
    6 #include <QList>
    7 #include <QSize>
     4class DeckModel;
    85
     6#include "editorwindow.h"
     7
     8#include "navigator.h"
    99#include "card.h"
    1010#include "widget.h"
    1111
    12 namespace QPunchCard {
     12using namespace QPunchCard;
    1313
    1414class DeckModel : public QAbstractListModel {
    1515        Q_OBJECT
    1616public:
    17         DeckModel(QObject* parent = 0);
     17        DeckModel(EditorWindow* parent = 0);
    1818
    1919        QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
     
    2121        int rowCount(const QModelIndex &parent) const;
    2222
    23         void setDeck(Deck* f);
    24         Deck* getDeck() { return deck; }
     23        QPunchCard::Deck* getDeck() { return deck; }
    2524        bool hasDeck() { return !deck.isNull(); }
    26         QSize getIconSize() { return icon_size; }
     25        QSize getIconSize() const { return icon_size; }
     26        void setIconSizeByWidth(int width);
     27        void setIconSizeByHeight(int height);
    2728
    2829public slots:
    29         void setIconSize(float size) { icon_size *= size; }
    30         void contentsChanged(int left, int right);
     30        //void setIconSize(float size) { icon_size *= size; }
     31        void contentsChanged(DeckIndex left, DeckIndex right);
     32        //void setDeck(QPointer<QPunchCard::Deck> new_deck);
     33        void setDeck(bool is_opened);
    3134
    3235signals:
    3336        // sowas in der Art, fuer EDITING hier
    34         void changeCard(int card, const Column& new_value);
     37        //void changeCard(int card, const Column& new_value);
    3538
    3639private:
    37         QPointer<Deck> deck;
    38         QList< QPointer<CardWidget> > cardwidgets;
     40        QPointer<QPunchCard::Deck> deck;
     41        QPointer<EditorWindow> main;
     42        QPointer<CardWidget> card_widget; // for any use
     43        //QList< QPointer<QPunchCard::CardWidget> > cardwidgets;
    3944        QSize icon_size;
    4045};
    4146
    42 }; // ns
    4347#endif // DECKMODEL_H
  • punch-card/punch-card-editor/src/qpunchcard/widget.h

    r44 r47  
    11#ifndef WIDGET_H
    22#define WIDGET_H
     3
     4namespace QPunchCard {
     5        class CardWidget;
     6}
    37
    48#include "card.h"
  • punch-card/punch-card-editor/src/src.pro.user

    r44 r47  
    8383    <value type="QString" >CONFIG_PROTECT_MASK=/etc/sandbox.d /etc/env.d/java/ /etc/php/cli-php5/ext-active/ /etc/php/cgi-php5/ext-active/ /etc/php/apache2-php5/ext-active/ /etc/udev/rules.d /etc/fonts/fonts.conf /etc/gconf /etc/terminfo /etc/texmf/web2c /etc/texmf/language.dat.d /etc/texmf/language.def.d /etc/texmf/updmap.d /etc/revdep-rebuild</value>
    8484    <value type="QString" >CVS_RSH=ssh</value>
    85     <value type="QString" >DBUS_SESSION_BUS_ADDRESS=unix:abstract=/tmp/dbus-8gv7ikb5YR,guid=c860e76ccc920a21e16e841d4b153f6e</value>
     85    <value type="QString" >DBUS_SESSION_BUS_ADDRESS=unix:abstract=/tmp/dbus-XAq30nyORB,guid=134c1bb9a70db62ad2f24a9f4b1e9bb3</value>
    8686    <value type="QString" >DCCC_PATH=/usr/lib/distcc/bin</value>
    8787    <value type="QString" >DESKTOP_SESSION=xfce</value>
     
    122122    <value type="QString" >QTDIR=/usr</value>
    123123    <value type="QString" >SANE_CONFIG_DIR=/etc/sane.d</value>
    124     <value type="QString" >SESSION_MANAGER=local/sveni:@/tmp/.ICE-unix/3920,unix/sveni:/tmp/.ICE-unix/3920</value>
     124    <value type="QString" >SESSION_MANAGER=local/sveni:@/tmp/.ICE-unix/3927,unix/sveni:/tmp/.ICE-unix/3927</value>
    125125    <value type="QString" >SHELL=/bin/bash</value>
    126126    <value type="QString" >SHLVL=1</value>
    127     <value type="QString" >SSH_AGENT_PID=3912</value>
    128     <value type="QString" >SSH_AUTH_SOCK=/tmp/ssh-DirvIx3911/agent.3911</value>
     127    <value type="QString" >SSH_AGENT_PID=3919</value>
     128    <value type="QString" >SSH_AUTH_SOCK=/tmp/ssh-vvipbU3918/agent.3918</value>
    129129    <value type="QString" >USB_DEVFS_PATH=/dev/bus/usb</value>
    130130    <value type="QString" >USER=sven</value>
     
    133133    <value type="QString" >XDG_CONFIG_DIRS=/etc/xdg</value>
    134134    <value type="QString" >XDG_DATA_DIRS=/usr/local/share:/usr/kde/4.2/share:/usr/kde/3.5/share:/usr/share:/usr/share</value>
    135     <value type="QString" >XDG_SESSION_COOKIE=4ca7d15657433fffff2f84004717d7fc-1259683693.942673-2127992562</value>
     135    <value type="QString" >XDG_SESSION_COOKIE=4ca7d15657433fffff2f84004717d7fc-1260297139.405734-2091533809</value>
    136136    <value type="QString" >XDM_MANAGED=method=classic</value>
    137137    <value type="QString" >_=/usr/bin/xfce4-session</value>
     
    160160    <value type="QString" >CONFIG_PROTECT_MASK=/etc/sandbox.d /etc/env.d/java/ /etc/php/cli-php5/ext-active/ /etc/php/cgi-php5/ext-active/ /etc/php/apache2-php5/ext-active/ /etc/udev/rules.d /etc/fonts/fonts.conf /etc/gconf /etc/terminfo /etc/texmf/web2c /etc/texmf/language.dat.d /etc/texmf/language.def.d /etc/texmf/updmap.d /etc/revdep-rebuild</value>
    161161    <value type="QString" >CVS_RSH=ssh</value>
    162     <value type="QString" >DBUS_SESSION_BUS_ADDRESS=unix:abstract=/tmp/dbus-8gv7ikb5YR,guid=c860e76ccc920a21e16e841d4b153f6e</value>
     162    <value type="QString" >DBUS_SESSION_BUS_ADDRESS=unix:abstract=/tmp/dbus-XAq30nyORB,guid=134c1bb9a70db62ad2f24a9f4b1e9bb3</value>
    163163    <value type="QString" >DCCC_PATH=/usr/lib/distcc/bin</value>
    164164    <value type="QString" >DESKTOP_SESSION=xfce</value>
     
    199199    <value type="QString" >QTDIR=/usr</value>
    200200    <value type="QString" >SANE_CONFIG_DIR=/etc/sane.d</value>
    201     <value type="QString" >SESSION_MANAGER=local/sveni:@/tmp/.ICE-unix/3920,unix/sveni:/tmp/.ICE-unix/3920</value>
     201    <value type="QString" >SESSION_MANAGER=local/sveni:@/tmp/.ICE-unix/3927,unix/sveni:/tmp/.ICE-unix/3927</value>
    202202    <value type="QString" >SHELL=/bin/bash</value>
    203203    <value type="QString" >SHLVL=1</value>
    204     <value type="QString" >SSH_AGENT_PID=3912</value>
    205     <value type="QString" >SSH_AUTH_SOCK=/tmp/ssh-DirvIx3911/agent.3911</value>
     204    <value type="QString" >SSH_AGENT_PID=3919</value>
     205    <value type="QString" >SSH_AUTH_SOCK=/tmp/ssh-vvipbU3918/agent.3918</value>
    206206    <value type="QString" >USB_DEVFS_PATH=/dev/bus/usb</value>
    207207    <value type="QString" >USER=sven</value>
     
    210210    <value type="QString" >XDG_CONFIG_DIRS=/etc/xdg</value>
    211211    <value type="QString" >XDG_DATA_DIRS=/usr/local/share:/usr/kde/4.2/share:/usr/kde/3.5/share:/usr/share:/usr/share</value>
    212     <value type="QString" >XDG_SESSION_COOKIE=4ca7d15657433fffff2f84004717d7fc-1259683693.942673-2127992562</value>
     212    <value type="QString" >XDG_SESSION_COOKIE=4ca7d15657433fffff2f84004717d7fc-1260297139.405734-2091533809</value>
    213213    <value type="QString" >XDM_MANAGED=method=classic</value>
    214214    <value type="QString" >_=/usr/bin/xfce4-session</value>
     
    233233    <value type="QString" >CONFIG_PROTECT_MASK=/etc/sandbox.d /etc/env.d/java/ /etc/php/cli-php5/ext-active/ /etc/php/cgi-php5/ext-active/ /etc/php/apache2-php5/ext-active/ /etc/udev/rules.d /etc/fonts/fonts.conf /etc/gconf /etc/terminfo /etc/texmf/web2c /etc/texmf/language.dat.d /etc/texmf/language.def.d /etc/texmf/updmap.d /etc/revdep-rebuild</value>
    234234    <value type="QString" >CVS_RSH=ssh</value>
    235     <value type="QString" >DBUS_SESSION_BUS_ADDRESS=unix:abstract=/tmp/dbus-8gv7ikb5YR,guid=c860e76ccc920a21e16e841d4b153f6e</value>
     235    <value type="QString" >DBUS_SESSION_BUS_ADDRESS=unix:abstract=/tmp/dbus-i5TbEPyS69,guid=df5ddbcc5e99ee37a66b52c84b1acc98</value>
    236236    <value type="QString" >DCCC_PATH=/usr/lib/distcc/bin</value>
    237237    <value type="QString" >DESKTOP_SESSION=xfce</value>
     
    272272    <value type="QString" >QTDIR=/usr</value>
    273273    <value type="QString" >SANE_CONFIG_DIR=/etc/sane.d</value>
    274     <value type="QString" >SESSION_MANAGER=local/sveni:@/tmp/.ICE-unix/3920,unix/sveni:/tmp/.ICE-unix/3920</value>
     274    <value type="QString" >SESSION_MANAGER=local/sveni:@/tmp/.ICE-unix/3916,unix/sveni:/tmp/.ICE-unix/3916</value>
    275275    <value type="QString" >SHELL=/bin/bash</value>
    276276    <value type="QString" >SHLVL=1</value>
    277     <value type="QString" >SSH_AGENT_PID=3912</value>
    278     <value type="QString" >SSH_AUTH_SOCK=/tmp/ssh-DirvIx3911/agent.3911</value>
     277    <value type="QString" >SSH_AGENT_PID=3908</value>
     278    <value type="QString" >SSH_AUTH_SOCK=/tmp/ssh-RXWoZv3907/agent.3907</value>
    279279    <value type="QString" >USB_DEVFS_PATH=/dev/bus/usb</value>
    280280    <value type="QString" >USER=sven</value>
     
    283283    <value type="QString" >XDG_CONFIG_DIRS=/etc/xdg</value>
    284284    <value type="QString" >XDG_DATA_DIRS=/usr/local/share:/usr/kde/4.2/share:/usr/kde/3.5/share:/usr/share:/usr/share</value>
    285     <value type="QString" >XDG_SESSION_COOKIE=4ca7d15657433fffff2f84004717d7fc-1259683693.942673-2127992562</value>
     285    <value type="QString" >XDG_SESSION_COOKIE=4ca7d15657433fffff2f84004717d7fc-1260047511.776293-2048873734</value>
    286286    <value type="QString" >XDM_MANAGED=method=classic</value>
    287287    <value type="QString" >_=/usr/bin/xfce4-session</value>
Note: See TracChangeset for help on using the changeset viewer.
© 2008 - 2013 technikum29 • Sven Köppel • Some rights reserved
Powered by Trac
Expect where otherwise noted, content on this site is licensed under a Creative Commons 3.0 License