CHDK_DE Vorschauversion  Trunk Rev. 6014
 Alle Datenstrukturen Dateien Funktionen Variablen Typdefinitionen Aufzählungen Aufzählungswerte Makrodefinitionen
Datenstrukturen | Makrodefinitionen | Funktionen | Variablen
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)
 
CMenu * get_curr_menu ()
 
void gui_menu_back ()
 
void gui_activate_sub_menu (CMenu *sub_menu)
 
CMenuItem * find_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 {
45  int gui_menu_curr_item;
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) == (unsigned)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 413 der Datei gui_menu.c.

414 {
415  // push current menu on stack
416  gui_menu_stack[gui_menu_stack_ptr].menu = curr_menu;
417  gui_menu_stack[gui_menu_stack_ptr].curpos = gui_menu_curr_item;
418  gui_menu_stack[gui_menu_stack_ptr].toppos = gui_menu_top_item;
419 
420  // Select first item in menu, (or none)
421  if (conf.menu_select_first_entry)
422  {
423  gui_menu_set_curr_menu(sub_menu, 0, 0);
424  if (isText(gui_menu_curr_item))
425  {
426  //++gui_menu_top_item;
427  ++gui_menu_curr_item;
428  }
429  }
430  else
431  gui_menu_set_curr_menu(sub_menu, 0, -1);
432 
433  gui_menu_stack_ptr++;
434 
435  // FIXME check on stack overrun;
436  if (gui_menu_stack_ptr > MENUSTACK_MAXDEPTH)
437  {
438  draw_string(1, 0, "E1", MAKE_COLOR(COLOR_RED, COLOR_YELLOW));
439  gui_menu_stack_ptr = 0;
440  }
441 
442  // Set active Tv override menu entry if present
443  extern void set_tv_override_menu(CMenu *menu);
444  set_tv_override_menu(curr_menu);
445 
446  // Force full redraw
447  gui_menu_erase_and_redraw();
448 }
void gui_menu_back ( )

Definiert in Zeile 278 der Datei gui_menu.c.

279 {
280  if (gui_menu_stack_ptr > 0)
281  {
282  gui_menu_stack_ptr--;
283  gui_menu_set_curr_menu(gui_menu_stack[gui_menu_stack_ptr].menu, gui_menu_stack[gui_menu_stack_ptr].toppos, gui_menu_stack[gui_menu_stack_ptr].curpos);
284  gui_menu_erase_and_redraw();
285  }
286  else
287  {
288  // 'Back' selected; but no menu to go back to
289  // Occurs when script menu opened using 'Func/Set' button
290  // Return to normal <ALT> mode.
291  gui_set_mode(&altGuiHandler);
292  }
293 }
void gui_menu_cancel_redraw ( )

Definiert in Zeile 254 der Datei gui_menu.c.

255 {
256  gui_menu_redraw = 0;
257  gui_cancel_need_restore();
258 }
void gui_menu_draw ( int  enforce_redraw)

Definiert in Zeile 965 der Datei gui_menu.c.

