CHDK_DE Vorschauversion  Trunk Rev. 5163
 Alle Datenstrukturen Dateien Funktionen Variablen Typdefinitionen Aufzählungen Aufzählungswerte Makrodefinitionen
gui_menu.h-Dateireferenz
+ Dieser Graph zeigt, welche Datei direkt oder indirekt diese Datei enthält:

gehe zum Quellcode dieser Datei

Datenstrukturen

struct  CMenuItem
 
struct  CMenu
 

Makrodefinitionen

#define MENUITEM_MASK   0x000f
 
#define MENUITEM_BOOL   1
 
#define MENUITEM_INT   2
 
#define MENUITEM_SUBMENU   3
 
#define MENUITEM_PROC   4
 
#define MENUITEM_UP   5
 
#define MENUITEM_TEXT   6
 
#define MENUITEM_SEPARATOR   7
 
#define MENUITEM_ENUM   8
 
#define MENUITEM_COLOR_BG   9
 
#define MENUITEM_COLOR_FG   10
 
#define MENUITEM_ENUM2   11
 
#define MENUITEM_SUBMENU_PROC   12
 
#define MENUITEM_STATE_VAL_PAIR   13
 
#define MENUITEM_ERROR   14
 
#define MENUITEM_WARNING   15
 
#define MENUITEM_F_MASK   0x00f0
 
#define MENUITEM_F_UNSIGNED   0x0010
 
#define MENUITEM_F_MIN   0x0020
 
#define MENUITEM_F_MAX   0x0040
 
#define MENUITEM_F_MINMAX   0x0060
 
#define MENUITEM_ARG_MASK   0x0300
 
#define MENUITEM_ARG_CALLBACK   0x0100
 
#define MENUITEM_USER_MODULE   0x0400
 
#define MENUITEM_HHMMSS   0x1000
 
#define MENUITEM_DECIMAL   0x2000
 
#define MENUITEM_SD_INT   0x4000
 
#define MENUITEM_SCRIPT_PARAM   0x8000
 
#define MENU_MINMAX(min, max)   (((max)<<16)|(min&0xFFFF))
 
#define MENU_MIN_UNSIGNED(arg)   ((unsigned short)(arg & 0xFFFF))
 
#define MENU_MAX_UNSIGNED(arg)   ((unsigned short)((arg>>16) & 0xFFFF))
 
#define MENU_MIN_SIGNED(arg)   ((short)(arg & 0xFFFF))
 
#define MENU_MAX_SIGNED(arg)   ((short)((arg>>16) & 0xFFFF))
 
#define MENU_ITEM(sym, txt, typ, val, arg)   { (char)sym, 0, (short)typ, (int)txt, (int*)val, (int)arg }
 
#define MENU_ENUM2(sym, txt, val, arg)   { (char)sym, sizeof(arg)/sizeof(arg[0]), MENUITEM_ENUM2, (int)txt, (int*)val, (int)arg }
 
#define MENU_ENUM2a(sym, txt, val, arg, num)   { (char)sym, (char)num, MENUITEM_ENUM2, (int)txt, (int*)val, (int)arg }
 

Funktionen

void gui_menu_init (CMenu *menu_ptr)
 
void gui_menu_erase_and_redraw ()
 
void gui_menu_cancel_redraw ()
 
int gui_menu_kbd_process ()
 
void gui_menu_draw (int enforce_redraw)
 
void gui_menu_force_redraw ()
 
int menu_get_increment_factor ()
 
void menu_set_increment_factor (int n)
 
char * menu_increment_factor_string ()
 
int menu_calc_max_increment_factor (int max_value)
 
CMenuget_curr_menu ()
 
void gui_menu_back ()
 
void gui_activate_sub_menu (CMenu *sub_menu)
 
CMenuItemfind_menu_item (CMenu *curr_menu, int itemid)
 

Variablen

gui_handler menuGuiHandler
 
CMenu root_menu
 

Makro-Dokumentation

#define MENU_ENUM2 (   sym,
  txt,
  val,
  arg 
)    { (char)sym, sizeof(arg)/sizeof(arg[0]), MENUITEM_ENUM2, (int)txt, (int*)val, (int)arg }

Definiert in Zeile 72 der Datei gui_menu.h.

#define MENU_ENUM2a (   sym,
  txt,
  val,
  arg,
  num 
)    { (char)sym, (char)num, MENUITEM_ENUM2, (int)txt, (int*)val, (int)arg }

