Пример #1
0
static void appWindow_load(Window *window) {
 int num_a_items = 0;
    first_menu_items[num_a_items++] = (SimpleMenuItem){
    // You should give each menu item a title and callback
    .title = first_string,
  };
  // The menu items appear in the order saved in the menu items array
  first_menu_items[num_a_items++] = (SimpleMenuItem){
    .title = second_string,
  };
  first_menu_items[num_a_items++] = (SimpleMenuItem){
    .title = third_string,
  };

  // Bind the menu items to the corresponding menu sections
  menu_sections[0] = (SimpleMenuSection){
    .num_items = NUM_FIRST_MENU_ITEMS,
    .items = first_menu_items,
  };

  Layer *appWindow_layer = window_get_root_layer(window);
  GRect bounds = layer_get_frame(appWindow_layer);

  // Initialize the simple menu layer
  simple_menu_layer = simple_menu_layer_create(bounds, window, menu_sections, NUM_MENU_SECTIONS, NULL);

  // Add it to the window for display
  layer_add_child(appWindow_layer, simple_menu_layer_get_layer(simple_menu_layer));

}
Пример #2
0
static void window_load(Window *window)
{
    unsigned int i;
    APP_LOG(APP_LOG_LEVEL_DEBUG, "Loading %d items into menu...", num_stops);
    for (i = 0; i < num_stops; i++)
    {
        first_menu_items[i] = (SimpleMenuItem) {
            .title = stops_data[i][ROUTE_TITLE],
             .subtitle = stops_data[i][STOP_TITLE],
              .callback = menu_select_callback,
        };
    }

    menu_sections[0] = (SimpleMenuSection) {
        .title = "Favourited Stops",
         .num_items = num_stops,
          .items = first_menu_items,
    };

    Layer *menu_layer = window_get_root_layer(window);
    GRect menu_bounds = layer_get_frame(menu_layer);
    main_menu = simple_menu_layer_create(menu_bounds, window, menu_sections, NUM_MENU_SECTIONS, NULL);
    layer_add_child(menu_layer, simple_menu_layer_get_layer(main_menu));
}

void window_unload(Window *window) {
    simple_menu_layer_destroy(main_menu);
}
Пример #3
0
void menu_init(Layer *root_layer, GRect bounds)
{
	int item_index = 0;
	
	menu_items[item_index++] = (SimpleMenuItem) {
		.title = "Quick Departures",
		.callback = menu_select_callback
	};
	menu_items[item_index++] = (SimpleMenuItem) {
		.title = "Select Station",
		.callback = menu_select_callback
	};
	
	menu_sections[0] = (SimpleMenuSection) {
		.num_items = NUM_MENU_ITEMS,
		.items = menu_items
	};
	
	menu = simple_menu_layer_create(bounds, my_window, menu_sections, NUM_SECTIONS, NULL);
	
	layer_add_child(root_layer, simple_menu_layer_get_layer(menu));
}

void window_load(Window *window)
{
	Layer *root_layer = window_get_root_layer(my_window);
	title_layer_init(root_layer, GRect(0, 0, 144, 60));
	menu_init(root_layer, GRect(0, 63, 144, 105));
}

