We are compiling again! Started refactoring UICaption to be more idiomatic

src/UICaption.cpp

@@ -21,3 +21,238 @@ PyObjectsEnum UICaption::derived_type()
 {
     return PyObjectsEnum::UICAPTION;
 }
+
+PyObject* UICaption::get_float_member(PyUICaptionObject* self, void* closure)
+{
+    auto member_ptr = reinterpret_cast<long>(closure);
+    if (member_ptr == 0)
+        return PyFloat_FromDouble(self->data->text.getPosition().x);
+    else if (member_ptr == 1)
+        return PyFloat_FromDouble(self->data->text.getPosition().y);
+    else if (member_ptr == 4)
+        return PyFloat_FromDouble(self->data->text.getOutlineThickness());
+    else if (member_ptr == 5)
+        return PyLong_FromLong(self->data->text.getCharacterSize());
+    else
+    {
+        PyErr_SetString(PyExc_AttributeError, "Invalid attribute");
+        return nullptr;
+    }
+}
+
+int UICaption::set_float_member(PyUICaptionObject* self, PyObject* value, void* closure)
+{
+    float val;
+    auto member_ptr = reinterpret_cast<long>(closure);
+    if (PyFloat_Check(value))
+    {
+        val = PyFloat_AsDouble(value);
+    }
+    else if (PyLong_Check(value))
+    {
+        val = PyLong_AsLong(value);
+    }
+    else
+    {
+        PyErr_SetString(PyExc_TypeError, "Value must be an integer.");
+        return -1;
+    }
+    if (member_ptr == 0) //x
+        self->data->text.setPosition(val, self->data->text.getPosition().y);
+    else if (member_ptr == 1) //y
+        self->data->text.setPosition(self->data->text.getPosition().x, val);
+    else if (member_ptr == 4) //outline
+        self->data->text.setOutlineThickness(val);
+    else if (member_ptr == 5) // character size
+        self->data->text.setCharacterSize(val);
+    return 0;
+}
+
+PyObject* UICaption::get_vec_member(PyUICaptionObject* self, void* closure)
+{
+    return PyVector(self->data->text.getPosition()).pyObject();
+}
+
+int UICaption::set_vec_member(PyUICaptionObject* self, PyObject* value, void* closure)
+{
+    self->data->text.setPosition(PyVector::fromPy(value));
+    return 0;
+}
+
+PyObject* UICaption::get_color_member(PyUICaptionObject* self, void* closure)
+{
+    // TODO: migrate this code to a switch statement - validate closure & return values in one tighter, more extensible structure
+
+    // validate closure (should be impossible to be wrong, but it's thorough)
+    auto member_ptr = reinterpret_cast<long>(closure);
+    if (member_ptr != 0 && member_ptr != 1)
+    {
+        PyErr_SetString(PyExc_AttributeError, "Invalid attribute");
+        return nullptr;
+    }
+
+    // TODO: manually calling tp_alloc to create a PyColorObject seems like an antipattern
+    // fetch correct member data
+    sf::Color color;
+
+    if (member_ptr == 0)
+    {
+        color = self->data->text.getFillColor();
+    }
+    else if (member_ptr == 1)
+    {
+        color = self->data->text.getOutlineColor();
+    }
+
+    return PyColor(color).pyObject();
+}
+
+int UICaption::set_color_member(PyUICaptionObject* self, PyObject* value, void* closure)
+{
+    auto member_ptr = reinterpret_cast<long>(closure);
+    //TODO: this logic of (PyColor instance OR tuple -> sf::color) should be encapsulated for reuse
+    int r, g, b, a;
+    if (PyObject_IsInstance(value, (PyObject*)&mcrfpydef::PyColorType))
+    {
+        // get value from mcrfpy.Color instance
+        auto c = ((PyColorObject*)value)->data;
+        r = c.r; g = c.g; b = c.b; a = c.a;
+        std::cout << "got " << int(r) << ", " << int(g) << ", " << int(b) << ", " << int(a) << std::endl;
+    }
+    else if (!PyTuple_Check(value) || PyTuple_Size(value) < 3 || PyTuple_Size(value) > 4)
+    {
+        // reject non-Color, non-tuple value
+        PyErr_SetString(PyExc_TypeError, "Value must be a tuple of 3 or 4 integers or an mcrfpy.Color object.");
+        return -1;
+    }
+    else // get value from tuples
+    {
+        r = PyLong_AsLong(PyTuple_GetItem(value, 0));
+        g = PyLong_AsLong(PyTuple_GetItem(value, 1));
+        b = PyLong_AsLong(PyTuple_GetItem(value, 2));
+        a = 255;
+
+        if (PyTuple_Size(value) == 4)
+        {
+            a = PyLong_AsLong(PyTuple_GetItem(value, 3));
+        }
+    }
+
+    if (r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255 || a < 0 || a > 255)
+    {
+        PyErr_SetString(PyExc_ValueError, "Color values must be between 0 and 255.");
+        return -1;
+    }
+
+    if (member_ptr == 0)
+    {
+        self->data->text.setFillColor(sf::Color(r, g, b, a));
+    }
+    else if (member_ptr == 1)
+    {
+        self->data->text.setOutlineColor(sf::Color(r, g, b, a));
+    }
+    else
+    {
+        PyErr_SetString(PyExc_AttributeError, "Invalid attribute");
+        return -1;
+    }
+
+    return 0;
+}
+
+
+//TODO: evaluate use of Resources::caption_buffer... can't I do this with a std::string?
+PyObject* UICaption::get_text(PyUICaptionObject* self, void* closure)
+{
+    Resources::caption_buffer = self->data->text.getString();
+    return PyUnicode_FromString(Resources::caption_buffer.c_str());
+}
+
+int UICaption::set_text(PyUICaptionObject* self, PyObject* value, void* closure)
+{
+    PyObject* s = PyObject_Str(value);
+    PyObject * temp_bytes = PyUnicode_AsEncodedString(s, "UTF-8", "strict"); // Owned reference
+    if (temp_bytes != NULL) {
+        Resources::caption_buffer = PyBytes_AS_STRING(temp_bytes); // Borrowed pointer
+        Py_DECREF(temp_bytes);
+    }
+    self->data->text.setString(Resources::caption_buffer);
+    return 0;
+}
+
+PyGetSetDef UICaption::getsetters[] = {
+    {"x", (getter)UICaption::get_float_member, (setter)UICaption::set_float_member, "X coordinate of top-left corner",   (void*)0},
+    {"y", (getter)UICaption::get_float_member, (setter)UICaption::set_float_member, "Y coordinate of top-left corner",   (void*)1},
+    {"pos", (getter)UICaption::get_vec_member, (setter)UICaption::set_vec_member, "(x, y) vector", (void*)0},
+    //{"w", (getter)PyUIFrame_get_float_member, (setter)PyUIFrame_set_float_member, "width of the rectangle",   (void*)2},
+    //{"h", (getter)PyUIFrame_get_float_member, (setter)PyUIFrame_set_float_member, "height of the rectangle",   (void*)3},
+    {"outline", (getter)UICaption::get_float_member, (setter)UICaption::set_float_member, "Thickness of the border",   (void*)4},
+    {"fill_color", (getter)UICaption::get_color_member, (setter)UICaption::set_color_member, "Fill color of the text", (void*)0},
+    {"outline_color", (getter)UICaption::get_color_member, (setter)UICaption::set_color_member, "Outline color of the text", (void*)1},
+    //{"children", (getter)PyUIFrame_get_children, NULL, "UICollection of objects on top of this one", NULL},
+    {"text", (getter)UICaption::get_text, (setter)UICaption::set_text, "The text displayed", NULL},
+    {"size", (getter)UICaption::get_float_member, (setter)UICaption::set_float_member, "Text size (integer) in points", (void*)5},
+    {"click", (getter)UIDrawable::get_click, (setter)UIDrawable::set_click, "Object called with (x, y, button) when clicked", (void*)PyObjectsEnum::UICAPTION},
+    {NULL}
+};
+
+PyObject* UICaption::repr(PyUICaptionObject* self)
+{
+    std::ostringstream ss;
+    if (!self->data) ss << "<Caption (invalid internal object)>";
+    else {
+        auto text = self->data->text;
+        auto fc = text.getFillColor();
+        auto oc = text.getOutlineColor();
+        ss << "<Caption (x=" << text.getPosition().x << ", y=" << text.getPosition().y << ", " <<
+            "text='" << (std::string)text.getString() << "', " <<
+            "outline=" << text.getOutlineThickness() << ", " <<
+            "fill_color=(" << (int)fc.r << ", " << (int)fc.g << ", " << (int)fc.b << ", " << (int)fc.a <<"), " <<
+            "outlinecolor=(" << (int)oc.r << ", " << (int)oc.g << ", " << (int)oc.b << ", " << (int)oc.a <<"), " <<
+            ")>";
+    }
+    std::string repr_str = ss.str();
+    return PyUnicode_DecodeUTF8(repr_str.c_str(), repr_str.size(), "replace");
+}
+
+int UICaption::init(PyUICaptionObject* self, PyObject* args, PyObject* kwds)
+{
+    using namespace mcrfpydef;
+    static const char* keywords[] = { "x", "y", "text", "font", "fill_color", "outline_color", nullptr };
+    float x = 0.0f, y = 0.0f;
+    char* text;
+    PyObject* font, fill_color, outline_color;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|ffzOOO",
+        const_cast<char**>(keywords), &x, &y, &text, &font, &fill_color, &outline_color))
+    {
+        return -1;
+    }
+
+    // check types for font, fill_color, outline_color
+
+    std::cout << PyUnicode_AsUTF8(PyObject_Repr(font)) << std::endl;
+    if (font != NULL && !PyObject_IsInstance(font, (PyObject*)&PyFontType)){
+        PyErr_SetString(PyExc_TypeError, "font must be a mcrfpy.Font instance");
+        return -1;
+    } else if (font != NULL)
+    {
+        auto font_obj = (PyFontObject*)font;
+        self->data->text.setFont(font_obj->data->font);
+        self->font = font;
+        Py_INCREF(font);
+    } else
+    {
+        // default font
+        //self->data->text.setFont(Resources::game->getFont());
+    }
+
+    self->data->text.setPosition(sf::Vector2f(x, y));
+    self->data->text.setString((std::string)text);
+    self->data->text.setFillColor(sf::Color(0,0,0,255));
+    self->data->text.setOutlineColor(sf::Color(128,128,128,255));
+
+    return 0;
+}
+

