Re-implement outline with color and size properties.

Author: narilee2006

buildconfig/stubs/pygame/font.pyi

@@ -57,9 +57,13 @@ class Font:
     @point_size.setter
     def point_size(self, value: int) -> None: ...
     @property
-    def outline(self) -> int: ...
-    @outline.setter
-    def outline(self, value: int) -> None: ...
+    def outline_size(self) -> int: ...
+    @outline_size.setter
+    def outline_size(self, value: int) -> None: ...
+    @property
+    def outline_color(self) -> ColorValue: ...
+    @outline_color.setter
+    def outline_color(self, value: ColorValue) -> None: ...
     def __init__(self, filename: Optional[FileArg] = None, size: int = 20) -> None: ...
     def render(
         self,

docs/reST/ref/font.rst

@@ -306,16 +306,27 @@ solves no longer exists, it will likely be removed in the future.
 
       .. ## Font.point_size ##
 
-   .. attribute:: outline
+   .. attribute:: outline_size
 
       | :sl:`Gets or sets the font's outline size`
-      | :sg:`outline -> int`
+      | :sg:`outline_size -> int`
 
       Returns the size of the outline.
 
       .. versionadded:: 2.5.0
 
-      .. ## Font.outline ##
+      .. ## Font.outline_size ##
+
+   .. attribute:: outline_color
+
+      | :sl:`Gets or sets the font's outline color`
+      | :sg:`outline_size -> RGB`
+
+      Returns the color of the outline.
+
+      .. versionadded:: 2.5.0
+
+      .. ## Font.outline_color ##
 
    .. method:: render
 

src_c/doc/font_doc.h

@@ -17,7 +17,8 @@
 #define DOC_FONT_FONT_STRIKETHROUGH "strikethrough -> bool\nGets or sets whether the font should be rendered with a strikethrough."
 #define DOC_FONT_FONT_ALIGN "align -> int\nSet how rendered text is aligned when given a wrap length."
 #define DOC_FONT_FONT_POINTSIZE "point_size -> int\nGets or sets the font's point size"
-#define DOC_FONT_FONT_OUTLINE "outline -> int\nGets or sets the font's outline size"
+#define DOC_FONT_FONT_OUTLINESIZE "outline_size -> int\nGets or sets the font's outline size"
+#define DOC_FONT_FONT_OUTLINECOLOR "outline_size -> RGB\nGets or sets the font's outline color"
 #define DOC_FONT_FONT_RENDER "render(text, antialias, color, bgcolor=None, wraplength=0) -> Surface\ndraw text on a new Surface"
 #define DOC_FONT_FONT_SIZE "size(text, /) -> (width, height)\ndetermine the amount of space needed to render text"
 #define DOC_FONT_FONT_SETUNDERLINE "set_underline(bool, /) -> None\ncontrol if text is rendered with an underline"

src_c/font.c

@@ -829,34 +829,91 @@ font_getter_style_name(PyObject *self, void *closure)
     return PyUnicode_FromString(font_style_name ? font_style_name : "");
 }
 
+static PyObject *
+font_getter_outline_size(PyFontObject *self, void *closure)
+{
+    if (!PgFont_GenerationCheck(self))
+        return RAISE_FONT_QUIT_ERROR();
+
+#if SDL_TTF_VERSION_ATLEAST(2, 0, 12)
+    return PyLong_FromLong(self->outline_size);
+#else
+    return RAISE(pgExc_SDLError,
+                 "Incorrect SDL_TTF version (requires 2.0.12)");
+#endif
+}
+
 static int
-font_setter_outline(PyObject *self, PyObject *value, void *closure)
+font_setter_outline_size(PyFontObject *self, PyObject *value, void *closure)
 {
     if (!PgFont_GenerationCheck(self)) {
         RAISE_FONT_QUIT_ERROR_RETURN(-1);
     }
 
-    TTF_Font *font = PyFont_AsFont(self);
-    int val;
+#if SDL_TTF_VERSION_ATLEAST(2, 0, 12)
+    int val = PyLong_AsLong(value);
 
-    DEL_ATTR_NOT_SUPPORTED_CHECK("outline", value);
+    if (PyErr_Occurred() && val == -1)
+        return -1;
 
-    val = PyLong_AsLong(value);
-    if ((val == -1) && (PyErr_Occurred() != NULL))
+    if (val < 0) {
+        PyErr_SetString(PyExc_ValueError,
+                        "outline_size cannot be less than 0");
         return -1;
+    }
+
+    self->outline_size = val;
 
-    TTF_SetFontOutline(font, val);
     return 0;
+#else
+    PyErr_SetString(pgExc_SDLError,
+                    "Incorrect SDL_TTF version (requires 2.0.12)");
+    return -1;
+#endif
 }
 
 static PyObject *
