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();
}
}
// handles setting time updates
void update_time(AppContextRef ctx, PblTm *current_time) {
char *time_format;
// set date
string_format_time(date_text, sizeof(date_text), "%b %d", current_time);
text_layer_set_text(&date_text_layer, date_text);
// check military time
if (clock_is_24h_style()) {
time_format = "%R";
} else {
time_format = "%I:%M";
}
// set time
string_format_time(time_text, sizeof(time_text), time_format, current_time);
text_layer_set_text(&time_text_layer, time_text);
}
static void tick_handler(struct tm *tick_time, TimeUnits units_changed) {
static char buff[] = "00:00:00:";
if (clock_is_24h_style()) {
strftime(buff, sizeof(buff), "%H:%M:%S", tick_time);
} else {
strftime(buff, sizeof(buff), "%I:%M:%S", tick_time);
}
text_layer_set_text(s_time_layer, buff);
// rotate path
layer_mark_dirty(window_get_root_layer(s_main_window));
}
static void update_time() {
time_t temp = time(NULL);
struct tm *tick_time = localtime(&temp);
static char buffer[] = "00:00";
srand( tick_time->tm_sec + tick_time->tm_min );
if(clock_is_24h_style() == true) {
strftime(buffer, sizeof("00:00"), "%H:%M", tick_time);
} else {
strftime(buffer, sizeof("00:00"), "%I:%M", tick_time);
}
text_layer_set_text(s_time_layer, buffer);
}
static void handle_minute_tick(struct tm *tick_time, TimeUnits units_changed) {
if(clock_is_24h_style()){
flip_layer_animate_to(layer_number[0], tick_time->tm_hour);
}
else {
flip_layer_animate_to(layer_number[0], tick_time->tm_hour % 12 == 0 ? 12 : tick_time->tm_hour % 12);
}
flip_layer_animate_to(layer_number[1], tick_time->tm_min);
snprintf(date_text, sizeof(date_text), "%s %d", MONTHS[getLanguage()][tick_time->tm_mon],tick_time->tm_mday);
layer_mark_dirty(text_layer_get_layer(text_date_layer));
if (units_changed & HOUR_UNIT && getHourly_vibration()) vibes_double_pulse();
}
static void time_handler(struct tm* tick_time, TimeUnits units_changed) {
static char time_text[] = "00:00"; // Needs to be static because it's used by the system later.
static char date_text[] = "Xxxxxxxxxxx Xxxxxxxxxx 00";
static char date_num[] = "00000000";
char *time_format;
strftime(date_text, sizeof(date_text), "%A, %b %e", tick_time);
text_layer_set_text(date_layer, date_text);
if(clock_is_24h_style()) {
time_format = "%R";
}
else {
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);
}
text_layer_set_text(time_layer, time_text);
battery_handler(battery_state_service_peek());
strftime(date_num, sizeof(date_num), "%Y%m%d", tick_time);
if(time(NULL) - start >= 300 || time(NULL) - start == 0) {
get_events_handler(date_num);
time(&start);
}
}
void update_display(PblTm *current_time) {
// Write the time (yawn)
static char timeText[] = "00:00 00";
char *timeFormat;
if (clock_is_24h_style()) {
timeFormat = " %R";
} else {
timeFormat = "%l:%M %p";
}
string_format_time(timeText, sizeof(timeText), timeFormat, current_time);
text_layer_set_text(&timeLayer, timeText);
// At 5pm, show the BEER O CLOCK graphic, and hide the actual time
bool showText = (current_time->tm_hour == 17) && (current_time->tm_min >= 0) && (current_time->tm_min <= 5);
layer_set_hidden(&imageBOC.layer.layer, !showText);
layer_set_hidden(&timeLayer.layer, showText);
// Calculate
int offset = beer_offset;
// Reset the beer before 9am
if (current_time->tm_hour < ANIMATION_START_TIME) {
offset = BEER_STARTING_Y;
// Animate the beer between 9-5
} else if ((current_time->tm_hour >= ANIMATION_START_TIME) && (current_time->tm_hour <= ANIMATION_END_TIME)) {
const int totalSeconds = (ANIMATION_END_TIME - ANIMATION_START_TIME) * 60 * 60;
int currentSeconds = ((current_time->tm_hour - ANIMATION_START_TIME) * 3600)
+ (current_time->tm_min * 60)
+ current_time->tm_sec;
offset = (int)((float)BEER_STARTING_Y - (((float)currentSeconds / (float)totalSeconds) * (float)BEER_STARTING_Y));
}
// Update the position of imageBeer if necessary
if (offset < 0) {
offset = 0;
}
if (offset != beer_offset) {
imageBeer.layer.layer.frame.origin.y = offset;
beer_offset = offset;
}
}
//Draws the hours and minutes
void handle_minute_tick(AppContextRef ctx, PebbleTickEvent *t) {
(void)ctx;
static char hours_text[] = " 00 00";
static char minutes_text[] = " 00 00";
char *minutes_format;
char *hours_format;
minutes_format = "MP %M/59";
if (clock_is_24h_style()) {
hours_format = "HP %H/23";
} else {
hours_format = "HP %I/12";
}
string_format_time(hours_text, sizeof(hours_text), hours_format, t->tick_time);
string_format_time(minutes_text, sizeof(minutes_text), minutes_format, t->tick_time);
if (t->tick_time->tm_hour>0&&t->tick_time->tm_hour<6&¤t_background!=2) {
//Moogle is asleep
set_background_image(&image_container,RESOURCE_ID_IMAGE_MOG_DEAD_WHITE);
current_background=2;
}
if (t->tick_time->tm_hour>6&&t->tick_time->tm_hour<9&¤t_background!=1) {
//Moogle is groggy
set_background_image(&image_container,RESOURCE_ID_IMAGE_MOG_HURT_WHITE);
current_background=1;
}
if (t->tick_time->tm_hour>9&&t->tick_time->tm_hour<21&¤t_background!=0) {
//Moogle is awake
set_background_image(&image_container,RESOURCE_ID_IMAGE_MOG_OK_WHITE);
current_background=0;
}
if (t->tick_time->tm_hour>21&&t->tick_time->tm_hour<24&¤t_background!=1) {
//Moogle is tired
set_background_image(&image_container,RESOURCE_ID_IMAGE_MOG_HURT_WHITE);
current_background=1;
}
text_layer_set_text(&text_hours_layer, hours_text);
text_layer_set_text(&text_minutes_layer, minutes_text);
}
static void update_time() {
time_t temp = time(NULL);
struct tm *tick_time = localtime(&temp);
static char time_buffer[] = "00:00";
if (clock_is_24h_style() == true) {
strftime(time_buffer, sizeof("00:00"), "%H:%M", tick_time);
} else {
strftime(time_buffer, sizeof("00:00"), "%I:%M", tick_time);
}
if (time_buffer[0] == '0') {
memmove(time_buffer, time_buffer + 1, strlen(time_buffer));
}
text_layer_set_text(time_layer, time_buffer);
static char seconds_buffer[8];
strftime(seconds_buffer, sizeof(seconds_buffer), "%S", tick_time);
text_layer_set_text(seconds_layer, seconds_buffer);
// setLocale is currently broken, so we format the date ourselves.
static char fw[2], weekday[3];
strftime(fw, sizeof(fw), "%w", tick_time);
if (strcmp("0", fw) == 0) {
strcpy(weekday, "So");
} else if (strcmp("1", fw) == 0) {
strcpy(weekday, "Mo");
} else if (strcmp("2", fw) == 0) {
strcpy(weekday, "Di");
} else if (strcmp("3", fw) == 0) {
strcpy(weekday, "Mi");
} else if (strcmp("4", fw) == 0) {
strcpy(weekday, "Do");
} else if (strcmp("5", fw) == 0) {
strcpy(weekday, "Fr");
} else if (strcmp("6", fw) == 0) {
strcpy(weekday, "Sa");
} else {
strcpy(weekday, "??");
}
static char day[11];
strftime(day, sizeof(day), "%d.%m.%y", tick_time);
static char date_buffer[16];
strcpy(date_buffer, weekday);
strcat(date_buffer, " ");
strcat(date_buffer, day);
text_layer_set_text(date_layer, date_buffer);
}
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
static char s_buffer[8];
strftime(s_buffer, sizeof(s_buffer), clock_is_24h_style() ? "%H%M" : "%I%M", tick_time);
// Display this time on screen
set_digit(topleft_image, s_buffer[0], true);
set_digit(topright_image, s_buffer[1], false);
set_digit(bottomleft_image, s_buffer[2], true);
set_digit(bottomright_image, s_buffer[3], false);
center();
}
/***Handle Time***/
static void update_time() {
//Get a tm structure
time_t temp = time(NULL);
struct tm *tick_time = localtime(&temp);
//Write current hours and minutes into a buffer
//Desired style: "Thu Mar 24 01:46"
static char time_text[] = "day mon dd hh:mm EST YYYY";
strftime(time_text, sizeof(time_text), clock_is_24h_style() ?
"%a %b %e %R" : "%a %b %e %I:%M", tick_time);
//Display time on the TextLayer
static char s_buffer[50];
snprintf(s_buffer, sizeof(s_buffer), "root@PC:/$ date\n%s",time_text);
text_layer_set_text(s_time_layer, s_buffer);
}
static void update_time(struct tm *tick_time) {
// 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 24 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);
}
// Display this time on the TextLayer
text_layer_set_text(s_time_layer, buffer);
}
// Invoke THIS function with time_manager
void string_time_update_proc() {
// Updates the string buffer_time, which should hopefully
// get updated with the right clock time...
time_t temp = time(NULL);
struct tm *tick_time = localtime(&temp);
buffer_time = "00:00";
if(clock_is_24h_style()) {
strftime(buffer_time, sizeof("00:00"), "%H:%M", tick_time);
} else {
strftime(buffer_time, sizeof("00:00"), "%I:%M", tick_time);
}
// This should have updated buffer_time.
// printf("Inside string_time it's %s", buffer_time);
}
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
static char s_buffer[8];
strftime(s_buffer, sizeof(s_buffer), clock_is_24h_style() ?
"%H:%M" : "%I:%M", tick_time);
// Display this time on the TextLayer
text_layer_set_text(s_time_layer, s_buffer);
// Copy date into buffer from tm structure
static char date_buffer[16];
strftime(date_buffer, sizeof(date_buffer), "%a, %b %d", tick_time);
// Show the date
text_layer_set_text(s_date_layer, date_buffer);
}
static void update_time () {
time_t temp = time(NULL);
struct tm *tick_time = localtime(&temp);
if(clock_is_24h_style() == true){
strftime(s_hour_buffer, sizeof(s_hour_buffer), "%H", tick_time);
} else {
strftime(s_hour_buffer, sizeof(s_hour_buffer), "%I", tick_time);
}
strftime(s_minute_buffer, sizeof(s_minute_buffer), "%M", tick_time);
strftime(date_buffer, sizeof(date_buffer),"%D", tick_time);
text_layer_set_text(date_layer, date_buffer);
text_layer_set_text(s_hour_layer, s_hour_buffer);
text_layer_set_text(s_minute_layer, s_minute_buffer);
}
static void handle_minute_tick(struct tm *tick_time, TimeUnits units_changed) {
time_t now = time(NULL);
struct tm *t = localtime(&now);
char *time_format;
if(clock_is_24h_style()) {
time_format = "%R";
} else {
time_format = "%I:%M";
}
strftime(timeText, sizeof(timeText), time_format, t);
text_layer_set_text(label_layer_time, timeText);
}