Definiert in Zeile 73 der Datei gui_menu.h.

#define MENU_ITEM (   sym,
  txt,
  typ,
  val,
  arg 
)    { (char)sym, 0, (short)typ, (int)txt, (int*)val, (int)arg }

Definiert in Zeile 71 der Datei gui_menu.h.

#define MENU_MAX_SIGNED (   arg)    ((short)((arg>>16) & 0xFFFF))

Definiert in Zeile 48 der Datei gui_menu.h.

#define MENU_MAX_UNSIGNED (   arg)    ((unsigned short)((arg>>16) & 0xFFFF))

Definiert in Zeile 46 der Datei gui_menu.h.

#define MENU_MIN_SIGNED (   arg)    ((short)(arg & 0xFFFF))

Definiert in Zeile 47 der Datei gui_menu.h.

#define MENU_MIN_UNSIGNED (   arg)    ((unsigned short)(arg & 0xFFFF))

Definiert in Zeile 45 der Datei gui_menu.h.

#define MENU_MINMAX (   min,
  max 
)    (((max)<<16)|(min&0xFFFF))

Definiert in Zeile 44 der Datei gui_menu.h.

#define MENUITEM_ARG_CALLBACK   0x0100

Definiert in Zeile 34 der Datei gui_menu.h.

#define MENUITEM_ARG_MASK   0x0300

Definiert in Zeile 32 der Datei gui_menu.h.

#define MENUITEM_BOOL   1

Definiert in Zeile 6 der Datei gui_menu.h.

#define MENUITEM_COLOR_BG   9

Definiert in Zeile 14 der Datei gui_menu.h.

#define MENUITEM_COLOR_FG   10

Definiert in Zeile 15 der Datei gui_menu.h.

#define MENUITEM_DECIMAL   0x2000

Definiert in Zeile 40 der Datei gui_menu.h.

#define MENUITEM_ENUM   8

Definiert in Zeile 13 der Datei gui_menu.h.

#define MENUITEM_ENUM2   11

Definiert in Zeile 16 der Datei gui_menu.h.

#define MENUITEM_ERROR   14

Definiert in Zeile 21 der Datei gui_menu.h.

#define MENUITEM_F_MASK   0x00f0

Definiert in Zeile 25 der Datei gui_menu.h.

#define MENUITEM_F_MAX   0x0040

Definiert in Zeile 28 der Datei gui_menu.h.

#define MENUITEM_F_MIN   0x0020

Definiert in Zeile 27 der Datei gui_menu.h.

#define MENUITEM_F_MINMAX   0x0060

Definiert in Zeile 29 der Datei gui_menu.h.

#define MENUITEM_F_UNSIGNED   0x0010

Definiert in Zeile 26 der Datei gui_menu.h.

#define MENUITEM_HHMMSS   0x1000

Definiert in Zeile 39 der Datei gui_menu.h.

#define MENUITEM_INT   2

Definiert in Zeile 7 der Datei gui_menu.h.

#define MENUITEM_MASK   0x000f

Definiert in Zeile 5 der Datei gui_menu.h.

#define MENUITEM_PROC   4

Definiert in Zeile 9 der Datei gui_menu.h.

#define MENUITEM_SCRIPT_PARAM   0x8000

Definiert in Zeile 42 der Datei gui_menu.h.

#define MENUITEM_SD_INT   0x4000

Definiert in Zeile 41 der Datei gui_menu.h.

#define MENUITEM_SEPARATOR   7

Definiert in Zeile 12 der Datei gui_menu.h.

#define MENUITEM_STATE_VAL_PAIR   13

Definiert in Zeile 18 der Datei gui_menu.h.

#define MENUITEM_SUBMENU   3

Definiert in Zeile 8 der Datei gui_menu.h.

#define MENUITEM_SUBMENU_PROC   12

Definiert in Zeile 17 der Datei gui_menu.h.

#define MENUITEM_TEXT   6

Definiert in Zeile 11 der Datei gui_menu.h.

#define MENUITEM_UP   5

Definiert in Zeile 10 der Datei gui_menu.h.

#define MENUITEM_USER_MODULE   0x0400

Definiert in Zeile 37 der Datei gui_menu.h.

#define MENUITEM_WARNING   15

Definiert in Zeile 22 der Datei gui_menu.h.