void window_unload(Window *window)
{
	text_layer_destroy(title_layer);
	simple_menu_layer_destroy(menu);
}
Пример #4
0
void show_menu()
{
	mainMenuSection[0].items = mainMenuItems;
	mainMenuSection[0].num_items = numOfGroups + 2;

	mainMenuItems[0].title = "Call History";
	mainMenuItems[0].icon = callHistoryIcon;
	mainMenuItems[0].callback = menu_picked;

	mainMenuItems[1].title = "All contacts";
	mainMenuItems[1].icon = contactsIcon;
	mainMenuItems[1].callback = menu_picked;

	for (int i = 0; i < numOfGroups; i++)
	{
		mainMenuItems[i + 2].title = MainMenuGroupNames[i];
		mainMenuItems[i + 2].icon = contactGroupIcon;
		mainMenuItems[i + 2].callback = menu_picked;

	}

	Layer* topLayer = window_get_root_layer(menuWindow);

	if (menuLayer != NULL) layer_remove_from_parent((Layer *) menuLayer);
	menuLayer = simple_menu_layer_create(GRect(0, 0, 144, 156), menuWindow, mainMenuSection, 1, NULL);
	layer_add_child(topLayer, (Layer *) menuLayer);

	layer_set_hidden((Layer *) menuLoadingLayer, true);
	layer_set_hidden((Layer *) menuLayer, false);
}
void show_menu()
{
  mainMenuSection[0].title = "Menu";
	mainMenuSection[0].items = mainMenuItems;	
	
	mainMenuSection[1].title = "Options";
	mainMenuSection[1].items = mainMenuOptionItems;
	mainMenuSection[1].num_items = 2;
	
  if(isNotificationListenerSupported == 1){
    mainMenuSection[0].num_items = 2;
  
	  mainMenuItems[0].title = "Active";
	  mainMenuItems[0].icon = currentIcon;
	  mainMenuItems[0].callback = menu_picked;

	  mainMenuItems[1].title = "History";
	  mainMenuItems[1].icon = historyIcon;
	  mainMenuItems[1].callback = menu_picked;
  } else {
    mainMenuSection[0].num_items = 1;

	  mainMenuItems[0].title = "History";
	  mainMenuItems[0].icon = historyIcon;
	  mainMenuItems[0].callback = menu_picked;
  }
	
	mainMenuOptionItems[0].title = "Vibration";
	if (vibrateEnabledStatus == 1){
	  mainMenuOptionItems[0].subtitle = "Enabled";
	} else {
	  mainMenuOptionItems[0].subtitle = "Disabled";
	}
	mainMenuOptionItems[0].icon = NULL;
	mainMenuOptionItems[0].callback = option_picked;
	
	mainMenuOptionItems[1].title = "Inverted Color";
	if (inverterEnabledStatus == 1){
	  mainMenuOptionItems[1].subtitle = "Enabled";
	} else {
	  mainMenuOptionItems[1].subtitle = "Disabled";
	}
	mainMenuOptionItems[1].icon = NULL;
	mainMenuOptionItems[1].callback = option_picked;

	Layer* topLayer = window_get_root_layer(menuWindow);

	if (menuLayer != NULL) layer_remove_from_parent((Layer *) menuLayer);
	menuLayer = simple_menu_layer_create(GRect(0, 0, 144, 156), menuWindow, mainMenuSection, 2, NULL);
	layer_add_child(topLayer, (Layer *) menuLayer);

	layer_set_hidden((Layer *) menuLoadingLayer, true);
	layer_set_hidden((Layer *) menuLayer, false);
	layer_set_hidden((Layer *) quitTitle, true);
	layer_set_hidden((Layer *) quitText, true);
	
	if(inverterEnabledStatus)
	  layer_add_child(topLayer, inverter_layer_get_layer(inverter_layer));
}
Пример #6
0
Файл: pc.c Проект: asyba/UR
static void window_load(Window *window) {

  int num_a_items = 0;
	
  menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "Shutdown",
        .subtitle ="",
	.callback = shutdown_select_callback,
  };
  menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "Restart",
        .subtitle ="",
	 .callback = restart_select_callback,
  };
  menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "Lock",
        .subtitle =  "",
	  .callback = lock_select_callback,
  };
  menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "Log Off",
        .subtitle =  "",
	  .callback = log_off_select_callback,
  };
  menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "Sleep",
        .subtitle =  "",
	  .callback = sleep_select_callback,
  };
  menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "Abort",
        .subtitle =  "",
	  .callback = abort_select_callback,
  };
 
  menu_sections[0] = (SimpleMenuSection){
  	.title = "Power",
  	.num_items = NUM_MENU_ITEMS,
  	.items = menu_items,
  };

  Layer *window_layer = window_get_root_layer(window);
  GRect bounds = layer_get_frame(window_layer);

  simple_menu_layer = simple_menu_layer_create( bounds, window, menu_sections, NUM_MENU_SECTIONS, NULL);

  layer_add_child(window_layer, simple_menu_layer_get_layer(simple_menu_layer));
}

void show_menu_pc(){
  window = window_create();
  window_set_window_handlers(window, (WindowHandlers) {
    .load = window_load,

    .unload = window_unload,
  });
         
  window_stack_push(window, true /* Animated */);
}
Пример #7
0
void menu_load(Window *menu)
{
	int num_menu_items = 0;
	
	main_menu_items[num_menu_items++] = (SimpleMenuItem) {
		.title = "Ask",
		.callback = search_select_callback,
	};
	
	main_menu_items[num_menu_items++] = (SimpleMenuItem) {
		.title = "Answers",
		//.callback = //callback to what you want this item to do when clicked
	};
	
	main_menu_items[num_menu_items++] = (SimpleMenuItem) {
		.title = "Questions",
		//.callback = //callback to what you want this item to do when clicked
	};
	
	main_menu_items[num_menu_items++] = (SimpleMenuItem) {
		.title = "Help",
		.callback = help_select_callback,
	};
	
	main_menu_sections[0] = (SimpleMenuSection) {
		.num_items = MENU_NUM_ITEMS,
		.items = main_menu_items
	};
	
	GRect bounds = layer_get_bounds(window_get_root_layer(menu));
	main_menu_layer = simple_menu_layer_create(bounds, menu, main_menu_sections, MENU_NUM_SECTIONS, NULL);
	
	layer_add_child(window_get_root_layer(menu), simple_menu_layer_get_layer(main_menu_layer));
}

void menu_unload(Window *menu)
{
	text_layer_destroy(menu_text);
	text_layer_destroy(select_text);
}

void title_load(Window *title)
{
	title_bitmap = gbitmap_create_with_resource(RESOURCE_ID_REDDIT_TITLE_IMAGE);
	title_layer = bitmap_layer_create(GRect(0, 0, 144, 180));
	bitmap_layer_set_bitmap(title_layer, title_bitmap);
	layer_add_child(window_get_root_layer(title), bitmap_layer_get_layer(title_layer));
}

void title_unload(Window *title)
{
	bitmap_layer_destroy(title_layer);
}