966 {
967  int i, j;
968  const char *ch = "";
969 
970  if ( enforce_redraw )
971  gui_menu_redraw = 2;
972 
973  if (gui_menu_redraw)
974  {
975  if (gui_menu_redraw==2)
976  gui_menu_draw_initial();
977 
978  gui_menu_redraw=0;
979 
980  for (imenu=gui_menu_top_item, i=0, yy=y; curr_menu->menu[imenu].text && i<num_lines; ++imenu, ++i, yy+=rbf_font_height())
981  {
982  cl = user_color((gui_menu_curr_item==imenu) ? conf.menu_cursor_color : conf.menu_color);
983  /*
984  * When cursor is over a symbol, force symbol background color to be the menu cursor color but
985  * keep the symbol color user defined.
986  * old method was to set the symbol color to the symbol background color when the cursor highlighted it.
987  * This method allows the user to have any symbol color and background color they want with the restriction
988  * that the symbol background color will match the rest of the line when the cursor highlights it.
989  * It creates a nice consistent look especially when the symbol color matches the menu text color.
990  * without this mod, there is no way to ever make the symbol color match the color of the rest of text menu line
991  * when the cursor highlights a line.
992  */
993  cl_symbol = (gui_menu_curr_item==imenu) ? MAKE_COLOR(BG_COLOR(cl),FG_COLOR(user_color(conf.menu_symbol_color))) : user_color(conf.menu_symbol_color); //color 8Bit=Hintergrund 8Bit=Vordergrund
994 
995  xx = x;
996 
997  switch (curr_menu->menu[imenu].type & MENUITEM_MASK)
998  {
999  case MENUITEM_STATE_VAL_PAIR:
1000  gui_menu_draw_state_value((CMenuItem*)(curr_menu->menu[imenu].value));
1001  break;
1002  case MENUITEM_BOOL:
1003  gui_menu_draw_value((*(curr_menu->menu[imenu].value))?"\x95":" ", len_bool);
1004  break;
1005  case MENUITEM_INT:
1006  get_int_disp_string(*(curr_menu->menu[imenu].value), (curr_menu->menu[imenu].type & MENUITEM_SD_INT)?6:4);
1007  gui_menu_draw_value(tbuf, (curr_menu->menu[imenu].type & MENUITEM_SD_INT)?len_enum:len_int);
1008  break;
1009  case MENUITEM_SUBMENU_PROC:
1010  case MENUITEM_SUBMENU:
1011  sprintf(tbuf, "%s%s", lang_str(curr_menu->menu[imenu].text),(conf.menu_symbol_enable)?"":" ->");
1012  gui_menu_draw_text(tbuf,2);
1013  break;
1014  case MENUITEM_UP:
1015  sprintf(tbuf, "%s%s", (conf.menu_symbol_enable)?"":"<- ", lang_str(curr_menu->menu[imenu].text));
1016  gui_menu_draw_text(tbuf,1);
1017  break;
1018  case MENUITEM_ERROR:
1019  menu_text(COLOR_RED);
1020  break;
1021  case MENUITEM_WARNING:
1022  menu_text(COLOR_YELLOW_DK);
1023  break;
1024  case MENUITEM_PROC:
1025  case MENUITEM_TEXT:
1026  gui_menu_draw_text(lang_str(curr_menu->menu[imenu].text),1);
1027  break;
1028  case MENUITEM_SEPARATOR:
1029  rbf_draw_char(x, yy, ' ', cl);
1030 
1031  if (lang_str(curr_menu->menu[imenu].text)[0])
1032  sprintf(tbuf," %s ",lang_str(curr_menu->menu[imenu].text));
1033  else
1034  tbuf[0] = 0;
1035 
1036  j = rbf_str_width(tbuf);
1037  xx += ((w - j) >> 1);
1038 
1039  if (xx > (x + len_space))
1040  {
1041  draw_rectangle(x+len_space, yy, xx-1, yy+rbf_font_height()/2-1, MAKE_COLOR(BG_COLOR(cl), BG_COLOR(cl)), RECT_BORDER0|DRAW_FILLED);
1042  draw_line(x+len_space, yy+rbf_font_height()/2, xx-1, yy+rbf_font_height()/2, FG_COLOR(cl));
1043  draw_rectangle(x+len_space, yy+rbf_font_height()/2+1, xx-1, yy+rbf_font_height()-1, MAKE_COLOR(BG_COLOR(cl), BG_COLOR(cl)), RECT_BORDER0|DRAW_FILLED);
1044  }
1045  else
1046  {
1047  xx = x;
1048  }
1049 
1050  if (j) xx += rbf_draw_clipped_string(xx, yy, tbuf, cl, 0, w);
1051 
1052  if (xx < (x+w-len_space))
1053  {
1054  draw_rectangle(xx, yy, x+w-len_space-1, yy+rbf_font_height()/2-1, MAKE_COLOR(BG_COLOR(cl), BG_COLOR(cl)), RECT_BORDER0|DRAW_FILLED);
1055  draw_line(xx, yy+rbf_font_height()/2, x+w-1-len_space, yy+rbf_font_height()/2, FG_COLOR(cl));
1056  draw_rectangle(xx, yy+rbf_font_height()/2+1, x+w-len_space-1, yy+rbf_font_height()-1, MAKE_COLOR(BG_COLOR(cl), BG_COLOR(cl)), RECT_BORDER0|DRAW_FILLED);
1057  }
1058 
1059  rbf_draw_char(x+w-len_space, yy, ' ', cl);
1060  break;
1061  case MENUITEM_COLOR_FG:
1062  {
1063  gui_menu_draw_symbol(1);
1064  xx+=rbf_draw_string_len(xx, yy, w-len_space-symbol_width, lang_str(curr_menu->menu[imenu].text), cl);
1065  color mc = FG_COLOR(user_color(*((confColor*)curr_menu->menu[imenu].value)));
1066  draw_rectangle(x+w-1-cl_rect-2-len_space, yy+2, x+w-1-2-len_space, yy+rbf_font_height()-1-2, MAKE_COLOR(mc,mc), RECT_BORDER0|DRAW_FILLED|RECT_ROUND_CORNERS);
1067  }
1068  break;
1069  case MENUITEM_COLOR_BG:
1070  {
1071  gui_menu_draw_symbol(1);
1072  xx+=rbf_draw_string_len(xx, yy, w-len_space-symbol_width, lang_str(curr_menu->menu[imenu].text), cl);
1073  color mc = BG_COLOR(user_color(*((confColor*)curr_menu->menu[imenu].value)));
1074  draw_rectangle(x+w-1-cl_rect-2-len_space, yy+2, x+w-1-2-len_space, yy+rbf_font_height()-1-2, MAKE_COLOR(mc,mc), RECT_BORDER0|DRAW_FILLED|RECT_ROUND_CORNERS);
1075  }
1076  break;
1077  case MENUITEM_ENUM:
1078  if (curr_menu->menu[imenu].value)
1079  ch = ((const char* (*)(int change, int arg))(curr_menu->menu[imenu].value))(0, curr_menu->menu[imenu].arg);
1080  gui_menu_draw_value(ch, len_enum);
1081  break;
1082  case MENUITEM_ENUM2:
1083  if (curr_menu->menu[imenu].value)
1084  {
1085  extern const char* gui_change_enum2(const CMenuItem *menu_item, int change);
1086  ch = gui_change_enum2(&curr_menu->menu[imenu], 0);
1087  }
1088  gui_menu_draw_value(ch, len_enum);
1089  break;
1090  }
1091  }
1092 
1093  // scrollbar
1094  if (count > num_lines)
1095  {
1096  i = num_lines*rbf_font_height()-1 -1; // full height
1097  j = i*num_lines/count; // bar height
1098  if (j<20) j=20;
1099  i = (i-j)*((gui_menu_curr_item<0)?0:gui_menu_curr_item)/(count-1); // top pos
1100  draw_rectangle((x+w)+2, y+1, (x+w)+6, y+1+i, MAKE_COLOR(COLOR_BLACK, COLOR_BLACK), RECT_BORDER0|DRAW_FILLED|RECT_ROUND_CORNERS);
1101  draw_rectangle((x+w)+2, y+i+j, (x+w)+6, y+num_lines*rbf_font_height()-1-1, MAKE_COLOR(COLOR_BLACK, COLOR_BLACK), RECT_BORDER0|DRAW_FILLED|RECT_ROUND_CORNERS);
1102  draw_rectangle((x+w)+2, y+1+i, (x+w)+6, y+i+j, MAKE_COLOR(COLOR_WHITE, COLOR_WHITE), RECT_BORDER0|DRAW_FILLED|RECT_ROUND_CORNERS);
1103  }
1104  }
1105 }
void gui_menu_erase_and_redraw ( )