Dokumentation der Funktionen

CMenuItem* find_menu_item ( CMenu curr_menu,
int  itemid 
)

Definiert in Zeile 43 der Datei gui_menu.c.

44 {
46  CMenuItem* rv=0;
47 
48  if ( itemid==0 )
49  return 0;
50 
51  gui_menu_curr_item = 0;
52  while(curr_menu->menu[gui_menu_curr_item].text) {
53  if ( lang_strhash31(curr_menu->menu[gui_menu_curr_item].text) == itemid){
54  return (CMenuItem*) &(curr_menu->menu[gui_menu_curr_item]);
55  }
56  if ((curr_menu->menu[gui_menu_curr_item].type & MENUITEM_MASK) == MENUITEM_SUBMENU)
57  {
58  if (curr_menu->menu[gui_menu_curr_item].text != LANG_MENU_USER_MENU) {
59  rv = find_menu_item((CMenu*)(curr_menu->menu[gui_menu_curr_item].value), itemid);
60  if ( rv )
61  return rv;
62  }
63  }
64  gui_menu_curr_item++;
65  }
66  return 0;
67 }
CMenu* get_curr_menu ( )

Definiert in Zeile 206 der Datei gui_menu.c.

207 {
208  return curr_menu;
209 }
void gui_activate_sub_menu ( CMenu sub_menu)

Definiert in Zeile 416 der Datei gui_menu.c.

417 {
418  // push current menu on stack
422 
423  // Select first item in menu, (or none)
425  {
426  gui_menu_set_curr_menu(sub_menu, 0, 0);
428  {
429  //++gui_menu_top_item;
431  }
432  }
433  else
434  gui_menu_set_curr_menu(sub_menu, 0, -1);
435 
437 
438  // FIXME check on stack overrun;
440  {
442  gui_menu_stack_ptr = 0;
443  }
444 
445  // Set active Tv override menu entry if present
446  extern void set_tv_override_menu(CMenu *menu);
448 
449  // Force full redraw
451 }
void gui_menu_back ( )

Definiert in Zeile 281 der Datei gui_menu.c.

282 {
283  if (gui_menu_stack_ptr > 0)
284  {
288  }
289  else
290  {
291  // 'Back' selected; but no menu to go back to
292  // Occurs when script menu opened using 'Func/Set' button
293  // Return to normal <ALT> mode.
295  }
296 }
void gui_menu_cancel_redraw ( )

Definiert in Zeile 257 der Datei gui_menu.c.

258 {
259  gui_menu_redraw = 0;
261 }
void gui_menu_draw ( int  enforce_redraw)

Definiert in Zeile 952 der Datei gui_menu.c.

