sup

A curses threads-with-tags style email client

ncursesw-ruby.git

git clone https://supmua.dev/git/ncursesw-ruby/

panel_wrap.c (11508B) - raw

      1 /*
      2  * ncurses-ruby is a ruby module for accessing the FSF's ncurses library
      3  * (C) 2002 Tobias Peters <t-peters@berlios.de>
      4  * (C) 2011 Tobias Herzke
      5  *
      6  *  This module is free software; you can redistribute it and/or
      7  *  modify it under the terms of the GNU Lesser General Public
      8  *  License as published by the Free Software Foundation; either
      9  *  version 2 of the License, or (at your option) any later version.
     10  *
     11  *  This module is distributed in the hope that it will be useful,
     12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     14  *  Lesser General Public License for more details.
     15  *
     16  *  You should have received a copy of the GNU Lesser General Public
     17  *  License along with this module; if not, write to the Free Software
     18  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
     19  */
     20 
     21 /* $Id: panel_wrap.c,v 1.3 2011-05-30 23:05:50 t-peters Exp $ */
     22 
     23 #if defined(HAVE_PANEL_H) || defined(HAVE_NCURSESW_PANEL_H)
     24 
     25 #include "panel_wrap.h"
     26 #include "ncurses_wrap.h"
     27 #include "compat.h"
     28 
     29 VALUE mPanel;
     30 VALUE cPANEL;
     31 
     32 static void panel_rb_mark(void * panel) {
     33     const void * userptr = panel_userptr((PANEL*)panel);
     34     if (userptr != NULL) rb_gc_mark((VALUE)userptr);
     35 }
     36 static const struct rb_data_type_struct panel_rbtype = {
     37     .wrap_struct_name = "Ncurses::Panel::PANEL",
     38     .function.dmark = panel_rb_mark,
     39 };
     40 static VALUE wrap_panel(PANEL* panel)
     41 {
     42     if (panel == 0) return Qnil;
     43     {
     44         VALUE panels_hash   = rb_iv_get(mPanel, "@panels_hash");
     45         VALUE panel_adress  = INT2NUM((long)(panel));
     46         VALUE rb_panel      = rb_hash_aref(panels_hash, panel_adress);
     47         if (rb_panel == Qnil) {
     48             rb_panel = TypedData_Wrap_Struct(cPANEL, &panel_rbtype, panel);
     49             rb_iv_set(rb_panel, "@destroyed", Qfalse);
     50             rb_hash_aset(panels_hash, panel_adress, rb_panel);
     51         }
     52         return rb_panel;
     53     }
     54 }
     55 static PANEL* get_panel(VALUE rb_panel)
     56 {
     57     PANEL* panel;
     58     if (rb_panel == Qnil) return 0;
     59     if (rb_iv_get(rb_panel, "@destroyed") == Qtrue) {
     60         rb_raise(rb_eRuntimeError, "Attempt to access a destroyed panel");
     61         return 0;
     62     }
     63     TypedData_Get_Struct(rb_panel, PANEL, &panel_rbtype, panel);
     64     return panel;
     65 }
     66 static VALUE rbncurs_c_del_panel(VALUE rb_panel) {
     67     VALUE panels_hash   = rb_iv_get(mPanel, "@panels_hash");
     68     PANEL* panel       = get_panel(rb_panel);
     69     VALUE panel_adress  = INT2NUM((long)(panel));
     70     rb_funcall(panels_hash, rb_intern("delete"), 1, panel_adress);
     71     rb_iv_set(rb_panel, "@destroyed", Qtrue);
     72     return INT2NUM(del_panel(panel));
     73 }
     74 static VALUE rbncurs_m_del_panel(VALUE dummy, VALUE rb_panel)
     75 { return rbncurs_c_del_panel(rb_panel); }
     76 
     77 static VALUE rbncurs_c_panel_window(VALUE rb_panel)
     78 { return wrap_window(panel_window(get_panel(rb_panel))); }
     79 static VALUE rbncurs_m_panel_window(VALUE dummy, VALUE rb_panel)
     80 { return rbncurs_c_panel_window(rb_panel); }
     81 
     82 static VALUE rbncurs_m_update_panels(VALUE dummy)
     83 { update_panels(); return Qnil; }
     84 
     85 static VALUE rbncurs_c_hide_panel(VALUE rb_panel)
     86 { return INT2NUM(hide_panel(get_panel(rb_panel))); }
     87 static VALUE rbncurs_m_hide_panel(VALUE dummy, VALUE rb_panel)
     88 { return rbncurs_c_hide_panel(rb_panel); }
     89 
     90 static VALUE rbncurs_c_show_panel(VALUE rb_panel)
     91 { return INT2NUM(show_panel(get_panel(rb_panel))); }
     92 static VALUE rbncurs_m_show_panel(VALUE dummy, VALUE rb_panel)
     93 { return rbncurs_c_show_panel(rb_panel); }
     94 
     95 static VALUE rbncurs_c_top_panel(VALUE rb_panel)
     96 { return INT2NUM(top_panel(get_panel(rb_panel))); }
     97 static VALUE rbncurs_m_top_panel(VALUE dummy, VALUE rb_panel)
     98 { return rbncurs_c_top_panel(rb_panel); }
     99 
    100 static VALUE rbncurs_c_bottom_panel(VALUE rb_panel)
    101 { return INT2NUM(bottom_panel(get_panel(rb_panel))); }
    102 static VALUE rbncurs_m_bottom_panel(VALUE dummy, VALUE rb_panel)
    103 { return rbncurs_c_bottom_panel(rb_panel); }
    104 
    105 static VALUE rbncurs_c_new_panel(VALUE rb_window)
    106 { return wrap_panel(new_panel(get_window(rb_window))); }
    107 static VALUE rbncurs_m_new_panel(VALUE dummy, VALUE rb_window)
    108 { return rbncurs_c_new_panel(rb_window); }
    109 static VALUE rbncurs_c_panel_above(VALUE rb_panel)
    110 { return wrap_panel(panel_above(get_panel(rb_panel))); }
    111 static VALUE rbncurs_m_panel_above(VALUE dummy, VALUE rb_panel)
    112 { return rbncurs_c_panel_above(rb_panel); }
    113 static VALUE rbncurs_c_panel_below(VALUE rb_panel)
    114 { return wrap_panel(panel_below(get_panel(rb_panel))); }
    115 static VALUE rbncurs_m_panel_below(VALUE dummy, VALUE rb_panel)
    116 { return rbncurs_c_panel_below(rb_panel); }
    117 static VALUE rbncurs_c_set_panel_userptr(VALUE rb_panel, VALUE userptr)
    118 { return INT2NUM(set_panel_userptr(get_panel(rb_panel),
    119                                    (void*)(userptr))); }
    120 static VALUE rbncurs_m_set_panel_userptr(VALUE dummy, VALUE rb_panel, VALUE userptr)
    121 { return rbncurs_c_set_panel_userptr(rb_panel, userptr); }
    122 static VALUE rbncurs_c_panel_userptr(VALUE rb_panel)
    123 { return (VALUE)(panel_userptr(get_panel(rb_panel))); }
    124 static VALUE rbncurs_m_panel_userptr(VALUE dummy, VALUE rb_panel)
    125 { return rbncurs_c_panel_userptr(rb_panel); }
    126 static VALUE rbncurs_c_move_panel(VALUE rb_panel, VALUE starty, VALUE startx)
    127 { return INT2NUM(move_panel(get_panel(rb_panel), NUM2INT(starty),
    128                             NUM2INT(startx))); }
    129 static VALUE rbncurs_m_move_panel(VALUE dummy, VALUE rb_panel, VALUE starty, VALUE startx)
    130 { return rbncurs_c_move_panel(rb_panel, starty, startx); }
    131 static VALUE rbncurs_c_replace_panel(VALUE rb_panel, VALUE rb_window)
    132 { return INT2NUM(replace_panel(get_panel(rb_panel), get_window(rb_window))); }
    133 static VALUE rbncurs_m_replace_panel(VALUE dummy, VALUE rb_panel, VALUE rb_window)
    134 { return rbncurs_c_replace_panel(rb_panel, rb_window); }
    135 static VALUE rbncurs_c_panel_hidden(VALUE rb_panel)
    136 { return panel_hidden(get_panel(rb_panel)) ? Qtrue : Qfalse; }
    137 static VALUE rbncurs_m_panel_hidden(VALUE dummy, VALUE rb_panel)
    138 { return rbncurs_c_panel_hidden(rb_panel); }
    139 
    140 
    141 void init_panel(void)
    142 {
    143     mPanel = rb_define_module_under(mNcurses, "Panel");
    144     rb_iv_set(mPanel, "@panels_hash", rb_hash_new());
    145     cPANEL  = rb_define_class_under(mPanel, "PANEL", rb_cObject);
    146     rb_undef_alloc_func(cPANEL);
    147     rb_define_singleton_method(mPanel, "del_panel",
    148                                (&rbncurs_m_del_panel),
    149                                1);
    150     rb_define_singleton_method(mPanel, "delpanel",
    151                                (&rbncurs_m_del_panel),
    152                                1);
    153     rb_define_method(cPANEL, "del",
    154                      (&rbncurs_c_del_panel), 0);
    155     rb_define_method(cPANEL, "delete",
    156                      (&rbncurs_c_del_panel), 0);
    157     rb_define_singleton_method(mPanel, "panel_window",
    158                                (&rbncurs_m_panel_window),
    159                                1);
    160     rb_define_method(cPANEL, "panel_window",
    161                      (&rbncurs_c_panel_window), 0);
    162     rb_define_method(cPANEL, "window",
    163                      (&rbncurs_c_panel_window), 0);
    164     rb_define_singleton_method(mPanel, "update_panels",
    165                                (&rbncurs_m_update_panels),
    166                                0);
    167     rb_define_singleton_method(mPanel, "update",
    168                                (&rbncurs_m_update_panels),
    169                                0);
    170     rb_define_singleton_method(mPanel, "hide_panel",
    171                                (&rbncurs_m_hide_panel),
    172                                1);
    173     rb_define_method(cPANEL, "hide_panel",
    174                      (&rbncurs_c_hide_panel), 0);
    175 
    176     rb_define_method(cPANEL, "hide",
    177                      (&rbncurs_c_hide_panel), 0);
    178     rb_define_singleton_method(mPanel, "show_panel",
    179                                (&rbncurs_m_show_panel),
    180                                1);
    181     rb_define_method(cPANEL, "show_panel",
    182                      (&rbncurs_c_show_panel), 0);
    183 
    184     rb_define_method(cPANEL, "show",
    185                      (&rbncurs_c_show_panel), 0);
    186     rb_define_singleton_method(mPanel, "top_panel",
    187                                (&rbncurs_m_top_panel), 1);
    188     rb_define_method(cPANEL, "top_panel",
    189                      (&rbncurs_c_top_panel), 0);
    190 
    191     rb_define_method(cPANEL, "top",
    192                      (&rbncurs_c_top_panel), 0);
    193     rb_define_singleton_method(mPanel, "bottom_panel",
    194                                (&rbncurs_m_bottom_panel),
    195                                1);
    196     rb_define_method(cPANEL, "bottom_panel",
    197                      (&rbncurs_c_bottom_panel), 0);
    198 
    199     rb_define_method(cPANEL, "bottom",
    200                      (&rbncurs_c_bottom_panel), 0);
    201     rb_define_singleton_method(mPanel, "new_panel",
    202                                (&rbncurs_m_new_panel),
    203                                1);
    204     rb_define_singleton_method(cPANEL, "new",
    205                                (&rbncurs_m_new_panel),
    206                                1);
    207     rb_define_method(cWINDOW, "new_panel",
    208                      (&rbncurs_c_new_panel),
    209                      0);
    210     rb_define_singleton_method(mPanel, "panel_above",
    211                                (&rbncurs_m_panel_above),
    212                                1);
    213     rb_define_method(cPANEL, "panel_above",
    214                      (&rbncurs_c_panel_above), 0);
    215     rb_define_method(cPANEL, "above",
    216                      (&rbncurs_c_panel_above), 0);
    217     rb_define_singleton_method(mPanel, "panel_below",
    218                                (&rbncurs_m_panel_below),
    219                                1);
    220     rb_define_method(cPANEL, "panel_below",
    221                      (&rbncurs_c_panel_below), 0);
    222     rb_define_method(cPANEL, "below",
    223                      (&rbncurs_c_panel_below), 0);
    224     rb_define_singleton_method(mPanel, "set_panel_userptr",
    225                                (&rbncurs_m_set_panel_userptr), 2);
    226     rb_define_method(cPANEL, "set_panel_userptr",
    227                      (&rbncurs_c_set_panel_userptr),
    228                      1);
    229     rb_define_method(cPANEL, "set_userptr",
    230                      (&rbncurs_c_set_panel_userptr),
    231                      1);
    232     rb_define_method(cPANEL, "userptr=",
    233                      (&rbncurs_c_set_panel_userptr),
    234                      1);
    235     rb_define_singleton_method(mPanel, "panel_userptr",
    236                                (&rbncurs_m_panel_userptr),
    237                                1);
    238     rb_define_method(cPANEL, "panel_userptr",
    239                      (&rbncurs_c_panel_userptr),
    240                      0);
    241     rb_define_method(cPANEL, "userptr",
    242                      (&rbncurs_c_panel_userptr),
    243                      0);
    244     rb_define_singleton_method(mPanel, "move_panel",
    245                                (&rbncurs_m_move_panel),
    246                                3);
    247     rb_define_method(cPANEL, "move_panel",
    248                      (&rbncurs_c_move_panel), 2);
    249     rb_define_method(cPANEL, "move",
    250                      (&rbncurs_c_move_panel), 2);
    251     rb_define_singleton_method(mPanel, "replace_panel",
    252                                (&rbncurs_m_replace_panel),
    253                                2);
    254     rb_define_method(cPANEL, "replace_panel",
    255                      (&rbncurs_c_replace_panel), 1);
    256     rb_define_method(cPANEL, "replace",
    257                      (&rbncurs_c_replace_panel), 1);
    258     rb_define_singleton_method(mPanel, "panel_hidden?",
    259                                (&rbncurs_m_panel_hidden),
    260                                1);
    261     rb_define_method(cPANEL, "panel_hidden?",
    262                      (&rbncurs_c_panel_hidden), 0);
    263     rb_define_method(cPANEL, "hidden?",
    264                      (&rbncurs_c_panel_hidden), 0);
    265 }
    266 
    267 #endif