Esempio n. 1
0
static void update_time() {
    time_t temp = time(NULL);
    struct tm *tick_time = localtime(&temp);

    static char s_buffer_h[3];
    strftime(s_buffer_h, sizeof(s_buffer_h), clock_is_24h_style() ? "%H" : "%I", tick_time);
    text_layer_set_text(s_timehours_layer, s_buffer_h);
    static char s_buffer_m[3];
    strftime(s_buffer_m, sizeof(s_buffer_m), "%M", tick_time);
    text_layer_set_text(s_timemins_layer, s_buffer_m);
    static char s_buffer_ampm[3];
    strftime(s_buffer_ampm, sizeof(s_buffer_ampm), clock_is_24h_style() ? "": "%p", tick_time);
    text_layer_set_text(s_time_ampm_layer, s_buffer_ampm);

    // Resize to ceneter
    GSize hoursSize = text_layer_get_content_size(s_timehours_layer);
    GSize minSize = text_layer_get_content_size(s_timemins_layer);
    GSize ampmSize = text_layer_get_content_size(s_time_ampm_layer);
    int combinedWidth = hoursSize.w + minSize.w;
    int halfWidth = combinedWidth / 2;

    text_layer_set_size(s_timehours_layer, GSize(xHalf + halfWidth - minSize.w, 90));
    text_layer_set_size(s_timemins_layer, GSize(xHalf + halfWidth, 68));
    text_layer_set_size(s_time_ampm_layer, GSize(xHalf + halfWidth - (minSize.w - ampmSize.w) + 2, 68));
}
Esempio n. 2
0
void storyview_init(char *title, char *summary) {
	window = window_create();

	Layer *window_layer = window_get_root_layer(window);
	GRect bounds = layer_get_bounds(window_layer);
	GRect max_text_bounds = GRect(2, 0, bounds.size.w - 4, 2000);

	scroll_layer = scroll_layer_create(bounds);
	scroll_layer_set_click_config_onto_window(scroll_layer, window);

	title_layer = text_layer_create(max_text_bounds);
	text_layer_set_font(title_layer, fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD));
	text_layer_set_text(title_layer, title);

	GSize title_max_size = text_layer_get_content_size(title_layer);
	text_layer_set_size(title_layer, GSize(title_max_size.w, title_max_size.h + 14));

	summary_layer = text_layer_create(GRect(2, title_max_size.h + 14, max_text_bounds.size.w, max_text_bounds.size.h - (title_max_size.h + 14)));
	text_layer_set_font(summary_layer, fonts_get_system_font(FONT_KEY_GOTHIC_18_BOLD));
	text_layer_set_text(summary_layer, summary);

	GSize summary_max_size = text_layer_get_content_size(summary_layer);
	text_layer_set_size(summary_layer, GSize(summary_max_size.w, summary_max_size.h + 14));

	scroll_layer_set_content_size(scroll_layer, GSize(bounds.size.w, title_max_size.h + 14 + summary_max_size.h + 8));

	scroll_layer_add_child(scroll_layer, text_layer_get_layer(title_layer));
	scroll_layer_add_child(scroll_layer, text_layer_get_layer(summary_layer));

	layer_add_child(window_layer, scroll_layer_get_layer(scroll_layer));
}
Esempio n. 3
0
File: main.c Progetto: akeif/BeeFace
static void update_sleep_bar_buffer() {
    HealthMetric sleep_metric = HealthMetricSleepSeconds;
    HealthMetric deep_sleep_metric = HealthMetricSleepRestfulSeconds;

    static double seconds_in_8_hours = 28000;
    static double pebble_time_pixel_width = 144;

    double s_sleep_pixel_length = (double)health_service_sum_today(sleep_metric) / seconds_in_8_hours * pebble_time_pixel_width;
    double s_deep_sleep_pixel_length = (double)health_service_sum_today(deep_sleep_metric) / seconds_in_8_hours * pebble_time_pixel_width;

    text_layer_set_size(s_sleep_bar_layer, GSize(s_sleep_pixel_length, 6));
    text_layer_set_size(s_deep_sleep_bar_layer, GSize(s_deep_sleep_pixel_length, 6));
}
Esempio n. 4
0
/**
 * Initializates the GUI Elements
 */
