Oubliette Class Reference

#include <oubliette.h>

Inheritance diagram for Oubliette:

[legend]Collaboration diagram for Oubliette:

[legend]List of all members.

---

Detailed Description

Definition at line 36 of file oubliette.h.

Signals
void	characterMoved (const QPoint &pt)
Public Member Functions
	Oubliette ()
	~Oubliette ()
const Cursor &	character () const
QPoint	visualCursorPos () const
Protected Member Functions
void	paintEvent (QPaintEvent *)
void	keyPressEvent (QKeyEvent *)
void	timerEvent (QTimerEvent *)
void	showEvent (QShowEvent *)
Private Slots
void	showInventoryItem (QListWidgetItem *lwi)
void	showInstructions ()
void	showVictory ()
Private Member Functions
void	showInventory ()
void	animateItem (const Item *item, const QPoint &pos)
bool	tryMove (const QPoint &newPos)
void	updateExplored ()
void	paintOubliette (QPainter *p, const QRect &rect)
void	fillTile (QPainter *p, int x, int y, Tile tile)
void	fillTile (QPainter *p, const QPoint &point, Tile tile)
Private Attributes
OubliettePlan	m_oubliettePlan
Cursor	m_character
QPoint	m_oldCursorPosition
int	m_currentLevel
QList< ItemEffect * >	m_effects
int	m_timerID

---

Constructor & Destructor Documentation

Oubliette::Oubliette

(

)

Definition at line 64 of file oubliette.cpp.

References QWidget::backgroundRole(), Qt::black, center(), QSize::height(), OubliettePlan::level(), m_character, m_currentLevel, m_oldCursorPosition, m_oubliettePlan, QWidget::palette(), Cursor::position(), QPalette::setColor(), QWidget::setFixedSize(), QWidget::setPalette(), Cursor::setPosition(), OublietteLevel::size(), TileHeight, TileWidth, and QSize::width().

    : m_timerID(-1)
{
    // set a fixed size, pased on the oubliette size
    m_currentLevel = 1;
    QSize sz = m_oubliettePlan.level(m_currentLevel)->size();
    setFixedSize(sz.width() * TileWidth, sz.height() * TileHeight);
    m_character.setPosition(QRect(QPoint(0, 0), sz).center(), false);
    m_oldCursorPosition = m_character.position();
    QPalette pal = palette();
    pal.setColor(backgroundRole(), Qt::black);
    setPalette(pal);
}

Here is the call graph for this function:

Oubliette::~Oubliette

(

)

Definition at line 78 of file oubliette.cpp.

{
}

---

Member Function Documentation

const Cursor& Oubliette::character

(

)

const [inline]

Definition at line 42 of file oubliette.h.

References m_character.

{ return m_character; }

QPoint Oubliette::visualCursorPos

(

)

const

Definition at line 291 of file oubliette.cpp.

References m_character, Cursor::position(), TileHeight, TileWidth, QPoint::x(), and QPoint::y().

Referenced by keyPressEvent(), and OublietteView::OublietteView().

{
    QPoint pt = m_character.position();
    return QPoint(pt.x() * TileWidth, pt.y() * TileHeight);
}

Here is the call graph for this function:

void Oubliette::paintEvent

(

QPaintEvent *

pe

)

[protected, virtual]

This event handler can be reimplemented in a subclass to receive paint events which are passed in the event parameter.

A paint event is a request to repaint all or part of the widget. It can happen as a result of repaint() or update(), or because the widget was obscured and has now been uncovered, or for many other reasons.

Many widgets can simply repaint their entire surface when asked to, but some slow widgets need to optimize by painting only the requested region: QPaintEvent::region(). This speed optimization does not change the result, as painting is clipped to that region during event processing. QListView and QTableView do this, for example.

Qt also tries to speed up painting by merging multiple paint events into one. When update() is called several times or the window system sends several paint events, Qt merges these events into one event with a larger region (see QRegion::united()). repaint() does not permit this optimization, so we suggest using update() whenever possible.

When the paint event occurs, the update region has normally been erased, so that you're painting on the widget's background.

The background can be set using setBackgroundRole() and setPalette().

From Qt 4.0, QWidget automatically double-buffers its painting, so there's no need to write double-buffering code in paintEvent() to avoid flicker.

Note: Under X11 it is possible to toggle the global double buffering by calling qt_x11_set_global_double_buffer(). Example usage:

    ...
    extern void qt_x11_set_global_double_buffer(bool);
    qt_x11_set_global_double_buffer(false);
    ...

