CHDK_DE Vorschauversion  Trunk Rev. 5163
 Alle Datenstrukturen Dateien Funktionen Variablen Typdefinitionen Aufzählungen Aufzählungswerte Makrodefinitionen
gui_menu.c-Dateireferenz
#include "camera_info.h"
#include "stdlib.h"
#include "conf.h"
#include "keyboard.h"
#include "font.h"
#include "lang.h"
#include "gui.h"
#include "gui_draw.h"
#include "gui_menu.h"
#include "gui_user_menu.h"
#include "gui_lang.h"
#include "gui_palette.h"
+ Include-Abhängigkeitsdiagramm für gui_menu.c:

gehe zum Quellcode dieser Datei

Datenstrukturen

struct  CMenuStacked
 

Makrodefinitionen

#define MENUSTACK_MAXDEPTH   4
 
#define MAX(a, b)   ((a>=b)?a:b)
 

Funktionen

CMenuItemfind_menu_item (CMenu *curr_menu, int itemid)
 
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)
 
static int increment_factor ()
 
static int decrement_factor ()
 
static void gui_menu_set_curr_menu (CMenu *menu_ptr, int top_item, int curr_item)
 
CMenuget_curr_menu ()
 
void gui_menu_init (CMenu *menu_ptr)
 
static int gui_menu_rows ()
 
void gui_menu_erase_and_redraw ()
 
void gui_menu_cancel_redraw ()
 
static void gui_menu_color_selected (chdkColor clr)
 
void gui_menu_back ()
 
static void do_callback (const CMenuItem *mi)
 
static void update_int_value (const CMenuItem *mi, int direction)
 
static void update_bool_value (const CMenuItem *mi)
 
static void update_enum_value (const CMenuItem *mi, int direction)
 
static int isText (int n)
 
void gui_activate_sub_menu (CMenu *sub_menu)
 
static void select_sub_menu ()
 
static void select_proc ()
 
static void gui_menu_updown (int increment)
 
static int gui_menu_touch_handler (int tx, int ty)
 
int gui_menu_kbd_process ()
 
void gui_menu_draw_initial ()
 
static void gui_menu_draw_symbol (int num_symbols)
 
static void gui_set_int_cursor (int offset)
 
static void gui_menu_draw_value (const char *str, int len_str)
 
static void gui_menu_draw_text (char *str, int num_symbols)
 
static int factor_disp_len ()
 
static void get_int_disp_string (int value, int dlen)
 
static void gui_menu_draw_state_value (CMenuItem *c)
 
static void menu_text (color c)
 
void gui_menu_draw (int enforce_redraw)
 
void gui_menu_kbd_process_menu_btn ()
 

Variablen

static CMenucurr_menu
 
static CMenuStacked gui_menu_stack [MENUSTACK_MAXDEPTH]
 
static unsigned int gui_menu_stack_ptr
 
static int gui_menu_curr_item
 
static int gui_menu_top_item
 
static int gui_menu_redraw
 
static int count
 
static int x
 
static int y
 
static int w
 
static int wplus
 
static int num_lines
 
static int len_bool
 
static int len_int
 
static int len_enum
 
static int len_space
 
static int len_br1
 
static int len_br2
 
static int cl_rect
 
static int int_incr = 1
 
static confColoritem_color
 
static int item_color_type
 
static int imenu
 
static int yy
 
static int xx
 
static int symbol_width
 
static twoColors cl
 
static twoColors cl_symbol
 
static char tbuf [64]
 
gui_handler menuGuiHandler = { GUI_MODE_MENU, gui_menu_draw, gui_menu_kbd_process, gui_menu_kbd_process_menu_btn, gui_menu_touch_handler, 0 }
 

Makro-Dokumentation

#define MAX (   a,
 
)    ((a>=b)?a:b)

Definiert in Zeile 113 der Datei gui_menu.c.

#define MENUSTACK_MAXDEPTH   4

Definiert in Zeile 16 der Datei gui_menu.c.

Dokumentation der Funktionen

static int decrement_factor ( )
static

Definiert in Zeile 186 der Datei gui_menu.c.

187 {
188  // Decrease int_incr
189  // Returns 1 if value changed.
190 
191  if (int_incr > 1)
192  {
193  int_incr /= 10;
194  return 1;
195  }
196  return 0;
197 }
static void do_callback ( const CMenuItem mi)
static

Definiert in Zeile 303 der Datei gui_menu.c.

304 {
305  if ((mi->type & MENUITEM_ARG_MASK) == MENUITEM_ARG_CALLBACK && mi->arg)
306  {
307  ((void (*)())(mi->arg))();
308  }
309 }
static int factor_disp_len ( )
static

