window.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 BAGEL_BOFLIB_GUI_WINDOW_H
#define BAGEL_BOFLIB_GUI_WINDOW_H

#include "common/list.h"
#include "common/events.h"
#include "bagel/boflib/array.h"
#include "bagel/boflib/stdinc.h"
#include "bagel/boflib/error.h"
#include "bagel/boflib/object.h"
#include "bagel/boflib/point.h"
#include "bagel/boflib/rect.h"
#include "bagel/boflib/size.h"
#include "bagel/boflib/timer.h"
#include "bagel/boflib/llist.h"
#include "bagel/boflib/gfx/bitmap.h"
#include "bagel/boflib/gfx/palette.h"
#include "bagel/boflib/gfx/text.h"

namespace Bagel {
class CBofString;

#define MAX_TITLE 64
#define USE_DEFAULT (-1)

class CBofBitmap;
class CBofTimerPacket;

class CBofWindow : public CLList, public CBofObject, public CBofError {
private:
    bool _visible = true;
    bool _enabled = true;
    Common::List<WindowTimer> _timers;
    uint32 _lastLButtonTime = 0, _lastRButtonTime = 0;

    uint32 translateKey(const Common::Event &event) const;

protected:
    void checkTimers();

public:
    CBofWindow();

    CBofWindow(const char *pszName, int x, int y, int nWidth, int nHeight, CBofWindow *pParent);

    virtual ~CBofWindow();

    static ErrorCode initialize();
    static ErrorCode shutdown();
    static Common::Point getMousePos();

    virtual ErrorCode create(const char *pszName, int x, int y, int nWidth, int nHeight, CBofWindow *pParent, uint32 nControlID = 0);

    virtual ErrorCode create(const char *pszName, CBofRect *pRect, CBofWindow *pParent, uint32 nControlID = 0);

    virtual void destroy();
    virtual void destroyWindow() {
        destroy();
    }

    void show();

    void select();

    void hide();

    void center();

    void move(int x, int y, bool bRepaint = false);

    void reSize(CBofRect *pRect, bool bRepaint = false);

    virtual ErrorCode close() {
        onClose();

        return ERR_NONE;
    }

    void postMessage(uint32 nMessage, uint32 lParam1, uint32 lParam2);

    void postUserMessage(uint32 lMessage, uint32 lExtraInfo);

    void setTimer(uint32 nID, uint32 nInterval, BofCallback pCallBack = nullptr);

    void killTimer(uint32 nID);

    void killMyTimers();

    CBofWindow *getParent() const {
        return _parent;
    }

    void validateAnscestors(CBofRect *pRect = nullptr);

    static CBofWindow *getActiveWindow() {
        return _pActiveWindow;
    }

    void setActive() {
        _pActiveWindow = this;
    }

    static CBofWindow *getWindowList() {
        return _pWindowList;
    }

    CBofRect getWindowRect() const {
        return _cWindowRect;
    }
    CBofRect getClientRect();

    CBofRect getRect() const {
        return _cRect;
    }

    int width() const {
        return _cRect.width();
    }
    int height() const {
        return _cRect.height();
    }

    void screenToClient(CBofPoint *pPoint);

    void selectPalette(CBofPalette *pPal);

    ErrorCode setBackdrop(CBofBitmap *pNewBitmap, bool bRefresh = false);

    ErrorCode setBackdrop(const char *pszFileName, bool bRefresh = false);

    void clearBackdrop() {
        _pBackdrop = nullptr;
    }

    CBofBitmap *getBackdrop() const {
        return _pBackdrop;
    }

    bool hasBackdrop() const {
        return _pBackdrop != nullptr;
    }

    void killBackdrop();

    ErrorCode paintBackdrop(CBofRect *pRect = nullptr, int nTransparentColor = -1);

    void setControlID(uint32 nID) {
        _nID = nID;
    }
    uint32 getControlID() const {
        return _nID;
    }

    void setBkColor(RGBCOLOR cColor) {
        _cBkColor = cColor;
    }
    RGBCOLOR getBkColor() const {
        return _cBkColor;
    }

    void setFgColor(RGBCOLOR cColor) {
        _cFgColor = cColor;
    }
    RGBCOLOR getFgColor() const {
        return _cFgColor;
    }

