root/deus/AuthorInterface_impl.cpp

/**
 * AuthorInterface_impl.cpp
 *
 * Concrete extension of AuthorInterface UI
 */

#include "AuthorInterface_impl.h"

#include <qlayout.h>
#include <qslider.h>
#include <qstring.h>
#include <qpushbutton.h>
#include <qmultilineedit.h>
#include <qtable.h>
#include <qlabel.h>
#include <qlineedit.h>
#include <qlistview.h>
#include <qmessagebox.h>

AuthorForm_impl::AuthorForm_impl( QWidget* parent, const char* name, WFlags fl)
        : AuthorForm(parent, name, fl)
{
        is_closing = false;
        viewing = STORY_VIEW;
        current_story = NULL;
        selected = NULL;
        ld = NULL;

        gd = new AuthorGraphDisplay(this, (QWidget*)Frame, "graph_display");
        QBoxLayout * l = new QVBoxLayout((QWidget *)Frame);     // auto deallocated
        l->addWidget(gd);       

        connect((QObject *)CenterButton, SIGNAL(clicked()), gd, SLOT(center()));
        connect((QObject *)FitButton, SIGNAL(clicked()), gd, SLOT(fit()));
        connect((QObject *)ZoomSlider, SIGNAL(valueChanged(int)), gd, SLOT(setZoom(int)));
        connect(gd, SIGNAL(zoomChanged(int)), (QObject *)ZoomSlider, SLOT(setValue(int)));
        ZoomSlider->setValue(DEFAULT_ZOOM);

        connect((QObject *)NewNodeButton, SIGNAL(clicked()), this, SLOT(addNode()));
        connect((QObject *)NewNodeName, SIGNAL(textChanged()), this, SLOT(newNodeTextChanged()));
        connect((QObject *)ReturnButton, SIGNAL(clicked()), this, SLOT(storyView()));
        connect((QObject *)Table, SIGNAL(valueChanged(int,int)), this, SLOT(cellValueChanged(int,int)));
        connect((QObject *)SaveName, SIGNAL(textChanged(const QString &)), this, SLOT(saveTextChanged(const QString &)));
        connect((QObject *)SaveButton, SIGNAL(clicked()), this, SLOT(save()));
        connect((QObject *)LoadButton, SIGNAL(clicked()), this, SLOT(load()));

        connect((QObject *)DoneButton, SIGNAL(clicked()), this, SLOT(close()));

        Table->setSelectionMode(QTable::NoSelection);
}


void
AuthorForm_impl::addNode()
{
        if (viewing == STORY_VIEW) 
        {
                if (selected == NULL && story_root != NULL) 
                        printf("Error: BZZZZT, how did you get here?");
                else if (story_root == NULL) 
                {
                        // this is the first node, make it the root
                        story_root = new StoryNode();
                        story_root->name = NewNodeName->text();
                        changeSelected(story_root);
                        gd->fit();
                }
                else if (selected != NULL) 
                {
                        // add a new node, selected is parent
                        StoryNode *n = new StoryNode();
                        n->name = NewNodeName->text();
                        n->parent = (StoryNode *)selected;
                        ((StoryNode *)selected)->next.push_back(n);
                        changeSelected(n);
                }
                else printf("Error: BZZZZT, how did you get here?");
        }

        else if (viewing == KEYFRAME_VIEW) 
        {
                ASSERT(current_story);
                if (selected == NULL && current_story->frame != NULL)
                        printf("Error: BZZZZT, how did you get here?");
                else if (current_story->frame == NULL) 
                {
                        // this is the first keyframe node, make it the frame
                        current_story->frame = new KeyFrameNode();
                        current_story->frame->name = NewNodeName->text();
                        changeSelected(current_story->frame);
                        gd->fit();
                }
                else if (selected != NULL)
                {
                        // add a new node, selected is parent
                        KeyFrameNode *n = new KeyFrameNode();
                        n->name = NewNodeName->text();
                        n->parent = (KeyFrameNode *)selected;
                        ((KeyFrameNode *)selected)->preconds.push_back(n);
                        changeSelected(n);
                }
                else printf("Error: BZZZZT, how did you get here?");
        }

        else printf("Error: What kind of view is this? %d\n", viewing);

        NewNodeName->clear();
        NewNodeButton->setEnabled(false);

        gd->repaint();
}