Definiert in Zeile 249 der Datei gui_menu.c.

250 {
251  gui_menu_redraw = 2;
252  gui_set_need_restore();
253 }
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) {
215  if (conf.menu_select_first_entry)
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);
223  set_tv_override_menu(curr_menu);
224  }
225 
226  len_bool = rbf_str_width("\x95");
227  len_int = rbf_str_width("99999");
228  len_enum = rbf_str_width("WUBfS3a");
229  len_space = rbf_char_width(' ');
230  len_br1 = rbf_char_width('[');
231  len_br2 = rbf_char_width(']');
232  cl_rect = rbf_font_height() - 4;
233  int_incr = 1;
234 
235  gui_menu_redraw=2;
236 }
int gui_menu_kbd_process ( )

Definiert in Zeile 543 der Datei gui_menu.c.

543  {
544 
545  switch (kbd_get_autoclicked_key() | get_jogdial_direction())
546  {
547  case KEY_ERASE:
548  case KEY_SHOOT_HALF:
549  if (!increment_factor())
550  int_incr = 1;
551  gui_menu_redraw=1;
552  break;
553  case JOGDIAL_LEFT:
554  case KEY_UP:
555  gui_menu_updown(-1);
556  break;
557  case JOGDIAL_RIGHT:
558  case KEY_DOWN:
559  gui_menu_updown(1);
560  break;
561  case FRONTDIAL_LEFT:
562  case KEY_LEFT:
563  if (gui_menu_curr_item >= 0) {
564  switch (curr_menu->menu[gui_menu_curr_item].type & MENUITEM_MASK) {
565  case MENUITEM_INT:
566  update_int_value(&curr_menu->menu[gui_menu_curr_item],-1);
567  break;
568  case MENUITEM_BOOL:
569  update_bool_value(&curr_menu->menu[gui_menu_curr_item]);
570  break;
571  case MENUITEM_ENUM:
572  case MENUITEM_ENUM2:
573  update_enum_value(&curr_menu->menu[gui_menu_curr_item],-1);
574  break;
575  case MENUITEM_UP:
576  gui_menu_back();
577  break;
578  case MENUITEM_STATE_VAL_PAIR:
579  {
580  CMenuItem *c = (CMenuItem*)(curr_menu->menu[gui_menu_curr_item].value);
581  if (*(c[1].value) == 0)
582  update_bool_value(&c[1]);
583  switch (c[0].type & MENUITEM_MASK)
584  {
585  case MENUITEM_INT:
586  update_int_value(&c[0],-1);
587  break;
588  case MENUITEM_ENUM:
589  case MENUITEM_ENUM2:
590  update_enum_value(&c[0],-1);
591  break;
592  }
593  }
594  break;
595  }
596  } else {
597  gui_menu_back();
598  }
599  break;
600  case FRONTDIAL_RIGHT:
601  case KEY_RIGHT:
602  if (gui_menu_curr_item >= 0) {
603  switch (curr_menu->menu[gui_menu_curr_item].type & MENUITEM_MASK){
604  case MENUITEM_INT:
605  update_int_value(&curr_menu->menu[gui_menu_curr_item],1);
606  break;
607  case MENUITEM_BOOL:
608  update_bool_value(&curr_menu->menu[gui_menu_curr_item]);
609  break;
610  case MENUITEM_ENUM:
611  case MENUITEM_ENUM2:
612  update_enum_value(&curr_menu->menu[gui_menu_curr_item],1);
613  break;
614  case MENUITEM_SUBMENU_PROC:
615  select_proc();
616  break;
617  case MENUITEM_SUBMENU:
618  select_sub_menu();
619  break;
620  case MENUITEM_STATE_VAL_PAIR:
621  {
622  CMenuItem *c = (CMenuItem*)(curr_menu->menu[gui_menu_curr_item].value);
623  if (*(c[1].value) == 0)
624  update_bool_value(&c[1]);
625  switch (c[0].type & MENUITEM_MASK)
626  {
627  case MENUITEM_INT:
628  update_int_value(&c[0],1);
629  break;
630  case MENUITEM_ENUM:
631  case MENUITEM_ENUM2:
632  update_enum_value(&c[0],1);
633  break;
634  }
635  }
636  break;
637  }
638  }
639  break;
640  case KEY_SET:
641  if (gui_menu_curr_item >= 0) {
642  switch (curr_menu->menu[gui_menu_curr_item].type & MENUITEM_MASK){
643  case MENUITEM_INT:
644  if (camera_info.state.is_shutter_half_press)
645  {
646  *(curr_menu->menu[gui_menu_curr_item].value) = 0;
647  gui_menu_redraw=1;
648  }
649  break;
650  case MENUITEM_BOOL:
651  update_bool_value(&curr_menu->menu[gui_menu_curr_item]);
652  break;
653  case MENUITEM_SUBMENU_PROC:
654  case MENUITEM_PROC:
655  select_proc();
656  break;
657  case MENUITEM_SUBMENU:
658  select_sub_menu();
659  break;
660  case MENUITEM_UP:
661  gui_menu_back();
662  break;
663  case MENUITEM_COLOR_FG:
664  item_color = (confColor*)(curr_menu->menu[gui_menu_curr_item].value);
665  item_color_type = MENUITEM_COLOR_FG;
666  libpalette->show_palette(PALETTE_MODE_SELECT, item_color->fg, gui_menu_color_selected);
667  gui_menu_redraw=2;
668  break;
669  case MENUITEM_COLOR_BG:
670  item_color = (confColor*)(curr_menu->menu[gui_menu_curr_item].value);
671  item_color_type = MENUITEM_COLOR_BG;
672  libpalette->show_palette(PALETTE_MODE_SELECT, item_color->bg, gui_menu_color_selected);
673  gui_menu_redraw=2;
674  break;
675  case MENUITEM_ENUM:
676  case MENUITEM_ENUM2:
677  update_enum_value(&curr_menu->menu[gui_menu_curr_item],1);
678  gui_menu_redraw=1;
679  break;
680  case MENUITEM_STATE_VAL_PAIR:
681  {
682  CMenuItem *c = (CMenuItem*)(curr_menu->menu[gui_menu_curr_item].value);
683  if ((c[1].type & MENUITEM_MASK) == MENUITEM_ENUM)
684  update_enum_value(&c[1],1);
685  else
686  update_bool_value(&c[1]);
687  }
688  break;
689  }
690  }
691  break;
692  case KEY_SHOOT_FULL: // run script directly from User Menu ?
693  if( (gui_menu_curr_item >= 0)
694  && ((curr_menu->menu[gui_menu_curr_item].type & MENUITEM_MASK) == MENUITEM_PROC)
695  && (curr_menu->menu[gui_menu_curr_item].value == (int *)gui_load_user_menu_script ))
696  select_proc();
697  break;
698  case KEY_ZOOM_IN:
699  if (decrement_factor())
700  gui_menu_redraw = 1;
701  break;
702 
703  case KEY_ZOOM_OUT:
704  if (increment_factor())
705  gui_menu_redraw = 1;
706  break;
707 
708  case KEY_DISPLAY:
709  if (camera_info.cam_has_zoom_lever)
710  {
711  gui_menu_back();
712  }
713  else
714  {
715  // For cams without zoom lever, DISP adjusts increment factor
716  if (!increment_factor())
717  int_incr = 1;
718  gui_menu_redraw=1;
719  }
720  break;
721  }
722 
723  return 0;
724 }
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 1127 der Datei gui_menu.c.

CMenu root_menu

Definiert in Zeile 2232 der Datei gui.c.