void about_window_load (Window *window) {
	GRect windowBounds = layer_get_frame(ui.windowLayer);
	GRect titleBounds = GRect(0, 0, windowBounds.size.w, 30);
	ui.titleLayer = text_layer_create(titleBounds);
	text_layer_set_text_color(ui.titleLayer, GColorWhite);
	text_layer_set_background_color(ui.titleLayer, GColorBlack);
	text_layer_set_text(ui.titleLayer, "About");
  	text_layer_set_font(ui.titleLayer, fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD));
  	text_layer_set_text_alignment(ui.titleLayer, GTextAlignmentCenter);
	layer_add_child(ui.windowLayer, text_layer_get_layer(ui.titleLayer));
	
	// Creates the Scroll
	GRect scrollBounds = GRect(0, 30, windowBounds.size.w, (windowBounds.size.h - 30));
	ui.scroll = scroll_layer_create(scrollBounds);
	scroll_layer_set_click_config_onto_window(ui.scroll, ui.window);
	layer_add_child(ui.windowLayer, scroll_layer_get_layer(ui.scroll));
	
	GRect textBounds = GRect(0, 0, scrollBounds.size.w, 2000);
	ui.textLayer = text_layer_create(textBounds);
	text_layer_set_text_color(ui.textLayer, GColorBlack);
	text_layer_set_background_color(ui.textLayer, GColorClear);
	text_layer_set_text(ui.textLayer, "Developer:\nYago Carballo ([email protected])\n\nGame By...\nameiga 2014\n\n");
  	text_layer_set_font(ui.textLayer, fonts_get_system_font(FONT_KEY_GOTHIC_18_BOLD));
  	text_layer_set_text_alignment(ui.textLayer, GTextAlignmentCenter);
	
	GSize max_size = text_layer_get_content_size(ui.textLayer);
	text_layer_set_size(ui.textLayer, max_size);
	scroll_layer_set_content_size(ui.scroll, GSize(windowBounds.size.w, max_size.h + 5));
	scroll_layer_add_child(ui.scroll, text_layer_get_layer(ui.textLayer));
}
// Setup the scroll layer on window load
// We do this here in order to be able to get the max used text size
static void window_load(Window *window) {
  Layer *window_layer = window_get_root_layer(window);
  GRect bounds = layer_get_frame(window_layer);
  GRect max_text_bounds = GRect(0, 0, bounds.size.w, 2000);

  // Initialize the scroll layer
  scroll_layer = scroll_layer_create(bounds);

  // This binds the scroll layer to the window so that up and down map to scrolling
  // You may use scroll_layer_set_callbacks to add or override interactivity
  scroll_layer_set_click_config_onto_window(scroll_layer, window);

  // Initialize the text layer
  text_layer = text_layer_create(max_text_bounds);
  text_layer_set_text(text_layer, scroll_text);

  // Change the font to a nice readable one
  // This is system font; you can inspect pebble_fonts.h for all system fonts
  // or you can take a look at feature_custom_font to add your own font
  text_layer_set_font(text_layer, fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD));

  // Trim text layer and scroll content to fit text box
  GSize max_size = text_layer_get_content_size(text_layer);
  text_layer_set_size(text_layer, max_size);
  scroll_layer_set_content_size(scroll_layer, GSize(bounds.size.w, max_size.h + vert_scroll_text_padding));

  // Add the layers for display
  scroll_layer_add_child(scroll_layer, text_layer_get_layer(text_layer));

  // The inverter layer will highlight some text
  inverter_layer = inverter_layer_create(GRect(0, 28, bounds.size.w, 28));
  scroll_layer_add_child(scroll_layer, inverter_layer_get_layer(inverter_layer));

  layer_add_child(window_layer, scroll_layer_get_layer(scroll_layer));
}
static void detail_window_load(Window *window)
{
  #ifdef PBL_COLOR
    window_colorize(window);
  #endif

  // set up text layer
  Layer *window_layer = window_get_root_layer(window);
  GRect bounds = layer_get_frame(window_layer);
  int16_t content_width = bounds.size.w-10;

  // Initialize the text layers
  GRect max_title_bounds = GRect(5, 0, content_width, 2000);
  s_detail_title_text_layer = detail_text_layer_create(max_title_bounds, s_detail_title, true);
  GSize title_size = text_layer_get_content_size(s_detail_title_text_layer);
  title_size.w = content_width;

  GRect max_text_bounds = GRect(5, title_size.h+2, content_width, 2000);
  s_detail_text_layer = detail_text_layer_create(max_text_bounds, s_detail_text, false);

  // Initialize the scroll layer
  s_detail_scroll_layer = scroll_layer_create(bounds);

  // This binds the scroll layer to the window so that up and down map to scrolling
  // You may use scroll_layer_set_callbacks to add or override interactivity
  scroll_layer_set_click_config_onto_window(s_detail_scroll_layer, window);

  // Add the layers for display

  scroll_layer_add_child(s_detail_scroll_layer, text_layer_get_layer(s_detail_text_layer));
  scroll_layer_add_child(s_detail_scroll_layer, text_layer_get_layer(s_detail_title_text_layer));

  layer_add_child(window_layer, scroll_layer_get_layer(s_detail_scroll_layer));

  // Trim text layer and scroll content to fit text box
  // GSize title_size = text_layer_get_content_size(s_detail_title_text_layer);
  title_size.w = content_width;
  title_size.h += 5;
  GSize text_size = text_layer_get_content_size(s_detail_text_layer);
  text_size.h += title_size.h;
  text_size.w = content_width;

  text_layer_set_size(s_detail_title_text_layer, title_size);
  text_layer_set_size(s_detail_text_layer, text_size);

  scroll_layer_set_content_size(s_detail_scroll_layer, GSize(bounds.size.w, title_size.h + text_size.h));
}
void scroll_text_layer_set_text(ScrollTextLayer* layer, char* text) {
  if (NULL == layer) {
    return;
  }
  text_layer_set_size(layer->text_layer, GSize(layer_get_bounds(scroll_layer_get_layer(layer->scroll_layer)).size.w - (PADDING_X * 2), MAX_HEIGHT));
  text_layer_set_text(layer->text_layer, text);
  scroll_text_layer_update(layer);
}
Esempio n. 8
0
void scroll_text_layer_set_text(ScrollTextLayer* layer, char* text) {
  if (layer == NULL) {
    return;
  }
  text_layer_set_text(layer->text_layer, text);
  GSize max_size = text_layer_get_content_size(layer->text_layer);
  text_layer_set_size(layer->text_layer, max_size);
  GRect bounds = layer_get_bounds(scroll_layer_get_layer(layer->scroll_layer));
  scroll_layer_set_content_size(layer->scroll_layer, GSize(bounds.size.w, max_size.h + (PADDING_Y * 3)));
}
static void window_load(Window *window) {
  Layer *window_layer = window_get_root_layer(window);

  s_icon_bitmap = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_ICONO_PRINCIPAL);
  GRect bitmap_bounds = gbitmap_get_bounds(s_icon_bitmap);


  s_fondo_layer = bitmap_layer_create(GRect(0, 0, 144, 40));
  bitmap_layer_set_background_color(s_fondo_layer, COLOR_CABECERA);
  layer_add_child(window_layer, bitmap_layer_get_layer(s_fondo_layer));



  s_scroll_layer = scroll_layer_create(GRect(10, 10 + bitmap_bounds.size.h + 5, 124, 168 - (10 + bitmap_bounds.size.h + 10)));
  scroll_layer_set_click_config_onto_window(s_scroll_layer, window);
  
  GRect bounds = layer_get_frame(window_layer);
  GRect max_text_bounds = GRect(0, 0, 120, 2000);
  s_label_layer = text_layer_create(max_text_bounds);
  text_layer_set_text(s_label_layer, i_lineas);
  text_layer_set_text_color(s_label_layer, COLOR_TEXTO_CUERPO);  
  text_layer_set_background_color(s_label_layer, GColorClear);
  if (i_total_lineas> 3)
    text_layer_set_font(s_label_layer, fonts_get_system_font(FONT_KEY_GOTHIC_24));
  else
    text_layer_set_font(s_label_layer, fonts_get_system_font(FONT_KEY_GOTHIC_28));
    
  //layer_add_child(window_layer, text_layer_get_layer(s_label_layer));
  
  
  
    // Trim text layer and scroll content to fit text box
  GSize max_size = text_layer_get_content_size(s_label_layer);
  text_layer_set_size(s_label_layer, max_size);
  scroll_layer_set_content_size(s_scroll_layer, GSize(bounds.size.w, max_size.h + 4));
  scroll_layer_set_shadow_hidden(s_scroll_layer, true);
  scroll_layer_add_child(s_scroll_layer, text_layer_get_layer(s_label_layer));
  layer_add_child(window_layer, scroll_layer_get_layer(s_scroll_layer));

  // CAPA DE LA PARADA
  s_titulo_layer = text_layer_create(GRect(38, 0 , 101, 40));
  text_layer_set_text(s_titulo_layer, string_parada);
  text_layer_set_background_color(s_titulo_layer, GColorClear );
  text_layer_set_text_color(s_titulo_layer, COLOR_TEXTO_CABECERA );
  text_layer_set_text_alignment(s_titulo_layer, GTextAlignmentCenter);
  text_layer_set_font(s_titulo_layer, fonts_get_system_font(FONT_KEY_GOTHIC_28_BOLD));
  layer_add_child(window_layer, text_layer_get_layer(s_titulo_layer));
  // FIN DE CAPA DE LA PARADA
  
  // CAPA DEL ICONO DEL BUS
  s_icon_layer = bitmap_layer_create(GRect(5, 5, bitmap_bounds.size.w, bitmap_bounds.size.h));
  bitmap_layer_set_bitmap(s_icon_layer, s_icon_bitmap);
  layer_add_child(window_layer, bitmap_layer_get_layer(s_icon_layer));
  // FIN DE LA CAPA
}
Esempio n. 10
0
static void handle_battery(BatteryChargeState charge_state) {
  static char battery_text[] = "100% charged";

  if (charge_state.is_charging) {
    snprintf(battery_text, sizeof(battery_text), "Charging %d%%", charge_state.charge_percent);
  } else {
    snprintf(battery_text, sizeof(battery_text), " %d%% Battery", charge_state.charge_percent);
  }
  
  text_layer_set_text(s_battery_layer, battery_text);
  text_layer_set_size(s_battery_layer, (GSize){charge_state.charge_percent *1.44,20} ); 
}
Esempio n. 11
0
static void window_load(Window *window) {

  Layer *window_layer = window_get_root_layer(window);
  GRect bounds = layer_get_bounds(window_layer);
  GRect max_text_bounds = GRect(0, 0, bounds.size.w, 2000);

  // Initialize the scroll layer
  s_scroll_layer = scroll_layer_create(GRect(0, 55, bounds.size.w, 98));

  // This binds the scroll layer to the window so that up and down map to scrolling
  // You may use scroll_layer_set_callbacks to add or override interactivity
  scroll_layer_set_click_config_onto_window(s_scroll_layer, window);
  
  // Initialize the social messages scrolling text layer
  s_text_layer = text_layer_create(max_text_bounds);
  text_layer_set_text(s_text_layer, s_scroll_text);
  text_layer_set_font(s_text_layer, fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD));

  // Trim text layer and scroll content to fit text box
  GSize max_size = text_layer_get_content_size(s_text_layer);
  text_layer_set_size(s_text_layer, max_size);
  scroll_layer_set_content_size(s_scroll_layer, GSize(bounds.size.w, max_size.h + 4));

  // Add the layers for display
  scroll_layer_add_child(s_scroll_layer, text_layer_get_layer(s_text_layer));
  layer_add_child(window_layer, scroll_layer_get_layer(s_scroll_layer));

  // Set the text of the application name layer
  text_layer_app_name = text_layer_create(GRect(0, 0, bounds.size.w, 20));
  text_layer_set_text(text_layer_app_name, "UbiSwim.org");
  text_layer_set_text_alignment(text_layer_app_name, GTextAlignmentCenter);
  layer_add_child(window_layer, text_layer_get_layer(text_layer_app_name));

  // Set the text of the social likes layer
  text_layer_likes = text_layer_create(GRect(0, 20, bounds.size.w, 40));
  text_layer_set_font(text_layer_likes, fonts_get_system_font(FONT_KEY_GOTHIC_28_BOLD)); 
  text_layer_set_text(text_layer_likes, "Likes:");
  text_layer_set_text_alignment(text_layer_likes, GTextAlignmentCenter);
  layer_add_child(window_layer, text_layer_get_layer(text_layer_likes));

  // Set the text of the info layer
  text_layer_msg = text_layer_create(GRect(0, 150, bounds.size.w, 30));
  text_layer_set_text(text_layer_msg, "U:Prev M:Like D:Next");
  text_layer_set_text_alignment(text_layer_msg, GTextAlignmentCenter);
  layer_add_child(window_layer, text_layer_get_layer(text_layer_msg));

  // Set the click config provider for the scrolling text layer
  scroll_layer_set_callbacks(s_scroll_layer, (ScrollLayerCallbacks) {
        .click_config_provider = &click_config_provider_updown
      });
