// // ticks every minute, updating the time and date. // void handle_minute_tick(AppContextRef ctx, PebbleTickEvent *t) { // // this seems pointless. // Glenn: Left this in because I don't know what it does. // (void)ctx; PblTm *tickTime = t->tick_time; // // set the date - only changing it when the day changes // format strings here: http://www.gnu.org/software/emacs/manual/html_node/elisp/Time-Parsing.html // static char dateText[] = "Sun 01 September 00"; static int lastShownDate = -1; int theDay = tickTime->tm_yday; if (theDay != lastShownDate) { lastShownDate = theDay; string_format_time(dateText, sizeof(dateText), "%a %B %e", tickTime ); text_layer_set_text(&_currentDate, dateText); } // // set the time // static char timeText[] = "00:00"; const char *timeFormat = clock_is_24h_style() ? "%R" : "%l:%M"; string_format_time(timeText, sizeof(timeText), timeFormat, tickTime); text_layer_set_text(&_currentTime, timeText); }
void update_rings() { PblTm t; get_time(&t); int hourAngle = ((t.tm_hour % 12) * 30) + (t.tm_min / 2); int minAngle = t.tm_min * 6; static char hour_str[] = "00"; static char minute_str[] = "00"; char *hour_format; if (clock_is_24h_style()) { hour_format = "%k"; } else { hour_format = "%l"; } string_format_time(hour_str, sizeof(hour_str), hour_format, &t); string_format_time(minute_str, sizeof(minute_str), "%M", &t); set_hand_text(&hourText, hourAngle, hour_str, GPoint(0,-55), GSize(26,26)); set_hand_text(&minuteText, minAngle, minute_str, GPoint(0,-24), GSize(18,18)); set_hand_angle(&hourImage, hourAngle, GPoint(0, -55)); set_hand_angle(&minuteImage, minAngle, GPoint(0, -24)); }
void update_display(PblTm *tick_time) { static char date_text[] = "Xxxxxxxxx, Xxxxxxxxx 00"; static char new_date_text[] = "Xxxxxxxxx, Xxxxxxxxx 00"; static char time_text[] = "00:00 "; char *time_format; // Date layer string_format_time(new_date_text, sizeof(date_text), "%A, %B %d", tick_time); if (strncmp(new_date_text, date_text, sizeof(date_text)) != 0) { strncpy(date_text, new_date_text, sizeof(date_text)); text_layer_set_text(&text_date_layer, date_text); } // Time layer if (clock_is_24h_style()) { time_format = "%R"; } else { time_format = "%I:%M %p"; } string_format_time(time_text, sizeof(time_text), time_format, tick_time); if (!clock_is_24h_style() && (time_text[0] == '0')) { memmove(time_text, &time_text[1], sizeof(time_text) - 1); } text_layer_set_text(&text_time_layer, time_text); }
void handle_minute_tick(AppContextRef ctx, PebbleTickEvent *t) { // Need to be static because they're used by the system later. static char time_text[] = "00:00"; static char date_text[] = "Xxxxxxxxx 00"; char *time_format; // TODO: Only update the date when it's changed. string_format_time(date_text, sizeof(date_text), "%B %e", t->tick_time); text_layer_set_text(&text_date_layer, date_text); if (clock_is_24h_style()) { time_format = "%R"; } else { time_format = "%I:%M"; } string_format_time(time_text, sizeof(time_text), time_format, t->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(&text_time_layer, time_text); }
void update_time() { PblTm time; get_time(&time); string_format_time(string_time, sizeof(string_time), format_time, &time); string_format_time(string_date, sizeof(string_date), format_date, &time); }
void updateDayAndNightInfo(bool update_everything) { static char sunrise_text[] = "00:00"; static char sunset_text[] = "00:00"; PblTm pblTime; get_time(&pblTime); if(update_everything || currentData != pblTime.tm_hour) { char *time_format; if (clock_is_24h_style()) { time_format = "%R"; } else { time_format = "%I:%M"; } float sunriseTime = calcSunRise(pblTime.tm_year, pblTime.tm_mon+1, pblTime.tm_mday, realLatitude, realLongitude, 91.0f); float sunsetTime = calcSunSet(pblTime.tm_year, pblTime.tm_mon+1, pblTime.tm_mday, realLatitude, realLongitude, 91.0f); adjustTimezone(&sunriseTime); adjustTimezone(&sunsetTime); if (!pblTime.tm_isdst) { sunriseTime+=1; sunsetTime+=1; } pblTime.tm_min = (int)(60*(sunriseTime-((int)(sunriseTime)))); pblTime.tm_hour = (int)sunriseTime; string_format_time(sunrise_text, sizeof(sunrise_text), time_format, &pblTime); text_layer_set_text(&text_sunrise_layer, sunrise_text); pblTime.tm_min = (int)(60*(sunsetTime-((int)(sunsetTime)))); pblTime.tm_hour = (int)sunsetTime; string_format_time(sunset_text, sizeof(sunset_text), time_format, &pblTime); text_layer_set_text(&text_sunset_layer, sunset_text); text_layer_set_text_alignment(&text_sunset_layer, GTextAlignmentRight); sunriseTime+=12.0f; sun_path_info.points[1].x = (int16_t)(my_sin(sunriseTime/24 * M_PI * 2) * 120); sun_path_info.points[1].y = -(int16_t)(my_cos(sunriseTime/24 * M_PI * 2) * 120); sunsetTime+=12.0f; sun_path_info.points[4].x = (int16_t)(my_sin(sunsetTime/24 * M_PI * 2) * 120); sun_path_info.points[4].y = -(int16_t)(my_cos(sunsetTime/24 * M_PI * 2) * 120); currentData = pblTime.tm_hour; //Update location unless being called from location update if (!update_everything) { http_time_request(); } } }
void arrivals_success(int32_t cookie, int http_status, DictionaryIterator* received, void* context) { Tuple *t = dict_find(received, 1); char *v = t->value->cstring; uint16_t index = 0; uint16_t len = t->length; arrivalsCount = 0; int16_t time = 0; MenuIndex top = { 0, 0 }; PblTm now; get_time(&now); if (clock_is_24h_style()) { string_format_time(arrival_time_str, sizeof(arrival_time_str), "Updated: %H:%M", &now); } else { string_format_time(arrival_time_str, sizeof(arrival_time_str), "Updated: %l:%M %p", &now); } for(unsigned char i=0;i<MAX_ARRIVALS && index < len;i++) { //stokenize(char *source, uint16_t index, char delimiter, char *target, uint16_t max_length) index = stokenize(v, index, ':', ARRIVALS[i].route, ARRIVAL_ROUTE_LENGTH, len); index = stokenize(v, index, ':', ARRIVALS[i].actual, sizeof(ARRIVALS[i].actual), len); index = stokenize(v, index, ':', ARRIVALS[i].scheduled, sizeof(ARRIVALS[i].scheduled), len); //TODO: DRY time = satoi(ARRIVALS[i].actual, strlen(ARRIVALS[i].actual)); if(abs(time) > 99*60 + 59) //Maximum displayable value. time = (99*60 + 59) * (time < 0 ? -1 : 1); if(time > 60 || time < -60) { snprintf(ARRIVALS[i].actual, ARRIVAL_TIME_LENGTH, "%d:%02d", time / 60, abs(time % 60)); } else { snprintf(ARRIVALS[i].actual, ARRIVAL_TIME_LENGTH, "%d", time % 60); } time = satoi(ARRIVALS[i].scheduled, strlen(ARRIVALS[i].scheduled)); if(abs(time) > 99*60 + 59) //Maximum displayable value. time = (99*60 + 59) * (time < 0 ? -1 : 1); if(time > 60 || time < -60) { snprintf(ARRIVALS[i].scheduled, ARRIVAL_TIME_LENGTH, "%d:%02d", time / 60, abs(time % 60)); } else { snprintf(ARRIVALS[i].scheduled, ARRIVAL_TIME_LENGTH, "%d", time % 60); } APP_LOG(APP_LOG_LEVEL_INFO, "Received route:%s actual:%s scheduled:%s (index:%d/%d)", ARRIVALS[i].route, ARRIVALS[i].actual, ARRIVALS[i].scheduled, index, len); ++arrivalsCount; } menu_layer_reload_data(&_arrivalsMenu); menu_layer_set_selected_index(&_arrivalsMenu, top, MenuRowAlignBottom, false); }
static void hand_layer_update( Layer * const me, GContext * ctx ) { ( void ) me; // Draw the hour hand outline in black and filled with white int hour_angle = ( ( now.tm_hour * 60 + now.tm_min ) * TRIG_MAX_ANGLE ) / ( 60 * 24 ); gpath_rotate_to(&hour_path, hour_angle); graphics_context_set_fill_color(ctx, GColorWhite); gpath_draw_filled(ctx, &hour_path); graphics_context_set_stroke_color(ctx, GColorBlack); gpath_draw_outline(ctx, &hour_path); // Draw the minute hand outline in black and filled with white int minute_angle = ( now.tm_min * TRIG_MAX_ANGLE ) / 60; gpath_rotate_to(&minute_path, minute_angle); graphics_context_set_fill_color(ctx, GColorWhite); gpath_draw_filled(ctx, &minute_path); graphics_context_set_stroke_color(ctx, GColorBlack); gpath_draw_outline(ctx, &minute_path); // Draw the second hand outline in black and filled with white int second_angle = ( now.tm_sec * TRIG_MAX_ANGLE ) / 60; gpath_rotate_to( &second_path, second_angle ); graphics_context_set_fill_color( ctx, GColorWhite ); gpath_draw_filled( ctx, &second_path ); graphics_context_set_stroke_color( ctx, GColorBlack ); gpath_draw_outline(ctx, &second_path); // Black circle over the hands. Looks nice. graphics_context_set_fill_color( ctx, GColorBlack ); graphics_fill_circle( ctx, GPoint( W / 2, H / 2 ), 30); // Put some date info in the center space. graphics_context_set_text_color( ctx, GColorWhite ); string_format_time( buffer, sizeof( buffer ), "%a", &now ); graphics_text_draw( ctx, buffer, font_date, GRect( W / 2 - 30, H / 2 - 30, 60, 24 ), GTextOverflowModeTrailingEllipsis, GTextAlignmentCenter, NULL ); string_format_time( buffer, sizeof( buffer ), "%m/%d", &now ); graphics_text_draw( ctx, buffer, font_date, GRect( W / 2 - 30 , H / 2 - 8, 60, 24 ), GTextOverflowModeTrailingEllipsis, GTextAlignmentCenter, NULL ); }
void handle_minute_tick(AppContextRef ctx, PebbleTickEvent *t) { (void)t; (void)ctx; // Need to be static because they're used by the system later. static char time_text[] = "00:00"; static char dom_text[] = "00"; string_format_time(dom_text, sizeof(dom_text), "%e", t->tick_time); static char dow_text[] = "xxx"; string_format_time(dow_text, sizeof(dow_text), "%a", t->tick_time); static char yon_text[] = "00"; string_format_time(yon_text, sizeof(yon_text), "%y", t->tick_time); static char mon_text[] = "xxx"; string_format_time(mon_text, sizeof(mon_text), "%b", t->tick_time); char *time_format; if (clock_is_24h_style()) { time_format = "%R"; } else { time_format = "%I:%M"; } string_format_time(time_text, sizeof(time_text), time_format, t->tick_time); if (!clock_is_24h_style() && (time_text[0] == '0')) { memmove(time_text, &time_text[1], sizeof(time_text) - 1); } text_layer_set_text(&dow_layer, dow_text); text_layer_set_text(&dom_layer, dom_text); text_layer_set_text(&yon_layer, yon_text); text_layer_set_text(&mon_layer, mon_text); text_layer_set_text(&text_time_layer, time_text); text_layer_set_text_alignment(&text_time_layer, GTextAlignmentCenter); rotbmp_pair_layer_set_angle(&bitmap_container.layer, TRIG_MAX_ANGLE * get24HourAngle(t->tick_time->tm_hour, t->tick_time->tm_min)); bitmap_container.layer.layer.frame.origin.x = (144/2) - (bitmap_container.layer.layer.frame.size.w/2); bitmap_container.layer.layer.frame.origin.y = (168/2) - (bitmap_container.layer.layer.frame.size.h/2); // Vibrate Every Hour #if HOUR_VIBRATION if ((t->tick_time->tm_min==0) && (t->tick_time->tm_sec==0)) { vibes_enqueue_custom_pattern(hour_pattern); } #endif updateDayAndNightInfo(false); }
void updateDayAndNightInfo() { static char sunrise_text[] = "00:00"; static char sunset_text[] = "00:00"; PblTm pblTime; get_time(&pblTime); if(currentData != pblTime.tm_hour) { moonphase_text[0] = 'a' + 26.0f * moon_phase(1900 + pblTime.tm_year, 1 + pblTime.tm_mon, pblTime.tm_mday); char *time_format; if (clock_is_24h_style()) { time_format = "%R"; } else { time_format = "%I:%M"; } float sunriseTime = calcSunRise(pblTime.tm_year, pblTime.tm_mon+1, pblTime.tm_mday, LATITUDE, LONGITUDE, 91.0f); float sunsetTime = calcSunSet(pblTime.tm_year, pblTime.tm_mon+1, pblTime.tm_mday, LATITUDE, LONGITUDE, 91.0f); adjustTimezone(&sunriseTime); adjustTimezone(&sunsetTime); if (!pblTime.tm_isdst) { sunriseTime+=1; sunsetTime+=1; } pblTime.tm_min = (int)(60*(sunriseTime-((int)(sunriseTime)))); pblTime.tm_hour = (int)sunriseTime; string_format_time(sunrise_text, sizeof(sunrise_text), time_format, &pblTime); text_layer_set_text(&text_sunrise_layer, sunrise_text); pblTime.tm_min = (int)(60*(sunsetTime-((int)(sunsetTime)))); pblTime.tm_hour = (int)sunsetTime; string_format_time(sunset_text, sizeof(sunset_text), time_format, &pblTime); text_layer_set_text(&text_sunset_layer, sunset_text); text_layer_set_text_alignment(&text_sunset_layer, GTextAlignmentRight); sunriseTime+=12.0f; sun_path_info.points[1].x = (int16_t)(my_sin(sunriseTime/24 * M_PI * 2) * 120); sun_path_info.points[1].y = -(int16_t)(my_cos(sunriseTime/24 * M_PI * 2) * 120); sunsetTime+=12.0f; sun_path_info.points[4].x = (int16_t)(my_sin(sunsetTime/24 * M_PI * 2) * 120); sun_path_info.points[4].y = -(int16_t)(my_cos(sunsetTime/24 * M_PI * 2) * 120); currentData = pblTime.tm_hour; } }
void update_time_text(PblTm *current_time) { static char time_text[] = "00:00"; if(clock_is_24h_style()) string_format_time(time_text, sizeof(time_text), "%R", current_time); else string_format_time(time_text, sizeof(time_text), "%I:%M", current_time); text_layer_set_text(&time_layer, time_text); display_time.tm_min = current_time->tm_min; }
void handle_tick(AppContextRef ctx, PebbleTickEvent *t) { (void)ctx; // If we were passed an event, then we should already have the current // time. If not, then we're probably being called from handle_init, so // we need to get it. if(t) pebble_time = *t->tick_time; else get_time(&pebble_time); // If digital readout is on, then print the time: if(digital_time) { // Format the time with the chosed time format string_format_time(time_text, sizeof(time_text), time_format, &pebble_time); // Replace the leading zero with blank if we're in 12h mode. if ((!is_24h) && (time_text[0] == '0')) { time_text[0] = ' '; } // And set it for display. This should automatically mark the // layer as dirty. text_layer_set_text(&time_layer, time_text); } // If we're displaying the date (ie. !big), update the date string // every hour, and also on initialisation. if(!big) { if(!t || (pebble_time.tm_sec == 0 && pebble_time.tm_min == 0)) { string_format_time(date_text, sizeof(date_text), "%a %e %b", &pebble_time); text_layer_set_text(&date_layer, date_text); } } // If we're displaying a second-hand, then mark the second-hand layer // as dirty for redrawing. if(seconds) { layer_mark_dirty(&sechand_layer); } // Update the hour/minute hands, if: // // a) !t, in which case, we're being called from handle_init, so // need to do the initial update; // // b) Current seconds = 0 (ie. we're on the minute); or // // c) Display of seconds is not enabled, which implies this event // handler is running every minute anyway. if (!seconds || (pebble_time.tm_sec == 0)) { layer_mark_dirty(&hmhands_layer); } }
void update_date_text(PblTm *current_time) { static char date_text[] = "Xxxxxxxxx 00"; if(current_time->tm_wday == 3) // "Wednesday" doesn't fit on the screen so just show "Wed" string_format_time(date_text, sizeof(date_text), "%a %e", current_time); else string_format_time(date_text, sizeof(date_text), "%A %e", current_time); text_layer_set_text(&date_layer, date_text); display_time.tm_mday = current_time->tm_mday; }
void handle_second_tick(AppContextRef ctx, PebbleTickEvent *t) { (void)ctx; layer_mark_dirty(&second_display_layer); layer_mark_dirty(&minute_display_layer); layer_mark_dirty(&hour_display_layer); #if SHOW_DAY_ARC layer_mark_dirty(&day_display_layer); #endif #if SHOW_MONTH_ARC layer_mark_dirty(&month_display_layer); #endif #if SHOW_TEXT_TIME // Need to be static because it's used by the system later. static char time_text[] = "00:00"; char *time_format; if (clock_is_24h_style()) { time_format = "%R"; } else { time_format = "%I:%M"; } string_format_time(time_text, sizeof(time_text), time_format, t->tick_time); text_layer_set_text(&text_time_layer, time_text); #endif #if SHOW_TEXT_DATE /* #if ROW_DATE static char date_text[] = "00 Xxx"; string_format_time(date_text, sizeof(date_text), "%e %b", t->tick_time); #else static char date_text[] = "Xxx 00"; string_format_time(date_text, sizeof(date_text), "%b %e", t->tick_time); #endif */ static char date_text[] = "00"; string_format_time(date_text, sizeof(date_text), "%e", t->tick_time); text_layer_set_text(&text_date_layer, date_text); #endif }
/* 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 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 %d", t->tick_time); if (date_text[4] == '0') /* is day of month < 10? */ { /* This is a hack to get rid of the leading zero of the day of month */ memmove(&date_text[4], &date_text[5], sizeof(date_text) - 1); } 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); if (hour_text[0] == '0') { /* This is a hack to get rid of the leading zero of the hour. */ memmove(&hour_text[0], &hour_text[1], sizeof(hour_text) - 1); } } 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 of the hour. */ 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); }
// -------------------------------------------------------- // date_update_proc() // // callback handler supplied to system during init // -------------------------------------------------------- void date_update_proc(Layer* me, GContext* ctx) { PblTm t; get_time(&t); string_format_time(s_data.day_buffer, sizeof(s_data.day_buffer), "%a", &t); text_layer_set_text(&s_data.day_label, s_data.day_buffer); string_format_time(s_data.num_buffer, sizeof(s_data.num_buffer), "%d", &t); text_layer_set_text(&s_data.num_label, s_data.num_buffer); } // date_update_proc()
void update_display_month(PblTm *tick_time) { // Month or Weekday static char month_text[] = "AAA"; #if (WEEKDAY_US_MM_DD || WEEKDAY_NON_US_DD_MM) // Show Weekday (3 letter abbrev) string_format_time(month_text, sizeof(month_text), "%a", tick_time); #else // Show Month (3 letter abbrev) string_format_time(month_text, sizeof(month_text), "%b", tick_time); #endif text_layer_set_text(&month, month_text); }
void update_display( PblTm* current_time ) { static char time_text[] = "HH:MM"; static char date_text[] = "AAAAAAAAA\nbbb dd, YYYY"; static char iso_text[] = "YYYY-mm-dd\nYYYY-WVV-u\nYYYY-jjj"; string_format_time( time_text, sizeof time_text, "%H:%M", current_time ); string_format_time( date_text, sizeof date_text, "%A\n%b %d, %Y", current_time ); string_format_time( iso_text, sizeof iso_text, "%Y-%m-%d\n%Y-W%V-%u\n%Y-%j", current_time ); text_layer_set_text( &text_time_layer, time_text ); text_layer_set_text( &text_date_layer, date_text ); text_layer_set_text( &text_iso_layer, iso_text ); }
/* 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); }
//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); }
void handle_tick(AppContextRef app_ctx, PebbleTickEvent *event) { float fracthour = event->tick_time->tm_hour + (event->tick_time->tm_min * 1.0 / 60) + (event->tick_time->tm_sec * 1.0 / 3600) - 1; double jc = julian_century(event->tick_time->tm_year + 1900, event->tick_time->tm_mon+1, event->tick_time->tm_mday, fracthour); /* h_m_chelek_string(jc, hour_count_start, hour_count_end, s_time_str_buffer);*/ string_format_time(s_time_str_buffer, 32, "%I:%M:%S %p", event->tick_time); text_layer_set_text(&normaltime, s_time_str_buffer); }
void draw_date(){ PblTm t; get_time(&t); string_format_time(date_text, sizeof(date_text), "%d", &t); text_layer_set_text(&date_layer, date_text); }
void handle_minute_tick(AppContextRef ctx, PebbleTickEvent *t) { (void)ctx; // Need to be static because they're used by the system later. static char time_text[] = "00:00"; char *time_format; if (clock_is_24h_style()) { time_format = "%R"; } else { time_format = "%I:%M"; } string_format_time(time_text, sizeof(time_text), time_format, t->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(&text_time_layer, time_text); layer_mark_dirty(&text_time_layer.layer); }
void update_time_display() { static char timeText[] = "00:00"; char *timeFormat; PblTm currentTime; GContext* ctx = app_get_current_graphics_context(); #ifdef INVERT_COLORS graphics_context_set_compositing_mode(ctx, GCompOpAssignInverted); #endif if (clock_is_24h_style()) { timeFormat = "%R"; } else { timeFormat = "%I:%M"; } get_time(¤tTime); string_format_time(timeText, sizeof(timeText), timeFormat, ¤tTime); // Kludge to handle lack of non-padded hour format string // for twelve hour clock. if (!clock_is_24h_style() && (timeText[0] == '0')) { memmove(timeText, &timeText[1], sizeof(timeText) - 1); } text_layer_set_text(&timeLayer, timeText); }
void update_watch(PblTm* t) { static char date_text[] = "XXXXXXXX, XXX 00"; //rotbmp_pair_layer_set_angle(&hour_hand_image_container.layer, ((t->tm_hour % 12) * 30) + (t->tm_min/2)); hour_hand_image_container.layer.white_layer.rotation = TRIG_MAX_ANGLE * (((t->tm_hour % 12) * 30) + (t->tm_min/2)) / 360; hour_hand_image_container.layer.black_layer.rotation = TRIG_MAX_ANGLE * (((t->tm_hour % 12) * 30) + (t->tm_min/2)) / 360; hour_hand_image_container.layer.layer.frame.origin.x = (144/2) - (hour_hand_image_container.layer.layer.frame.size.w/2); hour_hand_image_container.layer.layer.frame.origin.y = (168/2) - (hour_hand_image_container.layer.layer.frame.size.h/2); layer_mark_dirty(&hour_hand_image_container.layer.layer); //rotbmp_pair_layer_set_angle(&minute_hand_image_container.layer, t->tm_min * 6); minute_hand_image_container.layer.white_layer.rotation = TRIG_MAX_ANGLE * (t->tm_min * 6) / 360; minute_hand_image_container.layer.black_layer.rotation = TRIG_MAX_ANGLE * (t->tm_min * 6) / 360; minute_hand_image_container.layer.layer.frame.origin.x = (144/2) - (minute_hand_image_container.layer.layer.frame.size.w/2); minute_hand_image_container.layer.layer.frame.origin.y = (168/2) - (minute_hand_image_container.layer.layer.frame.size.h/2); layer_mark_dirty(&minute_hand_image_container.layer.layer); //Set Date text if (t->tm_wday != last_wday) { string_format_time(date_text, sizeof(date_text), "%A, %b %e", t); text_layer_set_text(&text_date_layer, date_text); last_wday = t->tm_wday; } }
void handle_minute_tick(AppContextRef ctx, PebbleTickEvent *t) { (void)ctx; static char time_text[] = "00:00"; char *time_format; //Time if (clock_is_24h_style()) { time_format = "%R"; } else { time_format = "%I:%M"; } string_format_time(time_text, sizeof(time_text), time_format, t->tick_time); if (!clock_is_24h_style() && (time_text[0] == '0')) { memmove(time_text, &time_text[1], sizeof(time_text) - 1); } text_layer_set_text(&text_time_layer, time_text); //Redraw layer layer_mark_dirty(&main_layer); Minutes_Open++; }
void handle_minute_tick(AppContextRef ctx, PebbleTickEvent *t) { (void)t; (void)ctx; // Need to be static because they're used by the system later. static char time_text[] = "00:00"; char *time_format; if (clock_is_24h_style()) { time_format = "%R"; } else { time_format = "%I:%M"; } string_format_time(time_text, sizeof(time_text), time_format, t->tick_time); if (!clock_is_24h_style() && (time_text[0] == '0')) { memmove(time_text, &time_text[1], sizeof(time_text) - 1); } text_layer_set_text(&text_time_layer, time_text); text_layer_set_text_alignment(&text_time_layer, GTextAlignmentCenter); rotbmp_pair_layer_set_angle(&bitmap_hour_container.layer, TRIG_MAX_ANGLE * get24HourAngle(t->tick_time->tm_hour, t->tick_time->tm_min)); bitmap_hour_container.layer.layer.frame.origin.x = (144/2) - (bitmap_hour_container.layer.layer.frame.size.w/2); bitmap_hour_container.layer.layer.frame.origin.y = (168/2) - (bitmap_hour_container.layer.layer.frame.size.h/2); updateDayAndNightInfo(); }
void handle_minute_tick(AppContextRef ctx, PebbleTickEvent *t) { (void)t; (void)ctx; // Need to be static because they're used by the system later. static char time_text[] = "00:00"; static char date_text[] = "00 Xxxxxxxxx"; char *time_format; // TODO: Only update the date when it's changed. string_format_time(date_text, sizeof(date_text), "%e %B", t->tick_time); text_layer_set_text(&text_date_layer, date_text); if (clock_is_24h_style()) { time_format = "%R"; } else { time_format = "%I:%M"; } string_format_time(time_text, sizeof(time_text), time_format, t->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(&text_time_layer, time_text); if(t->tick_time->tm_min%2==0) { layer_mark_dirty(&hour_display_layer); } layer_mark_dirty(&minute_display_layer); // Vibrate Every Five Minutes //#if HOUR_VIBRATION if ((t->tick_time->tm_min % 5 == 0 ) && (t->tick_time->tm_sec==0)) { //vibes_enqueue_custom_pattern(hour_pattern); vibes_double_pulse(); } //#endif }
void update_time_display() { static char timePast[] = "00:00"; static char timePresent[] = "00:00"; static char timeFuture[] = "00:00"; char *timeFormat; PblTm currentTime; PblTm pastTime; PblTm futureTime; timeFormat = "%I:%M"; //get pebble Time get_time(¤tTime); get_time(&pastTime); get_time(&futureTime); if(currentTime.tm_min == 0){ pastTime.tm_min = 59; pastTime.tm_hour = pastTime.tm_hour - 1; } else{ pastTime.tm_min = pastTime.tm_min - 1; } if(currentTime.tm_min == 59){ futureTime.tm_min = 0; futureTime.tm_hour = futureTime.tm_hour + 1; } else { futureTime.tm_min = futureTime.tm_min + 1; } string_format_time(timePast, sizeof(timePast), timeFormat, &pastTime); string_format_time(timePresent, sizeof(timePresent), timeFormat, ¤tTime); string_format_time(timeFuture, sizeof(timeFuture), timeFormat, &futureTime); if (!clock_is_24h_style() && (timePast[0] == '0')) { memmove(timePast, &timePast[1], sizeof(timePast) - 1); } if (!clock_is_24h_style() && (timePresent[0] == '0')) { memmove(timePresent, &timePresent[1], sizeof(timePresent) - 1); } if (!clock_is_24h_style() && (timeFuture[0] == '0')) { memmove(timeFuture, &timeFuture[1], sizeof(timeFuture) - 1); } text_layer_set_text(&timePastLayer, timePast); text_layer_set_text(&timePresentLayer, timePresent); text_layer_set_text(&timeFutureLayer, timeFuture); }