C++ clock_is_24h_style函数代码示例

void handle_init(AppContextRef ctx) {

  window_init(&window, "Simple Chinese");
  window_stack_push(&window, true /* Animated */);
  window_set_background_color(&window, BACKGROUNDCOLOR);

  resource_init_current_app(&APP_RESOURCES);

  layer_init(&line_layer, window.layer.frame);
  line_layer.update_proc = &line_layer_update_callback;
  layer_add_child(&window.layer, &line_layer);

  DTL_init(&time_layer, &window.layer, time_GRECT, time_FONT, _time_upd, _time_upd_cri);

  DTL_init(&date_layer, &window.layer, date_GRECT, date_FONT, _date_upd, _date_upd_cri);
  
  if(!clock_is_24h_style())
  	DTL_init(&period_layer, &window.layer, period_GRECT, period_FONT, _period_upd, _period_upd_cri);

  #if INCLUDE_CCD
  DTL_init(&cdate_layer, &window.layer, cdate_GRECT, cdate_FONT, _cdate_upd, _cdate_upd_cri);
  #endif

  #if INCLUDE_SEC
  DTL_init(&sec_layer, &window.layer, sec_GRECT, sec_FONT, _sec_upd, _sec_upd_cri);
  #endif

  DTL_init(&weather_layer, &window.layer, weather_GRECT, weather_FONT, _weather_upd, _weather_upd_cri);
  DTL_set_alignment(&weather_layer, GTextAlignmentRight);

  #if DEBUG
  DTL_init(&debug_layer, &window.layer, debug_GRECT, debug_FONT, NULL, NULL);
  #endif

  DTL_init(&info_layer, &window.layer, info_GRECT, info_FONT, NULL, NULL);
  DTL_set_alignment(&info_layer, GTextAlignmentRight);

  srand(time(NULL));
  int32_t HTTP_APP_ID = RAND_MAX/2 - rand(); 
  
  http_set_app_id(HTTP_APP_ID);
  HTTPCallbacks httpcallbacks = {
    .success = handle_success,
    .failure = handle_failed,
    .location = handle_location,
    .reconnect = handle_reconnect
  };
  http_register_callbacks(httpcallbacks, ctx);

}

void update_time() {
  time_t temp = time(NULL); 
  struct tm *tick_time = localtime(&temp);
  
  static char buffer[] = "00:00";
  
  if(clock_is_24h_style() == true) {
    strftime(buffer, sizeof(buffer), "%H:%M", tick_time);
  } else {
    strftime(buffer, sizeof(buffer), "%I:%M", tick_time);
  }
  
  rounded_text_layer_set_text(time_layer, buffer);
}

/*
 * Display the time in the tersest format possible.
 */
static void update_time(struct tm *local_time) {

	static char buff[9];

	if(clock_is_24h_style() == true) {
		(void) strftime(buff, sizeof(buff), "%H:%M:%S", local_time);
	} else {
		(void) strftime(buff, sizeof(buff), "%I:%M:%S", local_time);
	}

	text_layer_set_text_color(s_time_layer, theme_primary);
	text_layer_set_text(s_time_layer, buff);

}

void set_time(){
	time_t temp = time(NULL);
	struct tm *tick_time = localtime(&temp);
	
	static char time_[8];
	strftime(time_, sizeof(time_), clock_is_24h_style() ? "%H%M" : "%I%M", tick_time);
	
	
	bitmap_layer_set_bitmap(hour1, getBitmapFromChar(time_[0]));
	bitmap_layer_set_bitmap(hour2, getBitmapFromChar(time_[1]));
	bitmap_layer_set_bitmap(min1, getBitmapFromChar(time_[2]));
	bitmap_layer_set_bitmap(min2, getBitmapFromChar(time_[3]));
	
}

static void update_time() {
  // Get a tm structure
  time_t temp = time(NULL);
  struct tm *tick_time = localtime(&temp);

  // Write the current hours and minutes into a buffer
  strftime(s_time_buffer, sizeof(s_time_buffer), clock_is_24h_style() ? "%H:%M" : "%I:%M", tick_time);
//  strncpy(s_buffer, "23:59", 8);
  // Display this time on the TextLayer
  text_layer_set_text(s_time_layer, s_time_buffer);
  
  strftime(s_date_buffer, sizeof(s_date_buffer),"%a %d", tick_time);
  text_layer_set_text(s_date_layer, s_date_buffer);
}

static void handle_minute_tick(struct tm *tick_time, TimeUnits units_changed) {
  // Need to be static because they're used by the system later.
  static char s_time_text[] = "12:00";
  static char s_date_text[] = "25/12";

	// Date is currently updated every minute, should be changed later.
  strftime(s_date_text, sizeof(s_date_text), "%e/%m", tick_time);
  text_layer_set_text(s_date_layer, s_date_text);

  char *time_format;
  if (clock_is_24h_style()) {
    time_format = "%R";
  } else {
    time_format = "%I:%M";
  }
  strftime(s_time_text, sizeof(s_time_text), time_format, tick_time);

  // Handle lack of non-padded hour format string for twelve hour clock.
  if (!clock_is_24h_style() && (s_time_text[0] == '0')) {
    memmove(s_time_text, &s_time_text[1], sizeof(s_time_text) - 1);
  }
  text_layer_set_text(s_time_layer, s_time_text);
}