void title_click_handler(ClickRecognizerRef recognizer, void *context)
{
	window_stack_push(menu, true);
}
Пример #8
0
static void main_window_load(Window *window) {
  s_menu_icon_image = gbitmap_create_with_resource(RESOURCE_ID_dice2);
  s_menu_score_image = gbitmap_create_with_resource(RESOURCE_ID_score);
   
  // an int as such to easily change the order of menu items later
  int num_a_items = 0;

  s_first_menu_items[num_a_items++] = (SimpleMenuItem) {
    .icon=s_menu_score_image, 
    .title = "Score Counter",
    .subtitle = "Up to 6 players,",
    .callback = menu_select_callback,
    
  };
  s_second_menu_items[0] = (SimpleMenuItem) {
    .icon=s_menu_icon_image,
    .title = "Dice Simulator",
    .callback = menu_select_callback,
  };

  s_second_menu_items[1] = (SimpleMenuItem) {
    .title = "Previous Dice Rolls",
    .callback = special_select_callback,
  };
  

  s_menu_sections[0] = (SimpleMenuSection) {
    .num_items = NUM_FIRST_MENU_ITEMS,
    .items = s_first_menu_items,
  };
  s_menu_sections[1] = (SimpleMenuSection) {
    .num_items = NUM_SECOND_MENU_ITEMS,
    .items = s_second_menu_items,
  };
  
//gBitmap_set_bounds(s_menu_icon_image,
  Layer *window_layer = window_get_root_layer(window);
  GRect bounds = layer_get_frame(window_layer);

  s_simple_menu_layer = simple_menu_layer_create(bounds, window, s_menu_sections, NUM_MENU_SECTIONS, NULL);

  layer_add_child(window_layer, simple_menu_layer_get_layer(s_simple_menu_layer));
}

void main_window_unload(Window *window) {
  simple_menu_layer_destroy(s_simple_menu_layer);
  gbitmap_destroy(s_menu_icon_image);
}

static void init() {
  s_main_window = window_create();
  window_set_window_handlers(s_main_window, (WindowHandlers) {
    .load = main_window_load,
    .unload = main_window_unload,
  });
  window_stack_push(s_main_window, true);
}
Пример #9
0
 /**
  * Called when category window is loaded
  * @param window
  */
  static void c_window_load(Window *window) {
    createMenu();

    
    bounds = layer_get_frame(window_get_root_layer(c_window));
    c_menu_layer = simple_menu_layer_create(bounds,c_window, c_sections, 1, NULL);
    layer_add_child(window_get_root_layer(c_window), simple_menu_layer_get_layer(c_menu_layer));


  }
Пример #10
0
// window load and unload
static void window_handler_load(Window *w) {
  load_expenses();

  menu_section.title = section_title;
  menu_section.items = menu_items;
  menu_section.num_items = ninitdata;

  menu = simple_menu_layer_create(GRect(0,0,150,150), w, &menu_section, 1, NULL);
  layer_add_child(window_get_root_layer(me), simple_menu_layer_get_layer(menu));
}
Пример #11
0
Файл: main.c Проект: asyba/UR
static void window_load(Window *window) {

  int num_a_items = 0;

  bus_menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "Media Players",
        .subtitle = "",
    .callback = bus1_select_callback,
  };
  bus_menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "PC",
        .subtitle = "",
    .callback = bus2_select_callback,
  };
  bus_menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "Monitor",
        .subtitle = "",
    .callback = bus3_select_callback,
  };
  
  menu_sections[0] = (SimpleMenuSection){
  .title ="Control Category",
  .num_items = NUM_CLIENT_MENU_ITEMS,
  .items = bus_menu_items,
  };
      
  Layer *window_layer = window_get_root_layer(window);
  GRect bounds = layer_get_frame(window_layer);

  simple_menu_layer = simple_menu_layer_create(bounds, window, menu_sections,NUM_MENU_SECTIONS, NULL);

  layer_add_child(window_layer, simple_menu_layer_get_layer(simple_menu_layer));
}
static void window_unload(Window *window) {
  simple_menu_layer_destroy(simple_menu_layer);
}

