ncurses 5.3
[ncurses.git] / c++ / cursesf.cc
1 // * this is for making emacs happy: -*-Mode: C++;-*-
2 /****************************************************************************
3  * Copyright (c) 1998,2001 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  *   Contact: http://www.familiepfeifer.de/Contact.aspx?Lang=en             *
33  ****************************************************************************/
34
35 #include "internal.h"
36 #include "cursesf.h"
37 #include "cursesapp.h"
38
39 MODULE_ID("$Id: cursesf.cc,v 1.15 2002/07/06 15:47:52 juergen Exp $")
40
41 NCursesFormField::~NCursesFormField () {
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   int fieldCount = 0,lcv;
52   FIELD** old_fields;
53
54   assert(nfields != 0);
55
56   for (lcv=0; nfields[lcv]->field; ++lcv)
57     ++fieldCount;
58
59   FIELD** fields = new FIELD*[fieldCount + 1];
60
61   for (lcv=0;nfields[lcv]->field;++lcv) {
62     fields[lcv] = nfields[lcv]->field;
63   }
64   fields[lcv] = NULL;
65
66   my_fields = nfields;
67
68   if (form && (old_fields = ::form_fields(form))) {
69     ::set_form_fields(form,(FIELD**)0);
70     delete[] old_fields;
71   }
72   return fields;
73 }
74
75 void NCursesForm::setDefaultAttributes() {
76   NCursesApplication* S = NCursesApplication::getApplication();
77
78   int n = count();
79   if (n > 0) {
80     for(int i=0; i<n; i++) {
81       NCursesFormField* f = (*this)[i];
82       if ((f->options() & (O_EDIT|O_ACTIVE))==(O_EDIT|O_ACTIVE)) {
83         if (S) {
84           f->set_foreground(S->foregrounds());
85           f->set_background(S->backgrounds());
86         }
87         f->set_pad_character('_');
88       }
89       else {
90         if (S)
91           f->set_background(S->labels());
92       }
93     }
94   }
95
96   if (S) {
97     bkgd(' '|S->dialog_backgrounds());
98     if (sub)
99       sub->bkgd(' '|S->dialog_backgrounds());
100   }
101 }
102
103 void
104 NCursesForm::InitForm(NCursesFormField* nfields[],
105                       bool with_frame,
106                       bool autoDelete_Fields) {
107   int mrows, mcols;
108
109   keypad(TRUE);
110   meta(TRUE);
111
112   b_framed = with_frame;
113   b_autoDelete = autoDelete_Fields;
114
115   form = (FORM*)0;
116   form = ::new_form(mapFields(nfields));
117   if (!form)
118     OnError (E_SYSTEM_ERROR);
119
120   UserHook* hook = new UserHook;
121   hook->m_user   = NULL;
122   hook->m_back   = this;
123   hook->m_owner  = form;
124   ::set_form_userptr(form,(void*)hook);
125
126   ::set_form_init  (form, NCursesForm::frm_init);
127   ::set_form_term  (form, NCursesForm::frm_term);
128   ::set_field_init (form, NCursesForm::fld_init);
129   ::set_field_term (form, NCursesForm::fld_term);
130
131   scale(mrows, mcols);
132   ::set_form_win(form, w);
133
134   if (with_frame) {
135     if ((mrows > height()-2) || (mcols > width()-2))
136       OnError(E_NO_ROOM);
137     sub = new NCursesWindow(*this,mrows,mcols,1,1,'r');
138     ::set_form_sub(form, sub->w);
139     b_sub_owner = TRUE;
140   }
141   else {
142     sub = (NCursesWindow*)0;
143     b_sub_owner = FALSE;
144   }
145   options_on(O_NL_OVERLOAD);
146   setDefaultAttributes();
147 }
148
149 NCursesForm::~NCursesForm() {
150   UserHook* hook = (UserHook*)::form_userptr(form);
151   delete hook;
152   if (b_sub_owner) {
153     delete sub;
154     ::set_form_sub(form,(WINDOW *)0);
155   }
156   if (form) {
157     FIELD** fields = ::form_fields(form);
158     int cnt = count();
159
160     OnError(::set_form_fields(form,(FIELD**)0));
161
162     if (b_autoDelete) {
163       if (cnt>0) {
164         for (int i=0; i <= cnt; i++)
165           delete my_fields[i];
166       }
167       delete[] my_fields;
168     }
169
170     ::free_form(form);
171     // It's essential to do this after free_form()
172     delete[] fields;
173   }
174 }
175
176 void
177 NCursesForm::setSubWindow(NCursesWindow& nsub) {
178   if (!isDescendant(nsub))
179     OnError(E_SYSTEM_ERROR);
180   else {
181     if (b_sub_owner)
182       delete sub;
183     sub = &nsub;
184     ::set_form_sub(form,sub->w);
185   }
186 }
187
188 /* Internal hook functions. They will route the hook
189  * calls to virtual methods of the NCursesForm class,
190  * so in C++ providing a hook is done simply by
191  * implementing a virtual method in a derived class
192  */
193 void
194 NCursesForm::frm_init(FORM *f) {
195   getHook(f)->On_Form_Init();
196 }
197
198 void
199 NCursesForm::frm_term(FORM *f) {
200   getHook(f)->On_Form_Termination();
201 }
202
203 void
204 NCursesForm::fld_init(FORM *f) {
205   NCursesForm* F = getHook(f);
206   F->On_Field_Init (*(F->current_field ()));
207 }
208
209 void
210 NCursesForm::fld_term(FORM *f) {
211   NCursesForm* F = getHook(f);
212   F->On_Field_Termination (*(F->current_field ()));
213 }
214
215 void
216 NCursesForm::On_Form_Init() {
217 }
218
219 void
220 NCursesForm::On_Form_Termination() {
221 }
222
223 void
224 NCursesForm::On_Field_Init(NCursesFormField& field) {
225 }
226
227 void
228 NCursesForm::On_Field_Termination(NCursesFormField& field) {
229 }
230
231 // call the form driver and do basic error checking.
232 int
233 NCursesForm::driver (int c) {
234   int res = ::form_driver (form, c);
235   switch (res) {
236   case E_OK:
237   case E_REQUEST_DENIED:
238   case E_INVALID_FIELD:
239   case E_UNKNOWN_COMMAND:
240     break;
241   default:
242     OnError (res);
243   }
244   return (res);
245 }
246
247 void NCursesForm::On_Request_Denied(int c) const {
248   ::beep();
249 }
250
251 void NCursesForm::On_Invalid_Field(int c) const {
252   ::beep();
253 }
254
255 void NCursesForm::On_Unknown_Command(int c) const {
256   ::beep();
257 }
258
259 static const int CMD_QUIT = MAX_COMMAND + 1;
260
261 NCursesFormField*
262 NCursesForm::operator()(void) {
263   int drvCmnd;
264   int err;
265   int c;
266
267   post();
268   show();
269   refresh();
270
271   while (((drvCmnd = virtualize((c=getKey()))) != CMD_QUIT)) {
272     switch((err=driver(drvCmnd))) {
273     case E_REQUEST_DENIED:
274       On_Request_Denied(c);
275       break;
276     case E_INVALID_FIELD:
277       On_Invalid_Field(c);
278       break;
279     case E_UNKNOWN_COMMAND:
280       On_Unknown_Command(c);
281       break;
282     case E_OK:
283       break;
284     default:
285       OnError(err);
286     }
287   }
288
289   unpost();
290   hide();
291   refresh();
292   return my_fields[::field_index (::current_field (form))];
293 }
294
295 // Provide a default key virtualization. Translate the keyboard
296 // code c into a form request code.
297 // The default implementation provides a hopefully straightforward
298 // mapping for the most common keystrokes and form requests.
299 int
300 NCursesForm::virtualize(int c) {
301   switch(c) {
302
303   case KEY_HOME      : return(REQ_FIRST_FIELD);
304   case KEY_END       : return(REQ_LAST_FIELD);
305
306   case KEY_DOWN      : return(REQ_DOWN_CHAR);
307   case KEY_UP        : return(REQ_UP_CHAR);
308   case KEY_LEFT      : return(REQ_PREV_CHAR);
309   case KEY_RIGHT     : return(REQ_NEXT_CHAR);
310
311   case KEY_NPAGE     : return(REQ_NEXT_PAGE);
312   case KEY_PPAGE     : return(REQ_PREV_PAGE);
313
314   case KEY_BACKSPACE : return(REQ_DEL_PREV);
315   case KEY_ENTER     : return(REQ_NEW_LINE);
316   case KEY_CLEAR     : return(REQ_CLR_FIELD);
317
318   case CTRL('X')     : return(CMD_QUIT);        // eXit
319
320   case CTRL('F')     : return(REQ_NEXT_FIELD);  // Forward
321   case CTRL('B')     : return(REQ_PREV_FIELD);  // Backward
322   case CTRL('L')     : return(REQ_LEFT_FIELD);  // Left
323   case CTRL('R')     : return(REQ_RIGHT_FIELD); // Right
324   case CTRL('U')     : return(REQ_UP_FIELD);    // Up
325   case CTRL('D')     : return(REQ_DOWN_FIELD);  // Down
326
327   case CTRL('W')     : return(REQ_NEXT_WORD);
328   case CTRL('T')     : return(REQ_PREV_WORD);
329
330   case CTRL('A')     : return(REQ_BEG_FIELD);
331   case CTRL('E')     : return(REQ_END_FIELD);
332
333   case CTRL('I')     : return(REQ_INS_CHAR);
334   case CTRL('M')     :
335   case CTRL('J')     : return(REQ_NEW_LINE);
336   case CTRL('O')     : return(REQ_INS_LINE);
337   case CTRL('V')     : return(REQ_DEL_CHAR);
338   case CTRL('H')     : return(REQ_DEL_PREV);
339   case CTRL('Y')     : return(REQ_DEL_LINE);
340   case CTRL('G')     : return(REQ_DEL_WORD);
341   case CTRL('K')     : return(REQ_CLR_EOF);
342
343   case CTRL('N')     : return(REQ_NEXT_CHOICE);
344   case CTRL('P')     : return(REQ_PREV_CHOICE);
345
346   default:
347     return(c);
348   }
349 }
350 //
351 // -------------------------------------------------------------------------
352 // User Defined Fieldtypes
353 // -------------------------------------------------------------------------
354 //
355 bool UserDefinedFieldType::fcheck(FIELD *f, const void *u) {
356   NCursesFormField* F = (NCursesFormField*)u;
357   assert(F != 0);
358   UserDefinedFieldType* udf = (UserDefinedFieldType*)(F->fieldtype());
359   assert(udf != 0);
360   return udf->field_check(*F);
361 }
362
363 bool UserDefinedFieldType::ccheck(int c, const void *u) {
364   NCursesFormField* F = (NCursesFormField*)u;
365   assert(F != 0);
366   UserDefinedFieldType* udf =
367     (UserDefinedFieldType*)(F->fieldtype());
368   assert(udf != 0);
369   return udf->char_check(c);
370 }
371
372 void* UserDefinedFieldType::makearg(va_list* va) {
373   return va_arg(*va,NCursesFormField*);
374 }
375
376 FIELDTYPE* UserDefinedFieldType::generic_fieldtype =
377   ::new_fieldtype(UserDefinedFieldType::fcheck,
378                   UserDefinedFieldType::ccheck);
379
380 FIELDTYPE* UserDefinedFieldType_With_Choice::generic_fieldtype_with_choice =
381   ::new_fieldtype(UserDefinedFieldType::fcheck,
382                   UserDefinedFieldType::ccheck);
383
384 bool UserDefinedFieldType_With_Choice::next_choice(FIELD *f, const void *u) {
385   NCursesFormField* F = (NCursesFormField*)u;
386   assert(F != 0);
387   UserDefinedFieldType_With_Choice* udf =
388     (UserDefinedFieldType_With_Choice*)(F->fieldtype());
389   assert(udf != 0);
390   return udf->next(*F);
391 }
392
393 bool UserDefinedFieldType_With_Choice::prev_choice(FIELD *f, const void *u) {
394   NCursesFormField* F = (NCursesFormField*)u;
395   assert(F != 0);
396   UserDefinedFieldType_With_Choice* udf =
397     (UserDefinedFieldType_With_Choice*)(F->fieldtype());
398   assert(udf != 0);
399   return udf->previous(*F);
400 }
401
402 class UDF_Init {
403 private:
404   int code;
405   static UDF_Init* I;
406 public:
407   UDF_Init() {
408     code = ::set_fieldtype_arg(UserDefinedFieldType::generic_fieldtype,
409                                UserDefinedFieldType::makearg,
410                                NULL,
411                                NULL);
412     if (code==E_OK)
413       code = ::set_fieldtype_arg
414         (UserDefinedFieldType_With_Choice::generic_fieldtype_with_choice,
415          UserDefinedFieldType::makearg,
416          NULL,
417          NULL);
418     if (code==E_OK)
419       code = ::set_fieldtype_choice
420         (UserDefinedFieldType_With_Choice::generic_fieldtype_with_choice,
421          UserDefinedFieldType_With_Choice::next_choice,
422          UserDefinedFieldType_With_Choice::prev_choice);
423   }
424 };
425
426 UDF_Init* UDF_Init::I = new UDF_Init();
427