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