Esempio n. 12
0
static void history_window_load(Window *window) {
  Layer *window_layer = window_get_root_layer(window);
  GRect bounds = layer_get_bounds(window_layer);

  history_scroller = scroll_layer_create(bounds);
  scroll_layer_set_click_config_onto_window(history_scroller, window);

  int items = current_history_batch * HISTORY_BATCH_SIZE +
    history[current_history_batch].last_event + 1;
  int width = 142;
  int margin = (bounds.size.w - width)/2;
  GSize max_size = GSize(bounds.size.w, (items + 9) * 19); // font size is 18, 5 newlines before and 4 after
  history_layer = text_layer_create(GRect(margin, 0, width, max_size.h));
  if ((current_history_batch == 0) && (history[0].last_event < 0)) {
    strcpy(history_text, "No history recorded.");
  }
  else {
    // int history_events = current_history_batch * HISTORY_BATCH_SIZE + history[current_history_batch].last_event + 1;
    // APP_LOG(APP_LOG_LEVEL_DEBUG, "%d history events", history_events);
    strcpy(history_text, "\n\n\n\n\n");
    for (int b=current_history_batch; b>=0; b--) {
      // APP_LOG(APP_LOG_LEVEL_DEBUG, "Processing batch %d", b);
      for (int e=history[b].last_event; e>=0; e--) {
        // APP_LOG(APP_LOG_LEVEL_DEBUG, "Feeling %d at %d (%d/%d)", history[b].mood[e], (int) history[b].event_time[e], e, b);
        struct tm *lt = localtime(&history[b].event_time[e]);
        strftime(timestr, sizeof(timestr), "%V %a %k:%M", lt);
        snprintf(event_text, sizeof(event_text), "%s %s\n", timestr, Moods[history[b].mood[e]]);
        strncat(history_text, event_text, sizeof(event_text));
      }
    }
  }
  strncat(history_text, "\n\n\n\n", 5);
  text_layer_set_text(history_layer, history_text);
  text_layer_set_font(history_layer, fonts_get_system_font(FONT_KEY_GOTHIC_18));
  text_layer_set_overflow_mode(history_layer, GTextOverflowModeWordWrap);
  text_layer_set_text_color(history_layer, GColorBlack);
  text_layer_set_background_color(history_layer, GColorWhite);
  max_size = text_layer_get_content_size(history_layer);
  max_size.w = bounds.size.w;
  text_layer_set_size(history_layer, max_size);
  scroll_layer_set_content_size(history_scroller, max_size);
  scroll_layer_add_child(history_scroller, text_layer_get_layer(history_layer));
  scroll_layer_set_content_offset(history_scroller, GPoint(0, 40), true);
  layer_add_child(window_layer, scroll_layer_get_layer(history_scroller));
}
Esempio n. 13
0
void note_data_received(DictionaryIterator* iterator){
  
  Tuple *t = dict_read_first(iterator);

  // For all items
  while(t != NULL) {
    // Which key was received?
    
      APP_LOG(APP_LOG_LEVEL_ERROR, "Key %d ", (int)t->key);
    
  
    // Look for next item
    t = dict_read_next(iterator);
  }
  uint16_t location = dict_find(iterator, 1)->value->uint16;
  uint16_t segmentLength = dict_find(iterator, 2)->value->uint16;
  memcpy((void *) &fullNote[location], dict_find(iterator, 4)->value->cstring, segmentLength);
  GSize maxSize = graphics_text_layout_get_content_size(fullNote, fonts_get_system_font(FONT_KEY_GOTHIC_28_BOLD),
                                                        GRect(0, 0, 144, 1000), GTextOverflowModeWordWrap, GTextAlignmentLeft);
  if (maxSize.h < 168 - 16)
    maxSize.h = 168 - 16;

  text_layer_set_size(fullNoteText, maxSize);
  scroll_layer_set_content_size(scroller, maxSize);


  text_layer_set_text(fullNoteText, fullNote);

  if (segmentLength == 75){
    DictionaryIterator *iterator;
    app_message_outbox_begin(&iterator);
    
    dict_write_uint8(iterator, 0, 3);
    dict_write_uint16(iterator, 1, location + 75);
    
    app_message_outbox_send();
    
    app_comm_set_sniff_interval(SNIFF_INTERVAL_REDUCED);
    app_comm_set_sniff_interval(SNIFF_INTERVAL_NORMAL);
  }

}
Esempio n. 14
0
static void battery_handler(BatteryChargeState charge_state) { 
	int16_t value = 0;
	value = (122*charge_state.charge_percent)/100+10;
  layer_set_hidden(bitmap_layer_get_layer(s_battery_layer), !charge_state.is_charging || charge_state.charge_percent == 100);
	#ifdef PBL_COLOR
  if(charge_state.charge_percent<=25){
		s_connection_bar_color = GColorDarkCandyAppleRed;
		text_layer_set_background_color(s_connection_bg_layer, GColorBulgarianRose);
	}else{
    if(!charge_state.is_charging){
		  s_connection_bar_color = GColorCyan;
		  text_layer_set_background_color(s_connection_bg_layer, GColorTiffanyBlue);
    }else{
      s_connection_bar_color = GColorChromeYellow;
		  text_layer_set_background_color(s_connection_bg_layer, GColorWindsorTan);
    }
	}
  #endif
  
  text_layer_set_size(s_connection_layer, GSize(value, 18));
}
Esempio n. 15
0
static void window_load(Window *window) {
  Layer *window_layer = window_get_root_layer(window);
  GRect bounds = layer_get_frame(window_layer);
  GRect max_text_bounds = GRect(0, 0, bounds.size.w, 2000);

  // Initialize the scroll layer
  s_scroll_layer = scroll_layer_create(bounds);

  // This binds the scroll layer to the window so that up and down map to scrolling
  // You may use scroll_layer_set_callbacks to add or override interactivity
  scroll_layer_set_click_config_onto_window(s_scroll_layer, window);

  // Initialize the text layer
  s_text_layer = text_layer_create(max_text_bounds);
  text_layer_set_text(s_text_layer, s_scroll_text);

  // Change the font to a nice readable one
  // This is system font; you can inspect pebble_fonts.h for all system fonts
  // or you can take a look at feature_custom_font to add your own font
  text_layer_set_font(s_text_layer, fonts_get_system_font(FONT_KEY_GOTHIC_18_BOLD));
  text_layer_set_background_color(s_text_layer, GColorClear);

#if defined(PBL_PLATFORM_APLITE)
  text_layer_set_text_color(s_text_layer, GColorBlack);
#else
  text_layer_set_text_color(s_text_layer, GColorWhite);
#endif

  // Trim text layer and scroll content to fit text box
  GSize max_size = text_layer_get_content_size(s_text_layer);
  text_layer_set_size(s_text_layer, max_size);
  scroll_layer_set_content_size(s_scroll_layer, GSize(bounds.size.w, max_size.h + 4));

  // Add the layers for display
  scroll_layer_add_child(s_scroll_layer, text_layer_get_layer(s_text_layer));

  layer_add_child(window_layer, scroll_layer_get_layer(s_scroll_layer));
 
}
static void scroll_text_layer_update(ScrollTextLayer* layer) {
  GSize max_size = text_layer_get_content_size(layer->text_layer);
  text_layer_set_size(layer->text_layer, max_size);
  GRect bounds = layer_get_bounds(scroll_layer_get_layer(layer->scroll_layer));
  scroll_layer_set_content_size(layer->scroll_layer, GSize(bounds.size.w, max_size.h + (PADDING_Y * 3)));
}
Esempio n. 17
0
// load from beginning to end (to calculate runtimes) and put the text allways onto the top:
static void load_data(void){
  time_t time_stamp = 0;
  time_t period_since_begin = 0;
  time_t period_since_last_event = 0;
  
  if (app_worker_is_running()){
    snprintf(text_header, sizeof(text_header), "Worker is running\nLaunch result = %d\n%s", (int)AWresult, text_devider);
  } else {
    snprintf(text_header, sizeof(text_header), "Worker is NOT running\nLaunch result = %d\n%s", (int)AWresult, text_devider);
  }
  strcpy(text, "");
  //snprintf(text, TEXT_LENGTH, "%s", text_header);
  
  int read_pos = -1, write_pos = -1;
  int key = KEY_CURRENT_INDEX;
  int number_of_entries_read = 0;
  if (persist_exists(key)){
    read_pos = persist_read_int(key);
    write_pos = read_pos; //save which was the write_pos from the worker
    while (1){
      
      read_pos++;
      if (read_pos > NUMBER_OF_ENTRIES) read_pos = 0;
      if (read_pos < 0) read_pos = NUMBER_OF_ENTRIES-1;
      
      key = KEY_EVENT_STRING_001+read_pos;
      if (persist_exists(key)){
        uint8_t byte_array[3];
        persist_read_data(key, byte_array, sizeof(byte_array));
        
        //read time stamp:
        key = KEY_EVENT_TIME_STAMP_001+read_pos;
        if (persist_exists(key)){
          time_stamp = (time_t)persist_read_int(key);
          struct tm* loctime = localtime(&time_stamp);
          strftime(time_str, sizeof(time_str), "%Y-%m-%d_%H:%M:%S:\n", loctime);
          number_of_entries_read++;
        } else {
          snprintf(time_str, sizeof(time_str), "no time stamp found:\n");
          time_stamp = 0;
        }
        switch (byte_array[0]){ //message
          case 1: 
          case 2:
          case 3:
            period_begin = time_stamp;
            strcpy(text_buffer, text);
            snprintf(text, sizeof(text), "%s%s", text_devider, text_buffer);
            break;
        }
        period_since_begin = time_stamp - period_begin;
        period_since_last_event = time_stamp - last_event;
        if (byte_array[0] > 0) last_event = time_stamp;
        
        print_time(time1_str, sizeof(time1_str), period_since_begin, 0);
        print_time(time2_str, sizeof(time2_str), period_since_last_event, 0);
        
        strcpy(text_buffer, text);
        snprintf(text, TEXT_LENGTH, "%s    %d: %d %% --> %d %%\n    %s [%s]\n%s", time_str, byte_array[0], byte_array[2], byte_array[1], time1_str, time2_str, text_buffer);
      }
      
      if (read_pos == write_pos) break;
      if (number_of_entries_read > NUMBER_OF_ENTRIES_TO_SHOW) break;
    }
    
    strcpy(text_buffer, text);
    snprintf(text, TEXT_LENGTH, "%s%s\n", text_header, text_buffer);
  } else {
    snprintf(text, TEXT_LENGTH, "%sNo data found.\n", text_header);
  }
  
  text_layer_set_size(text_layer, GSize(bounds.size.w, 2000));
  text_layer_set_text(text_layer, text); 
  GSize max_size = text_layer_get_content_size(text_layer);
  text_layer_set_size(text_layer, max_size);
  scroll_layer_set_content_size(scroll_layer, GSize(bounds.size.w, max_size.h + 4 + STATUS_HIGH));
}
Esempio n. 18
0
static void handle_battery(BatteryChargeState charge_state) {
  static char battery_text[] = "100% chrgd";

  switch (charge_state.charge_percent) {
    case 100:
      text_layer_set_size(s_battery_layer, GSize(144, 10));
      break;
    case 90:
      text_layer_set_size(s_battery_layer, GSize(130, 10));
      break;
    case 80:
      text_layer_set_size(s_battery_layer, GSize(116, 10));
      break;
    case 70:
      text_layer_set_size(s_battery_layer, GSize(102, 10));
      break;
    case 60:
      text_layer_set_size(s_battery_layer, GSize(88, 10));
      break;
    case 50:
      text_layer_set_size(s_battery_layer, GSize(72, 10));
      break;
    case 40:
      text_layer_set_size(s_battery_layer, GSize(58, 10));
      break;
    case 30:
      text_layer_set_size(s_battery_layer, GSize(44, 10));
      break;
    case 20:
      //text_layer_set_background_color(s_battery_layer, COLOR_FALLBACK(GColorRed, GColorWhite));
      text_layer_set_size(s_battery_layer, GSize(32, 10));
      break;
    case 10:
      text_layer_set_size(s_battery_layer, GSize(18, 10));
      break;
    case 0:
      text_layer_set_size(s_battery_layer, GSize(5, 10));
      break;
  }
  
  
  
  
  if (charge_state.charge_percent > 50)
    {
    text_layer_set_text_color(battery_text_layer, GColorBlack);
  }
  else if (charge_state.charge_percent <= 20)
    {
    text_layer_set_text_color(battery_text_layer, COLOR_FALLBACK(GColorRed, GColorWhite));
    text_layer_set_background_color(s_battery_layer, COLOR_FALLBACK(GColorRed, GColorWhite));
  }
  else {
    text_layer_set_text_color(battery_text_layer, COLOR_FALLBACK(GColorWhite, GColorWhite));
    text_layer_set_background_color(s_battery_layer, COLOR_FALLBACK(GColorYellow, GColorWhite));
  }
  if (charge_state.is_charging) {
    snprintf(battery_text, sizeof(battery_text),"%d%%chrg", charge_state.charge_percent);
  } else {
    snprintf(battery_text, sizeof(battery_text), "%d%%", charge_state.charge_percent);
  }
  text_layer_set_text(battery_text_layer, "");
}