953 {
954  int i, j;
955  const char *ch = "";
956 
957  if ( enforce_redraw )
958  gui_menu_redraw = 2;
959 
960  if (gui_menu_redraw)
961  {
962  if (gui_menu_redraw==2)
964 
965  gui_menu_redraw=0;
966 
968  {
970  /*
971  * When cursor is over a symbol, force symbol background color to be the menu cursor color but
972  * keep the symbol color user defined.
973  * old method was to set the symbol color to the symbol background color when the cursor highlighted it.
974  * This method allows the user to have any symbol color and background color they want with the restriction
975  * that the symbol background color will match the rest of the line when the cursor highlights it.
976  * It creates a nice consistent look especially when the symbol color matches the menu text color.
977  * without this mod, there is no way to ever make the symbol color match the color of the rest of text menu line
978  * when the cursor highlights a line.
979  */
981 
982  xx = x;
983 
984  switch (curr_menu->menu[imenu].type & MENUITEM_MASK)
985  {
988  break;
989  case MENUITEM_BOOL:
991  break;
992  case MENUITEM_INT:
995  break;
997  case MENUITEM_SUBMENU:
1000  break;
1001  case MENUITEM_UP:
1002  sprintf(tbuf, "%s%s", (conf.menu_symbol_enable)?"":"<- ", lang_str(curr_menu->menu[imenu].text));
1004  break;
1005  case MENUITEM_ERROR:
1007  break;
1008  case MENUITEM_WARNING:
1010  break;
1011  case MENUITEM_PROC:
1012  case MENUITEM_TEXT:
1014  break;
1015  case MENUITEM_SEPARATOR:
1016  rbf_draw_char(x, yy, ' ', cl);
1017 
1018  if (lang_str(curr_menu->menu[imenu].text)[0])
1020  else
1021  tbuf[0] = 0;
1022 
1023  j = rbf_str_width(tbuf);
1024  xx += ((w - j) >> 1);
1025 
1026  if (xx > (x + len_space))
1027  {
1031  }
1032  else
1033  {
1034  xx = x;
1035  }
1036 
1037  if (j) xx += rbf_draw_clipped_string(xx, yy, tbuf, cl, 0, w);
1038 
1039  if (xx < (x+w-len_space))
1040  {
1044  }
1045 
1046  rbf_draw_char(x+w-len_space, yy, ' ', cl);
1047  break;
1048  case MENUITEM_COLOR_FG:
1049  {
1054  }
1055  break;
1056  case MENUITEM_COLOR_BG:
1057  {
1062  }
1063  break;
1064  case MENUITEM_ENUM:
1065  if (curr_menu->menu[imenu].value)
1066  ch = ((const char* (*)(int change, int arg))(curr_menu->menu[imenu].value))(0, curr_menu->menu[imenu].arg);
1068  break;
1069  case MENUITEM_ENUM2:
1070  if (curr_menu->menu[imenu].value)
1071  {
1072  extern const char* gui_change_enum2(const CMenuItem *menu_item, int change);
1073  ch = gui_change_enum2(&curr_menu->menu[imenu], 0);
1074  }
1076  break;
1077  }
1078  }
1079 
1080  // scrollbar
1081  if (count > num_lines)
1082  {
1083  i = num_lines*rbf_font_height()-1 -1; // full height
1084  j = i*num_lines/count; // bar height
1085  if (j<20) j=20;
1086  i = (i-j)*((gui_menu_curr_item<0)?0:gui_menu_curr_item)/(count-1); // top pos
1090  }
1091  }
1092 }
void gui_menu_erase_and_redraw ( )

Definiert in Zeile 252 der Datei gui_menu.c.

253 {
254  gui_menu_redraw = 2;
256 }
void gui_menu_force_redraw ( )
void gui_menu_init ( CMenu menu_ptr)

Definiert in Zeile 212 der Datei gui_menu.c.

212  {
213 
214  if (menu_ptr) {
216  gui_menu_set_curr_menu(menu_ptr, 0, 0);
217  else
218  gui_menu_set_curr_menu(menu_ptr, 0, -1);
219  gui_menu_stack_ptr = 0;
220 
221  // Set active Tv override menu entry if present
222  extern void set_tv_override_menu(CMenu *menu);
224  }
225 
229  len_bool = rbf_str_width("\x95");
230  len_int = rbf_str_width("99999");
231  len_enum = rbf_str_width("WUBfS3a");
232  len_space = rbf_char_width(' ');
233  len_br1 = rbf_char_width('[');
234  len_br2 = rbf_char_width(']');
235  cl_rect = rbf_font_height() - 4;
236  int_incr = 1;
237 
238  gui_menu_redraw=2;
239 }
int gui_menu_kbd_process ( )

Definiert in Zeile 546 der Datei gui_menu.c.

