ckTypes.h

Go to the documentation of this file.

/*
 *
 * Clapkit
 * ----------------------------------------------------------------------
 * A wrapper for creating a 'generalized' app for Classic MacOS
 * that (hopefully) can be ported easily to other platforms.
 *
 * CKTypes
 * ----------------------------------------------------------------------
 * App-wide type definitions.
 *
 */
 
#pragma once
 
#include "ckMacros.h"
#include "ckObject.h"
#include "ckProperty.h"
#include "ckUtils.h"
#include <exception>
 
typedef int32_t CKError;
 
#define CKPass 1
 
class CKException : public std::exception {
    public:
        const char* message;
        CKException(const char* msg)
            : message(msg) {}
        const char* what() {
            return this->message;
        }
};
 
enum class CKControlType {
    Unknown = 0,
    PushButton,
    Label,
    Checkbox,
    RadioButton,
    Canvas,
    TextField,
    Dropdown,
};
 
enum class CKMouseButton {
    None = 0,
    Left = 1,
    Middle = 2,
    Right = 3
};
 
enum class CKTextJustification {
    Left = 0,
    Center = 1,
    Right = 2
};
 
struct CKColor {
        u_int8_t r = 0;
        u_int8_t g = 0;
        u_int8_t b = 0;
        u_int8_t a = 255;
 
        CKColor(u_int8_t red, u_int8_t green, u_int8_t blue)
            : r(red), g(green), b(blue) {};
 
        CKColor()
            : r(0), g(0), b() {};
 
        RGBColor ToOS() {
            RGBColor toReturn;
            toReturn.red = r * 255;
            toReturn.green = g * 255;
            toReturn.blue = b * 255;
            return toReturn;
        }
 
        bool operator==(const CKColor& other) const {
            return r == other.r && g == other.g && b == other.b;
        }
 
        bool operator!=(const CKColor& other) const {
            return !(*this == other);
        }
};
 
struct CKPoint {
 
        CKProperty<int> x = 0;
        CKProperty<int> y = 0;
 
        CKPoint(int x, int y)
            : x(x), y(y) {};
        CKPoint()
            : x(0), y(0) {};
 
        Point ToOS() const {
            Point p;
            p.h = x;
            p.v = y;
            return p;
        }
 
        Point* ToOSPtr() {
            Point* p = (Point*)CKMalloc(sizeof(*p));
            p->h = x;
            p->v = y;
            return p;
        }
 
        static CKPoint FromOS(Point p) {
            CKPoint toReturn = {p.h, p.v};
            return toReturn;
        }
 
        inline bool operator==(const CKPoint& other) const {
            return this->x == other.x && this->y == other.y;
        }
 
        inline bool operator!=(const CKPoint& other) const {
            return !(*this == other);
        }
 
        void Subscribe(std::function<void()> cb) {
            x.onChange = cb;
            y.onChange = cb;
        }
};
 
struct CKSize {
 
        CKProperty<int> width = 0;
        CKProperty<int> height = 0;
 
        CKSize(int w, int h)
            : width(w), height(h) {};
 
        CKSize()
            : width(0), height(0) {};
 
        Point ToOS() const {
            Point p;
            p.h = width;
            p.v = height;
            return p;
        }
 
        static CKSize FromOS(Point p) {
            CKSize toReturn;
            toReturn.width = p.h;
            toReturn.height = p.v;
            return toReturn;
        }
 
        inline bool operator==(const CKSize& other) const {
            return this->width == other.width && this->height == other.height;
        }
 
        inline bool operator!=(const CKSize& other) const {
            return !(*this == other);
        }
 
        void Subscribe(std::function<void()> cb) {
            width.onChange = cb;
            height.onChange = cb;
        }
};
 
struct CKRect {
 
        CKProperty<CKPoint> origin;
        CKProperty<CKSize> size;
 
        CKRect(const CKRect& f) {
            this->origin = f.origin;
            this->size = f.size;
        }
 
        CKRect(CKPoint o, CKSize s) {
            this->origin = o;
            this->size = s;
        }
 
