Initial git commit.

1 files changed, 1494 insertions, 0 deletions

diff --git a/quacker/graphicalboard.cpp b/quacker/graphicalboard.cpp
new file mode 100644
index 0000000..194d4c9
--- /dev/null
+++ b/quacker/graphicalboard.cpp
@@ -0,0 +1,1494 @@
+/*
+ *  Quackle -- Crossword game artificial intelligence and analysis tool
+ *  Copyright (C) 2005-2006 Jason Katz-Brown and John O'Laughlin.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  
+ *  02110-1301  USA
+ */
+
+#include <iostream>
+#include <math.h>
+
+#include <QtGui>
+
+#include <game.h>
+#include <move.h>
+#include <boardparameters.h>
+#include <quackleio/util.h>
+
+#include "geometry.h"
+#include "graphicalboard.h"
+#include "quackersettings.h"
+#include "settings.h"
+
+const double GraphicalBoardFrame::s_markOtherLengthMultiplier = 0.6;
+
+const double TileWidget::s_defaultLetterScale = 0.7;
+
+GraphicalBoard::GraphicalBoard(QWidget *parent)
+    : BoardWithQuickEntry(parent)
+{
+    m_boardFrame = new GraphicalBoardFrame;
+    connect(m_boardFrame, SIGNAL(localCandidateChanged(const Quackle::Move &)), this, SLOT(setLocalCandidate(const Quackle::Move &)));
+
+    m_boardWrapper = new QWidget;
+
+    QVBoxLayout *helperLayout = new QVBoxLayout(m_boardWrapper);
+    Geometry::setupInnerLayout(helperLayout);
+
+    m_vlayout->addWidget(m_boardWrapper);
+    helperLayout->addWidget(m_boardFrame);
+    m_vlayout->setStretchFactor(m_boardWrapper, 10);
+
+    m_subviews.push_back(m_boardFrame);
+    connectSubviewSignals();
+}
+
+GraphicalBoard::~GraphicalBoard()
+{
+}
+
+void GraphicalBoard::expandToFullWidth()
+{
+    m_boardFrame->expandToSize(m_boardWrapper->size());
+}
+
+void GraphicalBoard::resizeEvent(QResizeEvent * /* event */)
+{
+    QTimer::singleShot(0, this, SLOT(expandToFullWidth()));
+}
+
+///////////////////
+
+GraphicalBoardFrame::GraphicalBoardFrame(QWidget *parent)
+    : View(parent), m_ignoreRack(false), m_alwaysShowVerboseLabels(false), m_boardSize(0, 0), m_sideLength(0)
+{
+    setFrameStyle(QFrame::StyledPanel | QFrame::Raised);
+    setLineWidth(2);
+
+    setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Maximum);
+    setFocusPolicy(Qt::StrongFocus);
+
+    QColor color(PixmapCacher::self()->markColor);
+    QPalette customPalette;
+    customPalette.setColor(QPalette::Light, color.light(s_highlightFactor));
+    customPalette.setColor(QPalette::Mid, color);
+    customPalette.setColor(QPalette::Dark, color.dark(130));
+    setPalette(customPalette);
+
+    PixmapCacher::self()->tileFont = font();
+#if defined(Q_WS_WIN)
+    PixmapCacher::self()->tileFont.setFamily(QString("Arial"));
+#endif // Q_WS_WIN
+
+    //expandToSize(QSize(15 * 25, 15 * 25));
+
+    m_board.prepareEmptyBoard();
+    m_candidate = Quackle::Move::createNonmove();
+    resetArrow();
+}
+
+GraphicalBoardFrame::~GraphicalBoardFrame()
+{
+    PixmapCacher::cleanUp();
+}
+
+void GraphicalBoardFrame::staticDrawPosition(const Quackle::GamePosition &position, const QSize &size, QPixmap *pixmap)
+{
+    GraphicalBoardFrame doozy;
+    doozy.positionChanged(position);
+    doozy.expandToSize(size);
+    doozy.generateBoardPixmap(pixmap);
+}
+
+void GraphicalBoardFrame::positionChanged(const Quackle::GamePosition &position)
+{
+    m_board = position.board();
+    m_rack = position.currentPlayer().rack();
+    m_ignoreRack = !position.currentPlayer().racksAreKnown();
+
+    m_board.updateBritishness();
+
+    resetArrow();
+    m_candidate = position.moveMade();
+
+    prepare();
+}
+
+void GraphicalBoardFrame::prepare()
+{
+    drawBoard(m_board);
+    drawMove(m_candidate);
+
+    if (isOnBoard(m_arrowRoot))
+        drawArrow(m_arrowRoot, m_arrowDirection);
+
+    generateBoardPixmap(&m_pixmap);
+    update();
+}
+
+void GraphicalBoardFrame::expandToSize(const QSize &maxSize)
+{
+    m_maxSize = maxSize;
+
+    // if empty we delay this call
+    if (m_boardSize.isEmpty())
+        return;
+    else
+    {
+        // TODO we get here too often while resizing
+
+        // do calculations in terms of one axis, arbitrarily, width
+        QSize lastCandidate;
+        QSize candidate(0, 0);
+        do
+        {
+            lastCandidate = candidate;
+            candidate += m_boardSize;
+        }
+        while (candidate.width() < m_maxSize.width() && candidate.height() < m_maxSize.height());
+
+        const int maxWidth = lastCandidate.width();
+
+        const double numBlocksWidthwise = ((double)m_boardSize.width() + s_markOtherLengthMultiplier);
+
+        m_sideLength = (int)floor((maxWidth - frameWidth() * 2) / numBlocksWidthwise);
+
+        if (m_sideLength < 0)
+            m_sideLength = 0;
+
+        resizeWidgets(m_sideLength);
+
+        const int shorterMarkWidth = markAt(QSize(0, 0))->size().width();
+        const int shorterMarkHeight = markAt(QSize(0, 0))->size().height();
+        m_tilesOffset.setX(shorterMarkWidth);
+        m_tilesOffset.setY(shorterMarkHeight);
+
+        m_sizeForBoard.setWidth(shorterMarkWidth + m_boardSize.width() * m_sideLength);
+        m_sizeForBoard.setHeight(shorterMarkHeight + m_boardSize.height() * m_sideLength);
+        setMaximumSize(m_sizeForBoard + QSize(frameWidth() * 2, frameWidth() * 2));
+
+        prepare();
+    }
+}
+
+void GraphicalBoardFrame::generateBoardPixmap(QPixmap *pixmap)
+{
+    if (m_sizeForBoard.isEmpty())
+    {
+        *pixmap = QPixmap(0, 0);
+        return;
+    }
+
+    *pixmap = QPixmap(m_sizeForBoard);
+    QPainter painter(pixmap);
+
+    for (QSize currentTile(0, 0); currentTile.height() < m_boardSize.height(); currentTile.setHeight(currentTile.height() + 1))
+    {
+        for (currentTile.setWidth(0); currentTile.width() < m_boardSize.width(); currentTile.setWidth(currentTile.width() + 1))
+        {
+            TileWidget *tile = tileAt(currentTile);
+            if (!tile)
+                continue;
+
+            painter.drawPixmap(coordinatesOfTile(currentTile), tile->tilePixmap());
+        }
+    }
+
+    for (int row = 0; row <= m_boardSize.height(); ++row)
+    {
+        const QSize location(0, row);
+        painter.drawPixmap(coordinatesOfMark(location), markAt(location)->tilePixmap());
+    }
+
+    for (int col = 1; col <= m_boardSize.width(); ++col)
+    {
+        const QSize location(col, 0);
+        painter.drawPixmap(coordinatesOfMark(location), markAt(location)->tilePixmap());
+    }
+}
+
+void GraphicalBoardFrame::drawBoard(const Quackle::Board &board)
+{
+    QSize newBoardSize(board.width(), board.height());
+
+    if (m_boardSize != newBoardSize)
+    {
+        // if it was empty, we need to recalculate
+        // tile widths
+        bool wasEmpty = m_boardSize.isEmpty();
+        
+        deleteWidgets();
+        m_boardSize = newBoardSize;
+        recreateWidgets();
+
+        if (wasEmpty)
+            expandToSize(m_maxSize);
+    }
+
+    for (QSize currentTile(0, 0); currentTile.height() < m_boardSize.height(); currentTile.setHeight(currentTile.height() + 1))
+    {
+        for (currentTile.setWidth(0); currentTile.width() < m_boardSize.width(); currentTile.setWidth(currentTile.width() + 1))
+        {
+            Quackle::Board::TileInformation info(board.tileInformation(currentTile.height(), currentTile.width()));
+
+            TileWidget *tile = tileAt(currentTile);
+            if (!tile)
+                continue;
+
+            tile->setInformation(info);
+
+            tile->setArrowDirection(NoArrow);
+            tile->setCemented(info.tileType == Quackle::Board::LetterTile);
+            tile->prepare();
+        }
+    }
+}
+
+TileWidget *GraphicalBoardFrame::tileAt(const QSize &loc)
+{
+    QSize mapEntry(loc + QSize(1, 1));
+    if (!m_tileWidgets.contains(mapEntry))
+    {
+        cerr << "error! graphical board can't find a tile" << endl;
+        return 0;
+    }
+
+    return m_tileWidgets.value(mapEntry);
+}
+
+QSize GraphicalBoardFrame::locationForPosition(const QPoint &pos)
+{
+    QPoint semiRegularized = (pos - QPoint(frameWidth(), frameWidth()) - m_tilesOffset);
+    QSize finalSize((int)floor((double)semiRegularized.x() / m_sideLength), (int)floor((double)semiRegularized.y() / m_sideLength));
+    return finalSize;
+}
+
+TileWidget *GraphicalBoardFrame::markAt(const QSize &loc)
+{
+    if (!m_tileWidgets.contains(loc))
+    {
+        cerr << "error! graphical board can't find a mark" << endl;
+        return 0;
+    }
+
+    return m_tileWidgets.value(loc);
+}
+
+void GraphicalBoardFrame::addTile(const QSize &loc, TileWidget *tile)
+{
+    m_tileWidgets.insert(loc + QSize(1, 1), tile);
+}
+
+void GraphicalBoardFrame::removeTile(const QSize &loc)
+{
+    m_tileWidgets.remove(loc + QSize(1, 1));
+}
+
+void GraphicalBoardFrame::addMark(const QSize &loc, MarkWidget *tile)
+{
+    m_tileWidgets.insert(loc, tile);
+}
+
+void GraphicalBoardFrame::removeMark(const QSize &loc)
+{
+    m_tileWidgets.remove(loc);
+}
+
+QPoint GraphicalBoardFrame::coordinatesOfTile(const QSize &loc)
+{
+    QPoint point(loc.width(), loc.height());
+    return (point * m_sideLength) + m_tilesOffset;
+}
+
+QPoint GraphicalBoardFrame::coordinatesOfMark(const QSize &loc)
+{
+    QPoint point(loc.width(), loc.height());
+
+    if (loc == QSize(0, 0))
+        return point;
+    
+    QPoint vector(point.x() == 0? 0 : 1, point.y() == 0? 0 : 1);
+
+    return ((point - vector) * m_sideLength + QPoint(m_tilesOffset.x() * vector.x(), m_tilesOffset.y() * vector.y()));
+}
+
+void GraphicalBoardFrame::drawMove(const Quackle::Move &move)
+{
+    if (move.action == Quackle::Move::Place)
+    {
+        if (move.tiles().empty())
+            return;
+
+        const QSize startTile(move.startcol, move.startrow);
+
+        const Quackle::LetterString::const_iterator end(move.tiles().end());
+        int i = 0;
+        for (Quackle::LetterString::const_iterator it = move.tiles().begin(); it != end; ++it, ++i)
+        {
+            // if this is a cemented letter that we shouldn't overwrite
+            if (move.isAlreadyOnBoard(*it))
+                continue;
+
+            QSize currentTile(startTile);
+            if (move.horizontal)
+                currentTile.setWidth(currentTile.width() + i);
+            else
+                currentTile.setHeight(currentTile.height() + i);
+
+            TileWidget *tileWidget = tileAt(currentTile);
+            if (!tileWidget)
+                continue;
+
+            Quackle::Board::TileInformation info;
+            info.tileType = Quackle::Board::LetterTile;
+
+            info.isBlank = QUACKLE_ALPHABET_PARAMETERS->isBlankLetter(*it);
+            info.letter = QUACKLE_ALPHABET_PARAMETERS->clearBlankness(*it);
+
+            tileWidget->setInformation(info);
+            tileWidget->setCemented(false);
+            tileWidget->prepare();
+        }
+    }
+}
+
+void GraphicalBoardFrame::drawArrow(const QSize &location, int arrowDirection)
+{
+    TileWidget *tile = tileAt(location);
+    if (!tile)
+        return;
+    
+    tile->setArrowDirection(arrowDirection);
+    tile->prepare();
+}
+
+void GraphicalBoardFrame::deleteWidgets()
+{
+    if (m_boardSize.isEmpty())
+        return;
+
+    for (QSize currentTile(0, 0); currentTile.height() < m_boardSize.height(); currentTile.setHeight(currentTile.height() + 1))
+    {
+        for (currentTile.setWidth(0); currentTile.width() < m_boardSize.width(); currentTile.setWidth(currentTile.width() + 1))
+        {
+            delete tileAt(currentTile);
+            removeTile(currentTile);
+        }
+    }
+
+    for (int row = 0; row <= m_boardSize.height(); ++row)
+    {
+        delete markAt(QSize(0, row));
+        removeMark(QSize(0, row));
+    }
+
+    for (int col = 1; col <= m_boardSize.width(); ++col)
+    {
+        delete markAt(QSize(col, 0));
+        removeMark(QSize(col, 0));
+    }
+}
+
+void GraphicalBoardFrame::recreateWidgets()
+{
+    Quackle::Board emptyBoard;
+    emptyBoard.prepareEmptyBoard();
+
+    for (QSize currentTile(0, 0); currentTile.height() < m_boardSize.height(); currentTile.setHeight(currentTile.height() + 1))
+    {
+        for (currentTile.setWidth(0); currentTile.width() < m_boardSize.width(); currentTile.setWidth(currentTile.width() + 1))
+        {
+            TileWidget *newTile = new TileWidget;
+
+            newTile->setLocation(currentTile);
+            newTile->setAlwaysShowVerboseLabels(m_alwaysShowVerboseLabels);
+            newTile->setOriginalInformation(emptyBoard.tileInformation(currentTile.height(), currentTile.width()));
+
+            addTile(currentTile, newTile);
+        }
+    }
+
+    for (int row = 0; row <= m_boardSize.height(); ++row)
+    {
+        MarkWidget *newMark = new MarkWidget;
+
+        if (row == 0)
+            newMark->setCapstone();
+        else
+            newMark->setRow(row);
+
+        addMark(QSize(0, row), newMark);
+    }
+
+    for (int col = 1; col <= m_boardSize.width(); ++col)
+    {
+        MarkWidget *newMark = new MarkWidget;
+        newMark->setCol(col);
+        addMark(QSize(col, 0), newMark);
+    }
+}
+
+void GraphicalBoardFrame::resizeWidgets(int sideLength)
+{
+    PixmapCacher::self()->invalidate();
+
+    bool firstTile = true;
+    for (QSize currentTile(0, 0); currentTile.height() < m_boardSize.height(); currentTile.setHeight(currentTile.height() + 1))
+    {
+        for (currentTile.setWidth(0); currentTile.width() < m_boardSize.width(); currentTile.setWidth(currentTile.width() + 1))
+        {
+            TileWidget *tile = tileAt(currentTile);
+            if (!tile)
+                continue;
+
+            tile->setSideLength(sideLength);
+
+            if (firstTile)
+            {
+                emit tileFontChanged(tile->actualLetterFont());
+                firstTile = false;
+            }
+        }
+    }
+
+    for (int row = 0; row <= m_boardSize.height(); ++row)
+    {
+        TileWidget *mark = markAt(QSize(0, row));
+        mark->setSideLength(sideLength);
+    }
+
+    for (int col = 1; col <= m_boardSize.width(); ++col)
+    {
+        TileWidget *mark = markAt(QSize(col, 0));
+        mark->setSideLength(sideLength);
+    }
+}
+
+void GraphicalBoardFrame::flushPixmapsAndRedraw()
+{
+    m_boardSize = QSize();
+    prepare();
+}
+
+void GraphicalBoardFrame::paintEvent(QPaintEvent *event)
+{
+    QPainter painter(this);
+    painter.drawPixmap(contentsRect().topLeft(), m_pixmap);
+    painter.end();
+
+    QFrame::paintEvent(event);
+}
+
+void GraphicalBoardFrame::mousePressEvent(QMouseEvent *event)
+{
+    setFocus();
+
+    if (!wantMousePressEvent(event))
+    {
+        event->ignore();
+        return;
+    }
+
+    const QPoint pos(event->pos());
+
+    QSize location = locationForPosition(pos);
+
+    if (location.isValid())
+        tileClicked(location, event);
+
+    event->accept();
+}
+
+void GraphicalBoardFrame::keyPressEvent(QKeyEvent *event)
+{
+    enum { Backspace = 0, Delete, Submit, Commit, Append } mode;
+
+    switch (event->key())
+    {
+    case Qt::Key_Backspace:
+        mode = Backspace;
+        break;
+
+    case Qt::Key_Delete:
+        mode = Delete;
+        break;
+
+    case Qt::Key_Return:
+    case Qt::Key_Enter:
+        mode = event->modifiers() & Qt::ShiftModifier || event->modifiers() & Qt::ControlModifier || event->modifiers() & Qt::MetaModifier? Commit : Submit;
+        break;
+
+    default:
+        mode = Append;
+        break;
+    }
+
+    if (!hasCandidate())
+    {
+        event->ignore();
+        return;
+    }
+
+    switch (mode)
+    {
+
+    // these modes need a candidate
+    case Submit:
+        submitHandler();
+        break;
+    
+    case Commit:
+        commitHandler();
+        break;
+    
+    default:
+        if (!hasArrow())
+        {
+            event->ignore();
+            return;
+        }
+
+        switch (mode)
+        {
+
+        // these modes need an arrow
+        case Delete:
+            deleteHandler();
+            break;
+        
+        case Backspace:
+            backspaceHandler();
+            break;
+        
+        case Append:
+            if (event->modifiers() & Qt::AltModifier || event->modifiers() & Qt::ControlModifier || event->text().isEmpty())
+            {
+                event->ignore();
+                return;
+            }
+    
+            appendHandler(event->text(), event->modifiers() & Qt::ShiftModifier);
+            break;
+
+        case Commit:
+        case Submit:
+            break;
+        }
+        break;
+    }
+
+    prepare();
+
+    event->accept();
+}
+
+bool GraphicalBoardFrame::wantMousePressEvent(const QMouseEvent *event) const
+{
+    return (event->button() == Qt::LeftButton);
+}
+
+Quackle::Move GraphicalBoardFrame::flip(const Quackle::Move &flippee)
+{
+    if (!m_board.isConnected(flippee))
+        return flippee;
+
+    Quackle::MoveList words = m_board.allWordsFormedBy(flippee);
+    Quackle::Move flipped = words.front();
+    if (flipped.tiles().length() > 1)
+    {
+        return flipped;
+    }
+    else
+    {
+        return flippee;
+    }
+}
+
+void GraphicalBoardFrame::prettifyAndSetLocalCandidate(const Quackle::Move &candidate)
+{
+    m_candidate = candidate;
+    m_candidate.setPrettyTiles(m_board.prettyTilesOfMove(m_candidate));
+
+    if (candidate.action == Quackle::Move::Place && candidate.wordTilesWithNoPlayThru().empty())
+    {
+        emit statusMessage(tr("Click again to switch arrow orientation, or type a word."));
+        return;
+    }
+
+    //UVcout << "m_candidate: " << m_candidate << endl;
+
+    if (m_candidate.wordTilesWithNoPlayThru().length() == 1) 
+    {
+        emit localCandidateChanged(flip(m_candidate));
+
+        emit statusMessage(tr("Press Enter to add %1 to candidate list, or Control+Enter to commit to it immediately.").arg(QuackleIO::Util::moveToDetailedString(flip(m_candidate))));
+    }
+    else
+    {
+        emit localCandidateChanged(m_candidate);
+
+        emit statusMessage(tr("Press Enter to add %1 to candidate list, or Control+Enter to commit to it immediately.").arg(QuackleIO::Util::moveToDetailedString(m_candidate)));
+    }
+}
+
+void GraphicalBoardFrame::setLocalCandidate(const Quackle::Move &candidate)
+{
+    m_candidate = candidate;
+    resetArrow();
+    prepare();
+}
+
+void GraphicalBoardFrame::backspaceHandler()
+{
+    unsigned int hoppedTiles = 0;
+    QSize currentTile(m_arrowRoot);
+    while (true)
+    {
+        const QSize previousTile = currentTile - arrowVector();
+
+        bool stopHere;
+
+        if (!isOnBoard(previousTile))
+            stopHere = true;
+        else
+        {
+            Quackle::Board::TileInformation previousTileInformation(m_board.tileInformation(previousTile.height(), previousTile.width()));
+
+            stopHere = previousTileInformation.tileType != Quackle::Board::LetterTile;
+        }
+
+        ++hoppedTiles;
+
+        if (stopHere)
+        {
+            m_arrowRoot = previousTile;
+            break;
+        }
+
+        currentTile = previousTile;
+    }
+
+    Quackle::LetterString tiles(m_candidate.tiles());
+    
+    if (hoppedTiles > tiles.length())
+        tiles = Quackle::LetterString();
+    else
+        tiles = Quackle::String::left(m_candidate.tiles(), m_candidate.tiles().length() - hoppedTiles);
+    
+    if (tiles.empty())
+    {
+        Quackle::Move originalMove;
+        Quackle::LetterString hoppedLetters;
+
+        currentTile = m_arrowRoot;
+        while (true)
+        {
+            const QSize previousTile = currentTile - arrowVector();
+    
+            bool stopHere;
+
+            if (!isOnBoard(previousTile))
+                stopHere = true;
+            else
+            {
+                Quackle::Board::TileInformation previousTileInformation(m_board.tileInformation(previousTile.height(), previousTile.width()));
+
+                stopHere = previousTileInformation.tileType != Quackle::Board::LetterTile;
+            }
+
+            if (stopHere)
+            {
+                const bool horizontal = m_arrowDirection == ArrowRight;
+                m_candidate = Quackle::Move::createPlaceMove(currentTile.height(), currentTile.width(), horizontal, hoppedLetters);
+                break;
+            }
+
+            hoppedLetters += QUACKLE_PLAYED_THRU_MARK;
+            currentTile = previousTile;
+        }
+    }
+    else
+    {
+        m_candidate.setTiles(tiles);
+    }
+
+    ensureCandidatePlacedProperly();
+    prettifyAndSetLocalCandidate(m_candidate);
+}
+
+void GraphicalBoardFrame::deleteHandler()
+{
+    setLocalCandidate(Quackle::Move::createNonmove());
+}
+
+void GraphicalBoardFrame::submitHandler()
+{
+    QTimer::singleShot(0, this, SLOT(setGlobalCandidate()));
+}
+
+void GraphicalBoardFrame::commitHandler()
+{
+    QTimer::singleShot(0, this, SLOT(setAndCommitGlobalCandidate()));
+}
+
+void GraphicalBoardFrame::setGlobalCandidate()
+{
+    if (m_candidate.action == Quackle::Move::Place && m_candidate.wordTilesWithNoPlayThru().empty())
+    {
+        emit statusMessage(tr("Click again to switch arrow orientation, or type a word."));
+        return;
+    }
+
+    if (m_candidate.wordTilesWithNoPlayThru().length() == 1) 
+    {
+        emit setCandidateMove(flip(m_candidate));
+    }
+    else
+    {
+        emit setCandidateMove(m_candidate);
+    }
+}
+
+void GraphicalBoardFrame::setAndCommitGlobalCandidate()
+{
+    setGlobalCandidate();
+    emit commit();
+}
+
+void GraphicalBoardFrame::appendHandler(const QString &text, bool shiftPressed)
+{
+    if (!isOnBoard(m_arrowRoot))
+        return;
+
+    if (!hasCandidate())
+        return;
+
+    Quackle::LetterString appendedLetterString(QuackleIO::Util::encode(text));
+
+    if (appendedLetterString.length() == 0 || Quackle::String::front(appendedLetterString) < QUACKLE_FIRST_LETTER)
+        return;
+    
+    if (shiftPressed)
+        appendedLetterString = Quackle::String::setBlankness(appendedLetterString);
+    else
+        appendedLetterString = Quackle::String::clearBlankness(appendedLetterString);
+
+    Quackle::Move newCandidate(m_candidate);
+    Quackle::LetterString newTiles(m_candidate.tiles() + appendedLetterString);
+    if (!m_ignoreRack && !m_rack.contains(Quackle::String::usedTiles(newTiles)))
+    {
+        Quackle::LetterString blankedNewTiles(m_candidate.tiles() + Quackle::String::setBlankness(appendedLetterString));
+
+        if (m_rack.contains(Quackle::String::usedTiles(blankedNewTiles)))
+        {
+            newTiles = blankedNewTiles;
+        }
+    }
+
+    newCandidate.setTiles(newTiles);
+
+    Quackle::LetterString hoppedTiles;
+
+    QSize currentTile(m_arrowRoot);
+    while (true)
+    {
+        const QSize nextTile = currentTile + arrowVector();
+
+        bool stopHere = false;
+        bool resetArrowAfter = false;
+
+        if (!isOnBoard(nextTile))
+        {
+            stopHere = true;
+        }
+        else
+        {
+            Quackle::Board::TileInformation nextTileInformation(m_board.tileInformation(nextTile.height(), nextTile.width()));
+
+            if (nextTileInformation.tileType != Quackle::Board::LetterTile)
+                stopHere = true;
+        }
+
+        if (stopHere)
+        {
+            newCandidate.setTiles(newCandidate.tiles() + hoppedTiles);
+
+            if (resetArrowAfter)
+                resetArrow();
+            else
+                m_arrowRoot = nextTile;
+
+            break;
+        }
+
+        hoppedTiles += QUACKLE_PLAYED_THRU_MARK;
+        currentTile = nextTile;
+    }
+
+    prettifyAndSetLocalCandidate(newCandidate);
+}
+
+void GraphicalBoardFrame::tileClicked(const QSize &tileLocation, const QMouseEvent * /* event */)
+{
+    Quackle::Board::TileInformation info(m_board.tileInformation(tileLocation.height(), tileLocation.width()));
+    if (info.tileType == Quackle::Board::LetterTile)
+        return;
+
+    if (m_arrowRoot == tileLocation)
+    {
+        ++m_arrowDirection;
+        if (m_arrowDirection == ArrowWorm)
+            m_arrowDirection = s_firstArrowDirection;
+    }
+    else
+        m_arrowDirection = s_firstArrowDirection;
+
+    m_arrowRoot = tileLocation;
+
+    Quackle::Move originalMove;
+    Quackle::LetterString hoppedTiles;
+
+    QSize currentTile(tileLocation);
+    while (true)
+    {
+        const QSize previousTile = currentTile - arrowVector();
+
+        bool stopHere;
+
+        if (!isOnBoard(previousTile))
+            stopHere = true;
+        else
+        {
+            Quackle::Board::TileInformation previousTileInformation(m_board.tileInformation(previousTile.height(), previousTile.width()));
+
+            stopHere = previousTileInformation.tileType != Quackle::Board::LetterTile;
+        }
+
+        if (stopHere)
+        {
+            const bool horizontal = m_arrowDirection == ArrowRight;
+            originalMove = Quackle::Move::createPlaceMove(currentTile.height(), currentTile.width(), horizontal, hoppedTiles);
+            break;
+        }
+
+        hoppedTiles += QUACKLE_PLAYED_THRU_MARK;
+        currentTile = previousTile;
+    }
+
+    prettifyAndSetLocalCandidate(originalMove);
+
+    // TODO work some cleverness so we can do this!
+    //emit setCandidateMove(Quackle::Move::createNonmove());
+
+    for (QSize currentTile(0, 0); currentTile.height() < m_boardSize.height(); currentTile.setHeight(currentTile.height() + 1))
+        for (currentTile.setWidth(0); currentTile.width() < m_boardSize.width(); currentTile.setWidth(currentTile.width() + 1))
+            if (currentTile != tileLocation)
+            {
+                TileWidget *tile = tileAt(currentTile);
+                if (!tile)
+                    continue;
+
+                tile->setArrowDirection(NoArrow);
+            }
+
+    prepare();
+}
+
+void GraphicalBoardFrame::resetArrow()
+{
+    m_arrowRoot = QSize(-1, -1);
+    m_arrowDirection = NoArrow;
+}
+
+bool GraphicalBoardFrame::hasArrow() const
+{
+    return m_arrowRoot.isValid();
+}
+
+QSize GraphicalBoardFrame::arrowVector() const
+{
+    const bool horizontal = (m_arrowDirection == ArrowRight);
+    return horizontal? QSize(1, 0) : QSize(0, 1);
+}
+
+bool GraphicalBoardFrame::hasCandidate() const
+{
+    return m_candidate.isAMove();
+}
+
+void GraphicalBoardFrame::ensureCandidatePlacedProperly()
+{
+    if (m_candidate.tiles().empty())
+    {
+        m_candidate.startrow = m_arrowRoot.height();
+        m_candidate.startcol = m_arrowRoot.width();
+    }
+}
+
+bool GraphicalBoardFrame::isOnBoard(const QSize &location) const
+{
+    return (location.width() >= 0 && location.width() < m_boardSize.width() && location.height() >= 0 && location.height() < m_boardSize.height());
+}
+
+////////////////
+
+unsigned int qHash(const QColor &color)
+{
+    return color.rgb();
+}
+
+PixmapCacher *PixmapCacher::m_self = 0;
+PixmapCacher *PixmapCacher::self()
+{
+    if (m_self == 0)
+        m_self = new PixmapCacher();
+
+    return m_self;
+}
+
+void PixmapCacher::cleanUp()
+{
+    delete m_self;
+    m_self = 0;
+}
+
+PixmapCacher::PixmapCacher()
+{
+    arrowColor = QColor("black");
+    letterColor = QColor("#6e6e6e");
+    britishLetterColor = QColor("#703d3d");
+
+    // tiles on rack will be of different sizes and thus are slightly
+    // altered to fool the pixmap cacher
+    rackColor = letterColor.light(101);
+
+    DLSColor = QColor("cornflowerblue");
+    TLSColor = QColor("slateblue");
+    DWSColor = QColor("palevioletred");
+    TWSColor = QColor("firebrick");
+
+    QLSColor = QColor("blueviolet").light();
+    QWSColor = QColor("goldenrod");
+
+    nothingColor = QColor("gainsboro");
+
+    cementedLetterTextColor = QColor("#f8f8ff");
+    cementedBritishLetterTextColor = QColor("#FFC0C0");
+    uncementedLetterTextColor = QColor("khaki");
+
+    markColor = QColor("tan");
+    markTextColor = markColor.dark();
+}
+
+bool PixmapCacher::contains(const QColor &color) const
+{
+    return m_pixmaps.contains(color);
+}
+
+QPixmap PixmapCacher::get(const QColor &color) const
+{
+    return m_pixmaps.value(color);
+}
+
+void PixmapCacher::put(const QColor &color, const QPixmap &pixmap)
+{
+    m_pixmaps.insert(color, pixmap);
+}
+
+void PixmapCacher::invalidate()
+{
+    m_pixmaps.clear();
+}
+
+////////////////
+
+TileWidget::TileWidget()
+    : m_cemented(false), m_arrowDirection(GraphicalBoardFrame::NoArrow), m_alwaysShowVerboseLabels(false)
+{
+}
+
+TileWidget::~TileWidget()
+{
+}
+
+void TileWidget::setSideLength(int sideLength)
+{
+    setOurSize(sideLength, sideLength);
+
+    if (!m_pixmap.isNull())
+        prepare();
+}
+
+int TileWidget::sideLength() const
+{
+    return m_size.width();
+}
+
+QSize TileWidget::size() const
+{
+    return m_size;
+}
+
+void TileWidget::setInformation(const Quackle::Board::TileInformation &information)
+{
+    m_information = information;
+}
+
+Quackle::Board::TileInformation TileWidget::information() const
+{
+    return m_information;
+}
+
+void TileWidget::setOriginalInformation(const Quackle::Board::TileInformation &originalInformation)
+{
+    if (originalInformation.tileType == Quackle::Board::BonusSquareTile)
+        m_backgroundColor = tileColor(originalInformation);
+}
+
+void TileWidget::setLocation(const QSize &location)
+{
+    m_location = location;
+}
+
+void TileWidget::setCemented(bool cemented)
+{
+    m_cemented = cemented;
+}
+
+bool TileWidget::cemented() const
+{
+    return m_cemented;
+}
+
+void TileWidget::setArrowDirection(int arrowDirection)
+{
+    m_arrowDirection = arrowDirection;
+}
+
+GraphicalBoardFrame::ArrowDirection TileWidget::arrowDirection() const
+{
+    return (GraphicalBoardFrame::ArrowDirection)m_arrowDirection;
+}
+
+void TileWidget::prepare()
+{
+    m_pixmap = generateTilePixmap();
+}
+
+const QPixmap &TileWidget::tilePixmap()
+{
+    return m_pixmap;
+}
+
+QColor TileWidget::tileColor()
+{
+    return tileColor(m_information);
+}
+
+QColor TileWidget::tileColor(const Quackle::Board::TileInformation &information)
+{
+    QColor ret;
+
+    PixmapCacher *cache = PixmapCacher::self();
+
+    switch (information.tileType)
+    {
+    case Quackle::Board::LetterTile:
+        if (information.isOnRack)
+            ret = cache->rackColor;
+        else if (information.isBritish && QuackerSettings::self()->britishColoring == TileBritishColoring)
+            ret = cache->britishLetterColor;
+        else
+            ret = cache->letterColor;
+        break;
+
+    case Quackle::Board::BonusSquareTile:
+        switch (information.bonusSquareType)
+        {
+        case Quackle::Board::LetterBonus:
+            if (information.bonusMultiplier == 2)
+                ret = cache->DLSColor;
+            else if (information.bonusMultiplier == 3)
+                ret = cache->TLSColor;
+            else if (information.bonusMultiplier == 4)
+                ret = cache->QLSColor;
+            else
+            {
+                // TODO general case
+            }
+            break;
+
+        case Quackle::Board::WordBonus:
+            if (information.bonusMultiplier == 2)
+                ret = cache->DWSColor;
+            else if (information.bonusMultiplier == 3)
+                ret = cache->TWSColor;
+            else if (information.bonusMultiplier == 4)
+                ret = cache->QWSColor;
+            else
+            {
+                // TODO general case
+            }
+            break;
+
+        case Quackle::Board::NoBonus:
+            // urps, this won't happen
+            ret = cache->nothingColor;
+            break;
+        }
+        break;
+
+    case Quackle::Board::NothingTile:
+        ret = cache->nothingColor;
+        break;
+    }
+    
+    return ret;
+}
+
+QColor TileWidget::backgroundColor()
+{
+    return m_backgroundColor;
+}
+
+QColor TileWidget::letterTextColor()
+{
+    QColor ret;
+
+    if (m_arrowDirection != GraphicalBoardFrame::NoArrow)
+        ret = PixmapCacher::self()->arrowColor;
+    else if (m_cemented)
+    {
+        if (m_information.isBritish && QuackerSettings::self()->britishColoring == TextBritishColoring)
+            ret = PixmapCacher::self()->cementedBritishLetterTextColor;
+        else
+            ret = PixmapCacher::self()->cementedLetterTextColor;
+    }
+    else if (m_information.letter == QUACKLE_NULL_MARK && m_information.isStartLocation)
+        ret = PixmapCacher::self()->arrowColor;
+    else if (m_information.letter == QUACKLE_NULL_MARK)
+        ret = tileColor().light(145);
+    else
+        ret = PixmapCacher::self()->uncementedLetterTextColor;
+
+    return ret;
+}
+
+QString TileWidget::letterText()
+{
+    int glyphIndex;
+
+    if (m_arrowDirection == GraphicalBoardFrame::ArrowRight)
+        glyphIndex = 0;
+    else if (m_arrowDirection == GraphicalBoardFrame::ArrowDown)
+        glyphIndex = 1;
+    else if (m_information.letter == QUACKLE_NULL_MARK)
+    {
+        if (m_information.isStartLocation)
+            glyphIndex = 2;
+        else
+        {
+            if (shouldShowVerboseLabels())
+            {
+                if (m_information.bonusSquareType == Quackle::Board::LetterBonus)
+                    return QString("%1LS").arg(m_information.bonusMultiplier);
+                else if (m_information.bonusSquareType == Quackle::Board::WordBonus)
+                    return QString("%1WS").arg(m_information.bonusMultiplier);
+            }
+
+            return QString::null;
+        }
+    }
+    else
+        return QuackleIO::Util::sanitizeUserVisibleLetterString(QuackleIO::Util::letterToQString(m_information.letter));
+    
+    QChar preferredGlyphs[] =  {QChar(0x21d2), QChar(0x21d3), QChar(0x2606)}; // double arrows, white star
+    QChar secondaryGlyphs[] =  {QChar(0x2192), QChar(0x2193), QChar(   '*')}; // single arrows, ASCII star
+    QChar asciiGlyphs[] =      {QChar(   '>'), QChar(   'v'), QChar(   '*')}; // 7-bit
+    QFontMetrics metrics(letterFont());
+
+#ifdef FORCE_SECONDARY_ARROW_GLYPHS
+    QChar macSecondaryGlyphs[] =  {QChar(0x2192), QChar(0x2193), QChar(0x2606)}; // single arrows, white star
+    return QString(macSecondaryGlyphs[glyphIndex]);
+#else
+    if (metrics.inFont(preferredGlyphs[0]) &&
+            metrics.inFont(preferredGlyphs[1]) &&
+            metrics.inFont(preferredGlyphs[2]))
+        return QString(preferredGlyphs[glyphIndex]);
+    else if (metrics.inFont(secondaryGlyphs[0]) &&
+            metrics.inFont(secondaryGlyphs[1]) &&
+            metrics.inFont(secondaryGlyphs[2]))
+        return QString(secondaryGlyphs[glyphIndex]);
+    else
+        return QString(asciiGlyphs[glyphIndex]);
+#endif
+}
+
+QFont TileWidget::letterFont()
+{
+    // Sorry for the hardcoded constants :( :(
+    if (m_information.isStartLocation && m_information.tileType != Quackle::Board::LetterTile)
+        return scaledFont(0.7);
+    else if (m_arrowDirection == GraphicalBoardFrame::NoArrow && m_information.tileType == Quackle::Board::BonusSquareTile)
+        return scaledFont(.35);
+    else
+    {
+        double initialScale = 0.7;
+        if (m_information.tileType == Quackle::Board::LetterTile)
+        {
+            QString text = letterText();
+            if (text.length() > 1)
+            {
+                initialScale = 1.0 / text.length();
+            }
+
+        }
+
+        double scale = m_information.isBlank? initialScale * 5 / 7 : initialScale;
+
+        QFont ret = scaledFont(scale);
+        ret.setBold(true);
+        return ret;
+    }
+}
+
+QFont TileWidget::actualLetterFont()
+{
+    return scaledFont(1);
+}
+
+QString TileWidget::miniText()
+{
+    if (m_information.letter != QUACKLE_NULL_MARK && QuackerSettings::self()->scoreLabels)
+    {   
+        if (m_information.isBlank)
+            return QString::null;
+        else
+            return QString::number(QUACKLE_ALPHABET_PARAMETERS->score(m_information.letter));
+    }
+    else
+        return QString::null;
+}
+
+QColor TileWidget::miniTextColor()
+{
+    return tileColor().light(170);
+}
+
+QFont TileWidget::miniFont()
+{
+    return scaledFont(miniText().length() > 1? .275 : .325);
+}
+
+bool TileWidget::shouldShowVerboseLabels() const
+{
+    return m_alwaysShowVerboseLabels || QuackerSettings::self()->verboseLabels;
+}
+
+QFont TileWidget::scaledFont(float multiplier)
+{
+    const int smallerSideLength = qMin(size().width(), size().height());
+
+    if (smallerSideLength == 0)
+        return PixmapCacher::self()->tileFont;
+
+    QFont ret(PixmapCacher::self()->tileFont);
+    ret.setPixelSize((int)(smallerSideLength * multiplier));
+    return ret;
+}
+
+void TileWidget::setOurSize(const QSize &size)
+{
+    m_size = size;
+}
+
+void TileWidget::setOurSize(int width, int height)
+{
+    setOurSize(QSize(width, height));
+}
+
+QPixmap TileWidget::generateTilePixmap()
+{
+    const QSize currentSize(size());
+
+    if (currentSize.isEmpty())
+        return QPixmap();
+
+    const QRect borderRect(0, 0, currentSize.width(), currentSize.height());
+    const int maxSideLength = qMax(currentSize.width(), currentSize.height());
+    const int borderWidth = 1;
+
+    const QPointF midpoint((double)(currentSize.width() + borderWidth) / 2, (double)(currentSize.height() + borderWidth) / 2);
+    const QColor color(tileColor());
+
+    QPixmap ret(currentSize);
+
+    if (PixmapCacher::self()->contains(color))
+        ret = PixmapCacher::self()->get(color);
+    else
+    {
+        //UVcout << "cache miss for color " << color.rgb() << endl;
+        double radius = maxSideLength / 2 * 1.41 + maxSideLength / 10 + 2;
+
+        // could be used for cool effect -- the color of the bonus square we're obscuring
+        //const QColor outerColor(backgroundColor());
+
+        QRadialGradient gradient(QPointF(radius, radius), radius * 3, QPointF(radius / 3, radius / 3));
+        gradient.setColorAt(0, color.light(GraphicalBoardFrame::s_highlightFactor));
+        gradient.setColorAt(.95, color.dark(GraphicalBoardFrame::s_highlightFactor));
+
+        QPainter painter(&ret);
+        painter.setBrush(gradient);
+    
+        painter.drawEllipse((int)(midpoint.x() - radius), (int)(midpoint.y() - radius), (int)(radius * 2), (int)(radius * 2));
+
+        QPalette customPalette;
+        customPalette.setColor(QPalette::Light, color.light(GraphicalBoardFrame::s_highlightFactor));
+        customPalette.setColor(QPalette::Dark, color);
+        customPalette.setColor(QPalette::Mid, color);
+
+        qDrawShadePanel(&painter, borderRect.x(), borderRect.y(), borderRect.width(), borderRect.height(), customPalette, false, borderWidth);
+
+        PixmapCacher::self()->put(color, ret);
+    }
+
+    const QString nanism = miniText();
+    const bool hasNanism = !nanism.isEmpty();
+
+    const QString text = letterText();
+    if (!text.isEmpty())
+    {
+        QPainter painter(&ret);
+        painter.setFont(letterFont());
+        QPen pen(letterTextColor());
+        painter.setPen(pen);
+        painter.setBrush(Qt::NoBrush);
+
+        const QRectF textSize(painter.boundingRect(borderRect, text));
+        const QPointF startPoint(midpoint - textSize.bottomRight() / 2);
+        const QPointF roundedStartPoint(floor(startPoint.x()), floor(startPoint.y()));
+
+        QRectF textRect(textSize);
+        textRect.moveTo(roundedStartPoint);
+
+        painter.drawText(textRect, Qt::TextDontClip, text);
+
+        if (m_information.isBlank)
+        {
+            painter.setBrush(Qt::NoBrush);
+            pen.setWidth(1);
+            painter.setPen(pen);
+
+            const int border = currentSize.width() / 5;
+            painter.drawRect(QRect(border, border, currentSize.width() - 2 * border, currentSize.height() - 2 * border));
+        }
+    }
+
+    if (hasNanism)
+    {
+        QPainter painter(&ret);
+        painter.setFont(miniFont());
+        QPen pen(miniTextColor());
+        painter.setPen(pen);
+        painter.setBrush(Qt::NoBrush);
+
+        const QRectF textSize(painter.boundingRect(borderRect, nanism));
+        const QPointF startPoint((midpoint * (nanism.length() > 1? 1.65 : 1.68)) - textSize.bottomRight() / 2);
+        const QPointF roundedStartPoint(floor(startPoint.x()), floor(startPoint.y()));
+
+        QRectF textRect(textSize);
+        textRect.moveTo(roundedStartPoint);
+
+        painter.drawText(textRect, Qt::TextDontClip, nanism);
+    }
+
+    return ret;
+}
+
+bool operator<(const QSize &firstSize, const QSize &secondSize)
+{
+    return (firstSize.height() + (QUACKLE_MAXIMUM_BOARD_SIZE + 1) * firstSize.width()) < (secondSize.height() + (QUACKLE_MAXIMUM_BOARD_SIZE + 1) * secondSize.width());
+}
+
+//////////////////
+
+MarkWidget::MarkWidget()
+    : m_horizontal(true), m_capstone(false)
+{
+    m_information.tileType = Quackle::Board::LetterTile;
+}
+
+MarkWidget::~MarkWidget()
+{
+}
+
+void MarkWidget::setRow(int row)
+{
+    m_horizontal = false;
+    m_letterText = QString::number(row);
+}
+
+void MarkWidget::setCol(int col)
+{
+    m_horizontal = true;
+    m_letterText = QChar('A' + col - 1);
+}
+
+void MarkWidget::setCapstone()
+{
+    m_capstone = true;
+    m_letterText = QString::null;
+}
+
+void MarkWidget::setSideLength(int sideLength)
+{
+    const int otherLength = (int)(sideLength * GraphicalBoardFrame::s_markOtherLengthMultiplier);
+
+    if (m_capstone)
+        setOurSize(otherLength, otherLength);
+    else if (m_horizontal)
+        setOurSize(sideLength, otherLength);
+    else
+        setOurSize(otherLength, sideLength);
+
+    prepare();
+}
+
+QColor MarkWidget::tileColor()
+{
+    // we slightly alter colors to fool the pixmap cacher!
+    if (m_capstone)
+        return PixmapCacher::self()->markColor.light(101);
+    else if (m_horizontal)
+        return PixmapCacher::self()->markColor;
+    else
+        return PixmapCacher::self()->markColor.dark(101);
+}
+
+QColor MarkWidget::letterTextColor()
+{
+    return PixmapCacher::self()->markTextColor;
+}
+
+QFont MarkWidget::letterFont()
+{
+    return scaledFont(0.7);
+}
+
+QString MarkWidget::letterText()
+{
+    return m_letterText;
+}