Definiert in Zeile 822 der Datei gui_menu.c.

823 {
824  int l = 0;
826  {
827  l = -1;
828  int n = int_incr;
829  while (n > 0)
830  {
831  l++;
832  n /= 10;
833  }
834  }
835  return l;
836 }
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 }
static void get_int_disp_string ( int  value,
int  dlen 
)
static

Definiert in Zeile 842 der Datei gui_menu.c.

843 {
844  if (dlen == 6)
845  sprintf(tbuf, "%7d", value);
846  else
847  sprintf(tbuf, "%5d", value);
848  if (value < 0)
849  {
850  int spos, cpos;
851  for (spos=0; spos<5; spos++) if (tbuf[spos] == '-') break;
852  cpos = dlen - factor_disp_len();
853  if ((cpos > 0) && (cpos <= spos))
854  {
855  tbuf[spos] = ' ';
856  tbuf[cpos-1] = '-';
857  }
858  }
859 }
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 }
static void gui_menu_color_selected ( chdkColor  clr)
static

Definiert in Zeile 266 der Datei gui_menu.c.

267 {
269  {
270  item_color->fg = clr;
271  }
272  else
273  {
274  item_color->bg = clr;
275  }
277 }
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_draw_initial ( )

Definiert in Zeile 731 der Datei gui_menu.c.

732 {
733  count = gui_menu_rows();
734 
735  y = (camera_screen.height - ((num_lines - 1) * rbf_font_height())) >> 1;
736  if (count > num_lines)
737  {
738  wplus = 8;
739  // scrollbar background
741  }
742  else
743  {
744  wplus = 0;
745  if (conf.menu_center)
746  {
747  y = (camera_screen.height - ((count - 1) * rbf_font_height())) >> 1;
748  }
749  }
750 
752 }
static void gui_menu_draw_state_value ( CMenuItem c)
static

Definiert in Zeile 862 der Datei gui_menu.c.

863 {
864  const char *ch = "";
865 
866  int text = curr_menu->menu[imenu].text;
867  if (c[0].text != 0)
868  text = c[0].text;
869 
871  if ((c[1].type & MENUITEM_MASK) == MENUITEM_ENUM)
872  wid -= len_space*3;
873  else
874  wid -= len_bool;
875 
877  xx += rbf_draw_string_len(xx, yy, wid, lang_str(text), cl);
878  xx += rbf_draw_string(xx, yy, " [", cl);
879  if ((c[1].type & MENUITEM_MASK) == MENUITEM_ENUM)
880  xx += rbf_draw_string_len(xx, yy, len_space*3, ((const char* (*)(int change, int arg))(c[1].value))(0, c[1].arg), cl);
881  else
882  xx += rbf_draw_string_len(xx, yy, len_bool, (*(c[1].value))?"\x95":"", cl);
883  xx += rbf_draw_string(xx, yy, "][", cl);
884 
885  switch (c[0].type & MENUITEM_MASK)
886  {
887  case MENUITEM_INT:
888  get_int_disp_string(*(c[0].value), (c[0].type & MENUITEM_SD_INT)?6:4);
889  gui_set_int_cursor((c[0].type & MENUITEM_SD_INT)?6:4);
890  ch = tbuf;
891  break;
892  case MENUITEM_ENUM:
893  if (c[0].value)
894  ch = ((const char* (*)(int change, int arg))(c[0].value))(0, c[0].arg);
895  if ((c[0].type & MENUITEM_HHMMSS) && (gui_menu_curr_item==imenu))
896  {
897  switch (int_incr)
898  {
899  case 1:
900  rbf_enable_cursor(5,6);
901  break;
902  case 10:
903  rbf_enable_cursor(2,3);
904  break;
905  default:
906  rbf_enable_cursor(0,0);
907  break;
908  }
909  }
910  else if (c[0].type & MENUITEM_DECIMAL)
911  {
912  if (int_incr == 100000)
913  rbf_enable_cursor(0,0); // Skip decimal point if incrementing leftmost digit
914  else
916  }
917  else if (c[0].type & MENUITEM_SD_INT)
918  {
919  if (isdigit(ch[strlen(ch)-1]))
921  }
922  else if (gui_menu_curr_item==imenu)
923  {
924  rbf_enable_cursor(0,6);
925  }
926  break;
927  case MENUITEM_ENUM2:
928  if (c[0].value)
929  {
930  extern const char* gui_change_enum2(const CMenuItem *menu_item, int change);
931  ch = gui_change_enum2(c, 0);
933  rbf_enable_cursor(0,6);
934  }
935  break;
936  }
937 
940  rbf_draw_string(xx, yy, "] ", cl);
941 }
static void gui_menu_draw_symbol ( int  num_symbols)
static