int main(void) {
  window = window_create();
    appmessage_init();

  window_set_window_handlers(window, (WindowHandlers) {
    .load = window_load,
    .unload = window_unload,
  });

  window_stack_push(window, true /* Animated */);

  APP_LOG(APP_LOG_LEVEL_DEBUG, "Done initializing, pushed window: %p", window);
	

  app_event_loop();

  window_destroy(window);
}
Пример #12
0
static void window_load(Window *window) {
  	num_a_items = 0;
	menu_items[num_a_items++] = (SimpleMenuItem){
      	.title = "-- START BOAT --",
	 	.subtitle = "Ping the stbd (boat) end. ",
    	.callback = menu_select_callback,
  };
  menu_items[num_a_items++] = (SimpleMenuItem){
    .title =  "---- START PIN ----",
	.subtitle = "Ping the port (pin) end. ",
     .callback = menu_select_callback,
  };
/*
	  menu_items[num_a_items++] = (SimpleMenuItem){
    .title =  "---- FINISH ----",
	.subtitle = "Ping the finish (time&loc'n). ",
     .callback = menu_select_callback,
  };	  menu_items[num_a_items++] = (SimpleMenuItem){
    .title =  "---- POI --(TBA) ----",
	.subtitle = "Ping a Point of Interest. ",
     .callback = menu_select_callback,
  };
*/
	// Bind the menu items to the corresponding menu sections
  menu_sections[0] = (SimpleMenuSection){
	  .title = "Ping Line menu",
    .num_items = 2,
    .items = menu_items,
  };
   Layer *window_layer = window_get_root_layer(window);
  GRect bounds = layer_get_frame(window_layer);
	menu_layer = simple_menu_layer_create(bounds, window, menu_sections, 1, NULL);

  layer_add_child(window_layer, simple_menu_layer_get_layer(menu_layer));
}
static void window_appear(){

}
static void window_unload(Window *window) {// Deinitialize resources on window unload that were initialized on window load
	window_destroy(window);
  	simple_menu_layer_destroy(menu_layer);
}

 void show_start_ping_menu(){
   	window = window_create();
	//window_set_fullscreen(window, true);
  	window_set_window_handlers(window, (WindowHandlers) {
    	.load = window_load,
    	.unload = window_unload,
		.appear = window_appear,
  });
	window_stack_push(window, true /* Animated */);
}
Пример #13
0
static void window_load(Window *window) {
  	num_a_items = 0;
	menu_items[num_a_items++] = (SimpleMenuItem){
      	.title = "---10 TEN mins ---",
	 	.subtitle = "Start 10 minute timer ",
    	.callback = menu_select_callback,
  };
  menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "---5 FIVE mins ---",
	.subtitle = "Start 5 minute timer ",
     .callback = menu_select_callback,
  };
	  menu_items[num_a_items++] = (SimpleMenuItem){
    .title =  "---4 FOUR mins ---",
	.subtitle = "Start 4 minute timer ",
     .callback = menu_select_callback,
  };
	// Bind the menu items to the corresponding menu sections
  menu_sections[0] = (SimpleMenuSection){
	  .title = "Start Timer Menu",
    .num_items = 3,
    .items = menu_items,
  };
	
	displayFields[GPSTIME] = text_layer_create(GRect(0, 0, 144, 30)); //GPS Time
  	text_layer_set_font( displayFields[GPSTIME],displayFont1);
	layer_add_child(window_get_root_layer(window), (Layer *)displayFields[GPSTIME]);
 	menu_layer = simple_menu_layer_create(GRect(0,30,144,138), window, menu_sections, 1, NULL);
	layer_set_update_proc((Layer *) menu_layer, refreshData);
 
  layer_add_child(window_get_root_layer(window), simple_menu_layer_get_layer(menu_layer));
}
static void window_appear(){

}
static void window_unload(Window *window) {// Deinitialize resources on window unload that were initialized on window load
	setCurrentWindow("none");
	window_destroy(window);
  	simple_menu_layer_destroy(menu_layer);
}

 void show_start_time_menu(){
   	window = window_create();
	//window_set_fullscreen(window, true);
	setCurrentWindow("start_time"); //Just GPS time
  	window_set_window_handlers(window, (WindowHandlers) {
    	.load = window_load,
    	.unload = window_unload,
		.appear = window_appear,
  });
	window_stack_push(window, true /* Animated */);
}
Пример #14
0
static void window_load(Window *window) {
  int num_a_items = 0;

  conversion_menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "Farenheit in C",
	.subtitle = "C = 5/9*(F-32)",
  };
  conversion_menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "Celcius in K",
	.subtitle = "K = C+273",
  };
  conversion_menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "Celcius in F",
	.subtitle = "F = 9/5*(C+32)",
  };
  conversion_menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "Miglia in Kilometri",
	.subtitle = "Km = mi/0.62137",
  };
  conversion_menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "Grammi in Once",
	.subtitle = "oz = 0.035274 g",
  };
  conversion_menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "Km/h in m/s",
	.subtitle = "1 km/h = 0.278 m/s",
  };


  menu_sections.num_items = NUM_CONVERSION_MENU_ITEMS;
  menu_sections.items = conversion_menu_items;

  Layer *window_layer = window_get_root_layer(window);
  GRect bounds = layer_get_frame(window_layer);

  simple_menu_layer = simple_menu_layer_create(bounds, window, &menu_sections, 1, NULL);

  layer_add_child(window_layer, simple_menu_layer_get_layer(simple_menu_layer));
}

void show_conversion_menu(){
   window = window_create();

  window_set_window_handlers(window, (WindowHandlers) {
    .load = window_load,
    .unload = window_unload,
  });
	
  
	
  window_stack_push(window, true /* Animated */);
}
Пример #15
0
static void window_load(Window *window) {

  int num_a_items = 0;

  physics_menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "Meccanica",
	.callback = cin_select_callback
  };
  physics_menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "Fluidodinamica",
	.callback = fluid_select_callback
  };
  physics_menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "Termodinamica",
	.callback = termo_select_callback
  };
  physics_menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "Circuiti",
	.callback = elec_select_callback
  };
  physics_menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "Elettromagnetismo",
	.callback = elet_select_callback
  };
  physics_menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "Quantistica",
	.callback = quant_select_callback
  };

  menu_sections.num_items = NUM_PHYSICS_MENU_ITEMS;
  menu_sections.items = physics_menu_items;

  Layer *window_layer = window_get_root_layer(window);
  GRect bounds = layer_get_frame(window_layer);

  simple_menu_layer = simple_menu_layer_create(bounds, window, &menu_sections, 1, NULL);
	
  layer_add_child(window_layer, simple_menu_layer_get_layer(simple_menu_layer));
}

