319 lines
14 KiB
C++
319 lines
14 KiB
C++
#pragma once
|
|
#include "Python.h"
|
|
#include "McRFPy_Doc.h"
|
|
#include "PyPositionHelper.h"
|
|
#include <memory>
|
|
|
|
class UIEntity;
|
|
typedef struct {
|
|
PyObject_HEAD
|
|
std::shared_ptr<UIEntity> data;
|
|
PyObject* weakreflist; // Weak reference support
|
|
} PyUIEntityObject;
|
|
|
|
class UIFrame;
|
|
typedef struct {
|
|
PyObject_HEAD
|
|
std::shared_ptr<UIFrame> data;
|
|
PyObject* weakreflist; // Weak reference support
|
|
} PyUIFrameObject;
|
|
|
|
class UICaption;
|
|
typedef struct {
|
|
PyObject_HEAD
|
|
std::shared_ptr<UICaption> data;
|
|
PyObject* font;
|
|
PyObject* weakreflist; // Weak reference support
|
|
} PyUICaptionObject;
|
|
|
|
class UIGrid;
|
|
typedef struct {
|
|
PyObject_HEAD
|
|
std::shared_ptr<UIGrid> data;
|
|
PyObject* weakreflist; // Weak reference support
|
|
} PyUIGridObject;
|
|
|
|
class UISprite;
|
|
typedef struct {
|
|
PyObject_HEAD
|
|
std::shared_ptr<UISprite> data;
|
|
PyObject* weakreflist; // Weak reference support
|
|
} PyUISpriteObject;
|
|
|
|
// Common Python method implementations for UIDrawable-derived classes
|
|
// These template functions provide shared functionality for Python bindings
|
|
|
|
// move method implementation (#98)
|
|
template<typename T>
|
|
static PyObject* UIDrawable_move(T* self, PyObject* args, PyObject* kwds)
|
|
{
|
|
float dx, dy;
|
|
if (!PyPosition_ParseFloat(args, kwds, &dx, &dy)) {
|
|
return NULL;
|
|
}
|
|
|
|
self->data->move(dx, dy);
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
// resize method implementation (#98)
|
|
template<typename T>
|
|
static PyObject* UIDrawable_resize(T* self, PyObject* args, PyObject* kwds)
|
|
{
|
|
float w, h;
|
|
if (!PyPosition_ParseFloat(args, kwds, &w, &h)) {
|
|
return NULL;
|
|
}
|
|
|
|
self->data->resize(w, h);
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
// animate method implementation - shorthand for creating and starting animations
|
|
// This free function is implemented in UIDrawable.cpp
|
|
// We use a free function instead of UIDrawable::animate_helper to avoid incomplete type issues
|
|
class UIDrawable;
|
|
PyObject* UIDrawable_animate_impl(std::shared_ptr<UIDrawable> target, PyObject* args, PyObject* kwds);
|
|
|
|
template<typename T>
|
|
static PyObject* UIDrawable_animate(T* self, PyObject* args, PyObject* kwds)
|
|
{
|
|
return UIDrawable_animate_impl(self->data, args, kwds);
|
|
}
|
|
|
|
// Macro to add common UIDrawable methods to a method array (without animate - for base types)
|
|
// #185: Removed get_bounds method - use .bounds property instead
|
|
#define UIDRAWABLE_METHODS_BASE \
|
|
{"move", (PyCFunction)UIDrawable_move<PyObjectType>, METH_VARARGS | METH_KEYWORDS, \
|
|
MCRF_METHOD(Drawable, move, \
|
|
MCRF_SIG("(dx, dy) or (delta)", "None"), \
|
|
MCRF_DESC("Move the element by a relative offset."), \
|
|
MCRF_ARGS_START \
|
|
MCRF_ARG("dx", "Horizontal offset in pixels (or use delta)") \
|
|
MCRF_ARG("dy", "Vertical offset in pixels (or use delta)") \
|
|
MCRF_ARG("delta", "Offset as tuple, list, or Vector: (dx, dy)") \
|
|
MCRF_NOTE("Accepts move(dx, dy), move((dx, dy)), move(Vector), or move(pos=(dx, dy)).") \
|
|
)}, \
|
|
{"resize", (PyCFunction)UIDrawable_resize<PyObjectType>, METH_VARARGS | METH_KEYWORDS, \
|
|
MCRF_METHOD(Drawable, resize, \
|
|
MCRF_SIG("(width, height) or (size)", "None"), \
|
|
MCRF_DESC("Resize the element to new dimensions."), \
|
|
MCRF_ARGS_START \
|
|
MCRF_ARG("width", "New width in pixels (or use size)") \
|
|
MCRF_ARG("height", "New height in pixels (or use size)") \
|
|
MCRF_ARG("size", "Size as tuple, list, or Vector: (width, height)") \
|
|
MCRF_NOTE("Accepts resize(w, h), resize((w, h)), resize(Vector), or resize(pos=(w, h)).") \
|
|
)}
|
|
|
|
// Macro to add common UIDrawable methods to a method array (includes animate for UIDrawable derivatives)
|
|
#define UIDRAWABLE_METHODS \
|
|
UIDRAWABLE_METHODS_BASE, \
|
|
{"animate", (PyCFunction)UIDrawable_animate<PyObjectType>, METH_VARARGS | METH_KEYWORDS, \
|
|
MCRF_METHOD(Drawable, animate, \
|
|
MCRF_SIG("(property: str, target: Any, duration: float, easing=None, delta=False, callback=None, conflict_mode='replace')", "Animation"), \
|
|
MCRF_DESC("Create and start an animation on this drawable's property."), \
|
|
MCRF_ARGS_START \
|
|
MCRF_ARG("property", "Name of the property to animate (e.g., 'x', 'fill_color', 'opacity')") \
|
|
MCRF_ARG("target", "Target value - type depends on property (float, tuple for color/vector, etc.)") \
|
|
MCRF_ARG("duration", "Animation duration in seconds") \
|
|
MCRF_ARG("easing", "Easing function: Easing enum value, string name, or None for linear") \
|
|
MCRF_ARG("delta", "If True, target is relative to current value; if False, target is absolute") \
|
|
MCRF_ARG("callback", "Optional callable invoked when animation completes") \
|
|
MCRF_ARG("conflict_mode", "'replace' (default), 'queue', or 'error' if property already animating") \
|
|
MCRF_RETURNS("Animation object for monitoring progress") \
|
|
MCRF_RAISES("ValueError", "If property name is not valid for this drawable type") \
|
|
MCRF_NOTE("This is a convenience method that creates an Animation, starts it, and adds it to the AnimationManager.") \
|
|
)}, \
|
|
{"realign", (PyCFunction)UIDrawable::py_realign, METH_NOARGS, \
|
|
MCRF_METHOD(Drawable, realign, \
|
|
MCRF_SIG("()", "None"), \
|
|
MCRF_DESC("Reapply alignment relative to parent, useful for responsive layouts."), \
|
|
MCRF_NOTE("Call this to recalculate position after parent changes size. " \
|
|
"For elements with align=None, this has no effect.") \
|
|
)}
|
|
|
|
// Legacy macro for backwards compatibility - same as UIDRAWABLE_METHODS
|
|
#define UIDRAWABLE_METHODS_FULL UIDRAWABLE_METHODS
|
|
|
|
// Macro for handling alignment in constructors
|
|
// Usage: UIDRAWABLE_PROCESS_ALIGNMENT(self->data, align_obj, margin, horiz_margin, vert_margin)
|
|
// Returns -1 on error (suitable for use in tp_init functions)
|
|
#define UIDRAWABLE_PROCESS_ALIGNMENT(self_data, align_obj, margin, horiz_margin, vert_margin) \
|
|
do { \
|
|
if ((align_obj) && (align_obj) != Py_None) { \
|
|
AlignmentType _align; \
|
|
if (!PyAlignment::from_arg(align_obj, &_align)) { \
|
|
return -1; \
|
|
} \
|
|
if (!UIDrawable::validateMargins(_align, margin, horiz_margin, vert_margin)) { \
|
|
return -1; \
|
|
} \
|
|
(self_data)->align_type = _align; \
|
|
(self_data)->align_margin = margin; \
|
|
(self_data)->align_horiz_margin = horiz_margin; \
|
|
(self_data)->align_vert_margin = vert_margin; \
|
|
} \
|
|
} while (0)
|
|
|
|
// Property getters/setters for visible and opacity
|
|
template<typename T>
|
|
static PyObject* UIDrawable_get_visible(T* self, void* closure)
|
|
{
|
|
return PyBool_FromLong(self->data->visible);
|
|
}
|
|
|
|
template<typename T>
|
|
static int UIDrawable_set_visible(T* self, PyObject* value, void* closure)
|
|
{
|
|
if (!PyBool_Check(value)) {
|
|
PyErr_SetString(PyExc_TypeError, "visible must be a boolean");
|
|
return -1;
|
|
}
|
|
self->data->visible = PyObject_IsTrue(value);
|
|
return 0;
|
|
}
|
|
|
|
template<typename T>
|
|
static PyObject* UIDrawable_get_opacity(T* self, void* closure)
|
|
{
|
|
return PyFloat_FromDouble(self->data->opacity);
|
|
}
|
|
|
|
template<typename T>
|
|
static int UIDrawable_set_opacity(T* self, PyObject* value, void* closure)
|
|
{
|
|
float opacity;
|
|
if (PyFloat_Check(value)) {
|
|
opacity = PyFloat_AsDouble(value);
|
|
} else if (PyLong_Check(value)) {
|
|
opacity = PyLong_AsDouble(value);
|
|
} else {
|
|
PyErr_SetString(PyExc_TypeError, "opacity must be a number");
|
|
return -1;
|
|
}
|
|
|
|
// Clamp to valid range
|
|
if (opacity < 0.0f) opacity = 0.0f;
|
|
if (opacity > 1.0f) opacity = 1.0f;
|
|
|
|
self->data->opacity = opacity;
|
|
return 0;
|
|
}
|
|
|
|
// Macro to add common UIDrawable properties to a getsetters array
|
|
#define UIDRAWABLE_GETSETTERS \
|
|
{"visible", (getter)UIDrawable_get_visible<PyObjectType>, (setter)UIDrawable_set_visible<PyObjectType>, \
|
|
MCRF_PROPERTY(visible, \
|
|
"Whether the object is visible (bool). " \
|
|
"Invisible objects are not rendered or clickable." \
|
|
), NULL}, \
|
|
{"opacity", (getter)UIDrawable_get_opacity<PyObjectType>, (setter)UIDrawable_set_opacity<PyObjectType>, \
|
|
MCRF_PROPERTY(opacity, \
|
|
"Opacity level (0.0 = transparent, 1.0 = opaque). " \
|
|
"Automatically clamped to valid range [0.0, 1.0]." \
|
|
), NULL}
|
|
|
|
// #122 & #102: Macro for parent/global_position properties (requires closure with type enum)
|
|
// These need the PyObjectsEnum value in closure, so they're added separately in each class
|
|
#define UIDRAWABLE_PARENT_GETSETTERS(type_enum) \
|
|
{"parent", (getter)UIDrawable::get_parent, (setter)UIDrawable::set_parent, \
|
|
MCRF_PROPERTY(parent, \
|
|
"Parent drawable. " \
|
|
"Get: Returns the parent Frame/Grid if nested, or None if at scene level. " \
|
|
"Set: Assign a Frame/Grid to reparent, or None to remove from parent." \
|
|
), (void*)type_enum}, \
|
|
{"global_position", (getter)UIDrawable::get_global_pos, NULL, \
|
|
MCRF_PROPERTY(global_position, \
|
|
"Global screen position (read-only). " \
|
|
"Calculates absolute position by walking up the parent chain." \
|
|
), (void*)type_enum}, \
|
|
{"bounds", (getter)UIDrawable::get_bounds_py, NULL, \
|
|
MCRF_PROPERTY(bounds, \
|
|
"Bounding box as (pos, size) tuple of Vectors. Returns (Vector(x, y), Vector(width, height))." \
|
|
), (void*)type_enum}, \
|
|
{"global_bounds", (getter)UIDrawable::get_global_bounds_py, NULL, \
|
|
MCRF_PROPERTY(global_bounds, \
|
|
"Bounding box as (pos, size) tuple of Vectors in screen coordinates. Returns (Vector(x, y), Vector(width, height))." \
|
|
), (void*)type_enum}, \
|
|
{"on_enter", (getter)UIDrawable::get_on_enter, (setter)UIDrawable::set_on_enter, \
|
|
MCRF_PROPERTY(on_enter, \
|
|
"Callback for mouse enter events. " \
|
|
"Called with (pos: Vector, button: str, action: str) when mouse enters this element's bounds." \
|
|
), (void*)type_enum}, \
|
|
{"on_exit", (getter)UIDrawable::get_on_exit, (setter)UIDrawable::set_on_exit, \
|
|
MCRF_PROPERTY(on_exit, \
|
|
"Callback for mouse exit events. " \
|
|
"Called with (pos: Vector, button: str, action: str) when mouse leaves this element's bounds." \
|
|
), (void*)type_enum}, \
|
|
{"hovered", (getter)UIDrawable::get_hovered, NULL, \
|
|
MCRF_PROPERTY(hovered, \
|
|
"Whether mouse is currently over this element (read-only). " \
|
|
"Updated automatically by the engine during mouse movement." \
|
|
), (void*)type_enum}, \
|
|
{"on_move", (getter)UIDrawable::get_on_move, (setter)UIDrawable::set_on_move, \
|
|
MCRF_PROPERTY(on_move, \
|
|
"Callback for mouse movement within bounds. " \
|
|
"Called with (pos: Vector, button: str, action: str) for each mouse movement while inside. " \
|
|
"Performance note: Called frequently during movement - keep handlers fast." \
|
|
), (void*)type_enum}
|
|
|
|
// Alignment system - automatic positioning relative to parent bounds
|
|
#define UIDRAWABLE_ALIGNMENT_GETSETTERS(type_enum) \
|
|
{"align", (getter)UIDrawable::get_align, (setter)UIDrawable::set_align, \
|
|
MCRF_PROPERTY(align, \
|
|
"Alignment relative to parent bounds (Alignment enum or None). " \
|
|
"When set, position is automatically calculated when parent is assigned or resized. " \
|
|
"Set to None to disable alignment and use manual positioning." \
|
|
), (void*)type_enum}, \
|
|
{"margin", (getter)UIDrawable::get_margin, (setter)UIDrawable::set_margin, \
|
|
MCRF_PROPERTY(margin, \
|
|
"General margin from edge when aligned (float). " \
|
|
"Applied to both horizontal and vertical edges unless overridden. " \
|
|
"Invalid for CENTER alignment (raises ValueError)." \
|
|
), (void*)type_enum}, \
|
|
{"horiz_margin", (getter)UIDrawable::get_horiz_margin, (setter)UIDrawable::set_horiz_margin, \
|
|
MCRF_PROPERTY(horiz_margin, \
|
|
"Horizontal margin override (float, 0 = use general margin). " \
|
|
"Invalid for vertically-centered alignments (TOP_CENTER, BOTTOM_CENTER, CENTER)." \
|
|
), (void*)type_enum}, \
|
|
{"vert_margin", (getter)UIDrawable::get_vert_margin, (setter)UIDrawable::set_vert_margin, \
|
|
MCRF_PROPERTY(vert_margin, \
|
|
"Vertical margin override (float, 0 = use general margin). " \
|
|
"Invalid for horizontally-centered alignments (CENTER_LEFT, CENTER_RIGHT, CENTER)." \
|
|
), (void*)type_enum}
|
|
|
|
// Rotation support - rotation angle and transform origin
|
|
#define UIDRAWABLE_ROTATION_GETSETTERS(type_enum) \
|
|
{"rotation", (getter)UIDrawable::get_rotation, (setter)UIDrawable::set_rotation, \
|
|
MCRF_PROPERTY(rotation, \
|
|
"Rotation angle in degrees (clockwise around origin). " \
|
|
"Animatable property." \
|
|
), (void*)type_enum}, \
|
|
{"origin", (getter)UIDrawable::get_origin, (setter)UIDrawable::set_origin, \
|
|
MCRF_PROPERTY(origin, \
|
|
"Transform origin as Vector (pivot point for rotation). " \
|
|
"Default (0,0) is top-left; set to (w/2, h/2) to rotate around center." \
|
|
), (void*)type_enum}, \
|
|
{"rotate_with_camera", (getter)UIDrawable::get_rotate_with_camera, (setter)UIDrawable::set_rotate_with_camera, \
|
|
MCRF_PROPERTY(rotate_with_camera, \
|
|
"Whether to rotate visually with parent Grid's camera_rotation (bool). " \
|
|
"False (default): stay screen-aligned. True: tilt with camera. " \
|
|
"Only affects children of UIGrid; ignored for other parents." \
|
|
), (void*)type_enum}
|
|
|
|
// #106: Shader support - GPU-accelerated visual effects
|
|
#define UIDRAWABLE_SHADER_GETSETTERS(type_enum) \
|
|
{"shader", (getter)UIDrawable::get_shader, (setter)UIDrawable::set_shader, \
|
|
MCRF_PROPERTY(shader, \
|
|
"Shader for GPU visual effects (Shader or None). " \
|
|
"When set, the drawable is rendered through the shader program. " \
|
|
"Set to None to disable shader effects." \
|
|
), (void*)type_enum}, \
|
|
{"uniforms", (getter)UIDrawable::get_uniforms, NULL, \
|
|
MCRF_PROPERTY(uniforms, \
|
|
"Collection of shader uniforms (read-only access to collection). " \
|
|
"Set uniforms via dict-like syntax: drawable.uniforms['name'] = value. " \
|
|
"Supports float, vec2/3/4 tuples, PropertyBinding, and CallableBinding." \
|
|
), (void*)type_enum}
|
|
|
|
// UIEntity specializations are defined in UIEntity.cpp after UIEntity class is complete
|