Definiert in Zeile 761 der Datei gui_menu.c.

762 {
764  {
765  xx += rbf_draw_char(xx, yy, ' ', cl_symbol);
767  symbol_width = (symbol_width * num_symbols) + len_space;
768  }
769  else
770  {
771  symbol_width = 0;
772  }
773 
774  xx += rbf_draw_char(xx, yy, ' ', cl);
775 }
static void gui_menu_draw_text ( char *  str,
int  num_symbols 
)
static

Definiert in Zeile 812 der Datei gui_menu.c.

813 {
814  gui_menu_draw_symbol(num_symbols);
816  if ((num_symbols == 2) && conf.menu_symbol_enable)
817  xx += rbf_draw_symbol(xx, yy, 0x52, cl_symbol);
818  rbf_draw_char(xx, yy, ' ', cl);
819 }
static void gui_menu_draw_value ( const char *  str,
int  len_str 
)
static

Definiert in Zeile 792 der Datei gui_menu.c.

793 {
796  xx += rbf_draw_string(xx, yy, " [", cl);
798  {
799  if (len_str == len_int)
801  else if (curr_menu->menu[imenu].type & MENUITEM_SD_INT)
803  else
804  rbf_enable_cursor(0,6);
805  }
806  xx += rbf_draw_string_right_len(xx, yy, len_str, str, cl);
808  rbf_draw_string(xx, yy, "] ", cl);
809 }
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_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 }
void gui_menu_kbd_process_menu_btn ( )

Definiert in Zeile 1096 der Datei gui_menu.c.

1097 {
1098  extern int gui_user_menu_flag;
1099 
1100  conf_save();
1101 
1102  if ( gui_user_menu_flag )
1103  {
1105  gui_user_menu_flag = 0;
1107  }
1108  else
1110 }
static int gui_menu_rows ( )
static

Definiert in Zeile 242 der Datei gui_menu.c.

243 {
244  int n;
245  // Count the number of rows in current menu
246  for(n = 0; curr_menu->menu[n].text; n++);
247  return n;
248 }
static void gui_menu_set_curr_menu ( CMenu menu_ptr,
int  top_item,
int  curr_item 
)
static

Definiert in Zeile 200 der Datei gui_menu.c.

200  {
201  curr_menu = menu_ptr;
202  gui_menu_top_item = top_item;
204 }
static int gui_menu_touch_handler ( int  tx,
int  ty 
)
static

Definiert in Zeile 524 der Datei gui_menu.c.

525 {
526  int h = ((count > num_lines) ? num_lines : count) * rbf_font_height();
527  if ((tx >= x) && (ty >= y) && (tx < (x + w)) && (ty < (y + h)))
528  {
529  int r = ((ty - y) / rbf_font_height()) + gui_menu_top_item;
530  if (!isText(r))
531  {
532  if (gui_menu_curr_item != r)
533  {
534  gui_menu_curr_item = r;
535  // Redraw menu if needed
536  if (gui_menu_redraw == 0) gui_menu_redraw = 1;
537  }
538  return KEY_SET;
539  }
540  }
541  return 0;
542 }
static void gui_menu_updown ( int  increment)
static

Definiert in Zeile 472 der Datei gui_menu.c.

473 {
474  int c, j;
475 
476  // Determine number of rows to move (1 or 4)
478 
479  for (j = 0; j < c; ++j)
480  {
481  do
482  {
483  // Move to next or previous row
484  gui_menu_curr_item += increment;
485 
486  if (gui_menu_curr_item < 0) // Off top, move to bottom
487  {
490  }
491  else if (gui_menu_curr_item >= gui_menu_rows()) // Off bottom, move to top
492  {
494  }
495  else if (increment == 1) // Still in menu, if moving down adjust scroll if needed
496  {
498  {
501  }
502  }
503  else // Still in menu, and moving up, adjust scroll
504  {
507  }
508 
509  // Check in case scroll moved off top of menu
511  } while (isText(gui_menu_curr_item));
512 
513  // Reset amount to increment integer values by
514  int_incr = 1;
518 
519  // Redraw menu if needed
520  if (gui_menu_redraw == 0) gui_menu_redraw=1;
521  }
522 }
static void gui_set_int_cursor ( int  offset)
static

Definiert in Zeile 777 der Datei gui_menu.c.

778 {
780  {
781  int n = int_incr;
782  while (n > 1)
783  {
784  n /= 10;
785  offset--;
786  }
788  }
789 }
static int increment_factor ( )
static