src/UICaption.h

@@ -19,19 +19,25 @@ class UICaption: public UIDrawable
 public:
     sf::Text text;
     void render(sf::Vector2f) override final;
-    PyObjectsEnum derived_type() override final; // { return PyObjectsEnum::UICaption;  };
+    PyObjectsEnum derived_type() override final;
     virtual UIDrawable* click_at(sf::Vector2f point) override final;
-};
 
-//class UICaption;
+    static PyObject* get_float_member(PyUICaptionObject* self, void* closure);
-//typedef struct {
+    static int set_float_member(PyUICaptionObject* self, PyObject* value, void* closure);
-//    PyObject_HEAD
+    static PyObject* get_vec_member(PyUICaptionObject* self, void* closure);
-//    std::shared_ptr<UICaption> data;
+    static int set_vec_member(PyUICaptionObject* self, PyObject* value, void* closure);
-//    PyObject* font;
+    static PyObject* get_color_member(PyUICaptionObject* self, void* closure);
-//} PyUICaptionObject;
+    static int set_color_member(PyUICaptionObject* self, PyObject* value, void* closure);
+    static PyObject* get_text(PyUICaptionObject* self, void* closure);
+    static int set_text(PyUICaptionObject* self, PyObject* value, void* closure);
+    static PyGetSetDef getsetters[];
+    static PyObject* repr(PyUICaptionObject* self);
+    static int init(PyUICaptionObject* self, PyObject* args, PyObject* kwds);
+};
 
 namespace mcrfpydef {
     //TODO: add this method to class scope; move implementation to .cpp file
+    /*
     static PyObject* PyUICaption_get_float_member(PyUICaptionObject* self, void* closure)
     {
         auto member_ptr = reinterpret_cast<long>(closure);
@@ -49,8 +55,10 @@ namespace mcrfpydef {
             return nullptr;
         }
     }
+    */
 
     //TODO: add this method to class scope; move implementation to .cpp file
+    /*
     static int PyUICaption_set_float_member(PyUICaptionObject* self, PyObject* value, void* closure)
     {
         float val;
@@ -78,8 +86,10 @@ namespace mcrfpydef {
             self->data->text.setCharacterSize(val);
         return 0;
     }
+    */
 
     //TODO: add this method to class scope; move implementation to .cpp file
+    /*
     static PyObject* PyUICaption_get_vec_member(PyUICaptionObject* self, void* closure)
     {
         return PyVector(self->data->text.getPosition()).pyObject();
@@ -91,8 +101,10 @@ namespace mcrfpydef {
         self->data->text.setPosition(PyVector::fromPy(value));
         return 0;
     }
+    */
 
     //TODO: add this method to class scope; move implementation to .cpp file
+    /*
     static PyObject* PyUICaption_get_color_member(PyUICaptionObject* self, void* closure)
     {
         // validate closure (should be impossible to be wrong, but it's thorough)
@@ -118,8 +130,10 @@ namespace mcrfpydef {
 
         return PyColor(color).pyObject();
     }
+    */
 
     //TODO: add this method to class scope; move implementation to .cpp file
+    /*
     static int PyUICaption_set_color_member(PyUICaptionObject* self, PyObject* value, void* closure)
     {
         auto member_ptr = reinterpret_cast<long>(closure);
@@ -173,8 +187,10 @@ namespace mcrfpydef {
 
         return 0;
     }
+    */
 
     //TODO: add this method to class scope; move implementation to .cpp file
+    /*
     static PyObject* PyUICaption_get_text(PyUICaptionObject* self, void* closure)
     {
         Resources::caption_buffer = self->data->text.getString();
@@ -193,8 +209,10 @@ namespace mcrfpydef {
         self->data->text.setString(Resources::caption_buffer);
         return 0;
     }
+    */
 
     //TODO: add this static array to class scope; move implementation to .cpp file
+    /*
     static PyGetSetDef PyUICaption_getsetters[] = {
         {"x", (getter)PyUICaption_get_float_member, (setter)PyUICaption_set_float_member, "X coordinate of top-left corner",   (void*)0},
         {"y", (getter)PyUICaption_get_float_member, (setter)PyUICaption_set_float_member, "Y coordinate of top-left corner",   (void*)1},
@@ -210,8 +228,10 @@ namespace mcrfpydef {
         {"click", (getter)UIDrawable::get_click, (setter)UIDrawable::set_click, "Object called with (x, y, button) when clicked", (void*)PyObjectsEnum::UICAPTION},
         {NULL}
     };
+    */
 
     //TODO: add this method to class scope; move implementation to .cpp file
+    /*
     static PyObject* PyUICaption_repr(PyUICaptionObject* self)
     {
         std::ostringstream ss;
@@ -230,8 +250,10 @@ namespace mcrfpydef {
         std::string repr_str = ss.str();
         return PyUnicode_DecodeUTF8(repr_str.c_str(), repr_str.size(), "replace");
     }
+    */
 
     //TODO: add this method to class scope; move implementation to .cpp file
+    /*
     static int PyUICaption_init(PyUICaptionObject* self, PyObject* args, PyObject* kwds)
     {
         //std::cout << "Init called\n";
@@ -271,21 +293,24 @@ namespace mcrfpydef {
 
         return 0;
     }
+    */
 
     static PyTypeObject PyUICaptionType = {
         //PyVarObject_HEAD_INIT(NULL, 0)
         .tp_name = "mcrfpy.Caption",
         .tp_basicsize = sizeof(PyUICaptionObject),
         .tp_itemsize = 0,
+        // TODO - move tp_dealloc to .cpp file as static function (UICaption::dealloc)
         .tp_dealloc = (destructor)[](PyObject* self)
         {
             PyUICaptionObject* obj = (PyUICaptionObject*)self;
+            // TODO - reevaluate with PyFont usage; UICaption does not own the font
             // release reference to font object
             if (obj->font) Py_DECREF(obj->font);
             obj->data.reset();
             Py_TYPE(self)->tp_free(self);
         },
-        .tp_repr = (reprfunc)PyUICaption_repr,
+        .tp_repr = (reprfunc)UICaption::repr,
         //.tp_hash = NULL,
         //.tp_iter
         //.tp_iternext
@@ -293,9 +318,10 @@ namespace mcrfpydef {
         .tp_doc = PyDoc_STR("docstring"),
         //.tp_methods = PyUIFrame_methods,
         //.tp_members = PyUIFrame_members,
-        .tp_getset = PyUICaption_getsetters,
+        .tp_getset = UICaption::getsetters,
         //.tp_base = NULL,
-        .tp_init = (initproc)PyUICaption_init,
+        .tp_init = (initproc)UICaption::init,
+        // TODO - move tp_new to .cpp file as a static function (UICaption::new)
         .tp_new = [](PyTypeObject* type, PyObject* args, PyObject* kwds) -> PyObject*
         {
             PyUICaptionObject* self = (PyUICaptionObject*)type->tp_alloc(type, 0);

src/UIDrawable.cpp

@@ -75,4 +75,7 @@ int UIDrawable::set_click(PyObject* self, PyObject* value, void* closure) {
     return 0;
 }
 
-
+void UIDrawable::click_register(PyObject* callable)
+{
+    click_callable = std::make_unique<PyClickCallable>(callable);
+}

src/UIEntity.cpp

@@ -1,4 +1,5 @@
 #include "UIEntity.h"
+#include "UIGrid.h"
 
 UIEntity::UIEntity() {} // this will not work lol. TODO remove default constructor by finding the shared pointer inits that use it
 
@@ -19,7 +20,7 @@ PyObject* UIEntity::at(PyUIEntityObject* self, PyObject* o) {
         return NULL;
     }
     
-    PyUIGridPointStateObject* obj = (PyUIGridPointStateObject*)((&PyUIGridPointStateType)->tp_alloc(&PyUIGridPointStateType, 0));
+    PyUIGridPointStateObject* obj = (PyUIGridPointStateObject*)((&mcrfpydef::PyUIGridPointStateType)->tp_alloc(&mcrfpydef::PyUIGridPointStateType, 0));
     //auto target = std::static_pointer_cast<UIEntity>(target);
     obj->data = &(self->data->gridstate[y + self->data->grid->grid_x * x]);
     obj->grid = self->data->grid;
@@ -28,7 +29,7 @@ PyObject* UIEntity::at(PyUIEntityObject* self, PyObject* o) {
 
 }
 
-int PyUIEntity::init(PyUIEntityObject* self, PyObject* args, PyObject* kwds) {
+int UIEntity::init(PyUIEntityObject* self, PyObject* args, PyObject* kwds) {
     static const char* keywords[] = { "x", "y", "texture", "sprite_index", "grid", nullptr };
     float x = 0.0f, y = 0.0f, scale = 1.0f;
     int sprite_index = -1;
@@ -57,7 +58,7 @@ int PyUIEntity::init(PyUIEntityObject* self, PyObject* args, PyObject* kwds) {
         // default tex?
     }*/
 
-    if (grid != NULL && !PyObject_IsInstance(grid, (PyObject*)&PyUIGridType)) {
+    if (grid != NULL && !PyObject_IsInstance(grid, (PyObject*)&mcrfpydef::PyUIGridType)) {
         PyErr_SetString(PyExc_TypeError, "grid must be a mcrfpy.Grid instance");
         return -1;
     }

src/UIEntity.h

@@ -15,6 +15,8 @@
 #include "UIGridPoint.h"
 #include "UIDrawable.h"
 #include "UIBase.h"
+#include "UISprite.h"
+
 class UIGrid;
 
 //class UIEntity;

src/UIFrame.cpp

@@ -1,5 +1,6 @@
 #include "UIFrame.h"
 #include "UICollection.h"
+#include "GameEngine.h"
 
 UIDrawable* UIFrame::click_at(sf::Vector2f point)
 {
@@ -54,10 +55,10 @@ void UIFrame::render(sf::Vector2f offset)
     }
 }
 
-PyObject* PyUIFrame::get_children(PyUIFrameObject* self, void* closure)
+PyObject* UIFrame::get_children(PyUIFrameObject* self, void* closure)
 {
     // create PyUICollection instance pointing to self->data->children
-    PyUICollectionObject* o = (PyUICollectionObject*)PyUICollectionType.tp_alloc(&PyUICollectionType, 0);
+    PyUICollectionObject* o = (PyUICollectionObject*)mcrfpydef::PyUICollectionType.tp_alloc(&mcrfpydef::PyUICollectionType, 0);
     if (o)
         o->data = self->data->children;
     return (PyObject*)o;

src/UIGrid.cpp

@@ -1,4 +1,5 @@
 #include "UIGrid.h"
+#include "GameEngine.h"
 
 UIGrid::UIGrid() {}
 
@@ -188,3 +189,12 @@ std::shared_ptr<PyTexture> UIGrid::getTexture()
 {
     return ptex;
 }
+
+UIDrawable* UIGrid::click_at(sf::Vector2f point)
+{
+    if (click_callable)
+    {
+        if(box.getGlobalBounds().contains(point)) return this;
+    }
+    return NULL;
+}

src/UIGridPoint.h

@@ -30,6 +30,7 @@ public:
 };
 
 class UIGrid;
+class UIEntity;
 
 typedef struct {
     PyObject_HEAD

src/UISprite.cpp

@@ -1,4 +1,5 @@
 #include "UISprite.h"
+#include "GameEngine.h"
 
 UIDrawable* UISprite::click_at(sf::Vector2f point)
 {

src/UISprite.h

@@ -12,6 +12,7 @@
 #include "PyVector.h"
 #include "PyFont.h"
 #include "UIDrawable.h"
+#include "UIBase.h"
 
 class UISprite: public UIDrawable
 {