static void window_load(Window *window) {
  Layer *window_layer = window_get_root_layer(window);
  GRect bounds = layer_get_bounds(window_layer);

	s_icon_bitmap_menu_1 = gbitmap_create_with_resource(RESOURCE_ID_SUB_MENU_1);
	s_icon_bitmap_menu_2 = gbitmap_create_with_resource(RESOURCE_ID_SUB_MENU_2);
	s_icon_bitmap_menu_3 = gbitmap_create_with_resource(RESOURCE_ID_SUB_MENU_3);
	s_icon_bitmap_menu_4 = gbitmap_create_with_resource(RESOURCE_ID_SUB_MENU_4);
	s_icon_bitmap_menu_5 = gbitmap_create_with_resource(RESOURCE_ID_SUB_MENU_5);
	s_icon_bitmap_menu_6 = gbitmap_create_with_resource(RESOURCE_ID_SUB_MENU_6);
	s_icon_bitmap_menu_7 = gbitmap_create_with_resource(RESOURCE_ID_SUB_MENU_7);
	s_icon_bitmap_menu_8 = gbitmap_create_with_resource(RESOURCE_ID_SUB_MENU_8);
	s_icon_bitmap_menu_9 = gbitmap_create_with_resource(RESOURCE_ID_SUB_MENU_9);

  s_menu_layer = menu_layer_create(bounds);
  menu_layer_set_click_config_onto_window(s_menu_layer, window);
  menu_layer_set_callbacks(s_menu_layer, NULL, (MenuLayerCallbacks) {
      .get_num_rows = (MenuLayerGetNumberOfRowsInSectionsCallback)get_num_rows_callback,
      .draw_row = (MenuLayerDrawRowCallback)draw_row_callback,
      .get_cell_height = (MenuLayerGetCellHeightCallback)get_cell_height_callback,
      .select_click = (MenuLayerSelectCallback)select_callback,
      .draw_header = (MenuLayerDrawHeaderCallback)draw_header_callback,
      .get_header_height = (MenuLayerGetHeaderHeightCallback)get_header_height_callback,
      .get_num_sections = (MenuLayerGetNumberOfSectionsCallback)get_num_sections_callback,
  });
Exemple #2
0
static void window_load(Window *window)
{ 
  char * buff = (char*)malloc(100 * sizeof(char*));
  if(amount > 1) snprintf(buff, 100, "Are you sure you want to send $%2d.00 to %s?", (int)amount, cont_name);
  else snprintf(buff, 100, "Are you sure you want to send $0.10 to %s?", cont_name);
  tlayer = text_layer_create(GRect(0, 0, 144, 55 + 12));
  text_layer_set_text(tlayer, buff);
  text_layer_set_background_color(tlayer, GColorClear);
  text_layer_set_text_color(tlayer, GColorBlack);
  text_layer_set_text_alignment(tlayer, GTextAlignmentCenter);
  text_layer_set_font(tlayer, fonts_get_system_font(FONT_KEY_GOTHIC_18_BOLD));
  layer_add_child(window_get_root_layer(window), text_layer_get_layer(tlayer));
  
  menu_layer = menu_layer_create(GRect(0, 55 + 12, 144, 152 - 55 - 12));
  menu_layer_set_click_config_onto_window(menu_layer, cpay_window);
  MenuLayerCallbacks callbacks = {
    .draw_row = (MenuLayerDrawRowCallback) draw_row_callback,
    .get_num_rows = (MenuLayerGetNumberOfRowsInSectionsCallback) num_rows_callback,
    .select_click = (MenuLayerSelectCallback) select_click_callback,
  };
  menu_layer_set_callbacks(menu_layer, NULL, callbacks);
  layer_add_child(window_get_root_layer(cpay_window), menu_layer_get_layer(menu_layer));
  free(buff);
}
 
void cpay_deinit()
{
  window_push--;
  window_destroy(cpay_window);
  menu_layer_destroy(menu_layer);
}
static void initialise_ui(void) {
  s_window = window_create();
  window_set_fullscreen(s_window, false);
  
  s_res_gothic_24_bold = fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD);
  s_res_gothic_18 = fonts_get_system_font(FONT_KEY_GOTHIC_18);
  // s_inverterlayer_1
  s_inverterlayer_1 = inverter_layer_create(GRect(0, 0, 144, 35));
  layer_add_child(window_get_root_layer(s_window), (Layer *)s_inverterlayer_1);
  
  // s_stop_name_layer
  s_stop_name_layer = text_layer_create(GRect(0, -7, 144, 29));
  text_layer_set_background_color(s_stop_name_layer, GColorClear);
  text_layer_set_text_color(s_stop_name_layer, GColorWhite);
  text_layer_set_text(s_stop_name_layer, "Mountain View");
  text_layer_set_text_alignment(s_stop_name_layer, GTextAlignmentCenter);
  text_layer_set_font(s_stop_name_layer, s_res_gothic_24_bold);
  layer_add_child(window_get_root_layer(s_window), (Layer *)s_stop_name_layer);
  
  // s_direction_layer
  s_direction_layer = text_layer_create(GRect(0, 14, 144, 19));
  text_layer_set_background_color(s_direction_layer, GColorClear);
  text_layer_set_text_color(s_direction_layer, GColorWhite);
  text_layer_set_text(s_direction_layer, "Southbound");
  text_layer_set_text_alignment(s_direction_layer, GTextAlignmentCenter);
  text_layer_set_font(s_direction_layer, s_res_gothic_18);
  layer_add_child(window_get_root_layer(s_window), (Layer *)s_direction_layer);
  
  // s_train_menu
  s_train_menu = menu_layer_create(GRect(0, 35, 144, 117));
  menu_layer_set_click_config_onto_window(s_train_menu, s_window);
  layer_add_child(window_get_root_layer(s_window), (Layer *)s_train_menu);
}
Exemple #4
0
void window_load(Window *me) {
	Layer *window_layer = window_get_root_layer(me);
	switch (current_level) {
		case 0:
		case 1:
		if (current_level == 1)
			for (int i = 0; i < item_count; i++)
				memset(item_names[i], 0, TITLE_SIZE);
			menu_layer[current_level] = menu_layer_create(layer_get_bounds(window_layer));
			menu_layer_set_callbacks(menu_layer[current_level], NULL, (MenuLayerCallbacks){
				.get_cell_height = menu_get_cell_height_callback,
				.get_num_rows = menu_get_num_rows_callback,
				.draw_row = menu_draw_row_callback,
				.select_click = menu_select_callback,
			});
			menu_layer_set_click_config_onto_window(menu_layer[current_level], me);
			layer_set_hidden(menu_layer_get_layer(menu_layer[current_level]), true);
			layer_add_child(window_layer, menu_layer_get_layer(menu_layer[current_level]));
			break;
		case 2:
			messageheader_layer = text_layer_create(GRect(0, 0, 144, INT16_MAX));
			messageseparator_layer = inverter_layer_create(GRect(0, 0, 144, INT16_MAX));
			messagetext_layer = text_layer_create(GRect(0, 0, 144, INT16_MAX));
			message_layer = scroll_layer_create(layer_get_bounds(window_layer));
			scroll_layer_add_child(message_layer, text_layer_get_layer(messageheader_layer));
			scroll_layer_add_child(message_layer, inverter_layer_get_layer(messageseparator_layer));
			scroll_layer_add_child(message_layer, text_layer_get_layer(messagetext_layer));
			scroll_layer_set_callbacks(message_layer, (ScrollLayerCallbacks){
				.click_config_provider = message_click_config_provider
			});
Exemple #5
0
void menu_layer_set_click_config_onto_window__patch(MenuLayer * menu_layer, Window * window) {
  if (!menu_layer_ccp) {
    menu_layer_set_click_config_onto_window(menu_layer, window);
    menu_layer_ccp = window_get_click_config_provider(window);
  }
  window_set_click_config_provider_with_context(window, (ClickConfigProvider) menu_layer_click_config_provider, menu_layer);
}
static void main_window_load(Window *window) {
	Layer *window_layer;
	GRect window_bounds;

	window_set_background_color(window, COLOR_WINDOW_BG);

	window_layer = window_get_root_layer(window);
	window_bounds = layer_get_bounds(window_layer);

	APP_LOG(APP_LOG_LEVEL_INFO, "bounds of window: %d,%d:%d,%d",
			window_bounds.origin.x, window_bounds.origin.y,
			window_bounds.size.w, window_bounds.size.h);

	main_menu_layer = menu_layer_create(window_bounds);
#ifdef PBL_SDK_3
	menu_layer_set_highlight_colors(main_menu_layer, COLOR_MENU_BG, COLOR_MENU_FG);
	menu_layer_set_normal_colors(main_menu_layer, COLOR_MENU_BG_HL, COLOR_MENU_FG_HL);
#endif
	menu_layer_set_click_config_onto_window(main_menu_layer, window);
	layer_add_child(window_layer, menu_layer_get_layer(main_menu_layer));

	menu_layer_set_callbacks(main_menu_layer, NULL, (MenuLayerCallbacks) {
		.get_header_height = main_menu_header_height,
		.draw_header = main_menu_header,
		.draw_row = main_menu_draw_row,
		.get_num_rows = main_menu_num_rows,
		.select_click = main_menu_select_click,
	});
Exemple #7
0
void arrivals_init_menu(char *stop) {
	static char title[16];
	snprintf(title, sizeof(title), "Arrivals: %s", current_stop_id);

	window_init(&arrival_window, title);

	//15px to make room for the title bar.
	menu_layer_init(&_arrivalsMenu, GRect(0, 0, arrival_window.layer.frame.size.w, arrival_window.layer.frame.size.h-15));
	menu_layer_set_click_config_onto_window(&_arrivalsMenu, &arrival_window);

	static MenuLayerCallbacks arrivals_callbacks = {
		.draw_header = arrivals_draw_header,
		.draw_row = arrivals_draw_row,
		.get_cell_height = arrivals_get_cell_height,
		.get_header_height = arrivals_get_header_height,
		.get_num_rows = arrivals_get_num_rows,
		.get_num_sections = arrivals_get_num_sections,
		.select_click = arrivals_select_click,
		.select_long_click = arrivals_select_long_click,
		.selection_changed = arrivals_selection_changed
	};

	menu_layer_set_callbacks(&_arrivalsMenu, ctx, arrivals_callbacks);

	layer_add_child(&arrival_window.layer, menu_layer_get_layer(&_arrivalsMenu));

	window_stack_push(&arrival_window, true);

	arrivalsCount = 0;
	http_request_arrivals(stop);

}
MenuIndex get_current_session_from_time() {
    time_t now = time(NULL);
    struct tm *tm_now = localtime(&now);
    MenuIndex current = {.section = 0, .row = 0};
    if (tm_now->tm_mon != event_month - 1 || tm_now->tm_mday != event_day) {
        return current;
    }
    for(int ts_idx=0; ts_idx<schedule.num_slots; ts_idx++) {
        TimeSlot *ts = &schedule.slots[ts_idx];
        if (tm_now->tm_hour < ts->start_hour) {
            break;
        } else if(tm_now->tm_hour == ts->start_hour && tm_now->tm_min < ts->start_min) {
            break;
        }
        current.section = ts_idx;
    }
    return current;
}

MenuIndex get_current_session_from_args() {
    int args = launch_get_args();
    MenuIndex current = {.section = args / 10, .row = args % 10};
    return current;
}

MenuIndex get_current_session() {
    #ifdef PBL_COLOR
    if (launch_reason() == APP_LAUNCH_TIMELINE_ACTION && launch_get_args() > 0) {
        return get_current_session_from_args();
    }
    #endif
    return get_current_session_from_time();
}

static void main_window_load(Window *window) {
  Layer *window_layer = window_get_root_layer(window);
  GRect bounds = layer_get_frame(window_layer);

  menu_schedule = menu_layer_create(bounds);

  #ifdef PBL_COLOR
  menu_layer_set_normal_colors(menu_schedule, ROW_BG_COLOR, ROW_FG_COLOR);
  menu_layer_set_highlight_colors(menu_schedule, HIGHLIGHT_BG_COLOR, HIGHLIGHT_FG_COLOR);
  #endif

  menu_layer_set_callbacks(menu_schedule, NULL, (MenuLayerCallbacks) {
    .get_num_sections = menu_get_num_sections_callback,
    .get_num_rows = menu_get_num_rows_callback,
    .get_header_height = menu_get_header_height_callback,
    .get_cell_height = menu_get_height_callback,
    .draw_header = menu_draw_header_callback,
    .draw_row = menu_draw_row_callback,
    .select_click = menu_select_callback,
  });

  menu_layer_set_click_config_onto_window(menu_schedule, window);
  MenuIndex idx = get_current_session();
  menu_layer_set_selected_index(menu_schedule, idx, MenuRowAlignCenter, false);
  layer_add_child(window_layer, menu_layer_get_layer(menu_schedule));
}
Exemple #9
0
void window_load(Window *window)
{
  // Create time TextLayer
  window_layer = text_layer_create(GRect(0, 15, 144, 50));
  text_layer_set_background_color(window_layer, GColorClear);
  text_layer_set_text_color(window_layer, GColorBlack);
  text_layer_set_text(window_layer, "Article Topics");
  
  // Improve the layout to be more like a watchface
  text_layer_set_font(window_layer, fonts_get_system_font(FONT_KEY_GOTHIC_18_BOLD));
  text_layer_set_text_alignment(window_layer, GTextAlignmentCenter);

  // Add it as a child layer to the Window's root layer
  layer_add_child(window_get_root_layer(window), text_layer_get_layer(window_layer));
  
  
  // Menu Layer
  //Create it - 12 is approx height of the top bar
  menu_layer = menu_layer_create(GRect(0, 55, 144, 113 - 16));
 
  //Let it receive clicks
  menu_layer_set_click_config_onto_window(menu_layer, window);
 
  //Give it its callbacks
  MenuLayerCallbacks callbacks = {
      .draw_row = (MenuLayerDrawRowCallback) draw_row_callback,
      .get_num_rows = (MenuLayerGetNumberOfRowsInSectionsCallback) num_rows_callback,
      .select_click = (MenuLayerSelectCallback) select_click_callback
  };
  menu_layer_set_callbacks(menu_layer, NULL, callbacks);
  //Add to Window
  layer_add_child(window_get_root_layer(window), menu_layer_get_layer(menu_layer));
  // Menu Layer
  
}
Exemple #10
0
static void window_load( Window *window ) {
    Layer *window_layer = window_get_root_layer(window);

    /* Create the event menu, and bind it to this window. */
    event_menu = event_menu_layer_create(layer_get_frame(window_layer));
    menu_layer_set_click_config_onto_window(event_menu, window);
    layer_add_child(window_layer, menu_layer_get_layer(event_menu));
    layer_set_hidden(menu_layer_get_layer(event_menu), true);

    /* On the first run, the time zone offset must be fetched from the phone.
     * This creates a message box telling the user what's happening. */
    if ( have_tz_offset() == false ) {
        tz_message = text_layer_create((GRect) { {6, 52}, {132, 44}
        });
        text_layer_set_text(tz_message, "Getting time zone from your phone");
        text_layer_set_background_color(tz_message, GColorBlack);
        text_layer_set_text_alignment(tz_message, GTextAlignmentCenter);
        text_layer_set_font(tz_message, fonts_get_system_font(FONT_KEY_GOTHIC_18_BOLD));
        text_layer_set_text_color(tz_message, GColorWhite);
        layer_add_child(window_layer, text_layer_get_layer(tz_message));
    }

    load_event_reminders();

    tick_timer_service_subscribe(SECOND_UNIT, tick_second_handler);
}
static void initialise_ui(void) {
  s_window = window_create();
  window_set_fullscreen(s_window, 0);
  
  // question_menu_layer
  question_menu_layer = menu_layer_create(GRect(0, 0, 144, 168));
  menu_layer_set_click_config_onto_window(question_menu_layer, s_window);
  layer_add_child(window_get_root_layer(s_window), (Layer *)question_menu_layer);
}
static void initialise_ui(void) {
  s_window = window_create();
  window_set_fullscreen(s_window, false);
  
  // language_menu_layer
  language_menu_layer = menu_layer_create(GRect(0, 0, 144, 152));
  menu_layer_set_click_config_onto_window(language_menu_layer, s_window);
  layer_add_child(window_get_root_layer(s_window), (Layer *)language_menu_layer);
}
/*
 * Main window load callback
 */
static void main_window_load(Window *window) {
  Layer *window_layer = window_get_root_layer(window);

  menu_layer = menu_layer_create(layer_get_bounds(window_layer));
  menu_layer_set_callbacks(menu_layer, pebble_fonts, menu_callbacks);
  menu_layer_set_click_config_onto_window(menu_layer, window);

  layer_add_child(window_layer, menu_layer_get_layer(menu_layer));
}
Exemple #14
0
//----- Begin main menu window load/unload
static void window_load(Window *window) {
  Layer *window_layer = window_get_root_layer(window);
  GRect frame = layer_get_frame(window_layer);

  menu_layer_main_menu = menu_layer_create(frame);
  menu_layer_set_click_config_onto_window(menu_layer_main_menu, window);
  menu_layer_set_callbacks(menu_layer_main_menu, NULL, menu_layer_callbacks);
  
  layer_add_child(window_layer, menu_layer_get_layer(menu_layer_main_menu));
}
static void initialise_ui(void) {
  s_window = window_create();
  #ifndef PBL_SDK_3
    window_set_fullscreen(s_window, true);
  #endif
  
  // action_menu
  action_menu = menu_layer_create(GRect(0, 0, 144, 96));
  menu_layer_set_click_config_onto_window(action_menu, s_window);
  layer_add_child(window_get_root_layer(s_window), (Layer *)action_menu);
}
Exemple #16
0
static void initialise_ui(void) {
  s_window = window_create();
  IF_2(window_set_fullscreen(s_window, true));
  s_header_font = fonts_get_system_font(FONT_KEY_GOTHIC_14_BOLD);
  
  // settings_layer
  settings_layer = menu_layer_create(GRect(0, 0, 144, 168));
  menu_layer_set_click_config_onto_window(settings_layer, s_window);
  IF_3(menu_layer_set_normal_colors(settings_layer, GColorBlack, GColorWhite)); 
  IF_3(menu_layer_set_highlight_colors(settings_layer, GColorBlueMoon, GColorWhite));
  layer_add_child(window_get_root_layer(s_window), (Layer *)settings_layer);
}
Exemple #17
0
static void window_load(Window *window) {
  Layer *window_layer = window_get_root_layer(window);
  GRect bounds = layer_get_bounds(window_layer);

  s_menu_layer = menu_layer_create(bounds);
  menu_layer_set_click_config_onto_window(s_menu_layer, window);
  menu_layer_set_callbacks(s_menu_layer, NULL, (MenuLayerCallbacks) {
      .get_num_rows = get_num_rows_callback,
      .draw_row = draw_row_callback,
      .select_click = select_callback,
      .get_header_height = get_header_height_callback,
      .draw_header = draw_header_callback,
  });
Exemple #18
0
static void window_load(Window *window) {
    Layer* window_layer = window_get_root_layer(window);
    GRect bounds = layer_get_bounds(window_layer);
    
    menu_layer = menu_layer_create(GRect(0,0,bounds.size.w,bounds.size.h));
	menu_layer_set_click_config_onto_window(menu_layer, window);
	cbacks.get_num_rows = &menu_layer_get_num_rows_in_section;
	cbacks.get_cell_height = &menu_layer_get_cell_height; 
	cbacks.select_click = &menu_layer_select_click; 
	cbacks.draw_row = &menu_layer_draw_row;
	menu_layer_set_callbacks(menu_layer, NULL, cbacks);
	layer_add_child(window_get_root_layer(window), menu_layer_get_layer(menu_layer));
}
static void layerCreate(Window *menuWindow) {

    Layer *rootWindowLayer = window_get_root_layer(menuWindow);
    GRect bounds           = layer_get_frame(rootWindowLayer);
    
    s_menuLayer = basicMenuLayerCreate(bounds, s_menuModel);
        
    menu_layer_set_highlight_colors(s_menuLayer, GColorBabyBlueEyes, GColorBlack);
    
    menu_layer_set_click_config_onto_window(s_menuLayer, menuWindow);
    
    layer_add_child(rootWindowLayer, menu_layer_get_layer(s_menuLayer));
}
Exemple #20
0
static void initialise_ui(void) {
  s_window = window_create();
  #ifndef PBL_SDK_3
    window_set_fullscreen(s_window, true);
  #endif
  
  GRect bounds = layer_get_bounds(window_get_root_layer(s_window));
  
  // s_menulayer
  s_menulayer = menu_layer_create(GRect(0, 0, bounds.size.w, bounds.size.h));
  menu_layer_set_click_config_onto_window(s_menulayer, s_window);
  layer_add_child(window_get_root_layer(s_window), (Layer *)s_menulayer);
}
Exemple #21
0
static void window_load(Window *window) {
  Layer *window_layer = window_get_root_layer(window);
  GRect bounds = layer_get_bounds(window_layer);
  s_menu_layer = menu_layer_create(bounds);
  menu_layer_set_click_config_onto_window(s_menu_layer, window);
  menu_layer_set_normal_colors(s_menu_layer, GColorWhite, GColorBlack);
  menu_layer_set_highlight_colors(s_menu_layer, GColorCyan, GColorBlack);
  menu_layer_set_callbacks(s_menu_layer, NULL, (MenuLayerCallbacks) {
      .get_num_rows = get_num_rows_callback,
      .draw_row = draw_row_callback,
      .get_cell_height = get_cell_height_callback,
      .select_click = select_callback,
  });
Exemple #22
0
static void dashboard_window_load(Window *window) {
  Layer *window_layer = window_get_root_layer(window);
  GRect bounds = layer_get_bounds(window_layer);

  dashboard_menu_layer = menu_layer_create(bounds);
  menu_layer_set_click_config_onto_window(dashboard_menu_layer, window);
  menu_layer_set_callbacks(dashboard_menu_layer, NULL, (MenuLayerCallbacks) {
      .get_num_rows = (MenuLayerGetNumberOfRowsInSectionsCallback)dashboard_menu_get_num_rows_callback,
      .draw_row = (MenuLayerDrawRowCallback)dashboard_menu_draw_row_callback,
      //.get_cell_height = (MenuLayerGetCellHeightCallback)main_menu_get_cell_height_callback,
      .select_click = (MenuLayerSelectCallback)dashboard_menu_select_callback,
      .draw_header = (MenuLayerDrawHeaderCallback)dashboard_menu_draw_header_callback,
      .get_header_height = (MenuLayerGetHeaderHeightCallback)dashboard_menu_get_header_height_callback,
      .get_num_sections = (MenuLayerGetNumberOfSectionsCallback)dashboard_menu_get_num_sections_callback,
  });
static void window_load(Window *window) {
  Layer *window_layer = window_get_root_layer(window);
  GRect bounds = layer_get_bounds(window_layer);

  tick_black_bitmap = gbitmap_create_with_resource(RESOURCE_ID_TICK_BLACK);
  tick_white_bitmap = gbitmap_create_with_resource(RESOURCE_ID_TICK_WHITE);

  menu_layer = menu_layer_create(bounds);
  menu_layer_set_click_config_onto_window(menu_layer, window);
  menu_layer_set_callbacks(menu_layer, NULL, (MenuLayerCallbacks) {
      .get_num_rows = get_num_rows_callback,
      .draw_row = draw_row_callback,
      .get_cell_height = get_cell_height_callback,
      .select_click = select_callback,
  });
Exemple #24
0
static void initialise_ui(void) {
  s_window = window_create();
  window_set_background_color(s_window, BACKGROUND);
  Layer *window_layer = window_get_root_layer(s_window);
  GRect bounds = layer_get_bounds(window_layer);

  // s_menulayer_1
  s_menulayer_1 = menu_layer_create(bounds);
  menu_layer_set_click_config_onto_window(s_menulayer_1, s_window);
  menu_layer_set_callbacks(s_menulayer_1, NULL, (MenuLayerCallbacks){
    .get_num_rows = menu_get_num_rows_callback,
    .get_cell_height = menu_get_cell_height_callback,
    .draw_row = menu_draw_row_callback,
    .select_click = menu_select_callback
  });
Exemple #25
0
void menu_load(Window *window) {
  menu_layer = menu_layer_create(GRect(0, 0, 144, 154));

  num_rows = (uint16_t) get_data_keys(keys);

  // Prepare the callbacks
  menu_callbacks.draw_row = draw_row_callback;
  menu_callbacks.get_num_rows = get_num_rows_callback;
  menu_callbacks.select_click = select_click_callback;
  menu_layer_set_callbacks(menu_layer, 0, menu_callbacks);

  layer_add_child(window_get_root_layer(window), menu_layer_get_layer(menu_layer));

  menu_layer_set_click_config_onto_window(menu_layer, window);
  APP_LOG(APP_LOG_LEVEL_DEBUG, "Menu layer added");
}
Exemple #26
0
void InboxCreate()
{
	window_init	(&s_window, "email window");
	window_set_fullscreen(&s_window, true);
	menu_layer_init	(&s_menu_layer, s_window.layer.frame);
	layer_add_child(&s_window.layer, &s_menu_layer.scroll_layer.layer);
	s_waitingForData = false;
	menu_layer_set_callbacks(&s_menu_layer,  0, s_callbacks);

	menu_layer_set_click_config_onto_window	(&s_menu_layer, &s_window);

	WindowHandlers wh =  {.appear = s_appear, .disappear = s_disapear};

	window_set_window_handlers(&s_window, wh);

}
Exemple #27
0
static void window_load(Window *window) {
  Layer *window_layer = window_get_root_layer(window);
  GRect bounds = layer_get_bounds(window_layer);

  s_menu_layer = menu_layer_create(bounds);
  menu_layer_set_highlight_colors(s_menu_layer, COLOUR_MENU_HIGHLIGHT_BACKGROUND, COLOUR_MENU_HIGHLIGHT_FOREGROUND);
  menu_layer_set_click_config_onto_window(s_menu_layer, window);
  menu_layer_set_callbacks(s_menu_layer, NULL, (MenuLayerCallbacks) {
      .get_num_rows = (MenuLayerGetNumberOfRowsInSectionsCallback)get_num_rows_callback,
      .draw_row = (MenuLayerDrawRowCallback)draw_row_callback,
      .get_cell_height = (MenuLayerGetCellHeightCallback)get_cell_height_callback,
      .select_click = (MenuLayerSelectCallback)select_callback,
      .draw_header = (MenuLayerDrawHeaderCallback)draw_header_callback,
      .get_header_height = (MenuLayerGetHeaderHeightCallback)get_header_height_callback,
      .get_num_sections = (MenuLayerGetNumberOfSectionsCallback)get_num_sections_callback,
  });
static void window_load(Window *window) {
  APP_LOG(APP_LOG_LEVEL_DEBUG, "WINDOW LOAD");
  Layer *window_layer = window_get_root_layer(window);
  GRect bounds = layer_get_bounds(window_layer);

  s_menu_layer = menu_layer_create(bounds);
  menu_layer_set_click_config_onto_window(s_menu_layer, window);
#if defined(PBL_COLOR)
  menu_layer_set_normal_colors(s_menu_layer, GColorBlack, GColorWhite);
  menu_layer_set_highlight_colors(s_menu_layer, GColorRed, GColorWhite);
#endif
  menu_layer_set_callbacks(s_menu_layer, NULL, (MenuLayerCallbacks) {
      .get_num_rows = get_num_rows_callback,
      .draw_row = draw_row_callback,
      .get_cell_height = get_cell_height_callback,
      .select_click = select_callback,
  });
Exemple #29
0
static void initialise_ui(void) {
  s_window = window_create();
  window_set_fullscreen(s_window, true);
  window_set_background_color(s_window, COLOUR_WINDOW);
  
  // s_menu
  s_menu = menu_layer_create(layer_get_bounds(window_get_root_layer(s_window)));
  if(watch_info_get_firmware_version().major >= 3) {
    scroll_layer_set_shadow_hidden(menu_layer_get_scroll_layer(s_menu), true);
  }
#ifdef PBL_SDK_3
  menu_layer_set_highlight_colors(s_menu, COLOUR_MENU_HIGHLIGHT_BACKGROUND, COLOUR_MENU_HIGHLIGHT_FOREGROUND);
  menu_layer_set_normal_colors(s_menu, COLOUR_MENU_BACKGROUND, COLOUR_MENU_FOREGROUND);
#endif
  menu_layer_set_click_config_onto_window(s_menu, s_window);
  layer_add_child(window_get_root_layer(s_window), (Layer *)s_menu);
}
Exemple #30
0
void window_load(Window *window) {
  Layer *window_layer = window_get_root_layer(window);
  GRect bounds = layer_get_bounds(window_layer);

  s_menu_layer = menu_layer_create(bounds);
  menu_layer_set_click_config_onto_window(s_menu_layer, window);
//   menu_layer_set_callbacks(s_menu_layer, NULL, (MenuLayerCallbacks) {
//       .get_num_rows = (MenuLayerGetNumberOfRowsInSectionsCallback)get_num_rows_callback,
//       .draw_row = (MenuLayerDrawRowCallback)draw_row_callback,
//       .get_cell_height = (MenuLayerGetCellHeightCallback)get_cell_height_callback,
//       .select_click = (MenuLayerSelectCallback)select_callback,
//       .draw_header = (MenuLayerDrawHeaderCallback)draw_header_callback,
//       .get_header_height = (MenuLayerGetHeaderHeightCallback)get_header_height_callback,
//       .get_num_sections = (MenuLayerGetNumberOfSectionsCallback)get_num_sections_callback,
//   });
  layer_add_child(window_layer, menu_layer_get_layer(s_menu_layer));
}