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