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/spacebar/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/spacebar/boflib/timer.h"
#include "bagel/boflib/llist.h"
#include "bagel/spacebar/boflib/gfx/bitmap.h"
#include "bagel/boflib/palette.h"
#include "bagel/spacebar/boflib/gfx/text.h"
 
namespace Bagel {
 
class CBofString;
 
namespace SpaceBar {
 
#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(COLORREF cColor) {
        _cBkColor = cColor;
    }
    COLORREF getBkColor() const {
        return _cBkColor;
    }
 
    void setFgColor(COLORREF cColor) {
        _cFgColor = cColor;
    }
    COLORREF 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, COLORREF 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
 
    COLORREF _cBkColor = RGB(255, 255, 255);
    COLORREF _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 SpaceBar
} // namespace Bagel
 
#endif