macwindow.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * 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 3 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, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef GRAPHICS_MACGUI_MACWINDOW_H
#define GRAPHICS_MACGUI_MACWINDOW_H
 
#include "common/stream.h"
 
#include "graphics/managed_surface.h"
#include "graphics/nine_patch.h"
#include "graphics/font.h"
 
#include "graphics/macgui/macwidget.h"
#include "graphics/macgui/macwindowborder.h"
 
namespace Graphics {
 
class MacWindowManager;
class MacWindowBorder;
class MacWidget;
 
namespace MacWindowConstants {
enum WindowType {
    kWindowUnknown,
    kWindowWindow,
    kWindowMenu
};
 
enum {
    kBorderWidth = 17,
    kWindowMinWidth = 70,
    kWindowMinHeight = 70
};
 
enum WindowClick {
    kBorderNone = 0,
    kBorderScrollUp,
    kBorderScrollDown,
    kBorderScrollLeft,
    kBorderScrollRight,
    kBorderCloseButton,
    kBorderInner,
    kBorderBorder,
    kBorderResizeButton,
    kBorderActivate,
    kBorderDeactivate,
    kBorderDragged,
    kBorderResized,
    kBorderMaximizeButton,
};
 
enum {
    kWindowModeDynamicScrollbar = 1 << 0
};
}
using namespace MacWindowConstants;
 
class BaseMacWindow : public MacWidget {
public:
    BaseMacWindow(int id, bool editable, MacWindowManager *wm);
    virtual ~BaseMacWindow() {}
 
    int getId() { return _id; }
 
    WindowType getType() { return _type; }
 
    bool isEditable() override { return _editable; }
 
    virtual void setVisible(bool visible, bool silent = false);
    bool isVisible();
 
    ManagedSurface *getWindowSurface() { return _composeSurface; }
 
    virtual ManagedSurface *getBorderSurface() = 0;
 
    virtual const Common::Rect &getInnerDimensions() = 0;
 
    bool draw(bool forceRedraw = false) override = 0;
 
    bool draw(ManagedSurface *g, bool forceRedraw = false) override = 0;
 
    bool processEvent(Common::Event &event) override = 0;
 
    virtual bool isDirty() = 0;
 
    void setCallback(bool (*callback)(WindowClick, Common::Event &, void *), void *data) { _callback = callback; _dataPtr = data; }
 
    void setDraggable(bool draggable) { _draggable = draggable; }
 
protected:
    int _id;
    WindowType _type;
 
    bool _editable;
 
    bool (*_callback)(WindowClick, Common::Event &, void *);
    void *_dataPtr;
 
    bool _visible;
 
    bool _draggable;
};
 
class MacWindow : public BaseMacWindow {
public:
    MacWindow(int id, bool scrollable, bool resizable, bool editable, MacWindowManager *wm);
 
    MacWindow(const MacWindow &source);
    virtual ~MacWindow() {}
 
    void move(int x, int y);
 
    /*
     * Change the width and the height of the window (outer dimensions).
     * @param w New width of the window.
     * @param h New height of the window.
     */
    virtual void resize(int w, int h);
 
    /*
     * Change the width and the height of the inner window.
     * @param w New width of the window.
     * @param h New height of the window.
     */
    virtual void resizeInner(int w, int h);
 
    void setDimensions(const Common::Rect &r) override;
 
    void setInnerDimensions(const Common::Rect &r);
 
    void setBackgroundPattern(int pattern);
 
    bool draw(ManagedSurface *g, bool forceRedraw = false) override;
 
    bool draw(bool forceRedraw = false) override;
    void blit(ManagedSurface *g, Common::Rect &dest) override;
 
    const Common::Rect &getInnerDimensions() override { return _innerDims; }
    ManagedSurface *getBorderSurface() override { return &_borderSurface; }
 
    void center(bool toCenter = true);
 
    void setActive(bool active) override;
    bool isActive() const;
 
    void setTitle(const Common::String &title);
 
    virtual void setTitleVisible(bool visible);
 
    bool isTitleVisible();
 
    const Common::String &getTitle() const { return _title; };
 
    void setHighlight(WindowClick highlightedPart);
    void setScroll(float scrollPos, float scrollSize);
    bool processEvent(Common::Event &event) override;
    bool hasAllFocus() override { return _beingDragged || _beingResized; }
 
    void loadBorder(Common::SeekableReadStream &file, uint32 flags, int lo = -1, int ro = -1, int to = -1, int bo = -1);
    void loadBorder(Common::SeekableReadStream &file, uint32 flags, const BorderOffsets &offsets);
    void setBorder(Graphics::ManagedSurface *surface, uint32 flags, const BorderOffsets &offsets);
    void disableBorder();
    void loadInternalBorder(uint32 flags);
    void enableScrollbar(bool active) { _hasScrollBar = active; }
 
    void setCloseable(bool closeable);
 
    void setBorderType(int borderType);
    int getBorderType() const { return _borderType; };
 
    uint32 getBorderFlags() const;
 
    void addDirtyRect(const Common::Rect &r);
    void markAllDirty();
    void mergeDirtyRects();
    Common::Rect getDirtyRectBounds();
    void clearDirtyRects() { _dirtyRects.clear(); }
    Common::List<Common::Rect> &getDirtyRectList() { return _dirtyRects; }
 
    bool isDirty() override { return _borderIsDirty || _contentIsDirty; }
 
    void setBorderDirty(bool dirty) { _borderIsDirty = dirty; }
    void setContentDirty(bool dirty) { _contentIsDirty = dirty; }
    void resizeBorderSurface();
 
    void setMode(uint32 mode) { _mode = mode; }
    void setBorderOffsets(BorderOffsets &offsets) { _macBorder.setOffsets(offsets); }
    const BorderOffsets &getBorderOffsets() const { return _macBorder.getOffset(); }
 
    void updateInnerDims();
 
private:
    void rebuildSurface(); // Propagate dimensions change and recreate patter/borders, etc.
    void drawBorderFromSurface(ManagedSurface *g, uint32 flags);
    void drawPattern();
    void drawBox(ManagedSurface *g, int x, int y, int w, int h);
    void fillRect(ManagedSurface *g, int x, int y, int w, int h, int color);
    const Font *getTitleFont();
    void updateOuterDims();
 
    bool isInCloseButton(int x, int y) const;
    bool isInResizeButton(int x, int y) const;
    WindowClick isInScroll(int x, int y) const;
 
protected:
    void drawBorder();
    WindowClick isInBorder(int x, int y) const;
 
protected:
    ManagedSurface _borderSurface;
 
    bool _borderIsDirty;
    Common::Rect _innerDims;
 
    Common::List<Common::Rect> _dirtyRects;
    bool _hasScrollBar;
 
    uint32 _mode;
private:
    MacWindowBorder _macBorder;
 
    int _pattern;
    bool _hasPattern;
 
    bool _scrollable;
    bool _resizable;
 
    bool _closeable;
    bool _isTitleVisible;
 
    int _borderWidth;
 
    bool _beingDragged, _beingResized;
    int _draggedX, _draggedY;
 
    WindowClick _highlightedPart;
 
    Common::String _title;
    Common::String _shadowedTitle;
 
    int _borderType;
};
 
} // End of namespace Graphics
 
#endif