void show_physics_menu(){
   window = window_create();

  window_set_window_handlers(window, (WindowHandlers) {
    .load = window_load,
    .unload = window_unload,
  });
	
  
	
  window_stack_push(window, true /* Animated */);
}
Пример #16
0
// what happens when you select a function
// initializing the menu when the window loads
void window_load(Window *window) {

    //Initialize the layer so that it is the same size on the watch face as the window
    Layer *window_layer = window_get_root_layer(window);
    GRect bounds = layer_get_frame(window_layer);

    /* Beginning here, we will set the menu items:
     * 	1) Quick Text
     *	2) Dial 911
     */

    int menu_item_count = 0;

    // define menu item number one
    main_menu_items[menu_item_count++] = (SimpleMenuItem) {
        .callback = menu_select_callback_text,
         .icon = gbitmap_create_with_resource(RESOURCE_ID_TEXT_PEBBLE_1), //TODO: will update later
          .title = "QuickText"
    };

    main_menu_items[menu_item_count++] = (SimpleMenuItem) {
        .callback = menu_select_callback,
         .icon = gbitmap_create_with_resource(RESOURCE_ID_ALERT_PEBBLE_1), //TODO: Will update later
          .title = "Call 911"
    };

    menu_sections[0] = (SimpleMenuSection) {
        .num_items = NUM_FIRST_MENU_ITEMS,
         .items = main_menu_items,
          .title = "Alertr"
    };

    main_menu = simple_menu_layer_create(bounds, main_window, menu_sections, NUM_MENU_SECTIONS, NULL);

    // add the main menu to the window
    layer_add_child(window_layer, simple_menu_layer_get_layer(main_menu));
}

void window_unload(Window *window) {
    simple_menu_layer_destroy(main_menu);
}

static void init() {
    main_window = window_create();
    window_set_window_handlers(main_window, (WindowHandlers) {
        .load = window_load,
         .unload =window_unload
    });

    window_stack_push(main_window, true);
}
Пример #17
0
static void window_load(Window *window) {
  int num_a_items = 0;

  inverse_hyp_trig_menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "arcsinh'(x)",
	.subtitle = "1/(x²+1)^½",
  };
  inverse_hyp_trig_menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "arccosh'(x)",
	.subtitle = "1/(x²-1)^½",
  };
  inverse_hyp_trig_menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "arctanh'(x)",
	.subtitle = "1/(1-x²)",
  };
  inverse_hyp_trig_menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "arcsech'(x)",
  .subtitle = "-1/x(1-x²)^½",
  };
  inverse_hyp_trig_menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "arccoth'(x)",
  .subtitle = "1/(1-x²)",
  };
  inverse_hyp_trig_menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "arccsch'(x)",
  .subtitle = "-1/|x|(1+x²)^½",
  };

  menu_sections.num_items = NUM_INVERSE_HYP_TRIG_MENU_ITEMS;
  menu_sections.items = inverse_hyp_trig_menu_items;

  Layer *window_layer = window_get_root_layer(window);
  GRect bounds = layer_get_frame(window_layer);

  simple_menu_layer = simple_menu_layer_create(bounds, window, &menu_sections, 1, NULL);

  layer_add_child(window_layer, simple_menu_layer_get_layer(simple_menu_layer));
}

void show_inverse_hyp_trig_menu(){
   window = window_create();

  window_set_window_handlers(window, (WindowHandlers) {
    .load = window_load,
    .unload = window_unload,
  });
	
  
	
  window_stack_push(window, true /* Animated */);
}
Пример #18
0
void contact_window_load(Window *window){
  int curr_item = 0;

  contact_menu[curr_item++] = (SimpleMenuItem){
    .title = "C_Ryan",
    .callback = generic_callback,
  };

  contact_menu[curr_item++] = (SimpleMenuItem){
    .title = "C_Fedor",
    .callback = generic_callback,
  };

  contact_menu[curr_item++] = (SimpleMenuItem){
    .title = "C_Mike",
    .callback = generic_callback,
    .icon = contact_icon_image,
  };

  contact_menu_sections[0] = (SimpleMenuSection){
    .num_items = NUM_C_ITEMS,
    .items = contact_menu,
  };
  
  Layer *window_layer = window_get_root_layer(window);
  GRect bounds = layer_get_frame(window_layer);

  contact_menu_layer = simple_menu_layer_create(bounds, window, contact_menu_sections, NUM_C_SECTIONS, NULL);

  layer_add_child(window_layer, simple_menu_layer_get_layer(contact_menu_layer));
}


void contact_window_unload(Window *window) {
  simple_menu_layer_destroy(contact_menu_layer);

  gbitmap_destroy(contact_icon_image);
}