Definiert in Zeile 115 der Datei gui_menu.c.

116 {
117  // Increase int_incr
118  // Returns 1 if value changed.
119 
120  // Get info about the current menu item
121  int item_flags = curr_menu->menu[gui_menu_curr_item].type;
122  int item_type = item_flags & MENUITEM_MASK;
123  int item_arg = curr_menu->menu[gui_menu_curr_item].arg;
124  int item_val = *(curr_menu->menu[gui_menu_curr_item].value);
125  // If state / value menu pair get info from value entry
126  if (item_type == MENUITEM_STATE_VAL_PAIR)
127  {
129  item_flags = c[0].type;
130  item_type = item_flags & MENUITEM_MASK;
131  item_arg = c[0].arg;
132  item_val = *(c[0].value);
133  }
134 
135  // Calculate max allowed value for int_incr
136  // Default is 1000000 for DECIMAL, 10000 for positive int values, 1000 for negative values or 1 otherwise
137  int max = (item_flags & MENUITEM_DECIMAL) ? 100000 : (item_type == MENUITEM_INT) ? ((item_val < 0) ? 1000 : 10000) : 1;
138 
139  // If an int value has a defined MIN / MAX range then adjust int_incr max to fit the range
140  int vmax = 0;
141  if ( item_flags & MENUITEM_F_MINMAX )
142  {
143  if ( item_flags & MENUITEM_F_UNSIGNED )
144  {
145  vmax = MAX(MENU_MIN_UNSIGNED(item_arg),MENU_MAX_UNSIGNED(item_arg));
146  }
147  else
148  {
149  vmax = MAX(abs(MENU_MIN_SIGNED(item_arg)),abs(MENU_MAX_SIGNED(item_arg)));
150  }
151  }
152 
153  // Default for SD type (item_arg holds max allowed value)
154  if (item_flags & MENUITEM_SD_INT)
155  {
156  vmax = item_arg;
157  }
158 
159  // If a max value has been set adjust accordingly
160  if (vmax > 0)
161  {
162  max = menu_calc_max_increment_factor(vmax);
163  }
164 
165  // Default for HH:MM:SS type
166  if (item_flags & MENUITEM_HHMMSS)
167  {
168  max = 100;
169  }
170 
171  // Adjust value
172  if (int_incr < max)
173  {
174  int_incr *= 10;
175  return 1;
176  }
177  if (int_incr > max)
178  {
179  int_incr = max;
180  return 1;
181  }
182 
183  return 0;
184 }
static int isText ( int  n)
static

Definiert in Zeile 405 der Datei gui_menu.c.

406 {
407  return (
409  (curr_menu->menu[n].type & MENUITEM_MASK) == MENUITEM_ERROR ||
410  (curr_menu->menu[n].type & MENUITEM_MASK) == MENUITEM_WARNING ||
411  (curr_menu->menu[n].type & MENUITEM_MASK) == MENUITEM_SEPARATOR
412  );
413 }
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 }
static void menu_text ( color  c)
static

Definiert in Zeile 944 der Datei gui_menu.c.

945 {
946  twoColors save = cl;
947  cl = MAKE_COLOR(BG_COLOR(cl), c);
949  cl = save;
950 }
static void select_proc ( )
static

Definiert in Zeile 460 der Datei gui_menu.c.

461 {
463  {
465  //gui_menu_set_curr_menu(curr_menu, 0, 0); // restore this if it causes problems
466  gui_menu_redraw=2;
467  }
468 }
static void select_sub_menu ( )
static

Definiert in Zeile 454 der Datei gui_menu.c.

static void update_bool_value ( const CMenuItem mi)
static

Definiert in Zeile 370 der Datei gui_menu.c.

371 {
372  // update value
373  *(mi->value) = !(*(mi->value));
374 
375  // execute custom callback and on_change functions
376  do_callback(mi);
377 
378  // force menu redraw
379  gui_menu_redraw=1;
380 }
static void update_enum_value ( const CMenuItem mi,
int  direction 
)
static

Definiert in Zeile 383 der Datei gui_menu.c.

384 {
385  // update value
386  if (mi->value)
387  {
389  direction *= int_incr;
390  if ((mi->type & MENUITEM_MASK) == MENUITEM_ENUM)
391  {
392  ((const char* (*)(int change, int arg))(mi->value))(direction, mi->arg);
393  }
394  else
395  {
396  extern const char* gui_change_enum2(const CMenuItem *menu_item, int change);
398  }
399  }
400 
401  // force menu redraw
402  gui_menu_redraw=1;
403 }
static void update_int_value ( const CMenuItem mi,
int  direction 
)
static

