LCOV - code coverage report
Current view: | top level - Modules - _curses_panel.c (source / functions) |  |  | Hit | Total | Coverage
Test: | CPython 3.12 LCOV report [commit 5e6661bce9] |  | Lines: | 35 | 203 | 17.2 %
Date: | 2023-03-20 08:15:36 |  | Functions: | 6 | 28 | 21.4 %
|  |  | Branches: | 17 | 94 | 18.1 %

               Branch data     Line data    Source code
           1                 :            : /*
           2                 :            :  *   Interface to the ncurses panel library
           3                 :            :  *
           4                 :            :  * Original version by Thomas Gellekum
           5                 :            :  */
           6                 :            :
           7                 :            : /* Release Number */
           8                 :            :
           9                 :            : static const char PyCursesVersion[] = "2.1";
          10                 :            :
          11                 :            : /* Includes */
          12                 :            :
          13                 :            : #include "Python.h"
          14                 :            :
          15                 :            : #include "py_curses.h"
          16                 :            :
          17                 :            : #include <panel.h>
          18                 :            :
          19                 :            : typedef struct {
          20                 :            :     PyObject *PyCursesError;
          21                 :            :     PyTypeObject *PyCursesPanel_Type;
          22                 :            : } _curses_panel_state;
          23                 :            :
          24                 :            : static inline _curses_panel_state *
          25                 :         11 : get_curses_panel_state(PyObject *module)
          26                 :            : {
          27                 :         11 :     void *state = PyModule_GetState(module);
          28                 :            :     assert(state != NULL);
          29                 :         11 :     return (_curses_panel_state *)state;
          30                 :            : }
          31                 :            :
          32                 :            : static int
          33                 :          2 : _curses_panel_clear(PyObject *mod)
          34                 :            : {
          35                 :          2 :     _curses_panel_state *state = get_curses_panel_state(mod);
          36         [ +  + ]:          2 :     Py_CLEAR(state->PyCursesError);
          37         [ +  + ]:          2 :     Py_CLEAR(state->PyCursesPanel_Type);
          38                 :          2 :     return 0;
          39                 :            : }
          40                 :            :
          41                 :            : static int
          42                 :          8 : _curses_panel_traverse(PyObject *mod, visitproc visit, void *arg)
          43                 :            : {
          44   [ +  -  -  + ]:          8 :     Py_VISIT(Py_TYPE(mod));
          45                 :          8 :     _curses_panel_state *state = get_curses_panel_state(mod);
          46   [ +  -  -  + ]:          8 :     Py_VISIT(state->PyCursesError);
          47   [ +  -  -  + ]:          8 :     Py_VISIT(state->PyCursesPanel_Type);
          48                 :          8 :     return 0;
          49                 :            : }
          50                 :            :
          51                 :            : static void
          52                 :          1 : _curses_panel_free(void *mod)
          53                 :            : {
          54                 :          1 :     _curses_panel_clear((PyObject *) mod);
          55                 :          1 : }
          56                 :            :
          57                 :            : /* Utility Functions */
          58                 :            :
          59                 :            : /*
          60                 :            :  * Check the return code from a curses function and return None
          61                 :            :  * or raise an exception as appropriate.
          62                 :            :  */
          63                 :            :
          64                 :            : static PyObject *
          65                 :          0 : PyCursesCheckERR(_curses_panel_state *state, int code, const char *fname)
          66                 :            : {
          67         [ #  # ]:          0 :     if (code != ERR) {
          68                 :          0 :         Py_RETURN_NONE;
          69                 :            :     }
          70                 :            :     else {
          71         [ #  # ]:          0 :         if (fname == NULL) {
          72                 :          0 :             PyErr_SetString(state->PyCursesError, catchall_ERR);
          73                 :            :         }
          74                 :            :         else {
          75                 :          0 :             PyErr_Format(state->PyCursesError, "%s() returned ERR", fname);
          76                 :            :         }
          77                 :          0 :         return NULL;
          78                 :            :     }
          79                 :            : }
          80                 :            :
          81                 :            : /*****************************************************************************
          82                 :            :  The Panel Object
          83                 :            : ******************************************************************************/
          84                 :            :
          85                 :            : /* Definition of the panel object and panel type */
          86                 :            :
          87                 :            : typedef struct {
          88                 :            :     PyObject_HEAD
          89                 :            :     PANEL *pan;
          90                 :            :     PyCursesWindowObject *wo;   /* for reference counts */
          91                 :            : } PyCursesPanelObject;
          92                 :            :
          93                 :            : /* Some helper functions. The problem is that there's always a window
          94                 :            :    associated with a panel. To ensure that Python's GC doesn't pull
          95                 :            :    this window from under our feet we need to keep track of references
          96                 :            :    to the corresponding window object within Python. We can't use
          97                 :            :    dupwin(oldwin) to keep a copy of the curses WINDOW because the
          98                 :            :    contents of oldwin is copied only once; code like
          99                 :            :
         100                 :            :    win = newwin(...)
         101                 :            :    pan = win.panel()
         102                 :            :    win.addstr(some_string)
         103                 :            :    pan.window().addstr(other_string)
         104                 :            :
         105                 :            :    will fail. */
         106                 :            :
         107                 :            : /* We keep a linked list of PyCursesPanelObjects, lop. A list should
         108                 :            :    suffice, I don't expect more than a handful or at most a few
         109                 :            :    dozens of panel objects within a typical program. */
         110                 :            : typedef struct _list_of_panels {
         111                 :            :     PyCursesPanelObject *po;
         112                 :            :     struct _list_of_panels *next;
         113                 :            : } list_of_panels;
         114                 :            :
         115                 :            : /* list anchor */
         116                 :            : static list_of_panels *lop;
         117                 :            :
         118                 :            : /* Insert a new panel object into lop */
         119                 :            : static int
         120                 :          0 : insert_lop(PyCursesPanelObject *po)
         121                 :            : {
         122                 :            :     list_of_panels *new;
         123                 :            :
         124         [ #  # ]:          0 :     if ((new = (list_of_panels *)PyMem_Malloc(sizeof(list_of_panels))) == NULL) {
         125                 :          0 :         PyErr_NoMemory();
         126                 :          0 :         return -1;
         127                 :            :     }
         128                 :          0 :     new->po = po;
         129                 :          0 :     new->next = lop;
         130                 :          0 :     lop = new;
         131                 :          0 :     return 0;
         132                 :            : }
         133                 :            :
         134                 :            : /* Remove the panel object from lop */
         135                 :            : static void
         136                 :          0 : remove_lop(PyCursesPanelObject *po)
         137                 :            : {
         138                 :            :     list_of_panels *temp, *n;
         139                 :            :
         140                 :          0 :     temp = lop;
         141         [ #  # ]:          0 :     if (temp->po == po) {
         142                 :          0 :         lop = temp->next;
         143                 :          0 :         PyMem_Free(temp);
         144                 :          0 :         return;
         145                 :            :     }
         146   [ #  #  #  # ]:          0 :     while (temp->next == NULL || temp->next->po != po) {
         147         [ #  # ]:          0 :         if (temp->next == NULL) {
         148                 :          0 :             PyErr_SetString(PyExc_RuntimeError,
         149                 :            :                             "remove_lop: can't find Panel Object");
         150                 :          0 :             return;
         151                 :            :         }
         152                 :          0 :         temp = temp->next;
         153                 :            :     }
         154                 :          0 :     n = temp->next->next;
         155                 :          0 :     PyMem_Free(temp->next);
         156                 :          0 :     temp->next = n;
         157                 :          0 :     return;
         158                 :            : }
         159                 :            :
         160                 :            : /* Return the panel object that corresponds to pan */
         161                 :            : static PyCursesPanelObject *
         162                 :          0 : find_po(PANEL *pan)
         163                 :            : {
         164                 :            :     list_of_panels *temp;
         165         [ #  # ]:          0 :     for (temp = lop; temp->po->pan != pan; temp = temp->next)
         166         [ #  # ]:          0 :         if (temp->next == NULL) return NULL;    /* not found!? */
         167                 :          0 :     return temp->po;
         168                 :            : }
         169                 :            :
         170                 :            : /*[clinic input]
         171                 :            : module _curses_panel
         172                 :            : class _curses_panel.panel "PyCursesPanelObject *" "&PyCursesPanel_Type"
         173                 :            : [clinic start generated code]*/
         174                 :            : /*[clinic end generated code: output=da39a3ee5e6b4b0d input=2f4ef263ca850a31]*/
         175                 :            :
         176                 :            : #include "clinic/_curses_panel.c.h"
         177                 :            :
         178                 :            : /* ------------- PANEL routines --------------- */
         179                 :            :
         180                 :            : /*[clinic input]
         181                 :            : _curses_panel.panel.bottom
         182                 :            :
         183                 :            :     cls: defining_class
         184                 :            :
         185                 :            : Push the panel to the bottom of the stack.
         186                 :            : [clinic start generated code]*/
         187                 :            :
         188                 :            : static PyObject *
         189                 :          0 : _curses_panel_panel_bottom_impl(PyCursesPanelObject *self, PyTypeObject *cls)
         190                 :            : /*[clinic end generated code: output=8ec7fbbc08554021 input=6b7d2c0578b5a1c4]*/
         191                 :            : {
         192                 :          0 :     _curses_panel_state *state = PyType_GetModuleState(cls);
         193                 :          0 :     return PyCursesCheckERR(state, bottom_panel(self->pan), "bottom");
         194                 :            : }
         195                 :            :
         196                 :            : /*[clinic input]
         197                 :            : _curses_panel.panel.hide
         198                 :            :
         199                 :            :     cls: defining_class
         200                 :            :
         201                 :            : Hide the panel.
         202                 :            :
         203                 :            : This does not delete the object, it just makes the window on screen invisible.
         204                 :            : [clinic start generated code]*/
         205                 :            :
         206                 :            : static PyObject *
         207                 :          0 : _curses_panel_panel_hide_impl(PyCursesPanelObject *self, PyTypeObject *cls)
         208                 :            : /*[clinic end generated code: output=cc6ab7203cdc1450 input=1bfc741f473e6055]*/
         209                 :            : {
         210                 :          0 :     _curses_panel_state *state = PyType_GetModuleState(cls);
         211                 :          0 :     return PyCursesCheckERR(state, hide_panel(self->pan), "hide");
         212                 :            : }
         213                 :            :
         214                 :            : /*[clinic input]
         215                 :            : _curses_panel.panel.show
         216                 :            :
         217                 :            :     cls: defining_class
         218                 :            :
         219                 :            : Display the panel (which might have been hidden).
         220                 :            : [clinic start generated code]*/
         221                 :            :
         222                 :            : static PyObject *
         223                 :          0 : _curses_panel_panel_show_impl(PyCursesPanelObject *self, PyTypeObject *cls)
         224                 :            : /*[clinic end generated code: output=dc3421de375f0409 input=8122e80151cb4379]*/
         225                 :            : {
         226                 :          0 :     _curses_panel_state *state = PyType_GetModuleState(cls);
         227                 :          0 :     return PyCursesCheckERR(state, show_panel(self->pan), "show");
         228                 :            : }
         229                 :            :
         230                 :            : /*[clinic input]
         231                 :            : _curses_panel.panel.top
         232                 :            :
         233                 :            :     cls: defining_class
         234                 :            :
         235                 :            : Push panel to the top of the stack.
         236                 :            : [clinic start generated code]*/
         237                 :            :
         238                 :            : static PyObject *
         239                 :          0 : _curses_panel_panel_top_impl(PyCursesPanelObject *self, PyTypeObject *cls)
         240                 :            : /*[clinic end generated code: output=10a072e511e873f7 input=1f372d597dda3379]*/
         241                 :            : {
         242                 :          0 :     _curses_panel_state *state = PyType_GetModuleState(cls);
         243                 :          0 :     return PyCursesCheckERR(state, top_panel(self->pan), "top");
         244                 :            : }
         245                 :            :
         246                 :            : /* Allocation and deallocation of Panel Objects */
         247                 :            :
         248                 :            : static PyObject *
         249                 :          0 : PyCursesPanel_New(_curses_panel_state *state, PANEL *pan,
         250                 :            :                   PyCursesWindowObject *wo)
         251                 :            : {
         252                 :          0 :     PyCursesPanelObject *po = PyObject_New(PyCursesPanelObject,
         253                 :            :                                            state->PyCursesPanel_Type);
         254         [ #  # ]:          0 :     if (po == NULL) {
         255                 :          0 :         return NULL;
         256                 :            :     }
         257                 :            :
         258                 :          0 :     po->pan = pan;
         259         [ #  # ]:          0 :     if (insert_lop(po) < 0) {
         260                 :          0 :         po->wo = NULL;
         261                 :          0 :         Py_DECREF(po);
         262                 :          0 :         return NULL;
         263                 :            :     }
         264                 :          0 :     po->wo = (PyCursesWindowObject*)Py_NewRef(wo);
         265                 :          0 :     return (PyObject *)po;
         266                 :            : }
         267                 :            :
         268                 :            : static void
         269                 :          0 : PyCursesPanel_Dealloc(PyCursesPanelObject *po)
         270                 :            : {
         271                 :            :     PyObject *tp, *obj;
         272                 :            :
         273                 :          0 :     tp = (PyObject *) Py_TYPE(po);
         274                 :          0 :     obj = (PyObject *) panel_userptr(po->pan);
         275         [ #  # ]:          0 :     if (obj) {
         276                 :          0 :         (void)set_panel_userptr(po->pan, NULL);
         277                 :          0 :         Py_DECREF(obj);
         278                 :            :     }
         279                 :          0 :     (void)del_panel(po->pan);
         280         [ #  # ]:          0 :     if (po->wo != NULL) {
         281                 :          0 :         Py_DECREF(po->wo);
         282                 :          0 :         remove_lop(po);
         283                 :            :     }
         284                 :          0 :     PyObject_Free(po);
         285                 :          0 :     Py_DECREF(tp);
         286                 :          0 : }
         287                 :            :
         288                 :            : /* panel_above(NULL) returns the bottom panel in the stack. To get
         289                 :            :    this behaviour we use curses.panel.bottom_panel(). */
         290                 :            : /*[clinic input]
         291                 :            : _curses_panel.panel.above
         292                 :            :
         293                 :            : Return the panel above the current panel.
         294                 :            : [clinic start generated code]*/
         295                 :            :
         296                 :            : static PyObject *
         297                 :          0 : _curses_panel_panel_above_impl(PyCursesPanelObject *self)
         298                 :            : /*[clinic end generated code: output=70ac06d25fd3b4da input=c059994022976788]*/
         299                 :            : {
         300                 :            :     PANEL *pan;
         301                 :            :     PyCursesPanelObject *po;
         302                 :            :
         303                 :          0 :     pan = panel_above(self->pan);
         304                 :            :
         305         [ #  # ]:          0 :     if (pan == NULL) {          /* valid output, it means the calling panel
         306                 :            :                                    is on top of the stack */
         307                 :          0 :         Py_RETURN_NONE;
         308                 :            :     }
         309                 :          0 :     po = find_po(pan);
         310         [ #  # ]:          0 :     if (po == NULL) {
         311                 :          0 :         PyErr_SetString(PyExc_RuntimeError,
         312                 :            :                         "panel_above: can't find Panel Object");
         313                 :          0 :         return NULL;
         314                 :            :     }
         315                 :          0 :     return Py_NewRef(po);
         316                 :            : }
         317                 :            :
         318                 :            : /* panel_below(NULL) returns the top panel in the stack. To get
         319                 :            :    this behaviour we use curses.panel.top_panel(). */
         320                 :            : /*[clinic input]
         321                 :            : _curses_panel.panel.below
         322                 :            :
         323                 :            : Return the panel below the current panel.
         324                 :            : [clinic start generated code]*/
         325                 :            :
         326                 :            : static PyObject *
         327                 :          0 : _curses_panel_panel_below_impl(PyCursesPanelObject *self)
         328                 :            : /*[clinic end generated code: output=282861122e06e3de input=cc08f61936d297c6]*/
         329                 :            : {
         330                 :            :     PANEL *pan;
         331                 :            :     PyCursesPanelObject *po;
         332                 :            :
         333                 :          0 :     pan = panel_below(self->pan);
         334                 :            :
         335         [ #  # ]:          0 :     if (pan == NULL) {          /* valid output, it means the calling panel
         336                 :            :                                    is on the bottom of the stack */
         337                 :          0 :         Py_RETURN_NONE;
         338                 :            :     }
         339                 :          0 :     po = find_po(pan);
         340         [ #  # ]:          0 :     if (po == NULL) {
         341                 :          0 :         PyErr_SetString(PyExc_RuntimeError,
         342                 :            :                         "panel_below: can't find Panel Object");
         343                 :          0 :         return NULL;
         344                 :            :     }
         345                 :          0 :     return Py_NewRef(po);
         346                 :            : }
         347                 :            :
         348                 :            : /*[clinic input]
         349                 :            : _curses_panel.panel.hidden
         350                 :            :
         351                 :            : Return True if the panel is hidden (not visible), False otherwise.
         352                 :            : [clinic start generated code]*/
         353                 :            :
         354                 :            : static PyObject *
         355                 :          0 : _curses_panel_panel_hidden_impl(PyCursesPanelObject *self)
         356                 :            : /*[clinic end generated code: output=66eebd1ab4501a71 input=453d4b4fce25e21a]*/
         357                 :            : {
         358         [ #  # ]:          0 :     if (panel_hidden(self->pan))
         359                 :          0 :         Py_RETURN_TRUE;
         360                 :            :     else
         361                 :          0 :         Py_RETURN_FALSE;
         362                 :            : }
         363                 :            :
         364                 :            : /*[clinic input]
         365                 :            : _curses_panel.panel.move
         366                 :            :
         367                 :            :     cls: defining_class
         368                 :            :     y: int
         369                 :            :     x: int
         370                 :            :     /
         371                 :            :
         372                 :            : Move the panel to the screen coordinates (y, x).
         373                 :            : [clinic start generated code]*/
         374                 :            :
         375                 :            : static PyObject *
         376                 :          0 : _curses_panel_panel_move_impl(PyCursesPanelObject *self, PyTypeObject *cls,
         377                 :            :                               int y, int x)
         378                 :            : /*[clinic end generated code: output=ce546c93e56867da input=60a0e7912ff99849]*/
         379                 :            : {
         380                 :          0 :     _curses_panel_state *state = PyType_GetModuleState(cls);
         381                 :          0 :     return PyCursesCheckERR(state, move_panel(self->pan, y, x), "move_panel");
         382                 :            : }
         383                 :            :
         384                 :            : /*[clinic input]
         385                 :            : _curses_panel.panel.window
         386                 :            :
         387                 :            : Return the window object associated with the panel.
         388                 :            : [clinic start generated code]*/
         389                 :            :
         390                 :            : static PyObject *
         391                 :          0 : _curses_panel_panel_window_impl(PyCursesPanelObject *self)
         392                 :            : /*[clinic end generated code: output=5f05940d4106b4cb input=6067353d2c307901]*/
         393                 :            : {
         394                 :          0 :     return Py_NewRef(self->wo);
         395                 :            : }
         396                 :            :
         397                 :            : /*[clinic input]
         398                 :            : _curses_panel.panel.replace
         399                 :            :
         400                 :            :     cls: defining_class
         401                 :            :     win: object(type="PyCursesWindowObject *", subclass_of="&PyCursesWindow_Type")
         402                 :            :     /
         403                 :            :
         404                 :            : Change the window associated with the panel to the window win.
         405                 :            : [clinic start generated code]*/
         406                 :            :
         407                 :            : static PyObject *
         408                 :          0 : _curses_panel_panel_replace_impl(PyCursesPanelObject *self,
         409                 :            :                                  PyTypeObject *cls,
         410                 :            :                                  PyCursesWindowObject *win)
         411                 :            : /*[clinic end generated code: output=c71f95c212d58ae7 input=dbec7180ece41ff5]*/
         412                 :            : {
         413                 :          0 :     _curses_panel_state *state = PyType_GetModuleState(cls);
         414                 :            :
         415                 :          0 :     PyCursesPanelObject *po = find_po(self->pan);
         416         [ #  # ]:          0 :     if (po == NULL) {
         417                 :          0 :         PyErr_SetString(PyExc_RuntimeError,
         418                 :            :                         "replace_panel: can't find Panel Object");
         419                 :          0 :         return NULL;
         420                 :            :     }
         421                 :            :
         422                 :          0 :     int rtn = replace_panel(self->pan, win->win);
         423         [ #  # ]:          0 :     if (rtn == ERR) {
         424                 :          0 :         PyErr_SetString(state->PyCursesError, "replace_panel() returned ERR");
         425                 :          0 :         return NULL;
         426                 :            :     }
         427                 :          0 :     Py_SETREF(po->wo, (PyCursesWindowObject*)Py_NewRef(win));
         428                 :          0 :     Py_RETURN_NONE;
         429                 :            : }
         430                 :            :
         431                 :            : /*[clinic input]
         432                 :            : _curses_panel.panel.set_userptr
         433                 :            :
         434                 :            :     cls: defining_class
         435                 :            :     obj: object
         436                 :            :     /
         437                 :            :
         438                 :            : Set the panel's user pointer to obj.
         439                 :            : [clinic start generated code]*/
         440                 :            :
         441                 :            : static PyObject *
         442                 :          0 : _curses_panel_panel_set_userptr_impl(PyCursesPanelObject *self,
         443                 :            :                                      PyTypeObject *cls, PyObject *obj)
         444                 :            : /*[clinic end generated code: output=db74f3db07b28080 input=e3fee2ff7b1b8e48]*/
         445                 :            : {
         446         [ #  # ]:          0 :     PyCursesInitialised;
         447                 :          0 :     Py_INCREF(obj);
         448                 :          0 :     PyObject *oldobj = (PyObject *) panel_userptr(self->pan);
         449                 :          0 :     int rc = set_panel_userptr(self->pan, (void*)obj);
         450         [ #  # ]:          0 :     if (rc == ERR) {
         451                 :            :         /* In case of an ncurses error, decref the new object again */
         452                 :          0 :         Py_DECREF(obj);
         453                 :            :     }
         454                 :            :     else {
         455                 :          0 :         Py_XDECREF(oldobj);
         456                 :            :     }
         457                 :            :
         458                 :          0 :     _curses_panel_state *state = PyType_GetModuleState(cls);
         459                 :          0 :     return PyCursesCheckERR(state, rc, "set_panel_userptr");
         460                 :            : }
         461                 :            :
         462                 :            : /*[clinic input]
         463                 :            : _curses_panel.panel.userptr
         464                 :            :
         465                 :            :     cls: defining_class
         466                 :            :
         467                 :            : Return the user pointer for the panel.
         468                 :            : [clinic start generated code]*/
         469                 :            :
         470                 :            : static PyObject *
         471                 :          0 : _curses_panel_panel_userptr_impl(PyCursesPanelObject *self,
         472                 :            :                                  PyTypeObject *cls)
         473                 :            : /*[clinic end generated code: output=eea6e6f39ffc0179 input=f22ca4f115e30a80]*/
         474                 :            : {
         475                 :          0 :     _curses_panel_state *state = PyType_GetModuleState(cls);
         476                 :            :
         477         [ #  # ]:          0 :     PyCursesInitialised;
         478                 :          0 :     PyObject *obj = (PyObject *) panel_userptr(self->pan);
         479         [ #  # ]:          0 :     if (obj == NULL) {
         480                 :          0 :         PyErr_SetString(state->PyCursesError, "no userptr set");
         481                 :          0 :         return NULL;
         482                 :            :     }
         483                 :            :
         484                 :          0 :     return Py_NewRef(obj);
         485                 :            : }
         486                 :            :
         487                 :            :
         488                 :            : /* Module interface */
         489                 :            :
         490                 :            : static PyMethodDef PyCursesPanel_Methods[] = {
         491                 :            :     _CURSES_PANEL_PANEL_ABOVE_METHODDEF
         492                 :            :     _CURSES_PANEL_PANEL_BELOW_METHODDEF
         493                 :            :     _CURSES_PANEL_PANEL_BOTTOM_METHODDEF
         494                 :            :     _CURSES_PANEL_PANEL_HIDDEN_METHODDEF
         495                 :            :     _CURSES_PANEL_PANEL_HIDE_METHODDEF
         496                 :            :     _CURSES_PANEL_PANEL_MOVE_METHODDEF
         497                 :            :     _CURSES_PANEL_PANEL_REPLACE_METHODDEF
         498                 :            :     _CURSES_PANEL_PANEL_SET_USERPTR_METHODDEF
         499                 :            :     _CURSES_PANEL_PANEL_SHOW_METHODDEF
         500                 :            :     _CURSES_PANEL_PANEL_TOP_METHODDEF
         501                 :            :     _CURSES_PANEL_PANEL_USERPTR_METHODDEF
         502                 :            :     _CURSES_PANEL_PANEL_WINDOW_METHODDEF
         503                 :            :     {NULL,              NULL}   /* sentinel */
         504                 :            : };
         505                 :            :
         506                 :            : /* -------------------------------------------------------*/
         507                 :            :
         508                 :            : static PyType_Slot PyCursesPanel_Type_slots[] = {
         509                 :            :     {Py_tp_dealloc, PyCursesPanel_Dealloc},
         510                 :            :     {Py_tp_methods, PyCursesPanel_Methods},
         511                 :            :     {0, 0},
         512                 :            : };
         513                 :            :
         514                 :            : static PyType_Spec PyCursesPanel_Type_spec = {
         515                 :            :     .name = "_curses_panel.panel",
         516                 :            :     .basicsize = sizeof(PyCursesPanelObject),
         517                 :            :     .flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION,
         518                 :            :     .slots = PyCursesPanel_Type_slots
         519                 :            : };
         520                 :            :
         521                 :            : /* Wrapper for panel_above(NULL). This function returns the bottom
         522                 :            :    panel of the stack, so it's renamed to bottom_panel().
         523                 :            :    panel.above() *requires* a panel object in the first place which
         524                 :            :    may be undesirable. */
         525                 :            : /*[clinic input]
         526                 :            : _curses_panel.bottom_panel
         527                 :            :
         528                 :            : Return the bottom panel in the panel stack.
         529                 :            : [clinic start generated code]*/
         530                 :            :
         531                 :            : static PyObject *
         532                 :          0 : _curses_panel_bottom_panel_impl(PyObject *module)
         533                 :            : /*[clinic end generated code: output=3aba9f985f4c2bd0 input=634c2a8078b3d7e4]*/
         534                 :            : {
         535                 :            :     PANEL *pan;
         536                 :            :     PyCursesPanelObject *po;
         537                 :            :
         538         [ #  # ]:          0 :     PyCursesInitialised;
         539                 :            :
         540                 :          0 :     pan = panel_above(NULL);
         541                 :            :
         542         [ #  # ]:          0 :     if (pan == NULL) {          /* valid output, it means
         543                 :            :                                    there's no panel at all */
         544                 :          0 :         Py_RETURN_NONE;
         545                 :            :     }
         546                 :          0 :     po = find_po(pan);
         547         [ #  # ]:          0 :     if (po == NULL) {
         548                 :          0 :         PyErr_SetString(PyExc_RuntimeError,
         549                 :            :                         "panel_above: can't find Panel Object");
         550                 :          0 :         return NULL;
         551                 :            :     }
         552                 :          0 :     return Py_NewRef(po);
         553                 :            : }
         554                 :            :
         555                 :            : /*[clinic input]
         556                 :            : _curses_panel.new_panel
         557                 :            :
         558                 :            :     win: object(type="PyCursesWindowObject *", subclass_of="&PyCursesWindow_Type")
         559                 :            :     /
         560                 :            :
         561                 :            : Return a panel object, associating it with the given window win.
         562                 :            : [clinic start generated code]*/
         563                 :            :
         564                 :            : static PyObject *
         565                 :          0 : _curses_panel_new_panel_impl(PyObject *module, PyCursesWindowObject *win)
         566                 :            : /*[clinic end generated code: output=45e948e0176a9bd2 input=74d4754e0ebe4800]*/
         567                 :            : {
         568                 :          0 :     _curses_panel_state *state = get_curses_panel_state(module);
         569                 :            :
         570                 :          0 :     PANEL *pan = new_panel(win->win);
         571         [ #  # ]:          0 :     if (pan == NULL) {
         572                 :          0 :         PyErr_SetString(state->PyCursesError, catchall_NULL);
         573                 :          0 :         return NULL;
         574                 :            :     }
         575                 :          0 :     return (PyObject *)PyCursesPanel_New(state, pan, win);
         576                 :            : }
         577                 :            :
         578                 :            :
         579                 :            : /* Wrapper for panel_below(NULL). This function returns the top panel
         580                 :            :    of the stack, so it's renamed to top_panel(). panel.below()
         581                 :            :    *requires* a panel object in the first place which may be
         582                 :            :    undesirable. */
         583                 :            : /*[clinic input]
         584                 :            : _curses_panel.top_panel
         585                 :            :
         586                 :            : Return the top panel in the panel stack.
         587                 :            : [clinic start generated code]*/
         588                 :            :
         589                 :            : static PyObject *
         590                 :          0 : _curses_panel_top_panel_impl(PyObject *module)
         591                 :            : /*[clinic end generated code: output=86704988bea8508e input=e62d6278dba39e79]*/
         592                 :            : {
         593                 :            :     PANEL *pan;
         594                 :            :     PyCursesPanelObject *po;
         595                 :            :
         596         [ #  # ]:          0 :     PyCursesInitialised;
         597                 :            :
         598                 :          0 :     pan = panel_below(NULL);
         599                 :            :
         600         [ #  # ]:          0 :     if (pan == NULL) {          /* valid output, it means
         601                 :            :                                    there's no panel at all */
         602                 :          0 :         Py_RETURN_NONE;
         603                 :            :     }
         604                 :          0 :     po = find_po(pan);
         605         [ #  # ]:          0 :     if (po == NULL) {
         606                 :          0 :         PyErr_SetString(PyExc_RuntimeError,
         607                 :            :                         "panel_below: can't find Panel Object");
         608                 :          0 :         return NULL;
         609                 :            :     }
         610                 :          0 :     return Py_NewRef(po);
         611                 :            : }
         612                 :            :
         613                 :            : /*[clinic input]
         614                 :            : _curses_panel.update_panels
         615                 :            :
         616                 :            : Updates the virtual screen after changes in the panel stack.
         617                 :            :
         618                 :            : This does not call curses.doupdate(), so you'll have to do this yourself.
         619                 :            : [clinic start generated code]*/
         620                 :            :
         621                 :            : static PyObject *
         622                 :          0 : _curses_panel_update_panels_impl(PyObject *module)
         623                 :            : /*[clinic end generated code: output=2f3b4c2e03d90ded input=5299624c9a708621]*/
         624                 :            : {
         625         [ #  # ]:          0 :     PyCursesInitialised;
         626                 :          0 :     update_panels();
         627                 :          0 :     Py_RETURN_NONE;
         628                 :            : }
         629                 :            :
         630                 :            : /* List of functions defined in the module */
         631                 :            :
         632                 :            : static PyMethodDef PyCurses_methods[] = {
         633                 :            :     _CURSES_PANEL_BOTTOM_PANEL_METHODDEF
         634                 :            :     _CURSES_PANEL_NEW_PANEL_METHODDEF
         635                 :            :     _CURSES_PANEL_TOP_PANEL_METHODDEF
         636                 :            :     _CURSES_PANEL_UPDATE_PANELS_METHODDEF
         637                 :            :     {NULL,              NULL}           /* sentinel */
         638                 :            : };
         639                 :            :
         640                 :            : /* Initialization function for the module */
         641                 :            : static int
         642                 :          1 : _curses_panel_exec(PyObject *mod)
         643                 :            : {
         644                 :          1 :     _curses_panel_state *state = get_curses_panel_state(mod);
         645                 :            :     /* Initialize object type */
         646                 :          1 :     state->PyCursesPanel_Type = (PyTypeObject *)PyType_FromModuleAndSpec(
         647                 :            :         mod, &PyCursesPanel_Type_spec, NULL);
         648         [ -  + ]:          1 :     if (state->PyCursesPanel_Type == NULL) {
         649                 :          0 :         return -1;
         650                 :            :     }
         651                 :            :
         652         [ -  + ]:          1 :     if (PyModule_AddType(mod, state->PyCursesPanel_Type) < 0) {
         653                 :          0 :         return -1;
         654                 :            :     }
         655                 :            :
         656                 :          1 :     import_curses();
         657         [ -  + ]:          1 :     if (PyErr_Occurred()) {
         658                 :          0 :         return -1;
         659                 :            :     }
         660                 :            :
         661                 :            :     /* For exception _curses_panel.error */
         662                 :          1 :     state->PyCursesError = PyErr_NewException(
         663                 :            :         "_curses_panel.error", NULL, NULL);
         664                 :            :
         665         [ -  + ]:          1 :     if (PyModule_AddObject(mod, "error", Py_NewRef(state->PyCursesError)) < 0) {
         666                 :          0 :         Py_DECREF(state->PyCursesError);
         667                 :          0 :         return -1;
         668                 :            :     }
         669                 :            :
         670                 :            :     /* Make the version available */
         671                 :          1 :     PyObject *v = PyUnicode_FromString(PyCursesVersion);
         672         [ -  + ]:          1 :     if (v == NULL) {
         673                 :          0 :         return -1;
         674                 :            :     }
         675                 :            :
         676                 :          1 :     PyObject *d = PyModule_GetDict(mod);
         677         [ -  + ]:          1 :     if (PyDict_SetItemString(d, "version", v) < 0) {
         678                 :          0 :         Py_DECREF(v);
         679                 :          0 :         return -1;
         680                 :            :     }
         681         [ -  + ]:          1 :     if (PyDict_SetItemString(d, "__version__", v) < 0) {
         682                 :          0 :         Py_DECREF(v);
         683                 :          0 :         return -1;
         684                 :            :     }
         685                 :            :
         686                 :          1 :     Py_DECREF(v);
         687                 :            :
         688                 :          1 :     return 0;
         689                 :            : }
         690                 :            :
         691                 :            : static PyModuleDef_Slot _curses_slots[] = {
         692                 :            :     {Py_mod_exec, _curses_panel_exec},
         693                 :            :     {0, NULL}
         694                 :            : };
         695                 :            :
         696                 :            : static struct PyModuleDef _curses_panelmodule = {
         697                 :            :     PyModuleDef_HEAD_INIT,
         698                 :            :     .m_name = "_curses_panel",
         699                 :            :     .m_size = sizeof(_curses_panel_state),
         700                 :            :     .m_methods = PyCurses_methods,
         701                 :            :     .m_slots = _curses_slots,
         702                 :            :     .m_traverse = _curses_panel_traverse,
         703                 :            :     .m_clear = _curses_panel_clear,
         704                 :            :     .m_free = _curses_panel_free
         705                 :            : };
         706                 :            :
         707                 :            : PyMODINIT_FUNC
         708                 :          1 : PyInit__curses_panel(void)
         709                 :            : {
         710                 :          1 :     return PyModuleDef_Init(&_curses_panelmodule);
         711                 :            : }

Generated by: LCOV version 1.14