    void setPrevMouseDown(CBofPoint p) {
        _cPrevMouseDown = p;
    }
    CBofPoint getPrevMouseDown() const {
        return _cPrevMouseDown;
    }

    void setCapture();

    void releaseCapture();

    bool hasCapture() const;

    void setFocus();

    void releaseFocus();

    bool hasFocus() const;

    void flushAllMessages();

    void validateRect(const CBofRect *pRect);

    void invalidateRect(const CBofRect *pRect);

    virtual void onBofButton(CBofObject *pButton, int nExtraInfo);
    virtual void onBofScrollBar(CBofObject *pButton, int nNewPos);
    virtual void onBofListBox(CBofObject *pListBox, int nItemIndex);
    virtual void onMainLoop();

    virtual void onSoundNotify(CBofObject *pObject, uint32 lParam2);
    virtual void onMovieNotify(uint32 lParam1, uint32 lParam2);

    virtual void onMCINotify(uint32 wParam, uint32 lParam);

    virtual void onTimer(uint32 nTimerId);

    virtual void handleEvent(const Common::Event &event);

    Graphics::ManagedSurface *getSurface();

    bool isCreated() const {
        return _surface != nullptr;
    }

    virtual void enable() {
        _enabled = true;
        updateWindow();
    }
    virtual void disable() {
        _enabled = false;
        updateWindow();
    }
    bool isVisible() const {
        return _visible;
    }
    bool isEnabled() const {
        return _enabled;
    }

    void updateWindow();

    void setParent(CBofWindow *parent);

    void handleEvents();

    virtual void onKeyHit(uint32 lKey, uint32 lRepCount);
    void fillWindow(byte iColor);
    void fillRect(CBofRect *pRect, byte iColor);

    ErrorCode paintBeveledText(CBofRect *rect, const CBofString &string, int size, int weight, RGBCOLOR color, int justify, uint32 format);


protected:
    CBofWindow *_parent = nullptr;  // Pointer to parent window
    Array<CBofWindow *> _children;  // Child element pointers

    virtual void onMouseMove(uint32 nFlags, CBofPoint *pPoint, void * = nullptr);
    virtual void onLButtonDown(uint32 nFlags, CBofPoint *pPoint, void * = nullptr);
    virtual void onLButtonUp(uint32 nFlags, CBofPoint *pPoint, void * = nullptr);
    virtual void onLButtonDblClk(uint32 nFlags, CBofPoint *pPoint);

    virtual void onRButtonDown(uint32 nFlags, CBofPoint *pPoint);
    virtual void onRButtonUp(uint32 nFlags, CBofPoint *pPoint);
    virtual void onRButtonDblClk(uint32 nFlags, CBofPoint *pPoint);

    virtual void onReSize(CBofSize *pSize);
    virtual void onPaint(CBofRect *pRect);
    virtual void onClose();

    virtual void onUserMessage(uint32 nMessage, uint32 lParam);

    virtual void onActivate();
    virtual void onDeActivate();

    // Window Data
    char _szTitle[MAX_TITLE] = { 0 };   // Title of window
    CBofRect _cWindowRect;              // Screen based area of this window
    CBofRect _cRect;                    // Window-based area of this window
    CBofBitmap *_pBackdrop = nullptr;  // Backdrop bitmap
    uint32 _nID = 0;                        // ID of this window

    RGBCOLOR _cBkColor = RGB(255, 255, 255);
    RGBCOLOR _cFgColor = RGB(0, 0, 0);

    bool _bCaptured = false;
    Graphics::ManagedSurface *_surface = nullptr;

    static CBofWindow *_pWindowList;
    static CBofWindow *_pActiveWindow;
    static CBofTimerPacket *_pTimerList;
    CBofPoint _cPrevMouseDown;
    static int _mouseX;
    static int _mouseY;
};

class CBofMessage : public CBofObject {
public:
    CBofWindow *_pWindow; // destination window for message
    uint32 _nMessage;      // message to send (usually WM_USER)
    uint32 _lParam1;       // user defined info
    uint32 _lParam2;       // more user defined info
};

class CBofTimerPacket : public CBofObject, public CLList {
public:
    CBofWindow *_pOwnerWindow;
    BofCallback _pCallBack;
    uint32 _nID;
    uint32 _nInterval;
};

extern CBofWindow *g_hackWindow;

} // namespace Bagel

#endif