← Back to branch summary

~ubuntu-branches/ubuntu/trusty/libcdk5/trusty

« back to all changes in this revision

Viewing changes to traverse.c

  • Committer: Bazaar Package Importer
  • Author(s): John Goerzen
  • Date: 2007-06-06 03:54:31 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20070606035431-ba4gdvw0h6ybffsu
Tags: 5.0.20060507-1
http://bugs.debian.org/402978
http://bugs.debian.org/416336
http://bugs.debian.org/294709
* New upstream release.
* Fixed header patching.  Patch from Robert Schiele.
  Closes: #402978, #416336.
* Update widget count in description.  Closes: #294709.

Show diffs side-by-side

added added

removed removed

Lines of Context:
traverse.c
2
2
 
3
3
/*
4
4
 * $Author: tom $
5
 
 * $Date: 2005/03/08 21:48:30 $
6
 
 * $Revision: 1.17 $
 
5
 * $Date: 2005/12/30 01:32:53 $
 
6
 * $Revision: 1.21 $
7
7
 */
8
8
 
9
9
#define limitFocusIndex(screen, value) \
53
53
   return newobj;
54
54
}
55
55
 
 
56
static boolean checkMenuKey (int keyCode, int functionKey)
 
57
{
 
58
   int result = FALSE;
 
59
 
 
60
   result = (keyCode == KEY_ESC && !functionKey);
 
61
 
 
62
   return result;
 
63
}
 
64
 
56
65
static CDKOBJS *handleMenu (CDKSCREEN *screen, CDKOBJS *menu, CDKOBJS *oldobj)
57
66
{
58
67
   bool done = FALSE;
61
70
   switchFocus (menu, oldobj);
62
71
   while (!done)
63
72
   {
64
 
      int key = getcCDKObject (menu);
 
73
      boolean functionKey;
 
74
      int key = getchCDKObject (menu, &functionKey);
65
75
 
66
76
      switch (key)
67
77
      {
68
78
      case KEY_TAB:
69
 
         {
70
 
            done = TRUE;
71
 
            break;
72
 
         }
 
79
         done = TRUE;
 
80
         break;
 
81
 
73
82
      case KEY_ESC:
74
 
         {
75
 
            /* cleanup the menu */
76
 
            injectCDKMenu ((CDKMENU *) menu, key);
77
 
            done = TRUE;
78
 
            break;
79
 
         }
 
83
         /* cleanup the menu */
 
84
         injectCDKMenu ((CDKMENU *)menu, key);
 
85
         done = TRUE;
 
86
         break;
 
87
 
80
88
      default:
81
 
         {
82
 
            int m = injectCDKMenu ((CDKMENU *) menu, key);
83
 
            done = (m >= 0);
84
 
            break;
85
 
         }
 
89
         done = (injectCDKMenu ((CDKMENU *)menu, key) >= 0);
 
90
         break;
86
91
      }
87
92
   }
 
93
 
88
94
   if ((newobj = getCDKFocusCurrent (screen)) == 0)
89
95
      newobj = setCDKFocusNext (screen);
90
96
 
226
232
}
227
233
 
228
234
/*
229
 
 * Traverse the widgets on a screen
 
235
 * Set focus to a specific object, returning it.
 
236
 * If the object cannot be found, return null.
 
237
 */
 
238
CDKOBJS *setCDKFocusCurrent (CDKSCREEN *screen, CDKOBJS *newobj)
 
239
{
 
240
   CDKOBJS *result = 0;
 
241
   CDKOBJS *curobj;
 
242
   int n = getFocusIndex (screen);
 
243
   int first = n;
 
244
 
 
245
   for (;;)
 
246
   {
 
247
      if (++n >= screen->objectCount)
 
248
         n = 0;
 
249
 
 
250
      curobj = screen->object[n];
 
251
      if (curobj == newobj)
 
252
      {
 
253
         result = curobj;
 
254
         break;
 
255
      }
 
256
      else if (n == first)
 
257
      {
 
258
         break;
 
259
      }
 
260
   }
 
261
 
 
262
   setFocusIndex (screen, (result != 0) ? n : -1);
 
263
   return result;
 
264
}
 
265
 
 
266
/*
 
267
 * Set focus to the first object in the screen.
 
268
 */
 
269
CDKOBJS *setCDKFocusFirst (CDKSCREEN *screen)
 
270
{
 
271
   setFocusIndex (screen, screen->objectCount - 1);
 
272
   return switchFocus (setCDKFocusNext (screen), 0);
 
273
}
 
274
 
 
275
/*
 
276
 * Set focus to the last object in the screen.
 
277
 */
 
278
CDKOBJS *setCDKFocusLast (CDKSCREEN *screen)
 
279
{
 
280
   setFocusIndex (screen, 0);
 
281
   return switchFocus (setCDKFocusPrevious (screen), 0);
 
282
}
 
283
 
 
284
void traverseCDKOnce (CDKSCREEN *screen,
 
285
                      CDKOBJS *curobj,
 
286
                      int keyCode,
 
287
                      boolean functionKey,
 
288
                      CHECK_KEYCODE funcMenuKey)
 