        CKRect(int x, int y, int w, int h) {
            this->origin = CKPoint(x, y);
            this->size = CKSize(w, h);
        }
 
        CKRect(int w, int h) {
            this->origin = CKPoint();
            this->size = CKSize(w, h);
        }
 
        CKRect() {
            this->origin = CKPoint();
            this->size = CKSize();
        }
 
        Rect ToOS() const {
            Rect r;
            r.left = this->origin->x;
            r.right = this->origin->x + this->size->width;
            r.top = this->origin->y;
            r.bottom = this->origin->y + this->size->height;
            return r;
        }
 
        Rect* ToOSCopy() {
            Rect* toReturn = (Rect*)CKMalloc((sizeof(*toReturn)));
            toReturn->left = this->origin->x;
            toReturn->right = this->origin->x + this->size->width;
            toReturn->top = this->origin->y;
            toReturn->bottom = this->origin->y + this->size->height;
            return toReturn;
        }
 
        static CKRect FromOS(Rect r) {
            CKRect toReturn;
            toReturn.origin = CKPoint(r.left, r.top);
            toReturn.size = CKSize(r.right - r.left, r.bottom - r.top);
            return toReturn;
        }
 
        bool IntersectsPoint(CKPoint p) {
            if (p.x >= this->origin->x && p.x <= this->origin->x + this->size->width) {
                if (p.y >= this->origin->y && p.y <= this->origin->y + this->size->height) {
                    return true;
                }
            }
            return false;
        }
 
        bool IntersectsRect(CKRect r) {
            return (origin->x < (r.origin->x + r.size->width)) &&
                   ((origin->x + size->width) > r.origin->x) &&
                   (origin->y < (r.origin->y + r.size->height)) &&
                   ((origin->y + size->height) > r.origin->y);
        }
 
        inline bool operator==(const CKRect& other) const {
            return origin->x == other.origin->x &&
                   origin->y == other.origin->y &&
                   size->width == other.size->width &&
                   size->height == other.size->height;
        }
 
        inline bool operator!=(const CKRect& other) const {
            return !(*this == other);
        }
 
        void Subscribe(std::function<void()> cb) {
            origin.onChange = cb;
            size.onChange = cb;
            origin.get().Subscribe(cb);
            size.get().Subscribe(cb);
        }
};
 
enum class CKEventType {
    nullEvent = 0,
 
    click,
 
    doubleClick,
 
    mouseDown,
 
    mouseMove,
 
    mouseUp,
 
    keyDown,
 
    keyUp,
 
    moved,
 
    resized,
 
    deleted,
 
    removed,
 
    changed,
 
    tcpConnectionFailed,
 
    tcpDisconnected,
 
    tcpConnected,
 
    tcpReceivedData,
 
    tcpBufferFull,
 
    dataUndo,
 
    dataCut,
 
    dataCopy,
 
    dataPaste,
 
    dataClear,
 
};
 
class CKWindow;
class CKControl;
 
struct CKEvent {
 
        CKEventType type;
        CKPoint point;
        CKMouseButton mouseButton;
 
        bool shiftDown = false;
        bool cmdDown = false;
        bool optDown = false;
        bool ctrlDown = false;
 
        char key;       // Keycode of the key being pressed/released
        char character; // Character Code (A, B, C..) of the key pressed/released
 
        const CKWindow* window = nullptr;   // always set
        const CKControl* control = nullptr; // can be nullptr for window-only events
 
        CKEvent(CKEventType type)
            : type(type) {}
        CKEvent(CKEventType type, CKPoint point)
            : type(type), point(point) {}
 
        void fillFromOS(EventRecord e) {
            shiftDown = (e.modifiers & shiftKey) == shiftKey;
            cmdDown = (e.modifiers & cmdKey) == cmdKey;
            optDown = (e.modifiers & optionKey) == optionKey;
            ctrlDown = (e.modifiers & controlKey) == controlKey;
        }
};
 
enum class CKSystemIcon {
    noIcon = 0,
    message = 1,
    warning = 2,
    error = 3,
};
 
enum class CKScrollType {
    none = 0,
    vertical = 1,
    horizontal = 2,
    both = 3
};