void update_time(struct tm *tick_time) {
	// Write the current hours and minutes into the buffer
	if (clock_is_24h_style()) {
		strftime(buffer_layer_time, sizeof("00:00"), "%H:%M", tick_time);
	} else {
		strftime(buffer_layer_time, sizeof("00:00"), "%I:%M", tick_time);
	}
	
	// Display this time on the TextLayer
	text_layer_set_text(s_layer_time, buffer_layer_time);
	
	// Force ring to refresh
	layer_mark_dirty(layer_ring);
}

static void update_time() {
  time_t temp = time(NULL); 
  struct tm *tick_time = localtime(&temp);
 
  static char buffer[] = "00:00";

  if (clock_is_24h_style() == twenty_four_hour_format) {
    strftime(buffer, sizeof("00:00"), "20:19", tick_time);
  } else {
    strftime(buffer, sizeof("00:00"), "08:19", tick_time);
  }
 
  text_layer_set_text(s_text_layer, buffer);
}

static void tick_handler(struct tm *tick_time, TimeUnits units_changed) {
    s_time.hours = tick_time->tm_hour;
    if(!clock_is_24h_style()) {
	    s_time.hours -= (s_time.hours > 12) ? 12 : 0;
	    if(s_time.hours == 0) {
	        s_time.hours = 12;
	    }
    }
    s_time.minutes = tick_time->tm_min;
    // if(s_show_seconds){
        s_time.seconds = tick_time->tm_sec;
    // }
    update_positions();
}

void ClockArea_update_time(struct tm* time_info) {

  // hours
  if (clock_is_24h_style()) {
    strftime(time_hours, sizeof(time_hours), (globalSettings.showLeadingZero) ? "%H" : "%k", time_info);
  } else {
    strftime(time_hours, sizeof(time_hours), (globalSettings.showLeadingZero) ? "%I" : "%l", time_info);
  }

  // minutes
  strftime(time_minutes, sizeof(time_minutes), "%M", time_info);

  ClockArea_redraw();
}

static void update_time(struct tm *tick_time, bool first_update) {
  int hour = tick_time->tm_hour;
  int minute = tick_time->tm_min;

  APP_LOG(APP_LOG_LEVEL_DEBUG, "update_time(%d:%d)", (int)hour, (int)minute);
  APP_LOG(APP_LOG_LEVEL_DEBUG, "MEMORY USAGE = %d bytes", (int)heap_bytes_used());

  int formatted_hour = clock_is_24h_style() ? hour : hour % 12;

  update_layer_digit(layout.hour_tens, formatted_hour / 10, first_update);
  update_layer_digit(layout.hour_ones, formatted_hour % 10, first_update);
  update_layer_digit(layout.minute_tens, minute / 10, first_update);
  update_layer_digit(layout.minute_ones, minute % 10, first_update);
}

void handle_tick(struct tm *tick_time, TimeUnits units_changed) {
  char time_format[] = "%I:%M";

  strftime(seconds_text, sizeof(seconds_text), "%S", tick_time);

  if (clock_is_24h_style()) {
    strcpy(time_format,"%R");
  } else {
    strcpy(time_format,"%I:%M");
  }

  strftime(time_text, sizeof(time_text), time_format, tick_time);

  // Kludge to handle lack of non-padded hour format string
  // for twelve hour clock.
  if (!clock_is_24h_style() && (time_text[0] == '0')) {
    memmove(time_text, &time_text[1], sizeof(time_text) - 1);
  }
  
  if((strcmp(seconds_text,"00") == 0) || (FirstTime == 0)) {
     strftime(dayname_text, sizeof(dayname_text), "%A", tick_time);
     strftime(date_text,    sizeof(date_text), date_format, tick_time);

     text_layer_set_text(text_dayname_layer, dayname_text);
     text_layer_set_text(text_date_layer, date_text);
  }
     if (units_changed & DAY_UNIT) {
        // Only update the day name & date when it's changed.
        text_layer_set_text(text_dayname_layer, dayname_text);
        text_layer_set_text(text_date_layer, date_text);
     }
  
      if((strcmp(seconds_text,"00") == 0) || (FirstTime == 0)) {
         text_layer_set_text(text_time_layer, time_text); 
       }
     FirstTime = 1; 
}