289
{
 
290
   switch (keyCode)
 
291
   {
 
292
   case KEY_BTAB:
 
293
      switchFocus (setCDKFocusPrevious (screen), curobj);
 
294
      break;
 
295
 
 
296
   case KEY_TAB:
 
297
      switchFocus (setCDKFocusNext (screen), curobj);
 
298
      break;
 
299
 
 
300
   case KEY_F (10):
 
301
      /* save data and exit */
 
302
      exitOKCDKScreen (screen);
 
303
      break;
 
304
 
 
305
   case CTRL ('X'):
 
306
      exitCancelCDKScreen (screen);
 
307
      break;
 
308
 
 
309
   case CTRL ('R'):
 
310
      /* reset data to defaults */
 
311
      resetCDKScreen (screen);
 
312
      setFocus (curobj);
 
313
      break;
 
314
 
 
315
   case CDK_REFRESH:
 
316
      /* redraw screen */
 
317
      refreshCDKScreen (screen);
 
318
      setFocus (curobj);
 
319
      break;
 
320
 
 
321
   default:
 
322
      /* not everyone wants menus, so we make them optional here */
 
323
      if (funcMenuKey != 0 && funcMenuKey (keyCode, functionKey))
 
324
      {
 
325
         /* find and enable drop down menu */
 
326
         int j;
 
327
 
 
328
         for (j = 0; j < screen->objectCount; ++j)
 
329
            if (ObjTypeOf (screen->object[j]) == vMENU)
 
330
            {
 
331
               handleMenu (screen, screen->object[j], curobj);
 
332
               break;
 
333
            }
 
334
      }
 
335
      else
 
336
      {
 
337
         InjectObj (curobj, keyCode);
 
338
      }
 
339
      break;
 
340
   }
 
341
}
 
342
 
 
343
/*
 
344
 * Traverse the widgets on a screen.
230
345
 */
231
346
int traverseCDKScreen (CDKSCREEN *screen)
232
347
{
233
 
   CDKOBJS *curobj;
234
 
 
235
 
   setFocusIndex (screen, screen->objectCount - 1);
236
 
   curobj = switchFocus (setCDKFocusNext (screen), 0);
237
 
   if (curobj == 0)
238
 
      return 0;
239
 
 
240
 
   refreshDataCDKScreen (screen);
241
 
 
242
 
   screen->exitStatus = CDKSCREEN_NOEXIT;
243
 
 
244
 
   while ((curobj != 0) && (screen->exitStatus == CDKSCREEN_NOEXIT))
245
 
   {
246
 
      int key;
247
 
      key = getcCDKObject (curobj);
248
 
 
249
 
      switch (key)
250
 
      {
251
 
      case KEY_BTAB:
252
 
         {
253
 
            curobj = switchFocus (setCDKFocusPrevious (screen), curobj);
254
 
            break;
255
 
         }
256
 
      case KEY_TAB:
257
 
         {
258
 
            curobj = switchFocus (setCDKFocusNext (screen), curobj);
259
 
            break;
260
 
         }
261
 
      case KEY_F(10):
262
 
         {
263
 
            /* save data and exit */
264
 
            exitOKCDKScreen (screen);
265
 
            break;
266
 
         }
267
 
      case CTRL('X'):
268
 
         {
269
 
            exitCancelCDKScreen (screen);
270
 
            break;
271
 
         }
272
 
      case CTRL('R'):
273
 
         {
274
 
            /* reset data to defaults */
275
 
            resetCDKScreen (screen);
276
 
            setFocus (curobj);
277
 
            break;
278
 
         }
279
 
      case CDK_REFRESH:
280
 
         {
281
 
            /* redraw screen */
282
 
            refreshCDKScreen (screen);
283
 
            setFocus (curobj);
284
 
            break;
285
 
         }
286
 
      case KEY_ESC:
287
 
         {
288
 
            /* find and enable drop down menu */
289
 
            int j;
290
 
 
291
 
            for (j = 0; j < screen->objectCount; ++j)
292
 
               if (ObjTypeOf (screen->object[j]) == vMENU)
293
 
               {
294
 
                  curobj = handleMenu (screen, screen->object[j], curobj);
295
 
                  break;
296
 
               }
297
 
            break;
298
 
         }
299
 
      default:
300
 
         {
301
 
            InjectObj (curobj, key);
302
 
            break;
303
 
         }
304
 
      }
305
 
   }
306
 
 
307
 
   if (screen->exitStatus == CDKSCREEN_EXITOK)
308
 
   {
309
 
      saveDataCDKScreen (screen);
310
 
      return 1;
311
 
   }
312
 
   else
313
 
      return 0;
 
348
   int result = 0;
 
349
   CDKOBJS *curobj = setCDKFocusFirst (screen);
 
350
 
 
351
   if (curobj != 0)
 
352
   {
 
353
      refreshDataCDKScreen (screen);
 
354
 
 
355
      screen->exitStatus = CDKSCREEN_NOEXIT;
 
356
 
 
357
      while (((curobj = getCDKFocusCurrent (screen)) != 0)
 
358
             && (screen->exitStatus == CDKSCREEN_NOEXIT))
 
359
      {
 
360
         int key;
 
361
         boolean function;
 
362
 
 
363
         key = getchCDKObject (curobj, &function);
 
364
 
 
365
         traverseCDKOnce (screen, curobj, key, function, checkMenuKey);
 
366
      }
 
367
 
 
368
      if (screen->exitStatus == CDKSCREEN_EXITOK)
 
369
      {
 
370
         saveDataCDKScreen (screen);
 
371
         result = 1;
 
372
      }
 
373
   }
 
374
   return result;
314
375
}