Definiert in Zeile 312 der Datei gui_menu.c.

313 {
314  // do update
315  *(mi->value) += int_incr * direction;
316 
317  // Limit new value to defined bounds
318  if ((mi->type & MENUITEM_F_UNSIGNED) || (mi->type & MENUITEM_SD_INT))
319  {
320  if (*(mi->value) < 0)
321  *(mi->value) = 0;
322 
323  if ( mi->type & MENUITEM_F_MIN)
324  {
325  if (*(mi->value) < MENU_MIN_UNSIGNED(mi->arg))
326  *(mi->value) = MENU_MIN_UNSIGNED(mi->arg);
327  }
328  }
329  else
330  {
331  if (*(mi->value) < -9999)
332  *(mi->value) = -9999;
333 
334  if ( mi->type & MENUITEM_F_MIN)
335  {
336  if (*(mi->value) < MENU_MIN_SIGNED(mi->arg))
337  *(mi->value) = MENU_MIN_SIGNED(mi->arg);
338  }
339  }
340 
341  int maxval = (mi->type & MENUITEM_SD_INT) ? 9999999 : 99999;
342  if (*(mi->value) > maxval)
343  *(mi->value) = maxval;
344 
345  if (mi->type & MENUITEM_F_UNSIGNED)
346  {
347  if ( mi->type & MENUITEM_F_MAX)
348  {
349  if (*(mi->value) > MENU_MAX_UNSIGNED(mi->arg))
350  *(mi->value) = MENU_MAX_UNSIGNED(mi->arg);
351  }
352  }
353  else
354  {
355  if (mi->type & MENUITEM_F_MAX)
356  {
357  if (*(mi->value) > MENU_MAX_SIGNED(mi->arg))
358  *(mi->value) = MENU_MAX_SIGNED(mi->arg);
359  }
360  }
361 
362  // execute custom callback and on_change functions
363  do_callback(mi);
364 
365  // force menu redraw
366  gui_menu_redraw=1;
367 }

Variablen-Dokumentation

twoColors cl
static

Definiert in Zeile 758 der Datei gui_menu.c.

int cl_rect
static

Definiert in Zeile 37 der Datei gui_menu.c.

twoColors cl_symbol
static

Definiert in Zeile 758 der Datei gui_menu.c.

int count
static

Definiert in Zeile 34 der Datei gui_menu.c.

CMenu* curr_menu
static

Definiert in Zeile 27 der Datei gui_menu.c.

int gui_menu_curr_item
static

Definiert in Zeile 30 der Datei gui_menu.c.

int gui_menu_redraw
static

Definiert in Zeile 32 der Datei gui_menu.c.

CMenuStacked gui_menu_stack[MENUSTACK_MAXDEPTH]
static

Definiert in Zeile 28 der Datei gui_menu.c.

unsigned int gui_menu_stack_ptr
static

Definiert in Zeile 29 der Datei gui_menu.c.

int gui_menu_top_item
static

Definiert in Zeile 31 der Datei gui_menu.c.

int imenu
static

Definiert in Zeile 757 der Datei gui_menu.c.

int int_incr = 1
static

Definiert in Zeile 38 der Datei gui_menu.c.

confColor* item_color
static

Definiert in Zeile 39 der Datei gui_menu.c.

int item_color_type
static

Definiert in Zeile 40 der Datei gui_menu.c.

int len_bool
static

Definiert in Zeile 37 der Datei gui_menu.c.

int len_br1
static

Definiert in Zeile 37 der Datei gui_menu.c.

int len_br2
static

Definiert in Zeile 37 der Datei gui_menu.c.

int len_enum
static

Definiert in Zeile 37 der Datei gui_menu.c.

int len_int
static

Definiert in Zeile 37 der Datei gui_menu.c.

int len_space
static

Definiert in Zeile 37 der Datei gui_menu.c.

int num_lines
static

Definiert in Zeile 36 der Datei gui_menu.c.

int symbol_width
static

Definiert in Zeile 757 der Datei gui_menu.c.

char tbuf[64]
static

Definiert in Zeile 838 der Datei gui_menu.c.

int w
static

Definiert in Zeile 36 der Datei gui_menu.c.

int wplus
static

Definiert in Zeile 36 der Datei gui_menu.c.

int x
static

Definiert in Zeile 35 der Datei gui_menu.c.

int xx
static

Definiert in Zeile 757 der Datei gui_menu.c.

int y
static

Definiert in Zeile 35 der Datei gui_menu.c.

int yy
static

Definiert in Zeile 757 der Datei gui_menu.c.