void
AuthorForm_impl::newNodeTextChanged()
{
        QString text = NewNodeName->text();

        if ((text.length() > 0) && ( 
                ((viewing == STORY_VIEW) && (selected || story_root == NULL)) ||
                ((viewing == KEYFRAME_VIEW) && (selected || current_story->frame == NULL))
           ))
                NewNodeButton->setEnabled(true);
        else
                NewNodeButton->setEnabled(false);
}


void
AuthorForm_impl::saveTextChanged(const QString &text)
{
        if (text.length() > 0)  SaveButton->setEnabled(true);
        else                                    SaveButton->setEnabled(false);
}


void
AuthorForm_impl::changeSelected(AuthorNode *n)
{
        if (selected) selected->icon->deselect();

        if (!n) {
                // Hack to make sure things don't crash if cell is being edited
                for (int x = 0; x < Table->numRows(); x++)
                        for (int y = 0; y < Table->numCols(); y++) {
                                Table->clearCellWidget(x,y);
                                Table->clearCell(x,y);
                        }
                Table->setEnabled(false);
        }
        else
        {
                n->icon->select();
                if (n->type == NODE_STORY) {
                        // Hack to make sure things don't crash if cell is being edited
                        for (int x = 0; x < Table->numRows(); x++)
                                for (int y = 0; y < Table->numCols(); y++) {
                                        Table->clearCellWidget(x,y);
                                        Table->clearCell(x,y);
                                }
                        Table->setEnabled(false);
                }
                else {
                        Table->setEnabled(true);

                        // Populate table
                        for (int i = 0; i < NUM_COND; i++)
                                for (int j = 0; j < NUM_COND; j++)
                                        if (((KeyFrameNode*)n)->conditions.conditions[i][j].size() > 0)
                                                Table->setText(i, j, ((KeyFrameNode*)n)->conditions.conditions[i][j].c_str());
                                        else Table->clearCell(i,j);
                }
        }

        selected = n;
        gd->repaint();
}


void
AuthorForm_impl::storyView()
{
        ViewLabel->setText("Story View");
        ReturnButton->setEnabled(false);
        viewing = STORY_VIEW;
        changeSelected(NULL);

        gd->fit();
        gd->repaint();
}

void
AuthorForm_impl::keyframeView(StoryNode* current)
{
        ASSERT(current);

        ViewLabel->setText("Keyframe View");
        ReturnButton->setEnabled(true);
        viewing = KEYFRAME_VIEW;
        current_story = current;
        changeSelected(current->frame);

        gd->fit();
        gd->repaint();
}


void
AuthorForm_impl::cellValueChanged(int x, int y)
{
        if (selected && viewing == KEYFRAME_VIEW) {
                QTableItem *i = Table->item(x,y);

                if (CheckValidOps(string(Table->text(x,y)), x, y) || (Table->text(x,y).length() == 0))
                {
                        ((KeyFrameNode *)selected)->conditions.conditions[x][y] = 
                                Table->text(x,y);
                        QPixmap p;
                        i->setPixmap(p);
                }
                else
                {
                        QPixmap p(100,100);
                        p.fill(QColor(255,0,0));
                        i->setPixmap(p);
                }
        }
}




/************************************************
 * Save()/Load()/Delete() implementations --
 *      This just seemed like a convenient place to put them...
 ************************************************/
void
AuthorForm_impl::save()
{
        if (!conn) {printf("No DB connection!\n"); return;}
        char query[256], escape[256];
        MYSQL_ROW row;
        MYSQL_RES *result;
        int story_id = -1;

        // See if it already exists
        mysql_escape_string(escape, SaveName->text().latin1(), strlen(SaveName->text().latin1()));
        _snprintf(query, 256, 
                "SELECT story_id FROM Stories "
                "WHERE name = '%s'", escape);
        mysql_query(conn, query);
        if (mysql_error(conn)[0] != '\0') printf("%s\n", mysql_error(conn));
        result = mysql_store_result(conn);
        if (row = mysql_fetch_row(result))
                del_story(atoi(row[0]));        // Make way for new data
        mysql_free_result(result);

        // Insert data
        _snprintf(query, 256, 
                "INSERT INTO Stories "
                "VALUES(0, '%s', NOW())", escape);
        mysql_query(conn, query);
        if (mysql_error(conn)[0] != '\0') printf("%s\n", mysql_error(conn));
        story_id = mysql_insert_id(conn);       // Auto increment field

        if (story_root) story_root->save(story_id, 0);
}


