---

map_widget.h

/*
 *   EasySok --- A(nother) sokoban game for KDE.
 *
 *   Copyright (C) 2001 by Ralf Schmelter (ralfs@pc2a.chemie.uni-dortmund.de).
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License version 2 as
 *   published by the Free Software Foundation.
 *
 *   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., 675 Mass Ave, Cambridge, MA 02139, USA.
 */


#ifndef EASY_SOK_MAP_WIDGET_INC_GUARD_H
#define EASY_SOK_MAP_WIDGET_INC_GUARD_H


#include <vector>

#include <qcanvas.h>
#include <qpixmap.h>
#include <qpoint.h>

#include "atomic_move.h"
#include "move.h"
#include "theme.h"


class Map;
class PixmapProvider;
class QTimer;
class Theme;




class MapWidget : public QCanvasView
{
    Q_OBJECT

public:

    MapWidget(Map const * map, PixmapProvider * pixmap_provider, Theme const * theme,
              bool disable_auto_hide, QWidget * parent = 0, char const * name = 0);


    virtual ~MapWidget();


    void setMap(Map const * map);


    void setPixmapProvider(PixmapProvider * pixmap_provider, Theme const * theme);


    AtomicMove::AtomicMoveType keeperDirection();


    QPoint const & virtualKeeper() const;


public slots:


    void setKeeperDirection(AtomicMove::AtomicMoveType direction);


    void setArrows(std::vector<Move> const & arrows);


    void updateDisplay();


    void setVirtualKeeper(const QPoint & position);


    void configChanged();


    void switchToBetterScaling();


    void mouseRepeat();


    void cursorVisible(bool stop_autohide);


    void cursorHidden();


signals:

    void fieldClicked(QPoint point);


    void gemMoved(QPoint from, QPoint to);


    void keeperMoved(QPoint from, QPoint to);


    void undo();


    void redo();


protected:

    virtual void resizeEvent(QResizeEvent * event);


    virtual void contentsMousePressEvent(QMouseEvent * event);


    virtual void contentsMouseMoveEvent(QMouseEvent * event);


    virtual void contentsMouseReleaseEvent(QMouseEvent * event);


private:

    void deleteItems(std::vector<QCanvasSprite *> & items) const;


    void createItems(std::vector<QCanvasSprite *> & items, int type,
                     QPoint const & position, int x, int y, int z) const;


    void createItems(std::vector<QCanvasSprite *> & items, QPoint const & position, int x, int y, int z) const;


    void createItems(std::vector<QCanvasSprite *> & items, std::vector<int> image_indices,
                     int x, int y, int z) const;


    void placeItems(std::vector<QCanvasSprite *> & items, int x, int y, int z);


    void updateGeometry();


    void deletePixmaps();


    void deleteArrows();


    void addArrow(QPoint from, QPoint to);


    void deleteItems();


    void newItems();


    bool isValidPosition(QPoint position) const;


    QPoint getFieldFromPosition(QPoint position) const;


    void moveMovingItemPosition(QPoint const & offset);


    QCanvasPixmapArray * createPixmapArray(QPixmap const & pixmap) const;


    mutable QCanvas m_canvas;


    PixmapProvider * m_pixmap_provider;


    Theme const * m_theme;


    Map const * m_map;


    std::vector<int> m_pieces;


    int m_x_offset;


    int m_y_offset;


    int m_square_size;


    int m_map_width;


    int m_map_height;


    int m_size;


    bool m_force_update;


    bool m_valid_click;


    bool m_in_drag;


    bool m_is_keeper_drag;


    AtomicMove::AtomicMoveType m_keeper_direction;


    QPoint m_click_position;


    QPoint m_click_field;


    QPoint m_click_offset;


    QPoint m_last_mouse_position;


    QPoint m_virtual_keeper_pos;


    std::vector<QCanvasSprite *> m_virtual_keeper_item;


    std::vector<QCanvasSprite *> m_moving_item;


    std::vector<std::vector<QCanvasSprite *> > m_arrow_items;


    std::vector<std::vector<QCanvasSprite *> > m_items;


    mutable std::vector<QCanvasPixmapArray *> m_pixmaps;

    std::vector<Move> m_arrows;


    QTimer * m_timer;


    QTimer * m_repeat_timer;


    int m_mouse_repeat_state;


    int m_mouse_repeat_delay;


    int m_mouse_repeat_rate;


    int m_scaling_mode;


    int m_switch_time;


    int m_min_square_size;


    bool m_has_scrollbars;


    bool m_cursor_hidden;


    bool m_auto_hide_cursor;


    bool m_disable_auto_hide;


    int m_cursor_hide_delay;


    QTimer * m_cursor_timer;


    int m_virtual_keeper_direction;
};


#endif

---