See also:

event(), repaint(), update(), QPainter, QPixmap, QPaintEvent, {Analog Clock Example}

Reimplemented from QWidget.

Definition at line 88 of file oubliette.cpp.

References QDesktopWidget::availableGeometry(), QApplication::desktop(), QPixmapCache::find(), QList< T >::indexOf(), QPixmapCache::insert(), QPixmap::isNull(), m_character, m_effects, QWidget::mapToGlobal(), QWidget::move(), QRect::moveCenter(), p, paintOubliette(), Cursor::position(), QWidget::QPixmap, QPaintEvent::rect(), ItemEffect::rect, QList< T >::removeAt(), QWidget::resize(), QWidget::show(), ItemEffect::step, TileHeight, TileWidth, and ItemEffect::TotalSteps.

{
    QPainter p(this);
    paintOubliette(&p, pe->rect());

    QPoint pt = m_character.position();
    QPixmap pm;
    QString pcString = ":/qthack/images/human.png";
    QPixmapCache::find(pcString, pm);
    if (pm.isNull()) {
        pm = QPixmap(pcString);
        QPixmapCache::insert(pcString, pm);
    }
    p.drawPixmap(pt.x() * TileWidth, pt.y() * TileHeight, TileWidth, TileHeight, pm);

    // paint the moving cards
    foreach (ItemEffect *effect, m_effects) {
        if (effect->step >= ItemEffect::TotalSteps) {
            m_effects.removeAt(m_effects.indexOf(effect));
            ItemDialog *dlg = new ItemDialog(this, effect->item);
            QRect dlgRect(mapToGlobal(effect->rect.topLeft()), effect->rect.size());
            QRect desktopRect = QApplication::desktop()->availableGeometry(this);
            if (dlgRect.intersect(desktopRect) != dlgRect)
                dlgRect.moveCenter(desktopRect.center());
            dlg->resize(dlgRect.size());
            dlg->move(dlgRect.topLeft());
            dlg->show();
            delete effect;
            continue;
        }
        p.fillRect(effect->rect, QColor(150, 150, 150, 240));
    }
}

Here is the call graph for this function:

void Oubliette::keyPressEvent

(

QKeyEvent *

ke

)

[protected, virtual]

This event handler, for event event, can be reimplemented in a subclass to receive key press events for the widget.

A widget must call setFocusPolicy() to accept focus initially and have focus in order to receive a key press event.

If you reimplement this handler, it is very important that you ignore() the event if you do not understand it, so that the widget's parent can interpret it.

The default implementation closes popup widgets if the user presses Esc. Otherwise the event is ignored.

See also:

keyReleaseEvent(), QKeyEvent::ignore(), setFocusPolicy(), focusInEvent(), focusOutEvent(), event(), QKeyEvent, {Tetrix Example}

Reimplemented from QWidget.

Definition at line 177 of file oubliette.cpp.

References characterMoved(), emit, QKeyEvent::key(), Qt::Key_Down, Qt::Key_H, Qt::Key_I, Qt::Key_J, Qt::Key_K, Qt::Key_L, Qt::Key_Left, Qt::Key_Right, Qt::Key_Up, QWidget::keyPressEvent(), m_character, Cursor::position(), QPoint::rx(), QPoint::ry(), showInventory(), TileHeight, TileWidth, tryMove(), QWidget::update(), visualCursorPos(), QPoint::x(), and QPoint::y().

{
    QPoint newPos = m_character.position();
    switch (ke->key()) {
    case Qt::Key_Up:
    case Qt::Key_K:
        newPos.ry() -= 1;
        break;
    case Qt::Key_Down:
    case Qt::Key_J:
        newPos.ry() += 1;
        break;
    case Qt::Key_Left:
    case Qt::Key_H:
        newPos.rx() -= 1;
        break;
    case Qt::Key_Right:
    case Qt::Key_L:
        newPos.rx() += 1;
        break;
    case Qt::Key_I:
        showInventory();
        break;
    default:
        QWidget::keyPressEvent(ke);
    }
    if (tryMove(newPos)) {
        QRect r(QPoint((newPos.x() - 8) * TileWidth, (newPos.y() - 8) * TileHeight),
                QSize(24 * TileWidth, 24 * TileHeight));
        update(r);
        emit characterMoved(visualCursorPos());
    }
}

Here is the call graph for this function:

void Oubliette::timerEvent

(

QTimerEvent *

)