int
StoryNode::save(int story_id, int parent_id)
{
        if (!conn) {printf("No DB connection!\n"); return -1;}
        char query[256], escape[256];
        int node_id = -1, frame_id = -1;

        // Save this node's frame
        if (frame) frame_id = frame->save(story_id, 0);

        // Save this node
        mysql_escape_string(escape, name.c_str(), strlen(name.c_str()));
        _snprintf(query, 256,
                "INSERT INTO StoryNodes "
                "VALUES(0, %d, '%s', %d, %d, %d, %d)",
                story_id, escape, parent_id, frame_id, icon->ul_x, icon->ul_y);
        mysql_query(conn, query);
        if (mysql_error(conn)[0] != '\0') printf("%s\n", mysql_error(conn));
        node_id = mysql_insert_id(conn);        // Auto increment field

        // Save children
        std::vector<StoryNode*>::iterator It;
        for (It = next.begin(); It != next.end(); It++)
                if (*It) (*It)->save(story_id, node_id);

        return node_id;
}


int
KeyFrameNode::save(int story_id, int parent_id)
{
        if (!conn) {printf("No DB connection!\n"); return -1;}
        char query[256], escape[256];
        int node_id = -1;

        // Save this node
        mysql_escape_string(escape, name.c_str(), strlen(name.c_str()));
        _snprintf(query, 256,
                "INSERT INTO KeyFrameNodes "
                "VALUES(0, %d, '%s', %d, %d, %d)",
                story_id, escape, parent_id, icon->ul_x, icon->ul_y);
        mysql_query(conn, query);
        if (mysql_error(conn)[0] != '\0') printf("%s\n", mysql_error(conn));
        node_id = mysql_insert_id(conn);        // Auto increment field

        // Save this node's conditions
        for (int x = 0; x < NUM_COND; x++)
                for (int y = 0; y < NUM_COND; y++)
                        if (conditions.conditions[x][y].size() > 0)
                        {
                                mysql_escape_string(escape, conditions.conditions[x][y].c_str(), 
                                        strlen(conditions.conditions[x][y].c_str()));
                                _snprintf(query, 256,
                                        "INSERT INTO Conditions "
                                        "VALUES(%d, %d, %d, %d, '%s')",
                                        node_id, story_id, x, y, escape);
                                mysql_query(conn, query);
                                if (mysql_error(conn)[0] != '\0') printf("%s\n", mysql_error(conn));
                        }

        // Save children
        std::vector<KeyFrameNode*>::iterator It;
        for (It = preconds.begin(); It != preconds.end(); It++)
                if (*It) (*It)->save(story_id, node_id);

        return node_id;
}


void
AuthorForm_impl::del_story(int story_id)
{
        if (!conn) {printf("No DB connection!\n"); return;}
        char query[256];

        // Stories...
        _snprintf(query, 256,
                "DELETE FROM Stories WHERE story_id = %d", story_id);
        mysql_query(conn, query);
        if (mysql_error(conn)[0] != '\0') printf("%s\n", mysql_error(conn));

        // Conditions...
        _snprintf(query, 256,
                "DELETE FROM Conditions WHERE story_id = %d", story_id);
        mysql_query(conn, query);
        if (mysql_error(conn)[0] != '\0') printf("%s\n", mysql_error(conn));

        // StoryNodes...
        _snprintf(query, 256,
                "DELETE FROM StoryNodes WHERE story_id = %d", story_id);
        mysql_query(conn, query);
        if (mysql_error(conn)[0] != '\0') printf("%s\n", mysql_error(conn));

        // KeyFrameNodes...
        _snprintf(query, 256,
                "DELETE FROM KeyFrameNodes WHERE story_id = %d", story_id);
        mysql_query(conn, query);
        if (mysql_error(conn)[0] != '\0') printf("%s\n", mysql_error(conn));
}