void contact_list_callback(int index, void *ctx) {
  contact_window = window_create();

  window_set_window_handlers(contact_window, (WindowHandlers) {
    .load = contact_window_load,
    .unload = contact_window_unload,
  });

  window_stack_push(contact_window, true);

}
Пример #19
0
static void allValveSetCallback(Valve_s* valves) {
  static char text[100];
  snprintf(text, sizeof(text), "Fetch done (%d valves)", getValveNumber());
  text_layer_set_text(s_text_layer, text);
  
  s_first_menu_items = (SimpleMenuItem*)malloc(sizeof(SimpleMenuItem) * getValveNumber());
  for(int i=0; i < getValveNumber(); i++){
    char* guid_str = malloc(20);
    snprintf(guid_str, 20, "GUID %d", valves[i].guid);
    s_first_menu_items[i] = (SimpleMenuItem) {
      .title = valves[i].name,
      .subtitle = guid_str,
      .callback = menu_select_callback,
    };
  }

  s_menu_sections[0] = (SimpleMenuSection) {
    .num_items = getValveNumber(),
    .items = s_first_menu_items,
  };

  Layer *window_layer = window_get_root_layer(s_window);
  GRect bounds = layer_get_frame(window_layer);

  s_simple_menu_layer = simple_menu_layer_create(bounds, s_window, s_menu_sections, NUM_MENU_SECTIONS, NULL);
  
  initActionMenu();
  layer_add_child(window_layer, simple_menu_layer_get_layer(s_simple_menu_layer));
}

static void main_window_load(Window *window) {
  Layer *window_layer = window_get_root_layer(window);
  GRect bounds = layer_get_bounds(window_layer);
	
  // Create a text layer and set the text
	s_text_layer = text_layer_create(bounds);
	text_layer_set_text(s_text_layer, "Fetching valves ...");
  
  // Set the font and text alignment
	text_layer_set_font(s_text_layer, fonts_get_system_font(FONT_KEY_GOTHIC_28_BOLD));
	text_layer_set_text_alignment(s_text_layer, GTextAlignmentCenter);

	// Add the text layer to the window
	layer_add_child(window_layer, text_layer_get_layer(s_text_layer));
  
  // Enable text flow and paging on the text layer, with a slight inset of 10, for round screens
  text_layer_enable_screen_text_flow_and_paging(s_text_layer, 10);
  
  setValveSetCompleteCallback(allValveSetCallback);
}
Пример #20
0
// Main window is a menu window.
static void main_window_load(Window *window) {
  Layer *window_layer = window_get_root_layer(window);
  GRect bounds = layer_get_frame(window_layer);
  main_menu_layer = simple_menu_layer_create(bounds, window, main_menu_sections, 1, NULL);

  // Load main menu.
  build_menu_from_struc(main_menu, sizeof(main_menu) / sizeof(struct menu_item), main_menu_sections, main_menu_items, main_menu_callback);

  // Add the prepared layer to the screen.
  layer_add_child(window_layer, (Layer *)main_menu_layer);

  // Note: It's beyond me at the moment why I need to do that, considering
  // I don't need to call menu_layer_reload_date for other menus and
  // I am drawing this menu only once, but it fixes the scrolling issue.
  menu_layer_reload_data(simple_menu_layer_get_menu_layer(main_menu_layer));
}
Пример #21
0
static uint32_t setup_timestamp_menu(Window *window) {
  
  // Get saved timestamps and create an array for them
  num_entries = get_entries(&entries);
  smenu_items = (SimpleMenuItem *) malloc(sizeof(SimpleMenuItem) * num_entries);
  
  // For each time_t (epoch) timestamp, convert to string for menu display
  for (uint32_t i = 0; i < num_entries; i++) {
    time_t epoch = entries[i];
    struct tm *timedata = localtime(&epoch);
    char *title = (char *) malloc(64 * sizeof(char));  // Need non-stack mem
    strftime(title, 64, get_format(), timedata);
    smenu_items[i] = (SimpleMenuItem) {
//       .title = title,
//       .subtitle = NULL,
      .title = NULL,
      .subtitle = title,
      .callback = NULL
    };
  }
  
  // Setup the section with the items
  smenu_sections[0] = (SimpleMenuSection) {
    .title = "Timestamps",
    .num_items = num_entries,
    .items = smenu_items
  };
  
  // Setup the menu layer, give it the items, and push the new window.
  smenu_layer = simple_menu_layer_create(
                  GRect(0, 0, 144, 152),
                  window,
                  smenu_sections,
                  NSECTIONS,
                  NULL);  //The last one is void *ctx which can be abitrary data passed to callbacks
  layer_add_child(window_get_root_layer(window), (Layer *) smenu_layer);
  window_stack_push(window, true);
  
  return num_entries;
}