546  {
547 
549  {
550  case KEY_ERASE:
551  case KEY_SHOOT_HALF:
552  if (!increment_factor())
553  int_incr = 1;
554  gui_menu_redraw=1;
555  break;
556  case JOGDIAL_LEFT:
557  case KEY_UP:
558  gui_menu_updown(-1);
559  break;
560  case JOGDIAL_RIGHT:
561  case KEY_DOWN:
562  gui_menu_updown(1);
563  break;
564  case FRONTDIAL_LEFT:
565  case KEY_LEFT:
566  if (gui_menu_curr_item >= 0) {
568  case MENUITEM_INT:
570  break;
571  case MENUITEM_BOOL:
573  break;
574  case MENUITEM_ENUM:
575  case MENUITEM_ENUM2:
577  break;
578  case MENUITEM_UP:
579  gui_menu_back();
580  break;
582  {
584  if (*(c[1].value) == 0)
585  update_bool_value(&c[1]);
586  switch (c[0].type & MENUITEM_MASK)
587  {
588  case MENUITEM_INT:
589  update_int_value(&c[0],-1);
590  break;
591  case MENUITEM_ENUM:
592  case MENUITEM_ENUM2:
593  update_enum_value(&c[0],-1);
594  break;
595  }
596  }
597  break;
598  }
599  } else {
600  gui_menu_back();
601  }
602  break;
603  case FRONTDIAL_RIGHT:
604  case KEY_RIGHT:
605  if (gui_menu_curr_item >= 0) {
606  switch (curr_menu->menu[gui_menu_curr_item].type & MENUITEM_MASK){
607  case MENUITEM_INT:
609  break;
610  case MENUITEM_BOOL:
612  break;
613  case MENUITEM_ENUM:
614  case MENUITEM_ENUM2:
616  break;
618  select_proc();
619  break;
620  case MENUITEM_SUBMENU:
621  select_sub_menu();
622  break;
624  {
626  if (*(c[1].value) == 0)
627  update_bool_value(&c[1]);
628  switch (c[0].type & MENUITEM_MASK)
629  {
630  case MENUITEM_INT:
631  update_int_value(&c[0],1);
632  break;
633  case MENUITEM_ENUM:
634  case MENUITEM_ENUM2:
635  update_enum_value(&c[0],1);
636  break;
637  }
638  }
639  break;
640  }
641  }
642  break;
643  case KEY_SET:
644  if (gui_menu_curr_item >= 0) {
645  switch (curr_menu->menu[gui_menu_curr_item].type & MENUITEM_MASK){
646  case MENUITEM_INT:
648  {
650  gui_menu_redraw=1;
651  }
652  break;
653  case MENUITEM_BOOL:
655  break;
657  case MENUITEM_PROC:
658  select_proc();
659  break;
660  case MENUITEM_SUBMENU:
661  select_sub_menu();
662  break;
663  case MENUITEM_UP:
664  gui_menu_back();
665  break;
666  case MENUITEM_COLOR_FG:
670  gui_menu_redraw=2;
671  break;
672  case MENUITEM_COLOR_BG:
676  gui_menu_redraw=2;
677  break;
678  case MENUITEM_ENUM:
679  case MENUITEM_ENUM2:
681  gui_menu_redraw=1;
682  break;
684  {
686  if ((c[1].type & MENUITEM_MASK) == MENUITEM_ENUM)
687  update_enum_value(&c[1],1);
688  else
689  update_bool_value(&c[1]);
690  }
691  break;
692  }
693  }
694  break;
695  case KEY_SHOOT_FULL: // run script directly from User Menu ?
696  if( (gui_menu_curr_item >= 0)
697  && ((curr_menu->menu[gui_menu_curr_item].type & MENUITEM_MASK) == MENUITEM_PROC)
699  select_proc();
700  break;
701  case KEY_ZOOM_IN:
702  if (decrement_factor())
703  gui_menu_redraw = 1;
704  break;
705 
706  case KEY_ZOOM_OUT:
707  if (increment_factor())
708  gui_menu_redraw = 1;
709  break;
710 
711  case KEY_DISPLAY:
713  {
714  gui_menu_back();
715  }
716  else
717  {
718  // For cams without zoom lever, DISP adjusts increment factor
719  if (!increment_factor())
720  int_incr = 1;
721  gui_menu_redraw=1;
722  }
723  break;
724  }
725 
726  return 0;
727 }
int menu_calc_max_increment_factor ( int  max_value)

Definiert in Zeile 98 der Datei gui_menu.c.

99 {
100  int max = 1;
101  while (max_value/10 != 0)
102  {
103  max *= 10;
104  max_value /= 10;
105  }
106  return max;
107 }
int menu_get_increment_factor ( )

Definiert in Zeile 73 der Datei gui_menu.c.

74 {
75  return int_incr;
76 }
char* menu_increment_factor_string ( )

Definiert in Zeile 84 der Datei gui_menu.c.

85 {
86  static char buf[8];
87  buf[0] = 0;
88  if (int_incr >= 1000000)
89  sprintf(buf, "\xb1%dM",int_incr/1000000);
90  else if (int_incr >= 1000)
91  sprintf(buf, "\xb1%dK",int_incr/1000);
92  else
93  sprintf(buf, "\xb1%d",int_incr);
94  return buf;
95 }
void menu_set_increment_factor ( int  n)

Definiert in Zeile 78 der Datei gui_menu.c.

79 {
80  int_incr = n;
81 }

Variablen-Dokumentation

gui_handler menuGuiHandler

Definiert in Zeile 1114 der Datei gui_menu.c.

CMenu root_menu

Definiert in Zeile 2211 der Datei gui.c.