-font_getter_outline(PyObject *self, void *closure)
+font_getter_outline_color(PyFontObject *self, void *closure)
 {
-    if (!PgFont_GenerationCheck(self)) {
+    if (!PgFont_GenerationCheck(self))
         return RAISE_FONT_QUIT_ERROR();
+
+#if SDL_TTF_VERSION_ATLEAST(2, 0, 12)
+    return Py_BuildValue("(bbbb)", self->outline_color.r,
+                         self->outline_color.g, self->outline_color.b,
+                         self->outline_color.a);
+#else
+    return RAISE(pgExc_SDLError,
+                 "Incorrect SDL_TTF version (requires 2.0.12)");
+#endif
+}
+
+static int
+font_setter_outline_color(PyFontObject *self, PyObject *value, void *closure)
+{
+    Uint8 rgba[] = {0, 0, 0, 0};
+
+    if (!PgFont_GenerationCheck(self)) {
+        RAISE_FONT_QUIT_ERROR_RETURN(-1);
     }
 
-    return PyLong_FromLong(TTF_GetFontOutline(PyFont_AsFont(self)));
+#if SDL_TTF_VERSION_ATLEAST(2, 0, 12)
+    if (!pg_RGBAFromObjEx(value, rgba, PG_COLOR_HANDLE_ALL)) {
+        return -1;
+    }
+
+    if (PyErr_Occurred())
+        return -1;
+
+    SDL_Color val = {rgba[0], rgba[1], rgba[2], SDL_ALPHA_OPAQUE};
+    self->outline_color = val;
+
+    return 0;
+#else
+    PyErr_SetString(pgExc_SDLError,
+                    "Incorrect SDL_TTF version (requires 2.0.12)");
+    return -1;
+#endif
 }
 
 static PyObject *
@@ -1088,8 +1145,10 @@ static PyGetSetDef font_getsets[] = {
      DOC_FONT_FONT_ALIGN, NULL},
     {"point_size", (getter)font_getter_point_size,
      (setter)font_setter_point_size, DOC_FONT_FONT_POINTSIZE, NULL},
-    {"outline", (getter)font_getter_outline, (setter)font_setter_outline,
-     DOC_FONT_FONT_OUTLINE, NULL},
+    {"outline_color", (getter)font_getter_outline_color,
+     (setter)font_setter_outline_color, DOC_FONT_FONT_OUTLINECOLOR, NULL},
+    {"outline_size", (getter)font_getter_outline_size,
+     (setter)font_setter_outline_size, DOC_FONT_FONT_OUTLINESIZE, NULL},
     {NULL, NULL, NULL, NULL, NULL}};
 
 static PyMethodDef font_methods[] = {

src_c/include/pygame_font.h

@@ -29,6 +29,10 @@ typedef struct {
     PyObject_HEAD TTF_Font *font;
     PyObject *weakreflist;
     int ptsize;
+
+    SDL_Color outline_color;
+    int outline_size;
+
     unsigned int ttf_init_generation;
 } PyFontObject;
 #define PyFont_AsFont(x) (((PyFontObject *)x)->font)

test/font_test.py

@@ -981,7 +981,8 @@ def test_font_property_should_raise_exception_after_quit(self):
                 ("italic", True),
                 ("underline", True),
                 ("strikethrough", True),
-                ("outline", 2),
+                ("outline_size", 2),
+                ("outline_color", (20, 0, 6)),
             ]
             skip_properties = set()
             version = pygame.font.get_sdl_ttf_version()
@@ -1058,7 +1059,8 @@ def query(
         underline=False,
         strikethrough=False,
         antialiase=False,
-        outline=2,
+        outline_size=2,
+        outline_color=(20, 0, 6),
     ):
         if self.aborted:
             return False
@@ -1069,7 +1071,15 @@ def query(
         screen = self.screen
         screen.fill((255, 255, 255))
         pygame.display.flip()
-        if not (bold or italic or underline or strikethrough or antialiase or outline):
+        if not (
+            bold
+            or italic
+            or underline
+            or strikethrough
+            or antialiase
+            or outline_size
+            or outline_color
+        ):
             text = "normal"
         else:
             modes = []
@@ -1083,14 +1093,17 @@ def query(
                 modes.append("strikethrough")
             if antialiase:
                 modes.append("antialiased")
-            if outline:
-                modes.append("outline")
+            if outline_size:
+                modes.append("outline_size")
+            if outline_color:
+                modes.append("outline_color")
             text = f"{'-'.join(modes)} (y/n):"
         f.set_bold(bold)
         f.set_italic(italic)
         f.set_underline(underline)
         f.set_strikethrough(strikethrough)
-        f.outline = outline
+        f.outline_size = outline_size
+        f.outline_color = outline_color
         s = f.render(text, antialiase, (0, 0, 0))
         screen.blit(s, (offset, y))
         y += s.get_size()[1] + spacing
@@ -1130,8 +1143,11 @@ def test_strikethrough(self):
     def test_antialiase(self):
         self.assertTrue(self.query(antialiase=True))
 
-    def test_outline(self):
-        self.assertTrue(self.query(outline=True))
+    def test_outline_size(self):
+        self.assertTrue(self.query(outline_size=2))
+
+    def test_outline_color(self):
+        self.assertTrue(self.query(outline_color=(20, 0, 6)))
 
     def test_bold_antialiase(self):
         self.assertTrue(self.query(bold=True, antialiase=True))