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