static void setup_no_entries_window(Window *window) {
  TextLayer *text_layer = text_layer_create(GRect(0,0,144,152));
  text_layer_set_text(text_layer, no_entries_text);
  layer_add_child(window_get_root_layer(window), (Layer *) text_layer);
  window_stack_push(window, true);
}
Пример #22
0
static void main_window_load(Window *window) {
    //load main menu
    Layer* window_layer = window_get_root_layer(window);
    s_selected_text = text_layer_create(GRect(0, 90, 144, 40));
    text_layer_set_text(s_selected_text, "Selection goes here");
    
    init_menu();
    s_main_menu_layer = simple_menu_layer_create(GRect(0, 0, 144, 168), window, &s_menu_list, 2, NULL);
    if (s_main_menu_layer == NULL) {
        APP_LOG(APP_LOG_LEVEL_ERROR, "Could not create simple menu!");
    } else {
        layer_add_child(window_layer, simple_menu_layer_get_layer(s_main_menu_layer));
        layer_add_child(window_layer, text_layer_get_layer(s_selected_text));
    }
    
    init_message_handling();
}
Пример #23
0
 void in_received_handler(DictionaryIterator *received, void *context) {
	int count = 0;
	Tuple *tuple = dict_read_first(received);
	static char* section_title = "Menu title";
	while(tuple){
			count ++;
			if (tuple->key == 0) {
				menu_action = tuple->value->cstring;
			}
			tuple = dict_read_next(received);
	}
	int number_of_entries = count - 1;
	list_menu_items = malloc(number_of_entries * sizeof(SimpleMenuItem));
	int i = 0;
	tuple = dict_read_first(received);
	while (tuple) {
			if(tuple->key != 0){
					list_menu_items[i] = (SimpleMenuItem){
							.title = tuple->value->cstring,
							.callback = select_menu_callback
					};
					i++;
			}
			tuple = dict_read_next(received);
	}
	if  (strcmp(menu_action, "c") == 0) {
			section_title = "Clients";
	} else if(strcmp(menu_action, "t") == 0) {
			section_title = "Tasks";
	} else if (strcmp(menu_action, "p") == 0) {
			section_title = "Projects";
	} else {
			section_title = "Select";
	}
	list_menu_sections[0] = (SimpleMenuSection){
			.title = section_title,
			.num_items = number_of_entries,
			.items = list_menu_items
	};
	window_stack_push(menu_window, true);

	Layer *window_layer = window_get_root_layer(menu_window);
	menu_list_layer = simple_menu_layer_create(GRect(0, 5, 144, 163), menu_window, list_menu_sections, 1, NULL);
	layer_add_child(window_layer, simple_menu_layer_get_layer(menu_list_layer));
 }
Пример #24
0
void show_menu()
{
	mainMenuSection[0].items = mainMenuItems;
	mainMenuSection[0].num_items = 1;

	mainMenuItems[0].title = "Barclays Bikes";
	mainMenuItems[0].icon = bikesIcon;
	mainMenuItems[0].callback = menu_picked;

	Layer* topLayer = window_get_root_layer(menuWindow);

	if (menuLayer != NULL) layer_remove_from_parent((Layer *) menuLayer);
	menuLayer = simple_menu_layer_create(GRect(0, 0, 144, 156), menuWindow, mainMenuSection, 1, NULL);
	layer_add_child(topLayer, (Layer *) menuLayer);

	layer_set_hidden((Layer *) menuLoadingLayer, true);
	layer_set_hidden((Layer *) menuLayer, false);
}
Пример #25
0
static void nav_menu_window_load(Window *mWindow) {
  	num_a_items = 0;
	nav_menu_items[num_a_items++] = (SimpleMenuItem){
      .title = "Next Mark",
 	 .subtitle = wptName,
   	.callback = nav_menu_select_callback,
  };
  nav_menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "Next Leg",
	 .subtitle = nextLegName,
     .callback = nav_menu_select_callback,
  };
  nav_menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "Speed, heading etc. ",
    .subtitle = "Current, water temp, depth ",
    .callback = nav_menu_select_callback,
  };
 nav_menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "Course details ",
	 .subtitle = "Club, series,course. ",
    .callback = nav_menu_select_callback,
  };
 
 menu_sections[0] = (SimpleMenuSection){
	  .title = "Course Tracking Menu",
    .num_items = 4,
    .items = nav_menu_items,
  };
   	Layer *window_layer = window_get_root_layer(mWindow);
  	GRect bounds = layer_get_frame(window_layer); 
	nav_menu_layer = simple_menu_layer_create(bounds, mWindow, menu_sections, 1, NULL);
	layer_set_update_proc((Layer *) nav_menu_layer, refreshData);
   	layer_add_child(window_layer, simple_menu_layer_get_layer(nav_menu_layer));
}
void show_nav_menu(){
	//APP_LOG(APP_LOG_LEVEL_DEBUG, "In show_nav_menu free: %d", heap_bytes_free());	 
	//setCurrentWindow("nav_menu");
 mWindow = window_create();
  window_set_window_handlers(mWindow, (WindowHandlers) {
    .load = nav_menu_window_load,
    .unload = nav_menu_window_unload,
  });
		 window_stack_push(mWindow, true /* Animated */);
}
Пример #26
0
static void main_window_load(Window *window) {

    // Although we already defined NUM_FIRST_MENU_ITEMS, you can define
    // an int as such to easily change the order of menu items later
    int num_a_items = 0;

    s_first_menu_items[num_a_items++] = (SimpleMenuItem) {
        .title = "Quick Reply",
         .callback = menu_select_callback,
    };
    s_first_menu_items[num_a_items++] = (SimpleMenuItem) {
        .title = "Text Reply",

         .callback = menu_select_callback,
    };

    s_menu_sections[0] = (SimpleMenuSection) {
        .num_items = NUM_FIRST_MENU_ITEMS,
         .items = s_first_menu_items,
    };


    Layer *window_layer = window_get_root_layer(window);
    GRect bounds = layer_get_frame(window_layer);

    s_simple_menu_layer = simple_menu_layer_create(bounds, window, s_menu_sections, NUM_MENU_SECTIONS, NULL);

    layer_add_child(window_layer, simple_menu_layer_get_layer(s_simple_menu_layer));
}

void main_window_unload(Window *window) {
    simple_menu_layer_destroy(s_simple_menu_layer);

}

