c++/cursesf.cc

   1 // * this is for making emacs happy: -*-Mode: C++;-*-
   2 /****************************************************************************
   3  * Copyright 2019,2020 Thomas E. Dickey                                     *
   4  * Copyright 1998-2005,2011 Free Software Foundation, Inc.                  *
   5  *                                                                          *
   6  * Permission is hereby granted, free of charge, to any person obtaining a  *
   7  * copy of this software and associated documentation files (the            *
   8  * "Software"), to deal in the Software without restriction, including      *
   9  * without limitation the rights to use, copy, modify, merge, publish,      *
  10  * distribute, distribute with modifications, sublicense, and/or sell       *
  11  * copies of the Software, and to permit persons to whom the Software is    *
  12  * furnished to do so, subject to the following conditions:                 *
  13  *                                                                          *
  14  * The above copyright notice and this permission notice shall be included  *
  15  * in all copies or substantial portions of the Software.                   *
  16  *                                                                          *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
  19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
  20  * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
  21  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
  22  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
  23  * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
  24  *                                                                          *
  25  * Except as contained in this notice, the name(s) of the above copyright   *
  26  * holders shall not be used in advertising or otherwise to promote the     *
  27  * sale, use or other dealings in this Software without prior written       *
  28  * authorization.                                                           *
  29  ****************************************************************************/
  30
  31 /****************************************************************************
  32  *   Author: Juergen Pfeifer, 1997                                          *
  33  ****************************************************************************/
  34
  35 #include "internal.h"
  36 #include "cursesf.h"
  37 #include "cursesapp.h"
  38
  39 MODULE_ID("$Id: cursesf.cc,v 1.24 2020/02/02 23:34:34 tom Exp $")
  40
  41 NCursesFormField::~NCursesFormField () THROWS(NCursesException)
  42 {
  43   if (field)
  44     OnError(::free_field (field));
  45 }
  46
  47 /* Construct a FIELD* array from an array of NCursesFormField
  48  * objects.
  49  */
  50 FIELD**
  51 NCursesForm::mapFields(NCursesFormField* nfields[])
  52 {
  53   int fieldCount = 0,lcv;
  54   FIELD** old_fields;
  55
  56   assert(nfields != 0);
  57
  58   for (lcv=0; nfields[lcv]->field; ++lcv)
  59     ++fieldCount;
  60
  61   FIELD** fields = new FIELD*[fieldCount + 1];
  62
  63   for (lcv=0;nfields[lcv]->field;++lcv) {
  64     fields[lcv] = nfields[lcv]->field;
  65   }
  66   fields[lcv] = NULL;
  67
  68   my_fields = nfields;
  69
  70   if (form && (old_fields = ::form_fields(form))) {
  71     ::set_form_fields(form, static_cast<FIELD**>(0));
  72     delete[] old_fields;
  73   }
  74   return fields;
  75 }
  76
  77 void NCursesForm::setDefaultAttributes()
  78 {
  79   NCursesApplication* S = NCursesApplication::getApplication();
  80
  81   int n = count();
  82   if (n > 0) {
  83     for(int i=0; i<n; i++) {
  84       NCursesFormField* f = (*this)[i];
  85       if ((f->options() & (O_EDIT|O_ACTIVE))==(O_EDIT|O_ACTIVE)) {
  86         if (S) {
  87           f->set_foreground(S->foregrounds());
  88           f->set_background(S->backgrounds());
  89         }
  90         f->set_pad_character('_');
  91       }
  92       else {
  93         if (S)
  94           f->set_background(S->labels());
  95       }
  96     }
  97   }
  98
  99   if (S) {
 100     bkgd(' '|S->dialog_backgrounds());
 101     if (sub)
 102       sub->bkgd(' '|S->dialog_backgrounds());
 103   }
 104 }
 105
 106 void
 107 NCursesForm::InitForm(NCursesFormField* nfields[],
 108                       bool with_frame,
 109                       bool autoDelete_Fields)
 110 {
 111   int mrows, mcols;
 112
 113   keypad(TRUE);
 114   meta(TRUE);
 115
 116   b_framed = with_frame;
 117   b_autoDelete = autoDelete_Fields;
 118
 119   form = static_cast<FORM*>(0);
 120   form = ::new_form(mapFields(nfields));
 121   if (!form)
 122     OnError (E_SYSTEM_ERROR);
 123
 124   UserHook* hook = new UserHook;
 125   hook->m_user   = NULL;
 126   hook->m_back   = this;
 127   hook->m_owner  = form;
 128   ::set_form_userptr(form, reinterpret_cast<void*>(hook));
 129
 130   ::set_form_init  (form, _nc_xx_frm_init);
 131   ::set_form_term  (form, _nc_xx_frm_term);
 132   ::set_field_init (form, _nc_xx_fld_init);
 133   ::set_field_term (form, _nc_xx_fld_term);
 134
 135   scale(mrows, mcols);
 136   ::set_form_win(form, w);
 137
 138   if (with_frame) {
 139     if ((mrows > height()-2) || (mcols > width()-2))
 140       OnError(E_NO_ROOM);
 141     sub = new NCursesWindow(*this,mrows,mcols,1,1,'r');
 142     ::set_form_sub(form, sub->w);
 143     b_sub_owner = TRUE;
 144   }
 145   else {
 146     sub = static_cast<NCursesWindow*>(0);
 147     b_sub_owner = FALSE;
 148   }
 149   options_on(O_NL_OVERLOAD);
 150   setDefaultAttributes();
 151 }
 152
 153 NCursesForm::~NCursesForm() THROWS(NCursesException)
 154 {
 155   UserHook* hook = reinterpret_cast<UserHook*>(::form_userptr(form));
 156   delete hook;
 157   if (b_sub_owner) {
 158     delete sub;
 159     ::set_form_sub(form, static_cast<WINDOW *>(0));
 160   }
 161   if (form) {
 162     FIELD** fields = ::form_fields(form);
 163     int cnt = count();
 164
 165     OnError(::set_form_fields(form, static_cast<FIELD**>(0)));
 166
 167     if (b_autoDelete) {
 168       if (cnt>0) {
 169         for (int i=0; i <= cnt; i++)
 170           delete my_fields[i];
 171       }
 172       delete[] my_fields;
 173     }
 174
 175     ::free_form(form);
 176     // It's essential to do this after free_form()
 177     delete[] fields;
 178   }
 179 }
 180
 181 void
 182 NCursesForm::setSubWindow(NCursesWindow& nsub)
 183 {
 184   if (!isDescendant(nsub))
 185     OnError(E_SYSTEM_ERROR);
 186   else {
 187     if (b_sub_owner)
 188       delete sub;
 189     sub = &nsub;
 190     ::set_form_sub(form,sub->w);
 191   }
 192 }
 193
 194 /* Internal hook functions. They will route the hook
 195  * calls to virtual methods of the NCursesForm class,
 196  * so in C++ providing a hook is done simply by
 197  * implementing a virtual method in a derived class
 198  */
 199 void
 200 _nc_xx_frm_init(FORM *f)
 201 {
 202   NCursesForm::getHook(f)->On_Form_Init();
 203 }
 204
 205 void
 206 _nc_xx_frm_term(FORM *f)
 207 {
 208   NCursesForm::getHook(f)->On_Form_Termination();
 209 }
 210
 211 void
 212 _nc_xx_fld_init(FORM *f)
 213 {
 214   NCursesForm* F = NCursesForm::getHook(f);
 215   F->On_Field_Init (*(F->current_field ()));
 216 }
 217
 218 void
 219 _nc_xx_fld_term(FORM *f)
 220 {
 221   NCursesForm* F = NCursesForm::getHook(f);
 222   F->On_Field_Termination (*(F->current_field ()));
 223 }
 224
 225 void
 226 NCursesForm::On_Form_Init()
 227 {
 228 }
 229
 230 void
 231 NCursesForm::On_Form_Termination()
 232 {
 233 }
 234
 235 void
 236 NCursesForm::On_Field_Init(NCursesFormField& field)
 237 {
 238   (void) field;
 239 }
 240
 241 void
 242 NCursesForm::On_Field_Termination(NCursesFormField& field)
 243 {
 244   (void) field;
 245 }
 246
 247 // call the form driver and do basic error checking.
 248 int
 249 NCursesForm::driver (int c)
 250 {
 251   int res = ::form_driver (form, c);
 252   switch (res) {
 253   case E_OK:
 254   case E_REQUEST_DENIED:
 255   case E_INVALID_FIELD:
 256   case E_UNKNOWN_COMMAND:
 257     break;
 258   default:
 259     OnError (res);
 260   }
 261   return (res);
 262 }
 263
 264 void NCursesForm::On_Request_Denied(int c) const
 265 {
 266   (void) c;
 267   ::beep();
 268 }
 269
 270 void NCursesForm::On_Invalid_Field(int c) const
 271 {
 272   (void) c;
 273   ::beep();
 274 }
 275
 276 void NCursesForm::On_Unknown_Command(int c) const
 277 {
 278   (void) c;
 279   ::beep();
 280 }
 281
 282 static const int CMD_QUIT = MAX_COMMAND + 1;
 283
 284 NCursesFormField*
 285 NCursesForm::operator()(void)
 286 {
 287   int drvCmnd;
 288   int err;
 289   int c;
 290
 291   post();
 292   show();
 293   refresh();
 294
 295   while (((drvCmnd = virtualize((c=getKey()))) != CMD_QUIT)) {
 296     switch((err=driver(drvCmnd))) {
 297     case E_REQUEST_DENIED:
 298       On_Request_Denied(c);
 299       break;
 300     case E_INVALID_FIELD:
 301       On_Invalid_Field(c);
 302       break;
 303     case E_UNKNOWN_COMMAND:
 304       On_Unknown_Command(c);
 305       break;
 306     case E_OK:
 307       break;
 308     default:
 309       OnError(err);
 310     }
 311   }
 312
 313   unpost();
 314   hide();
 315   refresh();
 316   return my_fields[::field_index (::current_field (form))];
 317 }
 318
 319 // Provide a default key virtualization. Translate the keyboard
 320 // code c into a form request code.
 321 // The default implementation provides a hopefully straightforward
 322 // mapping for the most common keystrokes and form requests.
 323 int
 324 NCursesForm::virtualize(int c)
 325 {
 326   switch(c) {
 327
 328   case KEY_HOME      : return(REQ_FIRST_FIELD);
 329   case KEY_END       : return(REQ_LAST_FIELD);
 330
 331   case KEY_DOWN      : return(REQ_DOWN_CHAR);
 332   case KEY_UP        : return(REQ_UP_CHAR);
 333   case KEY_LEFT      : return(REQ_PREV_CHAR);
 334   case KEY_RIGHT     : return(REQ_NEXT_CHAR);
 335
 336   case KEY_NPAGE     : return(REQ_NEXT_PAGE);
 337   case KEY_PPAGE     : return(REQ_PREV_PAGE);
 338
 339   case KEY_BACKSPACE : return(REQ_DEL_PREV);
 340   case KEY_ENTER     : return(REQ_NEW_LINE);
 341   case KEY_CLEAR     : return(REQ_CLR_FIELD);
 342
 343   case CTRL('X')     : return(CMD_QUIT);        // eXit
 344
 345   case CTRL('F')     : return(REQ_NEXT_FIELD);  // Forward
 346   case CTRL('B')     : return(REQ_PREV_FIELD);  // Backward
 347   case CTRL('L')     : return(REQ_LEFT_FIELD);  // Left
 348   case CTRL('R')     : return(REQ_RIGHT_FIELD); // Right
 349   case CTRL('U')     : return(REQ_UP_FIELD);    // Up
 350   case CTRL('D')     : return(REQ_DOWN_FIELD);  // Down
 351
 352   case CTRL('W')     : return(REQ_NEXT_WORD);
 353   case CTRL('T')     : return(REQ_PREV_WORD);
 354
 355   case CTRL('A')     : return(REQ_BEG_FIELD);
 356   case CTRL('E')     : return(REQ_END_FIELD);
 357
 358   case CTRL('I')     : return(REQ_INS_CHAR);
 359   case CTRL('M')     :
 360   case CTRL('J')     : return(REQ_NEW_LINE);
 361   case CTRL('O')     : return(REQ_INS_LINE);
 362   case CTRL('V')     : return(REQ_DEL_CHAR);
 363   case CTRL('H')     : return(REQ_DEL_PREV);
 364   case CTRL('Y')     : return(REQ_DEL_LINE);
 365   case CTRL('G')     : return(REQ_DEL_WORD);
 366   case CTRL('K')     : return(REQ_CLR_EOF);
 367
 368   case CTRL('N')     : return(REQ_NEXT_CHOICE);
 369   case CTRL('P')     : return(REQ_PREV_CHOICE);
 370
 371   default:
 372     return(c);
 373   }
 374 }
 375 //
 376 // -------------------------------------------------------------------------
 377 // User Defined Fieldtypes
 378 // -------------------------------------------------------------------------
 379 //
 380 bool _nc_xx_fld_fcheck(FIELD *f, const void *u)
 381 {
 382   (void) f;
 383   NCursesFormField* F = reinterpret_cast<NCursesFormField*>(const_cast<void *>(u));
 384   assert(F != 0);
 385   UserDefinedFieldType* udf = reinterpret_cast<UserDefinedFieldType*>(F->fieldtype());
 386   assert(udf != 0);
 387   return udf->field_check(*F);
 388 }
 389
 390 bool _nc_xx_fld_ccheck(int c, const void *u)
 391 {
 392   NCursesFormField* F = reinterpret_cast<NCursesFormField*>(const_cast<void *>(u));
 393   assert(F != 0);
 394   UserDefinedFieldType* udf =
 395     reinterpret_cast<UserDefinedFieldType*>(F->fieldtype());
 396   assert(udf != 0);
 397   return udf->char_check(c);
 398 }
 399
 400 void* _nc_xx_fld_makearg(va_list* va)
 401 {
 402   return va_arg(*va,NCursesFormField*);
 403 }
 404
 405 FIELDTYPE* UserDefinedFieldType::generic_fieldtype =
 406   ::new_fieldtype(_nc_xx_fld_fcheck,
 407                   _nc_xx_fld_ccheck);
 408
 409 FIELDTYPE* UserDefinedFieldType_With_Choice::generic_fieldtype_with_choice =
 410   ::new_fieldtype(_nc_xx_fld_fcheck,
 411                   _nc_xx_fld_ccheck);
 412
 413 bool _nc_xx_next_choice(FIELD *f, const void *u)
 414 {
 415   (void) f;
 416   NCursesFormField* F = reinterpret_cast<NCursesFormField*>(const_cast<void *>(u));
 417   assert(F != 0);
 418   UserDefinedFieldType_With_Choice* udf =
 419     reinterpret_cast<UserDefinedFieldType_With_Choice*>(F->fieldtype());
 420   assert(udf != 0);
 421   return udf->next(*F);
 422 }
 423
 424 bool _nc_xx_prev_choice(FIELD *f, const void *u)
 425 {
 426   (void) f;
 427   NCursesFormField* F = reinterpret_cast<NCursesFormField*>(const_cast<void *>(u));
 428   assert(F != 0);
 429   UserDefinedFieldType_With_Choice* udf =
 430     reinterpret_cast<UserDefinedFieldType_With_Choice*>(F->fieldtype());
 431   assert(udf != 0);
 432   return udf->previous(*F);
 433 }
 434
 435 class UDF_Init
 436 {
 437 private:
 438   int code;
 439   static UDF_Init* I;
 440
 441 public:
 442   UDF_Init()
 443     : code(0)
 444   {
 445     code = ::set_fieldtype_arg(UserDefinedFieldType::generic_fieldtype,
 446                                _nc_xx_fld_makearg,
 447                                NULL,
 448                                NULL);
 449     if (code==E_OK)
 450       code = ::set_fieldtype_arg
 451         (UserDefinedFieldType_With_Choice::generic_fieldtype_with_choice,
 452          _nc_xx_fld_makearg,
 453          NULL,
 454          NULL);
 455     if (code==E_OK)
 456       code = ::set_fieldtype_choice
 457         (UserDefinedFieldType_With_Choice::generic_fieldtype_with_choice,
 458          _nc_xx_next_choice,
 459          _nc_xx_prev_choice);
 460   }
 461 };
 462
 463 UDF_Init* UDF_Init::I = new UDF_Init();