void 
AuthorForm_impl::del_story()
{
        if (!ld) return;

        if (!QMessageBox::warning(this, "DEUS", "Delete for good?", "Yes", "No way!", 0, 0, 1)) {
                del_story(atoi(ld->ListView->selectedItem()->text(0)));
                populateLoad();
        }
}


void
StoryNode::del_node()
{
        // Clear out children
        std::vector<StoryNode*>::iterator It;
        for (It = next.begin(); It != next.end(); It++) {
                if (*It) (*It)->del_node();
                delete *It;
        }
        
        // Clear out frame
        if (frame)      {
                frame->del_node();
                delete frame;
        }

        delete icon;
}


void
KeyFrameNode::del_node()
{
        // Clear out children
        std::vector<KeyFrameNode*>::iterator It;
        for (It = preconds.begin(); It != preconds.end(); It++) {
                if (*It) (*It)->del_node();
                delete *It;
        }

        delete icon;
}


void
AuthorForm_impl::load(int story_id)
{
        // First, clear out what's in memory
        if (story_root) {
                story_root->del_node();
                delete story_root;
                story_root = NULL;
                selected = NULL;
        }

        // Then, start loading from the story root
        if (!conn) {printf("No DB connection!\n"); return;}
        char query[256];
        MYSQL_ROW row;
        MYSQL_RES *result;

        // Story
        _snprintf(query, 256, 
                "SELECT name FROM Stories "
                "WHERE story_id = %d", story_id);
        mysql_query(conn, query);
        if (mysql_error(conn)[0] != '\0') printf("%s\n", mysql_error(conn));
        result = mysql_store_result(conn);
        if (row = mysql_fetch_row(result))
                        SaveName->setText(row[0]);
        mysql_free_result(result);


        // StoryNodes
        int cur_id; StoryNode* cur_node; std::pair<int,StoryNode*> cur_pair;
        map<int,StoryNode*> story_nodes;        // node_id -> Node*
        map<int,StoryNode*> saved_nodes;
        story_nodes.insert(std::pair<int,StoryNode*>(0,NULL));
        
        while (story_nodes.size() > 0)
        {
                cur_pair = *(story_nodes.begin());
                cur_id = cur_pair.first;
                cur_node = cur_pair.second;
                story_nodes.erase(cur_id);

                _snprintf(query, 256, 
                        "SELECT * FROM StoryNodes "
                        "WHERE story_id = %d "
                        "       AND parent_id = %d", story_id, cur_id);
                mysql_query(conn, query);
                if (mysql_error(conn)[0] != '\0') printf("%s\n", mysql_error(conn));
                result = mysql_store_result(conn);
                while (row = mysql_fetch_row(result))
                {
                        StoryNode *n = new StoryNode();
                        n->name = row[2];
                        n->parent = cur_node;
                        n->icon->ul_x = atoi(row[5]);
                        n->icon->ul_y = atoi(row[6]);
                        n->icon->draw();

                        story_nodes.insert(std::pair<int,StoryNode*>(atoi(row[0]), n));
                        saved_nodes.insert(std::pair<int,StoryNode*>(atoi(row[4]), n));
                        
                        if (cur_node) cur_node->next.push_back(n);
                        else story_root = n;
                }               
                mysql_free_result(result);
        }


        // KeyFrameNodes
        KeyFrameNode* cur_key; int cur_key_id; std::pair<int,KeyFrameNode*> cur_key_pair;
        std::map<int,KeyFrameNode*> keyframe_nodes, saved_keys;
        std::map<int,StoryNode*>::iterator It;
        for (It = saved_nodes.begin(); It != saved_nodes.end(); It++)
        {
                cur_id = It->first;             // this is now the frame_id
                cur_node = It->second;

                // root of each keyframe
                _snprintf(query, 256, 
                        "SELECT * FROM KeyFrameNodes "
                        "WHERE node_id = %d ", cur_id);
                mysql_query(conn, query);
                if (mysql_error(conn)[0] != '\0') printf("%s\n", mysql_error(conn));
                result = mysql_store_result(conn);
                if (row = mysql_fetch_row(result)) 
                {
                        KeyFrameNode *n = new KeyFrameNode();
                        n->name = row[2];
                        n->parent = NULL;
                        n->icon->ul_x = atoi(row[4]);
                        n->icon->ul_y = atoi(row[5]);
                        n->icon->draw();

                        keyframe_nodes.insert(std::pair<int,KeyFrameNode*>(atoi(row[0]), n));
                        saved_keys.insert(std::pair<int,KeyFrameNode*>(atoi(row[0]), n));
                        cur_node->frame = n;
                }
                mysql_free_result(result);
                        
                // keyframe children
                while (keyframe_nodes.size() > 0)
                {
                        cur_key_pair = *(keyframe_nodes.begin());
                        cur_key_id = cur_key_pair.first;
                        cur_key = cur_key_pair.second;
                        keyframe_nodes.erase(cur_key_id);

                        _snprintf(query, 256, 
                                "SELECT * FROM KeyFrameNodes "
                                "WHERE parent_id = %d ", cur_key_id);
                        mysql_query(conn, query);
                        if (mysql_error(conn)[0] != '\0') printf("%s\n", mysql_error(conn));
                        result = mysql_store_result(conn);
                        while (row = mysql_fetch_row(result)) 
                        {
                                KeyFrameNode *n = new KeyFrameNode();
                                n->name = row[2];
                                n->parent = cur_key;
                                n->icon->ul_x = atoi(row[4]);
                                n->icon->ul_y = atoi(row[5]);
                                n->icon->draw();

                                keyframe_nodes.insert(std::pair<int,KeyFrameNode*>(atoi(row[0]), n));
                                saved_keys.insert(std::pair<int,KeyFrameNode*>(atoi(row[0]), n));
                                cur_key->preconds.push_back(n);
                        }
                        mysql_free_result(result);
                }
        }

        
        // Conditions
        std::map<int,KeyFrameNode*>::iterator It2;
        for (It2 = saved_keys.begin(); It2 != saved_keys.end(); It2++)
        {
                cur_key_id = It2->first;
                cur_key = It2->second;

                _snprintf(query, 256, 
                        "SELECT * FROM Conditions "
                        "WHERE node_id = %d ", cur_key_id);
                mysql_query(conn, query);
                if (mysql_error(conn)[0] != '\0') printf("%s\n", mysql_error(conn));
                result = mysql_store_result(conn);
                while (row = mysql_fetch_row(result)) 
                        cur_key->conditions.conditions[atoi(row[2])][atoi(row[3])] = row[4];
                mysql_free_result(result);
        }

        storyView();    
}


