Window.h

#pragma once
#include <cstdint>
#include <memory>
#include <string>
#include <vector>
 
#include "WindowFlags.h"
#include "WindowStyle.h"
#include <Cyrus/Classes/PropertyClass.h>
#include <Cyrus/shared.h>
#include <cstdint>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
 
class ControlButton;
class ControlEdit;
struct WindowLayout;
 
class Window;
 
typedef int64_t (*ClickResponder_t)(Window *element);
 
#pragma pack(push, 1)
class ManagedList {
  void *vftable;                               // 0x00
  std::list<ClickResponder_t> clickResponders; // 0x8
 
public:
  std::list<ClickResponder_t> getList() { return clickResponders; }
};
#pragma pack(pop)
 
#pragma pack(push, 1)
class Window : public PropertyClass {
private:
  float N00000A81;                               // 0x0048
  int32_t windowID;                              // 0x004C
  std::string m_sName;                           // 0x50
  std::vector<std::shared_ptr<Window>> children; // 0x70
  Window *parent;                                // 0x88
  void *inputHandler; // 0x90 seems to handle all input, even mouse position,
                      // key presses, etc.
  WindowStyle_internal m_Style; // 0x0098
  WindowFlags_internal m_Flags; // 0x009C
  Rect transform;               // 0xA0
  VectorI2D parentOffset;       // 0xB0
  char pad_00B8[8];             // 0x00B8
  VectorI2D offset;             // 0xC0
  Vector2D scale;               // 0xC8
  uint32_t N00000417;           // 0x00D0
  float m_fTargetAlpha;         // 0x00D4
  float m_fDisabledAlpha;       // 0x00D8
  float N000008E4;              // 0x00DC
  float screen_time;      // 0x00E0 // seconds this window has been displayed on
                          // screen
  float screen_time_;     // 0x00E4 // seconds this window has been displayed on
                          // screen
  int64_t m_pWindowStyle; // 0x00E8
  void *soundDescriptor;  // 0x00F0
  std::wstring m_sHelp;   // 0x00F8
  char pad_0118[0x48];    // 0x0118
  std::string m_sScript;  // 0x0160
  uintptr_t pad_d;        // 0x180
  std::wstring m_sTip;    // 0x0188
  void *m_BubbleList;     // 0x01A8
  char pad_01B0[16];      // 0x01B0
  void *artDescriptor;    // 0x01C0
  char pad_01C8[120];     // 0x01C8
  char **internalClassName; // 0x0240
 
public:
  CYRUS int32_t getWindowID() const;
 
  CYRUS std::list<ClickResponder_t> getClickResponders();
 
  CYRUS std::string getName();
 
  CYRUS std::vector<std::shared_ptr<Window>> getChildren();
 
  CYRUS Window *getParent();
 
  CYRUS std::string getFlags();
 
  CYRUS std::string getStyles();
 
  CYRUS void addFlag(uint32_t flag);
 
  CYRUS void addStyle(uint32_t style);
 
  CYRUS void toggleFlag(uint32_t flag);
 
  CYRUS void toggleStyle(uint32_t style);
 
  CYRUS void removeFlag(uint32_t flag);
 
  CYRUS void removeStyle(uint32_t style);
 
  CYRUS Rect *getTransform();
 
  CYRUS void setTransform(Rect in);
 
  CYRUS VectorI2D getParentOffset() const;
 
  CYRUS float getTimeOnScreen() const;
 
  CYRUS void setTimeOnScreen(float screenTime);
 
  CYRUS float getDisabledAlpha() const;
 
  CYRUS void setFDisabledAlpha(float fDisabledAlpha);
 
  CYRUS float getTargetAlpha() const;
 
  CYRUS void setFTargetAlpha(float fTargetAlpha);
 
  CYRUS Vector2D getScale() const;
 
  CYRUS void setScale(float x, float y);
 
  CYRUS VectorI2D getOffset() const;
 
  CYRUS void performScale(float factor);
 
  template <class T> CYRUS T *findChild(const std::string &name) {
    for (auto &child : children) {
      if (child->getName() == name) {
        return child->as<T>();
      }
    }
    return nullptr;
  }
 
