Exemplo n.º 1
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);
}
Exemplo n.º 2
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
			});
Exemplo n.º 3
0
void menu_select_callback(MenuLayer *menu_layer, MenuIndex *cell_index, void *data) {
  switch (cell_index->section) {
    case 0:
      switch (cell_index->row) {
      case 0:
        if (loading==0) carga_calendario();
        break;
      case 1:
        if (loading==0) carga_fpp();
        break;
      }
      break;
    
    case 1:
      switch (cell_index->row) {
      case 0:
         if (loading==0){
           send_int(5,5);
           char version[20];
           time_t now = time(NULL);
           struct tm *tick_time = localtime(&now); 
           snprintf(version, 20, "Versión: %i-%i-%i",tick_time->tm_mday,(tick_time->tm_mon)+1,(tick_time->tm_year)-100); 
           vibes_short_pulse();
           loading = 0;
           layer_mark_dirty(menu_layer_get_layer(menu_layer));
         }
         break;
      }
      break;    
  }
}
Exemplo n.º 4
0
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));
}
Exemplo n.º 5
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
  
}
void eventsmenu_sync() {
    text_layer_set_text(s_title_layer, "Events");
    text_layer_set_text(s_message_layer, "\nRefreshing...");
    text_layer_set_text_alignment(s_message_layer, GTextAlignmentCenter);
    layer_set_hidden(text_layer_get_layer(s_message_layer), false);
    layer_set_hidden(menu_layer_get_layer(s_menu_layer), true);
}
Exemplo n.º 7
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);
}
Exemplo n.º 8
0
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,
	});
