ExternalWindow.h

Go to the documentation of this file.

/*
  Cavestory Multiplayer API
  Copyright (C) 2021 Johnny Ledger
 
  This software is provided 'as-is', without any express or implied
  warranty.  In no event will the authors be held liable for any damages
  arising from the use of this software.
 
  Permission is granted to anyone to use this software for any purpose,
  including commercial applications, and to alter it and redistribute it
  freely, subject to the following restrictions:
 
  1. The origin of this software must not be misrepresented; you must not
     claim that you wrote the original software. If you use this software
     in a product, an acknowledgment in the product documentation would be
     appreciated but is not required.
  2. Altered source versions must be plainly marked as such, and must not be
     misrepresented as being the original software.
  3. This notice may not be removed or altered from any source distribution.
*/
 
#ifndef CAVESTORY_MOD_API_H_
#error "Please include CavestoryModAPI.h before including sub-classes."
#endif
 
#include <CSMAPI_begincode.h>
 
#pragma once
 
 
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
class VideoTexture;
class ExternalWindow;
struct SDL_Texture;
struct SDL_Window;
struct SDL_Renderer;
union SDL_Event;
 
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
enum ExternalWindow_HitResult
{
    EXTERNAL_WINDOW_HITTEST_NORMAL = 0,//SDL_HITTEST_NORMAL,
 
    EXTERNAL_WINDOW_HITTEST_DRAGGABLE = 1,//SDL_HITTEST_DRAGGABLE,
 
    EXTERNAL_WINDOW_HITTEST_RESIZE_TOPLEFT = 2,//SDL_HITTEST_RESIZE_TOPLEFT,
 
    EXTERNAL_WINDOW_HITTEST_RESIZE_TOP = 3,//SDL_HITTEST_RESIZE_TOP,
 
    EXTERNAL_WINDOW_HITTEST_RESIZE_TOPRIGHT = 4,//SDL_HITTEST_RESIZE_TOPRIGHT,
 
    EXTERNAL_WINDOW_HITTEST_RESIZE_RIGHT = 5,//SDL_HITTEST_RESIZE_RIGHT,
 
    EXTERNAL_WINDOW_HITTEST_RESIZE_BOTTOMRIGHT = 6,//SDL_HITTEST_RESIZE_BOTTOMRIGHT,
 
    EXTERNAL_WINDOW_HITTEST_RESIZE_BOTTOM = 7,//SDL_HITTEST_RESIZE_BOTTOM,
 
    EXTERNAL_WINDOW_HITTEST_RESIZE_BOTTOMLEFT = 8,//SDL_HITTEST_RESIZE_BOTTOMLEFT,
 
    EXTERNAL_WINDOW_HITTEST_RESIZE_LEFT = 9,//SDL_HITTEST_RESIZE_LEFT
};
 
typedef ExternalWindow_HitResult (*ExternalWindow_HitTestFunc)(ExternalWindow* pWindow, GUI_POINT pPoint, void* pUserData);
 
typedef void (*ExternalWindow_OnResizeFunc)(ExternalWindow* pWindow, GUI_POINT pOldSize, GUI_POINT pNewSize, void* pUserData);
 
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
enum ExternalWindowFlags
{
    EXTERNAL_WINDOW_MINIMIZED = BIT(0),
 
    EXTERNAL_WINDOW_MAXIMIZED = BIT(1),
 
    EXTERNAL_WINDOW_HIDDEN = BIT(2),
 
    EXTERNAL_WINDOW_BORDERLESS = BIT(3),
 
    EXTERNAL_WINDOW_RESIZABLE = BIT(4),
 
    EXTERNAL_WINDOW_HAS_INPUT_FOCUS = BIT(5),
 
    EXTERNAL_WINDOW_HAS_MOUSE_FOCUS = BIT(6),
 
    EXTERNAL_WINDOW_TOOLWINDOW = BIT(7),
 
    EXTERNAL_WINDOW_TOPMOST = BIT(8),
};
 
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
struct EXTERNAL_WINDOW_TEXTURE
{
    SDL_Texture* texture;
};
 
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
class CAVESTORY_MOD_API ExternalWindow
{
public: // Linkage
 
    static SDL_Window* mouse_focused;
    
    static ExternalWindow* first;
 
    ExternalWindow* prev;
 
    ExternalWindow* next;
 
protected: // Protected variables
 
    bool m_bInitialized;
 
    VideoTexture** m_pVideoTextureList;
 
    int m_iVideoTextureCount;
    
    int m_iVideoTextureSize;
 
public: // Callbacks
 
    void* CallbackUserData;
 
    ExternalWindow_OnResizeFunc OnResize;
 
public: // Important variables
 
    ExternalWindow* m_pParent;
 
    ExternalWindow_HitTestFunc m_pHitTestFunc;
 
    void* m_pHitTestUserData;
 
    SDL_Renderer* m_pRenderer;
 
    SDL_Window* m_pWindow;
 
    unsigned int m_iFlags;
 
    EXTERNAL_WINDOW_TEXTURE m_pTextureList[SURFACE_ID_MAX];
    
    VideoTexture* m_pRendererTexture;
 
public: // Cache variables
 
    struct
    {
        GUI_RECT WindowRect;
 
        int WindowID;
    } m_pCache;
 
public: // C++ Stuff
 
    ExternalWindow();
 
    ~ExternalWindow();
 
public: // Protected methods
 
    bool Init(const char* pTitle, GUI_POINT* pPoint, GUI_POINT pSize, unsigned int iFlags = 0, int iMagnification = -1, bool bStartHidden = false);
 
    void Free();
 
    inline bool IsInitialized() { return m_bInitialized; }
 
public: // Update methods
 
    void UpdateFlags();
 
public: // Texture management
 
    void RegisterTexture(VideoTexture* pTexture);
 
    void UnregisterTexture(VideoTexture* pTexture);
 
public: // Window management methods
 
    void SetWindowMinimumSize(GUI_POINT pSize);
    
    void SetWindowMaximumSize(GUI_POINT pSize);
    
    void SetWindowOpacity(unsigned char iOpacity);
    
    unsigned char GetWindowOpacity();
    
    void SetWindowVisible(bool bVisible);
    
    bool IsWindowVisible();
 
    GUI_POINT GetWindowPosition();
 
    void SetWindowPosition(GUI_POINT pNewPosition);
    
    GUI_POINT GetWindowSize();
 
    void SetWindowSize(GUI_POINT pNewSize);
    
    const char* GetWindowTitle();
 
    void SetWindowTitle(const char* pNewTitle);
 
    void FocusWindow();
 
    void Maximize();
    
    void Minimize();
 
public: // Input methods
 
    void OnInputEvent(SDL_Event* pEvent);
 
    void SetHitTestFunc(ExternalWindow_HitTestFunc pFunc, void* pUserData);
 
    GUI_POINT GetMousePosition();
 
    static bool TestWindowInputFocus(ExternalWindow* pWindow);
    
    static bool TestWindowMouseFocus(ExternalWindow* pWindow);
 
public: // Render methods
 
    SDL_Texture* GetSurfaceTexture(Surface_Ids iSurfaceId);
 
    void FlipWindow();
};
 
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
#include <CSMAPI_endcode.h>
 
///