  template <class T> CYRUS T *findDescendant(const std::string &name) {
    for (auto &child : children) {
      if (child->getName() == name) {
        return child->as<T>();
      }
      T *descendant = child->findDescendant<T>(name);
      if (descendant != nullptr) {
        return descendant;
      }
    }
    return nullptr;
  }
 
public:
  virtual void func1();
  virtual void func2();
  virtual void func3();
  virtual void func4();
  virtual void func5();
  virtual void func6();
  virtual void func7();
  virtual void func8();
  virtual void func9();
  virtual void func10();
  virtual void func11();
  virtual void func12();
  virtual void func13();
  virtual void func14();
  virtual void func15();
  virtual void func16();
  virtual void func17();
  virtual void func18();
  virtual void func19();
  virtual void func20();
  virtual void func21();
  virtual void func22();
  virtual void func23();
  virtual void func24();
  virtual void func25();
  virtual void func26();
  virtual void func27();
  virtual void func28();
  virtual void func29();
  virtual void func30();
  virtual void func31();
  virtual void func32();
  virtual void func33();
  virtual void func34();
  virtual void func35();
  virtual bool updateDockPosition();
 
private:
  friend struct WindowLayout;
};
 
STATIC_ASSERT(sizeof(Window) == 0x248, "Window size is not correct");
struct WindowLayout {
  DEFINE_OFFSET_AND_STATIC_ASSERT(Window, N00000A81, 0x48);
  DEFINE_OFFSET_AND_STATIC_ASSERT(Window, windowID, 0x4C);
  DEFINE_OFFSET_AND_STATIC_ASSERT(Window, m_sName, 0x50);
  DEFINE_OFFSET_AND_STATIC_ASSERT(Window, children, 0x70);
  DEFINE_OFFSET_AND_STATIC_ASSERT(Window, parent, 0x88);
  DEFINE_OFFSET_AND_STATIC_ASSERT(Window, inputHandler, 0x90);
  DEFINE_OFFSET_AND_STATIC_ASSERT(Window, m_Style, 0x98);
  DEFINE_OFFSET_AND_STATIC_ASSERT(Window, m_Flags, 0x9C);
  DEFINE_OFFSET_AND_STATIC_ASSERT(Window, transform, 0xA0);
  DEFINE_OFFSET_AND_STATIC_ASSERT(Window, parentOffset, 0xB0);
  DEFINE_OFFSET_AND_STATIC_ASSERT(Window, pad_00B8, 0xB8);
  DEFINE_OFFSET_AND_STATIC_ASSERT(Window, offset, 0xC0);
  DEFINE_OFFSET_AND_STATIC_ASSERT(Window, scale, 0xC8);
  DEFINE_OFFSET_AND_STATIC_ASSERT(Window, N00000417, 0xD0);
  DEFINE_OFFSET_AND_STATIC_ASSERT(Window, m_fTargetAlpha, 0xD4);
  DEFINE_OFFSET_AND_STATIC_ASSERT(Window, m_fDisabledAlpha, 0xD8);
  DEFINE_OFFSET_AND_STATIC_ASSERT(Window, N000008E4, 0xDC);
  DEFINE_OFFSET_AND_STATIC_ASSERT(Window, screen_time, 0xE0);
  DEFINE_OFFSET_AND_STATIC_ASSERT(Window, screen_time_, 0xE4);
  DEFINE_OFFSET_AND_STATIC_ASSERT(Window, m_pWindowStyle, 0xE8);
  DEFINE_OFFSET_AND_STATIC_ASSERT(Window, soundDescriptor, 0xF0);
  DEFINE_OFFSET_AND_STATIC_ASSERT(Window, m_sHelp, 0xF8);
  DEFINE_OFFSET_AND_STATIC_ASSERT(Window, pad_0118, 0x118);
  DEFINE_OFFSET_AND_STATIC_ASSERT(Window, m_sScript, 0x160);
  DEFINE_OFFSET_AND_STATIC_ASSERT(Window, m_sTip, 0x188);
  DEFINE_OFFSET_AND_STATIC_ASSERT(Window, m_BubbleList, 0x1A8);
  DEFINE_OFFSET_AND_STATIC_ASSERT(Window, pad_01B0, 0x1B0);
  DEFINE_OFFSET_AND_STATIC_ASSERT(Window, artDescriptor, 0x1C0);
  DEFINE_OFFSET_AND_STATIC_ASSERT(Window, pad_01C8, 0x1C8);
  DEFINE_OFFSET_AND_STATIC_ASSERT(Window, internalClassName, 0x240);
};
#pragma pack(pop)