[protected, virtual]

This event handler can be reimplemented in a subclass to receive timer events for the object.

QTimer provides a higher-level interface to the timer functionality, and also more general information about timers. The timer event is passed in the event parameter.

See also:

startTimer(), killTimer(), event()

Reimplemented from QObject.

Definition at line 306 of file oubliette.cpp.

References QRect::adjust(), QList< T >::isEmpty(), QObject::killTimer(), m_effects, m_timerID, ItemEffect::rect, ItemEffect::step, ItemEffect::TotalSteps, and QWidget::update().

{
    if (m_effects.isEmpty()) {
        killTimer(m_timerID);
        m_timerID = -1;
    }
    QRegion region;
    foreach (ItemEffect *effect, m_effects) {
        if (effect->step >= ItemEffect::TotalSteps) {
            region += effect->rect;
            continue;
        }
        effect->rect.adjust(-10, -5, 10, 5);
        ++effect->step;
        region += effect->rect;
    }
    update(region);
}

Here is the call graph for this function:

void Oubliette::showEvent

(

QShowEvent *

ev

)

[protected, virtual]

This event handler can be reimplemented in a subclass to receive widget show events which are passed in the event parameter.

Non-spontaneous show events are sent to widgets immediately before they are shown. The spontaneous show events of windows are delivered afterwards.

Note: A widget receives spontaneous show and hide events when its mapping status is changed by the window system, e.g. a spontaneous hide event when the user minimizes the window, and a spontaneous show event when the window is restored again. After receiving a spontaneous hide event, a widget is still considered visible in the sense of isVisible().

See also:

visible, event(), QShowEvent

Reimplemented from QWidget.

Definition at line 82 of file oubliette.cpp.

References QWidget::showEvent(), showInstructions(), QTimer::singleShot(), and SLOT.

{
    QWidget::showEvent(ev);
    QTimer::singleShot(0, this, SLOT(showInstructions()));
}

Here is the call graph for this function:

void Oubliette::showInventoryItem

(

QListWidgetItem *

lwi

)

[private, slot]

Definition at line 325 of file oubliette.cpp.

References QList< T >::at(), QListWidgetItem::data(), QDialog::exec(), Cursor::items(), m_character, and QVariant::toInt().

Referenced by showInventory().

{
    ItemDialog *dlg = new ItemDialog(this, m_character.items().at(lwi->data(99).toInt()));
    dlg->exec();
}

void Oubliette::showInstructions

(

)

[private, slot]

Definition at line 331 of file oubliette.cpp.

References QMessageBox::information(), and QWidget::window().

Referenced by showEvent().

{
    QMessageBox::information(window(), tr("Easter Egg Found"),
                             tr("Welcome to the Trolltech Business Card Hunt\n"
                                "Use the direction keys to move around and find"
                                " the business cards for all the trolls."));
}

void Oubliette::showVictory

(

)

[private, slot]

Definition at line 339 of file oubliette.cpp.

References QMessageBox::information(), QCoreApplication::instance(), m_character, QCoreApplication::quit(), Cursor::totalSteps(), value, and QWidget::window().

Referenced by tryMove().

{
    int value = QMessageBox::information(window(), tr("You Did It!"),
            tr("You've collected all the Trolltech cards. It took you %1 steps.\n"
               "There's nothing more here. You should get back to work.").arg(m_character.totalSteps()),
            tr("That's rather anti-climatic"), tr("Quit"));
    if (value == 1)
        QApplication::instance()->quit();
}

void Oubliette::showInventory

(

)

[private]

Definition at line 211 of file oubliette.cpp.

References QGridLayout::addWidget(), Qt::AlignCenter, QObject::connect(), d, i, QList< T >::isEmpty(), Cursor::items(), OubliettePlan::level(), m_character, m_currentLevel, m_oubliettePlan, Item::name(), Item::pixmapName(), row, QLabel::setAlignment(), QListWidgetItem::setData(), QPushButton::setDefault(), QWidget::setFocus(), QListWidgetItem::setIcon(), showInventoryItem(), SIGNAL, QList< T >::size(), SLOT, OublietteLevel::totalItems(), Qt::WA_DeleteOnClose, and Qt::WA_ShowModal.

Referenced by keyPressEvent().