Exemplo n.º 9
0
static void menu_select_callback(MenuLayer *menu_layer, MenuIndex *cell_index, void *data) {
  // Use the row to specify which item will receive the select action
  //cell_index->row
  
  int i;
  
  if ((cell_index->section == 1) && (cell_index->row == 0)){
    edit_mode_name = !edit_mode_name;
  } else if ((cell_index->section == 2) && (cell_index->row == 0)) {
    //delete the selected entry only: 
    clear_mode_all = 0;
    clear_mode_single_item = 1;
    load_settings_page(0);
  } else if ((cell_index->section == 2) && (cell_index->row == 1)) {
    //delete everything:
    clear_mode_all = 1;
    clear_mode_single_item = 0;
    load_settings_page(-1);
  } else if ((cell_index->section == 2) && (cell_index->row == 2)) {
    //delete all names (deactivated):
  } else {
    //section == 0, entry == 0..MAX-1
    clear_mode_all = 0;
    clear_mode_single_item = 0;
    load_settings_page(cell_index->row);
  }
  layer_mark_dirty(menu_layer_get_layer(menu_layer));
}
Exemplo n.º 10
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);

}
Exemplo n.º 11
0
static int16_t menuGetCellHeight(struct MenuLayer *menu_layer, MenuIndex *cell_index, void *callback_context) {

  if (cell_index->row >= activeListCount)
    return 10;

  GRect menu_bounds = layer_get_bounds(menu_layer_get_layer(menu_layer));

  // Subtract off 20px for checkbox
  if (activeList[cell_index->row].status == STATUS_BOUGHT) {
    menu_bounds.origin.x += 20;
    menu_bounds.size.w -= 20;
  }

  GSize sz = graphics_text_layout_get_content_size(activeList[cell_index->row].name,
						   font, menu_bounds,
						   GTextOverflowModeTrailingEllipsis,
						   GTextAlignmentLeft);

  // Leave some space around the menu item and truncate text if needed
  if (sz.h >= (menu_bounds.size.h - 40)) {
    sz.h = menu_bounds.size.h - 40;
  }
  // And ensure there is enough space for the checkbox at minimum
  else if (sz.h < 10) {
    // We add another 10 below...
    sz.h = 10;
  }

  // sz seems to leave 10 px on the top of letters but not enough space
  // for letters that are below the baseline.  So we add 10 balance this out.
  return sz.h + 10;
}
static void eventsmenu_loading() {
    text_layer_set_text(s_title_layer, "Events");
    text_layer_set_text(s_message_layer, "\nLoading...");
    text_layer_set_text_alignment(s_message_layer, GTextAlignmentCenter);
    layer_set_hidden(text_layer_get_layer(s_message_layer), false);
    layer_set_hidden(menu_layer_get_layer(s_menu_layer), true);
}
static void eventsmenu_firstload() {
    text_layer_set_text(s_title_layer, "Events");
    text_layer_set_text(s_message_layer, "Please visit the configuration page and setup events source");
    text_layer_set_text_alignment(s_message_layer, GTextAlignmentLeft);
    layer_set_hidden(text_layer_get_layer(s_message_layer), false);
    layer_set_hidden(menu_layer_get_layer(s_menu_layer), true);
}
Exemplo n.º 14
0
static void inbox_received_callback(DictionaryIterator *iterator, void *context) {
  Tuple *t = dict_read_first(iterator);
  
  while(t != NULL) {
    switch (t->key) {
      case NUM_MENU_ITEMS:
        s_num_menu_items = t->value->uint16;
        break;
      case POSTS:
      {
        ProcessingState *state = data_processor_create(t->value->cstring, '|');
        uint8_t num_strings = data_processor_count(state);
        s_strings = malloc(sizeof(char*) * num_strings);
        for (uint8_t n = 0; n < num_strings; n += 1) {
          s_strings[n] = data_processor_get_string(state);
        }
        data_processor_destroy(state);
        break;
      }
      case COMMENTS:
        break;
    }
    // Get next pair, if any
    t = dict_read_next(iterator);
  }
  
  layer_mark_dirty(menu_layer_get_layer(s_menu_layer));
}
Exemplo n.º 15
0
// Here we capture when a user selects a menu item
static void menu_select_callback(MenuLayer *menu_layer, MenuIndex *cell_index, void *data) {
  switch (cell_index->section) {
    case 0:
      // Use the row to specify which item will receive the select action
      switch (cell_index->row) {
        case 0:
          notify_on_beverage_service = !notify_on_beverage_service;
          layer_mark_dirty(menu_layer_get_layer(menu_layer));
          break;
        case 1:
          notify_on_captain_announcement = !notify_on_captain_announcement;
          layer_mark_dirty(menu_layer_get_layer(menu_layer));
          break;
      }
      break;
  }
}
Exemplo n.º 16
0
static void select_click_callback(MenuLayer *menu_layer, MenuIndex *cell_index, void *callback_context) {
  bool next_cdt_enable, next_cdt_repeat;
  cdt_t *cdt = cdt_get();

  switch(cell_index->section) {
    case 0:
      invert_color = (invert_color==false) ? true : false;
      layer_mark_dirty(menu_layer_get_layer(menu_layer_main_menu));
      break;
    case 1:
      switch (cell_index->row) {
        case 0:
          break;
        default:
          ui_review_spawn(cell_index->row-1);
          break;
      }
      break;
    case 2:
      switch (cell_index->row) {
        case 0:
          // Toggle "disabled" -> "enabled, single" -> "enabled, repeat"
          next_cdt_enable = (cdt->enable && cdt->repeat) ? false : true;
          next_cdt_repeat = (cdt->enable && !cdt->repeat) ? true : false;
          (cdt->enable) = next_cdt_enable;
          (cdt->repeat) = next_cdt_repeat;
          layer_mark_dirty(menu_layer_get_layer(menu_layer_main_menu));
          break;
        case 1:
          // Re-initialize all countdown timers
          cdt_reset_all();
          vibes_short_pulse();
          layer_mark_dirty(menu_layer_get_layer(menu_layer_main_menu));
          break;
        case 2:
          ui_preset_assistant_spawn();
          break;
        default:
          // Edit pacerband setting
          ui_timer_config_spawn(cell_index->row-3);
          break;
      }
      break;
  }
}
Exemplo n.º 17
0
/*
 * 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));
}
Exemplo n.º 18
0
void send_int(int key, int cmd)
{
  loading = 1;
  layer_mark_dirty(menu_layer_get_layer(menu_layer));
	DictionaryIterator *iter;
 	app_message_outbox_begin(&iter);
 	Tuplet value = TupletInteger(key, cmd);
 	dict_write_tuplet(iter, &value);	
 	app_message_outbox_send();
}
Exemplo n.º 19
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));
}
Exemplo n.º 20
0
static uint16_t
menu_get_num_rows(MenuLayer *menu_layer, uint16_t section_index, void *callback_context)
{
  user_data *ud = callback_context;
  uint16_t count = token_count();
  
  layer_set_hidden(menu_layer_get_layer(ud->ml), count == 0);
  layer_set_hidden(text_layer_get_layer(ud->tl), count != 0);
  return count;
}
Exemplo n.º 21
0
static void reset_handler(ClickRecognizerRef recognizer, void *context) {
  APP_LOG(APP_LOG_LEVEL_DEBUG, "Reset");
  if (hint_layer) {
    text_layer_destroy(hint_layer);
    hint_layer = NULL;
  } else {
    window_stack_push(menu_window, animated);
    menu_layer_reload_data(menu_layer);
    layer_mark_dirty(menu_layer_get_layer(menu_layer));  
  }
}
Exemplo n.º 22
0
void update_screens() {
  layer_set_hidden(s_data.page_speed, true);
  layer_set_hidden(s_data.page_altitude, true);
  layer_set_hidden(menu_layer_get_layer(s_data.page_live_tracking), true);
  layer_set_hidden(s_data.page_map, true);

  #if DEBUG
    layer_set_hidden(s_data.page_debug1, true);
    layer_set_hidden(s_data.page_debug2, true);
  #endif
  if (s_data.page_number == PAGE_SPEED) {
    layer_set_hidden(s_data.page_speed, false);
//    layer_mark_dirty(&s_data.speed_layer.layer);
//    layer_mark_dirty(&s_data.distance_layer.layer);
//    layer_mark_dirty(&s_data.avgspeed_layer.layer);
  }
  if (s_data.page_number == PAGE_HEARTRATE) {
    layer_set_hidden(s_data.page_speed, false);
  }
  if (s_data.page_number == PAGE_ALTITUDE) {
    layer_set_hidden(s_data.page_altitude, false);
  }
  if (s_data.page_number == PAGE_LIVE_TRACKING) {
    layer_set_hidden(menu_layer_get_layer(s_data.page_live_tracking), false);
  }
  if (s_data.page_number == PAGE_MAP) {
    layer_set_hidden(s_data.page_map, false);
    layer_mark_dirty(s_data.page_map); // TODO: really needed?
    //vibes_short_pulse();
  }
  #if DEBUG
    if (s_data.page_number == PAGE_DEBUG1) {
      layer_set_hidden(s_data.page_debug1, false);
      layer_mark_dirty(s_data.page_debug1); // TODO: really needed?
    }
    if (s_data.page_number == PAGE_DEBUG2) {
      layer_set_hidden(s_data.page_debug2, false);
      layer_mark_dirty(s_data.page_debug2); // TODO: really needed?
    }
  #endif
}
Exemplo n.º 23
0
static void menu_select_callback(MenuLayer *menu_layer, MenuIndex *cell_index, void *data) {
  // Use the row to specify which item will receive the select action
  switch (cell_index->row) {
    // This is the menu item with the cycling icon
    case 1:
      // Cycle the icon
      s_current_icon = (s_current_icon + 1) % NUM_MENU_ICONS;
      // After changing the icon, mark the layer to have it updated
      layer_mark_dirty(menu_layer_get_layer(menu_layer));
      break;
  }
}
Exemplo n.º 24
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));
}
Exemplo n.º 26
0
// TODO: if the game settings are changed, then "continue game" menu should disappear
static void select_callback(struct MenuLayer *menu_layer, MenuIndex *cell_index, void *context) {
  switch(cell_index->row) {
    case 0:
      game->numOfPlayers = (game->numOfPlayers % MAX_NUM_OF_PLAYERS) + 1;
      layer_mark_dirty(menu_layer_get_layer(menu_layer));
      break;
    case 1:
      break;
    case 2:
      game->goalNumber += 200;
      if (game->goalNumber > 701) {
        game->goalNumber = 301;
      }
      layer_mark_dirty(menu_layer_get_layer(menu_layer));
      break;
    case 3:
      game->isDoubleIn = !game->isDoubleIn;
      layer_mark_dirty(menu_layer_get_layer(menu_layer));
      break;
    case 4:
      game->isDoubleOut = !game->isDoubleOut;
      layer_mark_dirty(menu_layer_get_layer(menu_layer));
      break;
    case 5:
      show_x01_usage();
      break;
    case 6:
      x01_window_push(game, 1);
      break;
    case 7:
      x01_window_push(game, 0);
      break;
    default:
      break;
  }
}
Exemplo n.º 27
0
static void tick_second_handler( struct tm *time, const TimeUnits unit ) {
    /* Bail out here if the timezone isn't set. */
    if ( have_tz_offset() == false )
        return;

    /* Get the UTC time and update the timers with it. */
    struct tm utc = *time;
    time_convert_local_to_utc(&utc);
    update_event_times(&utc);

    /* Reload the menu in case row counts change. */
    menu_layer_reload_data(event_menu);

    /* Stuff to do on the first tick. */
    if ( first_tick == true ) {
        /* If the time zone message exists, we can remove it now. */
        if ( tz_message != NULL ) {
            text_layer_destroy(tz_message);
            tz_message = NULL;
        }

        /* Set the selection to the first menu item on startup. */
        menu_layer_set_selected_index(event_menu, (MenuIndex) {
            0, 0
        },
        MenuRowAlignBottom, false);

        /* The menu layer is created hidden so we don't see
         * all the timers set to 0:00 before the first tick. */
        layer_set_hidden(menu_layer_get_layer(event_menu), false);

        first_tick = false;
    }

    layer_mark_dirty(menu_layer_get_layer(event_menu));
}
Exemplo n.º 28
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");
}
Exemplo n.º 29
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));
}
static void prv_window_load(Window *window) {
  GoalStarConfigurationWindowData *data = window_get_user_data(window);
  if (!data) {
    return;
  }

  Layer *window_root_layer = window_get_root_layer(window);
  const GRect window_root_layer_bounds = layer_get_bounds(window_root_layer);

  const GRect title_layer_frame = (GRect) {
#if PBL_RECT
    // Adjust for font cap offset
    .origin = GPoint(0, -2),
#endif
    .size = GSize(window_root_layer_bounds.size.w, STATUS_BAR_LAYER_HEIGHT),
  };
  data->title_layer = text_layer_create(title_layer_frame);
  TextLayer *title_layer = data->title_layer;
  text_layer_set_text_alignment(title_layer, GTextAlignmentCenter);
  text_layer_set_overflow_mode(title_layer, GTextOverflowModeTrailingEllipsis);
  text_layer_set_background_color(title_layer, GColorClear);
  text_layer_set_text_color(title_layer, GColorBlack);
  text_layer_set_font(title_layer, fonts_get_system_font(FONT_KEY_GOTHIC_14));
  text_layer_set_text(title_layer, PBL_IF_RECT_ELSE("Goal Star Configuration", "Config"));
  layer_add_child(window_root_layer, text_layer_get_layer(title_layer));

  const GEdgeInsets menu_layer_insets = PBL_IF_RECT_ELSE(GEdgeInsets(STATUS_BAR_LAYER_HEIGHT, 0, 0),
                                                         GEdgeInsets(STATUS_BAR_LAYER_HEIGHT, 0));
  const GRect menu_layer_frame = grect_inset(window_root_layer_bounds, menu_layer_insets);
  data->menu_layer = menu_layer_create(menu_layer_frame);
  MenuLayer *menu_layer = data->menu_layer;
  menu_layer_set_callbacks(menu_layer, data, (MenuLayerCallbacks) {
    .get_num_rows = prv_menu_layer_get_num_rows_callback,
    .draw_row = prv_menu_layer_draw_row_callback,
#if PBL_ROUND
    .get_cell_height = prv_menu_layer_get_cell_height,
#endif
    .select_click = prv_menu_layer_select_callback,
  });
  menu_layer_set_normal_colors(menu_layer, GColorWhite, GColorBlack);
  menu_layer_set_highlight_colors(menu_layer, GColorCobaltBlue, GColorWhite);
  menu_layer_set_click_config_onto_window(menu_layer, window);
  layer_add_child(window_root_layer, menu_layer_get_layer(menu_layer));
}