void
AuthorForm_impl::load()
{
        delete ld;
        ld = new LoadDialog(this, "load_story", true);
        connect((QObject *)ld->LoadButton, SIGNAL(clicked()), (QObject *)ld, SLOT(accept()));
        connect((QObject *)ld->CancelButton, SIGNAL(clicked()), (QObject *)ld, SLOT(reject()));
        connect((QObject *)ld->DeleteButton, SIGNAL(clicked()), this, SLOT(del_story()));
        
        // populate load dialog
        populateLoad();

        if (ld->exec())
                load(atoi(ld->ListView->selectedItem()->text(0)));
}


void 
AuthorForm_impl::populateLoad()
{
        if (!ld) return;
        ld->ListView->clear();

        // Populate the list
        if (!conn) {printf("No DB connection!\n"); return;}
        MYSQL_ROW row;
        MYSQL_RES *result;
        QListViewItem *lv = NULL;       // this will be the selected item

        mysql_query(conn, "SELECT * FROM Stories");
        if (mysql_error(conn)[0] != '\0') printf("%s\n", mysql_error(conn));
        result = mysql_store_result(conn);
        while (row = mysql_fetch_row(result)) 
        {
                QListViewItem * li = new QListViewItem(ld->ListView, row[0], row[1], row[2]);
                if (!lv) lv = li;
        }
        mysql_free_result(result);
        ld->ListView->setSelected(lv, true);
}