{
    QDialog *d = new QDialog();
    d->setWindowTitle(tr("Inventory"));
    QGridLayout *gl = new QGridLayout(d);
    int row = 0;
    QLabel *label;
    const QList<const Item *> items = m_character.items();
    if (items.isEmpty()) {
        label = new QLabel(tr("You have <B>No</B> Items"), d);
        label->setAlignment(Qt::AlignCenter);
        gl->addWidget(label, row, 0, 1, 4);
        ++row;
    } else {
        QListWidget *lw = new QListWidget(d);
        gl->addWidget(lw, 0, 0, 1, 4);
        int i = 0;
        foreach (const Item *item, items) {
            QListWidgetItem *lwi = new QListWidgetItem(item->name(), lw);
            lwi->setIcon(QIcon(item->pixmapName()));
            lwi->setData(99, i);
            ++i;
        }
        connect(lw, SIGNAL(itemActivated(QListWidgetItem*)),
                this, SLOT(showInventoryItem(QListWidgetItem*)));
    }
    label = new QLabel(tr("You have %1 of %2 items")
                      .arg(items.size())
                      .arg(m_oubliettePlan.level(m_currentLevel)->totalItems()), d);
    gl->addWidget(label, 1, 1, 1, 1);
    QPushButton *btn = new QPushButton(tr("OK"), d);
    btn->setDefault(true);
    btn->setFocus();
    gl->addWidget(btn, 2, 3, 1, 1);
    connect(btn, SIGNAL(clicked()), d, SLOT(accept()));
    d->setAttribute(Qt::WA_ShowModal);
    d->setAttribute(Qt::WA_DeleteOnClose);
    d->show();
}

Here is the call graph for this function:

void Oubliette::animateItem	(	const Item *	item,
		const QPoint &	pos
	)			[private]

Definition at line 297 of file oubliette.cpp.

References QList< T >::append(), m_effects, m_timerID, QWidget::pos(), and QObject::startTimer().

Referenced by tryMove().

{
    ItemEffect *newEffect = new ItemEffect(item, pos);
    m_effects.append(newEffect);
    if (m_timerID == -1) {
        m_timerID = startTimer(20);
    }
}

Here is the call graph for this function:

bool Oubliette::tryMove

(

const QPoint &

newPos

)

[private]

Definition at line 255 of file oubliette.cpp.

References Cursor::addItem(), animateItem(), QList< T >::clear(), Tile::ClosedDoor, Tile::Floor, QList< T >::isEmpty(), Cursor::items(), Tile::items, level, OubliettePlan::level(), m_character, m_currentLevel, m_oldCursorPosition, m_oubliettePlan, Tile::OpenDoor, Cursor::position(), Cursor::setPosition(), showVictory(), QTimer::singleShot(), QList< T >::size(), SLOT, OublietteLevel::totalItems(), Tile::type, and updateExplored().

Referenced by keyPressEvent().

{
    OublietteLevel *level = m_oubliettePlan.level(m_currentLevel);
    Tile le = level->tile(newPos);
    if (le.type == Tile::Floor || le.type == Tile::ClosedDoor || le.type == Tile::OpenDoor) {
        m_oldCursorPosition = m_character.position();
        m_character.setPosition(newPos);
        if (le.type == Tile::ClosedDoor) {
            le.type = Tile::OpenDoor;
            level->setTile(newPos, le);
        }
        if (!le.items.isEmpty()) {
            foreach (const Item *item, le.items) {
                m_character.addItem(item);
                animateItem(item, newPos);
                if (m_character.items().size() == m_oubliettePlan.level(m_currentLevel)->totalItems())
                    QTimer::singleShot(0, this, SLOT(showVictory()));

            }
            le.items.clear();
            level->setTile(newPos, le);
        }
        updateExplored();
        return true;
    }
    return false;
}

Here is the call graph for this function:

void Oubliette::updateExplored

(

)

[private]

Definition at line 283 of file oubliette.cpp.

References level, OubliettePlan::level(), m_character, m_currentLevel, m_oubliettePlan, Cursor::position(), FOV::start(), QPoint::x(), and QPoint::y().

Referenced by tryMove().

{
    static SIMPLEFOV fov;
    QPoint exploredPoint = m_character.position();
    OublietteLevel *level = m_oubliettePlan.level(m_currentLevel);
    fov.start(level, exploredPoint.x(), exploredPoint.y(), 8);
}

Here is the call graph for this function:

void Oubliette::paintOubliette	(	QPainter *	p,
		const QRect &	rect
	)			[private]

Definition at line 122 of file oubliette.cpp.

