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
};

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() { 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;

    virtual bool draw(bool forceRedraw = false) = 0;

    virtual bool draw(ManagedSurface *g, bool forceRedraw = false) = 0;

    virtual bool processEvent(Common::Event &event) = 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 = true; }
    void setContentDirty(bool dirty) { _contentIsDirty = true; }
    void resizeBorderSurface();

    void setMode(uint32 mode) { _mode = mode; }
    void setBorderOffsets(BorderOffsets &offsets) { _macBorder.setOffsets(offsets); }

    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;
    const BorderOffsets &getBorderOffsets() const { return _macBorder.getOffset(); }

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