void handle_second_tick(struct tm *tick_time, TimeUnits units_changed) {
	static char time_text[] = "00:00";
	
	if (clock_is_24h_style()) {
		strftime(time_text, sizeof(time_text), "%H:%M", tick_time);
	} else {
		strftime(time_text, sizeof(time_text), "%I:%M", tick_time);
	}
	text_layer_set_text(text_time_layer, time_text);
	
	unsigned int unix_time = time(NULL);
    unix_time = unix_time + ((-current_timezone_offset)*3600); // Adjust to current time zone
	
	int days;
	int hours;
	int minutes;
    int seconds;
    
    static char countdownString[] = "XXX : XX : XX : XX";
    
	
    int timeRemaining = COUNTDOWN - (int)unix_time;
	days = (timeRemaining/86400);
	hours = (timeRemaining/3600) - days*24;
	minutes = (timeRemaining/60) - days*1440 - hours*60;
	seconds = (timeRemaining) - days*86400 - hours*3600 - minutes*60;
    
    if (days <= 0 && hours <= 0 && minutes <= 0) {
        snprintf(countdownString, sizeof(countdownString), "%d", seconds);
    } else if (days <= 0 && hours <= 0) {
        snprintf(countdownString, sizeof(countdownString), "%d %d", minutes, seconds);
    } else if (days <= 0) {
        snprintf(countdownString, sizeof(countdownString), "%d %d %d", hours, minutes, seconds);
    } else {
        snprintf(countdownString, sizeof(countdownString), "%d %d %d %d", days, hours, minutes, seconds);
    }

    // Guess this feature *__*
    if (days <= 0 && hours <= 0 && minutes <= 0 && seconds <= 0) {
        /*
        layer_set_hidden(bitmap_layer_get_layer(logo_image_layer), true);
        layer_set_hidden(bitmap_layer_get_layer(text_image_layer), true);
        layer_set_hidden(bitmap_layer_get_layer(tim_cook_image_layer), false);
        tim_cook_visible = true;*/
        snprintf(countdownString, sizeof(countdownString), "Have fun!");
    }

    text_layer_set_text(text_countdown_layer, countdownString);
}

static void tick_handler(struct tm *tick_time, TimeUnits units_changed) 
{
    if (units_changed & MINUTE_UNIT)
    {
        // Create a long-lived buffer
        static char buffer[] = "00:00";

        // Write the current hours and minutes into the buffer
        if(clock_is_24h_style() == true)    //Use 24h hour format
        {
            strftime(buffer, sizeof("00:00"), "%H:%M", tick_time);
        } 
        else     //Use 12 hour format
        {
            strftime(buffer, sizeof("00:00"), "%I:%M", tick_time);
            if (buffer[0] == '0')
            {
                buffer [0] = buffer[1];
                buffer [1] = buffer[2];
                buffer [2] = buffer[3];
                buffer [3] = buffer[4];
                buffer [4] = '\0';
            }
        }
        
        // Display this time on the TextLayer
        text_layer_set_text(s_time_layer, buffer);
    }
    
    if (units_changed & DAY_UNIT)
    {
        static char dateBuffer[] = "MM/DD/YY";
        strftime(dateBuffer, sizeof(dateBuffer), "%D", tick_time);
        
        static char dayOfWeekBuffer[] = "Sun";
        strftime(dayOfWeekBuffer, sizeof(dayOfWeekBuffer),"%a",tick_time);
        
        // this selects day of month so lyrics will be the same for a full day
        static char dayOfYearBuffer[] = "000";
        strftime(dayOfYearBuffer,sizeof(dayOfYearBuffer),"%j",tick_time);
        dayOfYear = atoi(dayOfYearBuffer);
    
        // Display this date on the TextLayer
        text_layer_set_text(s_date_layer, dateBuffer);
        text_layer_set_text(s_dayOfWeek_layer, dayOfWeekBuffer);
        
        chooseLyrics(s_lyrics_layer, dayOfYear);
    }
}

/* Called by the OS once per minute. Update the time and date.
*/
void handle_minute_tick(AppContextRef ctx, PebbleTickEvent *t)
{
    /* Need to be static because pointers to them are stored in the text
    * layers.
    */
    static char date_text[] = "XXX, XXX 00";
    static char hour_text[] = "00";
    static char minute_text[] = ":00";

    (void)ctx;  /* prevent "unused parameter" warning */

    if (t->units_changed & DAY_UNIT)
    {
        string_format_time(date_text,
                           sizeof(date_text),
                           "%a, %b %d",
                           t->tick_time);
        text_layer_set_text(&date_layer, date_text);
    }

    if (clock_is_24h_style())
    {
        string_format_time(hour_text, sizeof(hour_text), "%H", t->tick_time);
    }
    else
    {
        string_format_time(hour_text, sizeof(hour_text), "%I", t->tick_time);
        if (hour_text[0] == '0')
        {
            /* This is a hack to get rid of the leading zero.
            */
            memmove(&hour_text[0], &hour_text[1], sizeof(hour_text) - 1);
        }
    }

    string_format_time(minute_text, sizeof(minute_text), ":%M", t->tick_time);
    time_layer_set_text(&time_layer, hour_text, minute_text);
	
	if(!located || !(t->tick_time->tm_min % 15))
	{
		//Every 15 minutes, request updated weather
		http_location_request();
	}
	else
	{
		//Every minute, ping the phone
		link_monitor_ping();
	}
}