References fillTile(), QRect::height(), level, OubliettePlan::level(), m_currentLevel, m_oubliettePlan, p, TileHeight, TileWidth, QRect::width(), QRect::x(), QWidget::x(), QRect::y(), and QWidget::y().

Referenced by paintEvent().

{
   // snap down
    int tile_x1 = paintRect.x() / TileWidth;
    int tile_y1 = paintRect.y() / TileHeight;

    // snap up
    int tile_x2 = (paintRect.x() + paintRect.width()) / TileWidth + TileWidth;
    int tile_y2 = (paintRect.y() + paintRect.height()) / TileHeight + TileHeight;

    OublietteLevel *level = m_oubliettePlan.level(m_currentLevel);
    for (int y = tile_y1; y <= tile_y2; ++y) {
        for (int x = tile_x1; x <= tile_x2; ++x) {
            fillTile(p, x, y, level->tile(x, y));
        }
    }
}

Here is the call graph for this function:

void Oubliette::fillTile	(	QPainter *	p,
		int	x,
		int	y,
		Tile	tile
	)			[private]

Definition at line 140 of file oubliette.cpp.

References QList< T >::at(), Tile::ClosedDoor, Tile::Explored, QPixmapCache::find(), Tile::flags, Tile::Floor, QPixmapCache::insert(), QList< T >::isEmpty(), QString::isEmpty(), QPixmap::isNull(), Tile::items, Tile::OpenDoor, p, Item::pixmapName(), QWidget::QPixmap, TileHeight, TileWidth, Tile::type, and Tile::Wall.

Referenced by fillTile(), and paintOubliette().

{
    QString str;
    switch (le.type) {
    case Tile::ClosedDoor:
        str = ":/qthack/images/dngn_closed_door.png";
        break;
    case Tile::OpenDoor:
        str = ":/qthack/images/dngn_open_door.png";
        break;
    case Tile::Wall:
        str = ":/qthack/images/dngn_rock_wall_07.png";
        break;
    case Tile::Floor:
        break;
    default:
        return; // Don't draw it...
    }

    if (!le.items.isEmpty())
        str = le.items.at(0)->pixmapName();
    if (le.flags & Tile::Explored) {
        if (str.isEmpty()) {
            p->fillRect(x * TileWidth, y * TileHeight, TileWidth, TileHeight, QColor("teal"));
        } else {
            p->fillRect(x * TileWidth, y * TileHeight, TileWidth, TileHeight, QColor("teal"));
            QPixmap pm;
            QPixmapCache::find(str, pm);
            if (pm.isNull()) {
                pm = QPixmap(str);
                QPixmapCache::insert(str, pm);
            }
            p->drawPixmap(x * TileWidth, y * TileHeight, TileWidth, TileHeight, pm);
        }
    }
}

Here is the call graph for this function:

void Oubliette::fillTile	(	QPainter *	p,
		const QPoint &	point,
		Tile	tile
	)			[inline, private]

Definition at line 63 of file oubliette.h.

References fillTile(), p, QPoint::x(), and QPoint::y().

    { fillTile(p, point.x(), point.y(), tile); }

Here is the call graph for this function:

void Oubliette::characterMoved

(

const QPoint &

pt

)

[signal]

Referenced by keyPressEvent().

---

Member Data Documentation

OubliettePlan Oubliette::m_oubliettePlan [private]

Definition at line 70 of file oubliette.h.

Referenced by Oubliette(), paintOubliette(), showInventory(), tryMove(), and updateExplored().

Cursor Oubliette::m_character [private]

Definition at line 71 of file oubliette.h.

Referenced by character(), keyPressEvent(), Oubliette(), paintEvent(), showInventory(), showInventoryItem(), showVictory(), tryMove(), updateExplored(), and visualCursorPos().

QPoint Oubliette::m_oldCursorPosition [private]

Definition at line 72 of file oubliette.h.

Referenced by Oubliette(), and tryMove().

int Oubliette::m_currentLevel [private]

Definition at line 73 of file oubliette.h.

Referenced by Oubliette(), paintOubliette(), showInventory(), tryMove(), and updateExplored().

QList<ItemEffect *> Oubliette::m_effects [private]

Definition at line 74 of file oubliette.h.

Referenced by animateItem(), paintEvent(), and timerEvent().

int Oubliette::m_timerID [private]

Definition at line 75 of file oubliette.h.

Referenced by animateItem(), and timerEvent().

---

The documentation for this class was generated from the following files:

• tools/designer/src/designer/extra/oubliette.h
• tools/designer/src/designer/extra/oubliette.cpp

---