static void init() {
    app_message_register_inbox_received(in_received_handler); //
    app_message_open(app_message_inbox_size_maximum(), app_message_outbox_size_maximum()); //
    s_main_window = window_create();
    window_set_window_handlers(s_main_window, (WindowHandlers) {
        .load = main_window_load,
         .unload = main_window_unload,
    });
Пример #27
0
static void window_load(Window *window) {

  int num_a_items = 0;

  bio_menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "Growth Formula",
	.subtitle ="Pf = Pi*2^t/d",
  };
  bio_menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "Hardy Weinberg 1",
	.subtitle ="p + q = 1",
  };
  bio_menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "Hardy Weinberg 2",
	.subtitle ="p2+2pq+q2=1",
  };



  menu_sections.num_items = NUM_BIO_MENU_ITEMS;
  menu_sections.items = bio_menu_items;

  Layer *window_layer = window_get_root_layer(window);
  GRect bounds = layer_get_frame(window_layer);

  simple_menu_layer = simple_menu_layer_create(bounds, window, &menu_sections, 1, NULL);

  layer_add_child(window_layer, simple_menu_layer_get_layer(simple_menu_layer));
}

void show_bio_menu(){
   window = window_create();

  window_set_window_handlers(window, (WindowHandlers) {
    .load = window_load,
    .unload = window_unload,
  });
	
  
	
  window_stack_push(window, true /* Animated */);
}
Пример #28
0
static void window_load(Window *window) {
  int num_a_items = 0;

  geometry_menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "Teorema de Pythagoras",
	.subtitle = "A²+B²=C²"
  };
  geometry_menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "Área do Circulo",
	.subtitle = "pi*r²"
  };
  geometry_menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "Área do Triangulo",
	.subtitle = "1/2*B*H"
  };
  geometry_menu_items[num_a_items++] = (SimpleMenuItem){
    .title = "Volume do Cone",
	.subtitle = "(1/3)b*h = 1/3*pi*r²*h"
  };
  menu_sections.num_items = NUM_GEOMETRY_MENU_ITEMS;
  menu_sections.items = geometry_menu_items;

  Layer *window_layer = window_get_root_layer(window);
  GRect bounds = layer_get_frame(window_layer);

  simple_menu_layer = simple_menu_layer_create(bounds, window, &menu_sections, 1, NULL);

  layer_add_child(window_layer, simple_menu_layer_get_layer(simple_menu_layer));
}

void show_geometry_menu(){
   window = window_create();

  window_set_window_handlers(window, (WindowHandlers) {
    .load = window_load,
    .unload = window_unload,
  });
	
  
	
  window_stack_push(window, true /* Animated */);
}
Пример #29
0
void show_menu_prompt() {
  if (active_controller == 0) {
    return;
  }
  
  Layer *window_layer = window_get_root_layer(active_controller->window);
  GRect bounding_frame = layer_get_frame(window_layer);
                                          
  sectionItems[0] = (SimpleMenuItem){.title="Run Home", .callback=(SimpleMenuLayerSelectCallback) &run_home_select, .icon=gbitmap_create_with_resource(RESOURCE_ID_RUN_HOME)};
  sectionItems[1] = (SimpleMenuItem){.title="End Run", .callback=(SimpleMenuLayerSelectCallback) &end_run, .icon=gbitmap_create_with_resource(RESOURCE_ID_CANCEL_ICON)};  
  sectionItems[2] = (SimpleMenuItem){.title="Back", .callback=(SimpleMenuLayerSelectCallback) &cancel_menu, .icon=gbitmap_create_with_resource(RESOURCE_ID_BACK)};
  
  sections[0] = (SimpleMenuSection) {.items=sectionItems, .num_items=3};
  
  active_controller->menu = simple_menu_layer_create(
    bounding_frame, 
    active_controller->window, sections, 1, on_menu_select);
  
  layer_add_child(window_layer, 
                  menu_layer_get_layer(simple_menu_layer_get_menu_layer(active_controller->menu)));
}
Пример #30
0
/* Create the main menu window */
static void window_load(Window *window) {  
  Layer *window_layer = window_get_root_layer(window);
  GRect bounds = layer_get_frame(window_layer);
  
  s_first_menu_items[0] = (SimpleMenuItem) {
    .title = "Current Temperature",
    .callback = current_temp_callback,
  };
  
  s_first_menu_items[1] = (SimpleMenuItem) {
    .title = "Statistics",
    .callback = statistics_callback,
  };
  
  s_first_menu_items[2] = (SimpleMenuItem) {
    .title = "Change Units",
    .subtitle = "Celsius",
    .callback = units_callback,
  };
  
  s_menu_sections[0] = (SimpleMenuSection) {
    .num_items = NUM_FIRST_MENU_ITEMS,
    .items = s_first_menu_items,
  };

  s_simple_menu_layer = simple_menu_layer_create(bounds, window, s_menu_sections, NUM_MENU_SECTIONS, NULL);
  
  hello_layer = text_layer_create((GRect) { .origin = { 0, 35 }, .size = { bounds.size.w, 120 } });
  text_layer_set_text_alignment(hello_layer, GTextAlignmentCenter);
  
  layer_add_child(window_layer, simple_menu_layer_get_layer(s_simple_menu_layer));
}

/* Called when the app is exited */
static void window_unload(Window *window) {
  text_layer_destroy(hello_layer);
  simple_menu_layer_destroy(s_simple_menu_layer);
}