static void window_load(Window *window) { Layer *window_layer = window_get_root_layer(window); ui.bounds = layer_get_bounds(window_layer); ui.top_text = text_layer_create((GRect) { .origin = { 0, 0 }, .size = { ui.bounds.size.w, 32 } });
static void anim_update2_proc(Layer *layer, GContext *ctx) { APP_LOG(APP_LOG_LEVEL_INFO, "Paint BOX2"); int x = layer_get_bounds(layer).size.w / 2 ; graphics_context_set_fill_color(ctx, GColorLightGray); graphics_fill_circle(ctx, GPoint(x,x) ,x -1); }
static void bt_update_proc(Layer *layer, GContext *ctx) { graphics_context_set_fill_color(ctx, data_get_color(AppKeyBackgroundColor)); graphics_fill_rect(ctx, layer_get_bounds(layer), 0 , GCornerNone); }
static void main_window_load(Window *window) { GRect bounds = layer_get_bounds(window_get_root_layer(window)); action_bar = action_bar_layer_create(); action_bar_layer_set_click_config_provider(action_bar, click_config_provider); #ifdef PBL_COLOR action_bar_layer_set_icon_animated(action_bar,BUTTON_ID_UP,gbitmap_create_with_resource(RESOURCE_ID_IMAGE_ACTION_ICON_CROSS_INV),true); action_bar_layer_set_icon_animated(action_bar,BUTTON_ID_DOWN,gbitmap_create_with_resource(RESOURCE_ID_IMAGE_ACTION_ICON_ZZ_INV),true); #else action_bar_layer_set_icon(action_bar,BUTTON_ID_UP,gbitmap_create_with_resource(RESOURCE_ID_IMAGE_ACTION_ICON_CROSS)); action_bar_layer_set_icon(action_bar,BUTTON_ID_DOWN,gbitmap_create_with_resource(RESOURCE_ID_IMAGE_ACTION_ICON_ZZ)); #endif action_bar_layer_add_to_window(action_bar,window); // Create output TextLayer s_output_layer = text_layer_create(GRect(0, bounds.size.h/2-21-(clock_is_24h_style()?0:21), bounds.size.w-ACTION_BAR_WIDTH, bounds.size.h)); text_layer_set_text_alignment(s_output_layer, GTextAlignmentCenter); text_layer_set_font(s_output_layer,fonts_get_system_font(FONT_KEY_BITHAM_42_BOLD)); //snprintf(output_text, sizeof(output_text), "00:00"); text_layer_set_text(s_output_layer, output_text); layer_add_child(window_get_root_layer(window), text_layer_get_layer(s_output_layer)); //snprintf(output_text, sizeof(output_text), "00:00"); if(alarm_has_description(s_alarm)) { // Create Description s_description_layer = text_layer_create(GRect(0, 6, bounds.size.w-ACTION_BAR_WIDTH, 36)); text_layer_set_text_alignment(s_description_layer, GTextAlignmentCenter); text_layer_set_font(s_description_layer,fonts_get_system_font(FONT_KEY_GOTHIC_28_BOLD)); text_layer_set_text(s_description_layer, s_alarm->description); layer_add_child(window_get_root_layer(window), text_layer_get_layer(s_description_layer)); } else { // Create Bitmap s_bitmap_layer = bitmap_layer_create(GRect(0,10,bounds.size.w-ACTION_BAR_WIDTH, bounds.size.h)); s_logo = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_LOGO); bitmap_layer_set_bitmap(s_bitmap_layer,s_logo); bitmap_layer_set_alignment(s_bitmap_layer,GAlignTop); layer_add_child(window_get_root_layer(window),bitmap_layer_get_layer(s_bitmap_layer)); } #ifdef PBL_SDK_2 s_inverter_layer = inverter_layer_create(GRect(0,0,bounds.size.w,bounds.size.h)); layer_add_child(window_get_root_layer(window), inverter_layer_get_layer(s_inverter_layer)); #endif s_vibration_pattern = load_persistent_storage_int(VIBRATION_PATTERN_KEY,0); s_vibration_duration = load_persistent_storage_int(VIBRATION_DURATION_KEY, 2); s_auto_snooze = load_persistent_storage_bool(AUTO_SNOOZE_KEY, true); do_vibrate(); // switch off vibration after x minutes switch (s_vibration_duration) { case 0: s_vibration_duration = 30; break; case 1: s_vibration_duration = 60; break; case 2: s_vibration_duration = 120; break; case 3: s_vibration_duration = 300; break; default: break; } cancel_vibe_timer = app_timer_register(1000*s_vibration_duration,cancel_vibe_timer_callback,NULL); // test snoozing with the accelerometer /*if(s_flip_to_snooze) { accel_tap_service_subscribe(&accel_tap_handler); }*/ }
static void hands_update_proc(Layer *layer, GContext *ctx) { GRect bounds = layer_get_bounds(layer); GPoint center = grect_center_point(&bounds); graphics_draw_circle(ctx, center, bounds.size.w / 2); int16_t second_hand_length = bounds.size.w / 3; time_t now = time(NULL); struct tm *t = localtime(&now); int32_t second_angle = TRIG_MAX_ANGLE * t->tm_sec / 60; GPoint second_hand = { .x = (int16_t)(sin_lookup(second_angle) * (int32_t)second_hand_length / TRIG_MAX_RATIO) + center.x, .y = (int16_t)(-cos_lookup(second_angle) * (int32_t)second_hand_length / TRIG_MAX_RATIO) + center.y, }; gpath_rotate_to(s_second_arrow, second_angle); graphics_context_set_stroke_color(ctx, GColorBlack); graphics_context_set_stroke_width(ctx, 1); graphics_draw_circle(ctx, second_hand, 5); // second hand //graphics_context_set_stroke_color(ctx, GColorBlack); //graphics_draw_line(ctx, second_hand, center); // minute/hour hand //graphics_context_set_fill_color(ctx, GColorBlack); //graphics_context_set_stroke_color(ctx, GColorBlack); int16_t minute_hand_length = bounds.size.w / 3; int32_t minute_angle = TRIG_MAX_ANGLE * t->tm_min / 60; GPoint minute_hand = { .x = (int16_t)(sin_lookup(minute_angle) * (int32_t)minute_hand_length / TRIG_MAX_RATIO) + center.x, .y = (int16_t)(-cos_lookup(minute_angle) * (int32_t)minute_hand_length / TRIG_MAX_RATIO) + center.y, }; gpath_rotate_to(s_minute_arrow, minute_angle); //gpath_draw_filled(ctx, s_minute_arrow); //gpath_draw_outline(ctx, s_minute_arrow); graphics_context_set_stroke_color(ctx, GColorBlack); //graphics_context_set_fill_color(ctx, GColorBlack); graphics_context_set_stroke_width(ctx, 1); graphics_draw_circle(ctx, minute_hand, 15); //graphics_context_set_fill_color(ctx, GColorWhite); //graphics_fill_circle(ctx, minute_hand, 8); int16_t hour_hand_length = bounds.size.w / 3; int32_t hour_angle = (TRIG_MAX_ANGLE * (((t->tm_hour % 12) * 6) + (t->tm_min / 10))) / (12 * 6); GPoint hour_hand = { .x = (int16_t)(sin_lookup(hour_angle) * (int32_t)hour_hand_length / TRIG_MAX_RATIO) + center.x, .y = (int16_t)(-cos_lookup(hour_angle) * (int32_t)hour_hand_length / TRIG_MAX_RATIO) + center.y, }; gpath_rotate_to(s_hour_arrow, hour_angle); //gpath_draw_filled(ctx, s_hour_arrow); //gpath_draw_outline(ctx, s_hour_arrow); graphics_context_set_stroke_color(ctx, GColorBlack); graphics_context_set_stroke_width(ctx, 1); graphics_draw_circle(ctx, hour_hand, 8); // dot in the middle graphics_context_set_fill_color(ctx, GColorBlack); //graphics_fill_rect(ctx, GRect(bounds.size.w / 2 - 1, bounds.size.h / 2 - 1, 3, 3), 0, GCornerNone); graphics_fill_circle(ctx, center, 3); } static void window_load(Window *window) { Layer *window_layer = window_get_root_layer(window); GRect bounds = layer_get_frame(window_layer); s_simple_bg_layer = layer_create(bounds); layer_set_update_proc(s_simple_bg_layer, bg_update_proc); layer_add_child(window_layer, s_simple_bg_layer); s_hands_layer = layer_create(bounds); layer_set_update_proc(s_hands_layer, hands_update_proc); layer_add_child(window_layer, s_hands_layer); } static void window_unload(Window *window) { layer_destroy(s_hands_layer); } static void init() { window = window_create(); window_set_window_handlers(window, (WindowHandlers) { .load = window_load, .unload = window_unload, });
/** * Window load handler function */ static void mainWindowLoad(Window *w) { init_hardware_icons(); // Get information about the root window Layer *windowLayer = window_get_root_layer(w); GRect bounds = layer_get_bounds(windowLayer); // Set sleepy time flag time_t temp_time = time(NULL); struct tm *cur_time = localtime(&temp_time); s_is_sleepy_time = (cur_time->tm_hour <= SLEEPY_TIME_END_HOUR && cur_time->tm_hour >= SLEEPY_TIME_START_HOUR); ////////////////////////////////////////// // Battery GRect bat_icon_bounds = get_battery_icon_bounds(); // Create BitmapLayer to display the GBitmap s_powerIconLayer = bitmap_layer_create(GRect(bounds.size.w - (bat_icon_bounds.size.w + 2), 0, bat_icon_bounds.size.w, bat_icon_bounds.size.h)); // set background colout and compositing mode bitmap_layer_set_background_color(s_powerIconLayer, POWER_ICON_BACK_COLOR); bitmap_layer_set_compositing_mode(s_powerIconLayer, GCompOpSet); update_power_status(battery_state_service_peek()); // add the bitmap layer to the window layer_add_child(windowLayer, bitmap_layer_get_layer(s_powerIconLayer)); ////////////////////////////////////////// // BT connection GRect bt_icon_bounds = get_bt_icon_bounds(); // Create BitmapLayer to display the GBitmap s_btIconLayer = bitmap_layer_create(GRect(bounds.size.w - (bat_icon_bounds.size.w + bt_icon_bounds.size.w + 4), 4, bt_icon_bounds.size.w, bt_icon_bounds.size.h)); // set background colout and compositing mode bitmap_layer_set_background_color(s_btIconLayer, BT_ICON_BACK_COLOR); bitmap_layer_set_compositing_mode(s_btIconLayer, GCompOpSet); update_bt_status(connection_service_peek_pebble_app_connection()); // add the bitmap layer to the window layer_add_child(windowLayer, bitmap_layer_get_layer(s_btIconLayer)); //////////////////////////////////// // Create the time text layers // time accuracy text layer s_timeAccText = text_layer_create(GRect(2, PBL_IF_ROUND_ELSE(-2, -6), 94, 28)); // Improve the layout to be more like a watchface text_layer_set_background_color(s_timeAccText, TIME_TEXT_BACK_COLOR); text_layer_set_text_color(s_timeAccText, (s_is_sleepy_time ? TIME_TEXT_FORE_COLOR_NIGHT : TIME_TEXT_FORE_COLOR_DAY)); //s_timeFont = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_FFF_TUSJ_42)); GFont timeFont = fonts_get_system_font(FONT_KEY_GOTHIC_24); text_layer_set_font(s_timeAccText, timeFont); text_layer_set_text_alignment(s_timeAccText, GTextAlignmentLeft); // Add it as a child layer to the Window's root layer layer_add_child(windowLayer, text_layer_get_layer(s_timeAccText)); // time text layer s_timeText = text_layer_create(GRect(2, PBL_IF_ROUND_ELSE(20, 16), bounds.size.w-4, 100)); // Improve the layout to be more like a watchface text_layer_set_background_color(s_timeText, TIME_TEXT_BACK_COLOR); text_layer_set_text_color(s_timeText, (s_is_sleepy_time ? TIME_TEXT_FORE_COLOR_NIGHT : TIME_TEXT_FORE_COLOR_DAY)); update_timeish(s_timeText,s_timeAccText); //s_timeFont = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_FFF_TUSJ_42)); timeFont = fonts_get_system_font(FONT_KEY_BITHAM_30_BLACK); text_layer_set_font(s_timeText, timeFont); text_layer_set_text_alignment(s_timeText, GTextAlignmentLeft); // Add it as a child layer to the Window's root layer layer_add_child(windowLayer, text_layer_get_layer(s_timeText)); /////////////////////////////////// // Create the date text layer s_dateText = text_layer_create(GRect(2, PBL_IF_ROUND_ELSE(128, 122), bounds.size.w-4, 16)); // Improve the layout to be more like a watchface text_layer_set_background_color(s_dateText, TIME_TEXT_BACK_COLOR); text_layer_set_text_color(s_dateText, (s_is_sleepy_time ? TIME_TEXT_FORE_COLOR_NIGHT : TIME_TEXT_FORE_COLOR_DAY)); update_date(s_dateText); //s_dateFont = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_FFF_TUSJ_24)); GFont dateFont = fonts_get_system_font(FONT_KEY_GOTHIC_14_BOLD); text_layer_set_font(s_dateText, dateFont); text_layer_set_text_alignment(s_dateText, GTextAlignmentLeft); // Add it as a child layer to the Window's root layer layer_add_child(windowLayer, text_layer_get_layer(s_dateText)); ////////////////////////////////// // Create the weather text layer s_weatherText = text_layer_create(GRect(2, PBL_IF_ROUND_ELSE(112, 108), bounds.size.w-4, 18)); // Improve the layout to be more like a watchface text_layer_set_background_color(s_weatherText, TIME_TEXT_BACK_COLOR); update_weather((Tuple *)NULL,(Tuple *)NULL, (Tuple *)NULL); GFont weatherFont = fonts_get_system_font(FONT_KEY_GOTHIC_14); text_layer_set_font(s_weatherText, weatherFont); text_layer_set_text_alignment(s_weatherText, GTextAlignmentLeft); // Set weather text colour set_weather_text_colour(); // Add it as a child layer to the Window's root layer layer_add_child(windowLayer, text_layer_get_layer(s_weatherText)); ////////////////////////////////// // Create the news text layer s_newsText = text_layer_create(GRect(2, PBL_IF_ROUND_ELSE(142, 136), bounds.size.w-4, 30)); // Improve the layout to be more like a watchface text_layer_set_background_color(s_newsText, TIME_TEXT_BACK_COLOR); text_layer_set_text_color(s_newsText, (s_is_sleepy_time ? TIME_TEXT_FORE_COLOR_NIGHT : TIME_TEXT_FORE_COLOR_DAY)); display_news_weather(); text_layer_set_font(s_newsText, weatherFont); text_layer_set_text_alignment(s_newsText, GTextAlignmentLeft); // Add it as a child layer to the Window's root layer layer_add_child(windowLayer, text_layer_get_layer(s_newsText)); }
static void window_load(Window *window) { Layer *window_layer = window_get_root_layer(window); GRect bounds = layer_get_bounds(window_layer); current_slide_text_layer = text_layer_create((GRect) { .origin = { 0, 0 }, .size = { bounds.size.w, 50 } });
static void main_window_load(Window *window) { // Get information about the window needed for drawing text 'n shit Layer *window_layer = window_get_root_layer(window); GRect bounds = layer_get_bounds(window_layer); /* Bitmap layer for displaying the background */ // Create GBitmap s_background_bitmap = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_BACKGROUND); // Create BitmapLayer to display the GBitmap s_background_layer = bitmap_layer_create(bounds); // Add bitmap to the layer and add the layer to the window as a child bitmap_layer_set_bitmap(s_background_layer, s_background_bitmap); layer_add_child(window_layer, bitmap_layer_get_layer(s_background_layer)); /* Text layer for displaying the time */ // Create TextLayer s_time_layer = text_layer_create( GRect(0, 53, bounds.size.w, 50)); // Set layout options text_layer_set_background_color(s_time_layer, GColorRed); text_layer_set_text_color(s_time_layer, GColorYellow); text_layer_set_font(s_time_layer, fonts_get_system_font(FONT_KEY_LECO_42_NUMBERS)); text_layer_set_text_alignment(s_time_layer, GTextAlignmentCenter); // Add child layer_add_child(window_layer, text_layer_get_layer(s_time_layer)); /* Text layer for displaying the current date */ // Create TextLayer s_date_layer = text_layer_create(GRect(-10, 105, bounds.size.w, 20)); // Set layout options text_layer_set_background_color(s_date_layer, GColorRed); text_layer_set_text_color(s_date_layer, GColorYellow); text_layer_set_font(s_date_layer, fonts_get_system_font(FONT_KEY_LECO_20_BOLD_NUMBERS)); text_layer_set_text_alignment(s_date_layer, GTextAlignmentRight); // Add child layer_add_child(window_layer, text_layer_get_layer(s_date_layer)); /* Text Layer for displaying battery info */ // Create TextLayer s_battery_info_layer = text_layer_create(GRect(-10, 10, bounds.size.w, 20)); // Set layout options text_layer_set_background_color(s_battery_info_layer, GColorRed); text_layer_set_text_color(s_battery_info_layer, GColorYellow); text_layer_set_font(s_battery_info_layer, fonts_get_system_font(FONT_KEY_LECO_20_BOLD_NUMBERS)); text_layer_set_text_alignment(s_battery_info_layer, GTextAlignmentRight); // Add child layer_add_child(window_layer, text_layer_get_layer(s_battery_info_layer)); // Get first value BatteryChargeState charge = battery_state_service_peek(); static char charge_percent_char[] = "00000000000"; snprintf(charge_percent_char, sizeof(charge_percent_char), "%d", charge.charge_percent); text_layer_set_text(s_battery_info_layer, charge_percent_char); /* Text Layer for displaying steps counted by Pebble Health */ // Create TextLayer s_step_count_layer = text_layer_create(GRect(-10, 30, bounds.size.w, 20)); // Set layout options text_layer_set_background_color(s_step_count_layer, GColorRed); text_layer_set_text_color(s_step_count_layer, GColorYellow); text_layer_set_font(s_step_count_layer, fonts_get_system_font(FONT_KEY_LECO_20_BOLD_NUMBERS)); text_layer_set_text_alignment(s_step_count_layer, GTextAlignmentRight); // Add child layer_add_child(window_layer, text_layer_get_layer(s_step_count_layer)); // Get first value update_step_counter(); }
//BT Logo Callback; void BTLine_update_callback(Layer *BTLayer1, GContext* BT1ctx) { GPoint BTLinePointStart; GPoint BTLinePointEnd; graphics_context_set_stroke_color(BT1ctx, TextColorHold); if (BTConnected == 0) { #ifdef PBL_COLOR graphics_context_set_stroke_color(BT1ctx, GColorRed); graphics_context_set_fill_color(BT1ctx, GColorWhite); graphics_fill_rect(BT1ctx, layer_get_bounds(BTLayer1), 0, GCornerNone); #else graphics_context_set_stroke_color(BT1ctx, GColorBlack); graphics_context_set_fill_color(BT1ctx, GColorWhite); graphics_fill_rect(BT1ctx, layer_get_bounds(BTLayer1), 0, GCornerNone); #endif // "X"" Line 1 BTLinePointStart.x = 1; BTLinePointStart.y = 1; BTLinePointEnd.x = 20; BTLinePointEnd.y = 20; graphics_draw_line(BT1ctx, BTLinePointStart, BTLinePointEnd); // "X"" Line 2 BTLinePointStart.x = 1; BTLinePointStart.y = 20; BTLinePointEnd.x = 20; BTLinePointEnd.y = 1; graphics_draw_line(BT1ctx, BTLinePointStart, BTLinePointEnd); } else { //Line 1 BTLinePointStart.x = 10; BTLinePointStart.y = 1; BTLinePointEnd.x = 10; BTLinePointEnd.y = 20; graphics_draw_line(BT1ctx, BTLinePointStart, BTLinePointEnd); //Line 2 BTLinePointStart.x = 10; BTLinePointStart.y = 1; BTLinePointEnd.x = 16; BTLinePointEnd.y = 5; graphics_draw_line(BT1ctx, BTLinePointStart, BTLinePointEnd); //Line 3 BTLinePointStart.x = 4; BTLinePointStart.y = 5; BTLinePointEnd.x = 16; BTLinePointEnd.y = 16; graphics_draw_line(BT1ctx, BTLinePointStart, BTLinePointEnd); //Line 4 BTLinePointStart.x = 4; BTLinePointStart.y = 16; BTLinePointEnd.x = 16; BTLinePointEnd.y = 5; graphics_draw_line(BT1ctx, BTLinePointStart, BTLinePointEnd); //Line 5 BTLinePointStart.x = 10; BTLinePointStart.y = 20; BTLinePointEnd.x = 16; BTLinePointEnd.y = 16; graphics_draw_line(BT1ctx, BTLinePointStart, BTLinePointEnd); } }
static void hands_update_proc(Layer *layer, GContext *ctx) { GRect bounds = layer_get_bounds(layer); GPoint center = grect_center_point(&bounds); int16_t second_hand_length = bounds.size.w / 2 - 5; int16_t second_hand_tail_length = 15; time_t now = time(NULL); struct tm *t = localtime(&now); int32_t second_angle = TRIG_MAX_ANGLE * t->tm_sec / 60; int32_t second_angle_tail = TRIG_MAX_ANGLE * (t->tm_sec + 30) / 60; GPoint second_hand = { .x = (int16_t)(sin_lookup(second_angle) * (int32_t)second_hand_length / TRIG_MAX_RATIO) + center.x, .y = (int16_t)(-cos_lookup(second_angle) * (int32_t)second_hand_length / TRIG_MAX_RATIO) + center.y, }; GPoint second_hand_tail = { .x = (int16_t)(sin_lookup(second_angle_tail) * (int32_t)second_hand_tail_length / TRIG_MAX_RATIO) + center.x, .y = (int16_t)(-cos_lookup(second_angle_tail) * (int32_t)second_hand_tail_length / TRIG_MAX_RATIO) + center.y, }; // temperature if (b_show_temperature) { graphics_context_set_text_color(ctx, gcolor_numbers); int offset = !b_show_numbers * 10; #ifdef PBL_RECT graphics_draw_text(ctx, s_temp_buffer, fonts_get_system_font(FONT_KEY_GOTHIC_14), GRect(27 - offset, 75, 40 + offset, 14), GTextOverflowModeWordWrap, GTextAlignmentCenter, NULL); #else graphics_draw_text(ctx, s_temp_buffer, fonts_get_system_font(FONT_KEY_GOTHIC_18), GRect(40 - offset, 78, 40 + offset, 14), GTextOverflowModeWordWrap, GTextAlignmentCenter, NULL); #endif } // minute hand graphics_context_set_fill_color(ctx, gcolor_minute_hand); gpath_rotate_to(s_minute_arrow, TRIG_MAX_ANGLE * t->tm_min / 60); gpath_draw_filled(ctx, s_minute_arrow); // hour hand graphics_context_set_fill_color(ctx, gcolor_hour_hand); gpath_rotate_to(s_hour_arrow, (TRIG_MAX_ANGLE * (((t->tm_hour % 12) * 6) + (t->tm_min / 10))) / (12 * 6)); gpath_draw_filled(ctx, s_hour_arrow); // second hand if (b_show_second_hand) { graphics_context_set_stroke_color(ctx, gcolor_second_hand); graphics_draw_line(ctx, second_hand, center); graphics_draw_line(ctx, second_hand_tail, center); } // dot in the middle graphics_context_set_fill_color(ctx, gcolor_second_hand); graphics_fill_circle(ctx, GPoint(bounds.size.w / 2, bounds.size.h / 2), 4); } static void update_date(void){ time_t now = time(NULL); struct tm *t = localtime(&now); //corrects for 24h time int hour = (t->tm_hour < 13) ? t->tm_hour : t->tm_hour - 12; static char date_buffer[16]; //strategically put the date where the hands are not covering if((t->tm_min < 7 || t->tm_min > 23) && (hour < 1 || hour >= 5)){ strftime(date_buffer, sizeof(date_buffer), "%a\n%d", t); text_layer_set_text(date_layer_right, date_buffer); text_layer_set_text(date_layer_left, "\0"); text_layer_set_text(date_layer_bottom, "\0"); } else if((t->tm_min < 37 || t->tm_min > 53) && (hour < 7 || hour > 11)){ strftime(date_buffer, sizeof(date_buffer), "%a\n%d", t); text_layer_set_text(date_layer_left, date_buffer); text_layer_set_text(date_layer_right, "\0"); text_layer_set_text(date_layer_bottom, "\0"); } else{ strftime(date_buffer, sizeof(date_buffer), "%a %d", t); text_layer_set_text(date_layer_bottom, date_buffer); text_layer_set_text(date_layer_right, "\0"); text_layer_set_text(date_layer_left, "\0"); } } static void handle_second_tick(struct tm *tick_time, TimeUnits units_changed) { layer_mark_dirty(window_get_root_layer(window)); update_date(); }
static void window_load(Window *window) { Layer *window_layer = window_get_root_layer(window); GRect bounds = layer_get_bounds(window_layer); int offset = !b_show_numbers * 10; s_simple_bg_layer = layer_create(bounds); layer_set_update_proc(s_simple_bg_layer, bg_update_proc); layer_add_child(window_layer, s_simple_bg_layer); window_set_background_color(window, gcolor_background); #ifdef PBL_RECT date_layer_right = text_layer_create(GRect( (bounds.size.w - DATE_LAYER_HORIZONTAL_OFFSET), (bounds.size.h/2 - DATE_LAYER_VERTICAL_OFFSET), DATE_LAYER_HORIZONTAL_OFFSET, 60)); date_layer_left = text_layer_create(GRect( 0, (bounds.size.h/2 - DATE_LAYER_VERTICAL_OFFSET), DATE_LAYER_HORIZONTAL_OFFSET + offset, 60)); date_layer_bottom = text_layer_create(GRect( 0, (bounds.size.h - DATE_LAYER_BOTTOM_OFFSET), bounds.size.w, DATE_LAYER_BOTTOM_OFFSET)); #else date_layer_right = text_layer_create(GRect( (bounds.size.w - DATE_LAYER_HORIZONTAL_OFFSET), (bounds.size.h/2 - DATE_LAYER_VERTICAL_OFFSET), DATE_LAYER_HORIZONTAL_OFFSET, 60)); date_layer_left = text_layer_create(GRect( 0, (bounds.size.h/2 - DATE_LAYER_VERTICAL_OFFSET), DATE_LAYER_HORIZONTAL_OFFSET + (offset * 4), 60)); date_layer_bottom = text_layer_create(GRect( 0, (bounds.size.h - DATE_LAYER_BOTTOM_OFFSET), bounds.size.w, DATE_LAYER_BOTTOM_OFFSET + (offset * 2))); #endif text_layer_set_background_color(date_layer_right, GColorClear); text_layer_set_text_color(date_layer_right, gcolor_numbers); text_layer_set_text_alignment(date_layer_right, GTextAlignmentCenter); text_layer_set_font(date_layer_right, fonts_get_system_font(FONT_KEY_GOTHIC_18_BOLD)); text_layer_set_background_color(date_layer_left, GColorClear); text_layer_set_text_color(date_layer_left, gcolor_numbers); text_layer_set_text_alignment(date_layer_left, GTextAlignmentCenter); text_layer_set_font(date_layer_left, fonts_get_system_font(FONT_KEY_GOTHIC_18_BOLD)); text_layer_set_background_color(date_layer_bottom, GColorClear); text_layer_set_text_color(date_layer_bottom, gcolor_numbers); text_layer_set_text_alignment(date_layer_bottom, GTextAlignmentCenter); text_layer_set_font(date_layer_bottom, fonts_get_system_font(FONT_KEY_GOTHIC_18_BOLD)); update_date(); layer_add_child(window_layer, text_layer_get_layer(date_layer_right)); layer_add_child(window_layer, text_layer_get_layer(date_layer_left)); layer_add_child(window_layer, text_layer_get_layer(date_layer_bottom)); s_hands_layer = layer_create(bounds); layer_set_update_proc(s_hands_layer, hands_update_proc); layer_add_child(window_layer, s_hands_layer); load_persisted_values(); }
static void bg_update_proc(Layer *layer, GContext *ctx) { GRect bounds = layer_get_bounds(layer); GRect frame = grect_inset(bounds, GEdgeInsets(4 * INSET)); GRect inner_hour_frame = grect_inset(bounds, GEdgeInsets((4 * INSET) + 8)); GRect inner_minute_frame = grect_inset(bounds, GEdgeInsets((4 * INSET) + 6)); graphics_context_set_stroke_color(ctx, gcolor_hour_marks); graphics_context_set_stroke_width(ctx, 3); // Hours marks for(int i = 0; i < 12; i++) { int hour_angle = get_angle_for_hour(i); GPoint p0 = gpoint_from_polar(frame, GOvalScaleModeFitCircle, DEG_TO_TRIGANGLE(hour_angle)); GPoint p1 = gpoint_from_polar(inner_hour_frame, GOvalScaleModeFitCircle, DEG_TO_TRIGANGLE(hour_angle)); graphics_draw_line(ctx, p0, p1); } // Minute Marks graphics_context_set_stroke_color(ctx, gcolor_minute_marks); graphics_context_set_stroke_width(ctx, 1); for(int i = 0; i < 60; i++) { if (i % 5) { int minute_angle = get_angle_for_minute(i); GPoint p0 = gpoint_from_polar(frame, GOvalScaleModeFitCircle, DEG_TO_TRIGANGLE(minute_angle)); GPoint p1 = gpoint_from_polar(inner_minute_frame, GOvalScaleModeFitCircle, DEG_TO_TRIGANGLE(minute_angle)); graphics_draw_line(ctx, p0, p1); } } // numbers if (b_show_numbers) { graphics_context_set_text_color(ctx, gcolor_numbers); #ifdef PBL_RECT graphics_draw_text(ctx, "12", fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD), GRect(63, 18, 20, 20), GTextOverflowModeWordWrap, GTextAlignmentCenter, NULL); graphics_draw_text(ctx, "1", fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD), GRect(85, 23, 20, 20), GTextOverflowModeWordWrap, GTextAlignmentRight, NULL); graphics_draw_text(ctx, "2", fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD), GRect(104, 43, 20, 20), GTextOverflowModeWordWrap, GTextAlignmentRight, NULL); graphics_draw_text(ctx, "3", fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD), GRect(112, 68, 20, 20), GTextOverflowModeWordWrap, GTextAlignmentRight, NULL); graphics_draw_text(ctx, "4", fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD), GRect(104, 93, 20, 20), GTextOverflowModeWordWrap, GTextAlignmentRight, NULL); graphics_draw_text(ctx, "5", fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD), GRect(85, 110, 20, 20), GTextOverflowModeWordWrap, GTextAlignmentRight, NULL); graphics_draw_text(ctx, "6", fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD), GRect(62, 118, 20, 20), GTextOverflowModeWordWrap, GTextAlignmentCenter, NULL); graphics_draw_text(ctx, "7", fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD), GRect(39, 110, 20, 20), GTextOverflowModeWordWrap, GTextAlignmentLeft, NULL); graphics_draw_text(ctx, "8", fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD), GRect(20, 93, 20, 20), GTextOverflowModeWordWrap, GTextAlignmentLeft, NULL); graphics_draw_text(ctx, "9", fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD), GRect(14, 68, 20, 20), GTextOverflowModeWordWrap, GTextAlignmentLeft, NULL); graphics_draw_text(ctx, "10", fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD), GRect(20, 43, 20, 20), GTextOverflowModeWordWrap, GTextAlignmentLeft, NULL); graphics_draw_text(ctx, "11", fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD), GRect(39, 23, 20, 20), GTextOverflowModeWordWrap, GTextAlignmentLeft, NULL); #else graphics_draw_text(ctx, "12", fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD), GRect(80, 10, 20, 20), GTextOverflowModeWordWrap, GTextAlignmentCenter, NULL); graphics_draw_text(ctx, "1", fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD), GRect(107, 20, 20, 20), GTextOverflowModeWordWrap, GTextAlignmentRight, NULL); graphics_draw_text(ctx, "2", fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD), GRect(130, 43, 20, 20), GTextOverflowModeWordWrap, GTextAlignmentRight, NULL); graphics_draw_text(ctx, "3", fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD), GRect(140, 74, 20, 20), GTextOverflowModeWordWrap, GTextAlignmentRight, NULL); graphics_draw_text(ctx, "4", fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD), GRect(130, 106, 20, 20), GTextOverflowModeWordWrap, GTextAlignmentRight, NULL); graphics_draw_text(ctx, "5", fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD), GRect(107, 126, 20, 20), GTextOverflowModeWordWrap, GTextAlignmentRight, NULL); graphics_draw_text(ctx, "6", fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD), GRect(81, 136, 20, 20), GTextOverflowModeWordWrap, GTextAlignmentCenter, NULL); graphics_draw_text(ctx, "7", fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD), GRect(53, 124, 20, 20), GTextOverflowModeWordWrap, GTextAlignmentLeft, NULL); graphics_draw_text(ctx, "8", fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD), GRect(29, 106, 20, 20), GTextOverflowModeWordWrap, GTextAlignmentLeft, NULL); graphics_draw_text(ctx, "9", fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD), GRect(20, 74, 20, 20), GTextOverflowModeWordWrap, GTextAlignmentLeft, NULL); graphics_draw_text(ctx, "10", fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD), GRect(28, 42, 20, 20), GTextOverflowModeWordWrap, GTextAlignmentLeft, NULL); graphics_draw_text(ctx, "11", fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD), GRect(50, 22, 20, 20), GTextOverflowModeWordWrap, GTextAlignmentLeft, NULL); #endif } }
// @private Called to redraw the layer static void OutputTextLabel_Redraw(struct Layer* layer, GContext* ctx) { // Get class container OutputTextLabel* label = layer_get_data(layer); // Get window bounds GRect bounds = layer_get_bounds(layer); // Clear the view area graphics_context_set_fill_color(ctx, GColorBlack); graphics_fill_rect(ctx, bounds, 0, 0); // Check if got text if (strlen(label->text) == 0) return; // Check if can use giant font if (label->giantFont) { // Get bounds of text GSize textSize = graphics_text_layout_get_content_size(label->text, label->giantFont, bounds, GTextOverflowModeWordWrap, GTextAlignmentCenter); if (textSize.h < bounds.size.h) { // We can use the large font, draw it! graphics_context_set_stroke_color(ctx, GColorWhite); graphics_draw_text(ctx, label->text, label->giantFont, GRect(0, bounds.size.h / 2 - textSize.h / 2, bounds.size.w, bounds.size.h), GTextOverflowModeWordWrap, GTextAlignmentCenter, 0); return; } } // Check if can use large font if (label->largeFont) { // Get bounds of text GSize textSize = graphics_text_layout_get_content_size(label->text, label->largeFont, bounds, GTextOverflowModeWordWrap, GTextAlignmentCenter); if (textSize.h < bounds.size.h) { // We can use the large font, draw it! graphics_context_set_stroke_color(ctx, GColorWhite); graphics_draw_text(ctx, label->text, label->largeFont, GRect(0, bounds.size.h / 2 - textSize.h / 2, bounds.size.w, bounds.size.h), GTextOverflowModeWordWrap, GTextAlignmentCenter, 0); return; } } // Check if can use medium font if (label->mediumFont) { // Get bounds of text GSize textSize = graphics_text_layout_get_content_size(label->text, label->mediumFont, bounds, GTextOverflowModeWordWrap, GTextAlignmentCenter); if (textSize.h < bounds.size.h) { // We can use the large font, draw it! graphics_context_set_stroke_color(ctx, GColorWhite); graphics_draw_text(ctx, label->text, label->mediumFont, GRect(0, bounds.size.h / 2 - textSize.h / 2, bounds.size.w, bounds.size.h), GTextOverflowModeWordWrap, GTextAlignmentCenter, 0); return; } } // Check if can use small font if (label->smallFont) { // Get bounds of text GSize textSize = graphics_text_layout_get_content_size(label->text, label->smallFont, bounds, GTextOverflowModeWordWrap, GTextAlignmentCenter); // Draw it no matter the size graphics_context_set_stroke_color(ctx, GColorWhite); graphics_draw_text(ctx, label->text, label->smallFont, GRect(0, MAX(bounds.size.h / 2 - textSize.h / 2, 0), bounds.size.w, bounds.size.h), GTextOverflowModeWordWrap, GTextAlignmentCenter, 0); return; } }
static void window_load(Window *window) { // Load the bitmap asset // resource_init_current_app must be called before all asset loading. menu_icons[0] = gbitmap_create_with_resource(RESOURCE_ID_HAPPY); menu_icons[1] = gbitmap_create_with_resource(RESOURCE_ID_SAD); menu_icons[2] = gbitmap_create_with_resource(RESOURCE_ID_STRESSED); menu_icons[3] = gbitmap_create_with_resource(RESOURCE_ID_CALM); // ******** Menu Items ******** // First menu item. first_menu_items[0] = (SimpleMenuItem) { .icon = menu_icons[0], .title = "Happy", .subtitle = "Sweet!", .callback = menu_select_callback, }; // Second menu item. first_menu_items[1] = (SimpleMenuItem) { .icon = menu_icons[1], .title = "Sad", .subtitle = "Cheer Up!", .callback = menu_select_callback, }; // Third menu item. first_menu_items[2] = (SimpleMenuItem) { .icon = menu_icons[2], .title = "Stressed", .subtitle = "Take a chill pill!", .callback = menu_select_callback, }; // Fourth menu item. first_menu_items[3] = (SimpleMenuItem){ .icon = menu_icons[3], .title = "Calm", .subtitle = "Like a felon!", .callback = menu_select_callback, }; // ******** SECTIONS ******** menu_sections[0] = (SimpleMenuSection) { .num_items = NUM_FIRST_MENU_ITEM, .items = first_menu_items, }; // Required: gets the root layer. ( base layer ) Layer *window_layer = window_get_root_layer(window); // Required: Gets the dimensions of the whole pebble screen. GRect bounds = layer_get_bounds(window_layer); // initialize the menu. simple_menu_layer = simple_menu_layer_create(bounds, window, menu_sections, NUM_MENU_SECTIONS, NULL); // Required: add the window for display layer_add_child(window_layer, simple_menu_layer_get_layer(simple_menu_layer)); } /************************************************************/ /* window_unload */ /* */ /* Handles all the clean up before destroying the window. */ /************************************************************/ static void window_unload(Window *window) { simple_menu_layer_destroy(simple_menu_layer); // Destroy the images for(int i = 0; i < NUM_MENU_ICONS; i++){ gbitmap_destroy(menu_icons[i]); } } /************************************************************/ /* init */ /* */ /* Creates the window, sets the click_config_provider, sets */ /* the window handlers, and pushes the window onto the top */ /* of the stack so it is visible. */ /************************************************************/ static void init(void) { // Required: Creates the window. Needed to display everything. window = window_create(); // Required. Sets the hanldlers for the window. window_load for when the user enters the watchapp and // window_unload, for when the user leave the watch app. window_set_window_handlers(window, (WindowHandlers) { .load = window_load, .unload = window_unload, }); // Setup the messaging handlers. app_message_register_outbox_sent(out_sent_handler); app_message_register_outbox_failed(out_failed_handler); const uint32_t inbound_size = 10; const uint32_t outbound_size = 64; app_message_open(inbound_size, outbound_size); // Vibrate to let the user know. vibes_short_pulse(); // Required: Will push the window to the top of the stack and therefore making it visible. const bool animated = true; window_stack_push(window, animated); } /************************************************************/ /* deinit */ /* */ /* Destroys the window and performs all of the necessary */ /* clean up. */ /************************************************************/ static void deinit(void) { window_destroy(window); }
void draw_marine_layer(Layer *layer, GContext *ctx) { int next_x = 0; int next_y = 5 - ceil(anim_data.current_battery_state.charge_percent / 20.0); next_y = next_y > MAX_SPRITE_Y ? MAX_SPRITE_Y : next_y; bool destroy_new_sprite = false; GBitmap* new_sprite = NULL; if (!anim_data.current_battery_state.is_charging && !anim_data.current_battery_state.is_plugged) { switch (anim_data.current_x) { case 2: next_x = 1; break; case 1: switch (anim_data.previous_x) { case 2: next_x = 0; break; case 0: next_x = 2; break; case 1: next_x = 0; break; default: return; } break; case 0: next_x = 1; break; default: return; } anim_data.previous_x = anim_data.current_x; anim_data.current_x = next_x; new_sprite = get_sprite_by_index(marine_spritesheet, next_x, next_y); if (!new_sprite) { APP_LOG(APP_LOG_LEVEL_ERROR, "Error getting new sprite! x:%d y:%d", next_x, next_y); return; } destroy_new_sprite = true; } else { new_sprite = marine_charging; } #ifdef PBL_PLATFORM_BASALT GRect image_size = gbitmap_get_bounds(new_sprite); #else GRect image_size = new_sprite->bounds; #endif GRect bounds = layer_get_bounds(layer); grect_align(&image_size, &bounds, GAlignCenter, true); graphics_context_set_compositing_mode(ctx, GCompOpAssign); graphics_draw_bitmap_in_rect(ctx, new_sprite, image_size); if (destroy_new_sprite) { gbitmap_destroy(new_sprite); } }
static void layer_update_callback(Layer *me, GContext* ctx) { // preparations GRect bounds = layer_get_bounds(me); uint16_t width = bounds.size.w; uint16_t height = bounds.size.h; uint16_t stride = (bounds.size.w + 31) / 32 * 32; uint16_t max = (height - 1) * stride + width; uint16_t shake = stride - width; uint16_t shake_stride = shake * stride; // handle shake if (do_shake) { do_shake = false; light_enable_interaction(); for (uint16_t i = 0, j = rand(); i < NUM_FLAKES; i++, j+=31) { for (uint16_t k = 0; k < 2; k++, j+=31) { uint16_t next = flakes[i] + j % (max * 2) - max; if (next < max && next % stride < width && get_pixel(ctx, next) == GColorBlack) { flakes[i] = next; break; } } } last_time = 0; } // update time text time_t t = time(NULL); if (t / UPDATE_S > last_time) { last_time = t / UPDATE_S; char time_text[6]; clock_copy_time_string(time_text, sizeof(time_text)); graphics_context_set_fill_color(ctx, GColorBlack); graphics_fill_rect(ctx, bounds, 0, GCornerNone); GRect rect = (GRect) {{0, 60}, {width, 50}}; GFont font = fonts_get_system_font(FONT_KEY_BITHAM_42_BOLD); graphics_draw_text(ctx, time_text, font, rect, GTextOverflowModeTrailingEllipsis, GTextAlignmentCenter, NULL); graphics_context_set_stroke_color(ctx, GColorWhite); for (uint16_t i = 0, j = rand(); i < NUM_FLAKES; i++) { if (get_pixel(ctx, flakes[i]) == GColorBlack) { graphics_draw_pixel(ctx, GPoint(flakes[i] % stride, flakes[i] / stride)); } else { for (uint16_t k = 0; k < 8; k++, j++) { uint16_t next = flakes[i] + (j % 9 / 3 - 1) * shake_stride + (j % 3 - 1) * shake; if (next < max && next % stride < width && get_pixel(ctx, next) == GColorBlack) { flakes[i] = next; graphics_draw_pixel(ctx, GPoint(flakes[i] % stride, flakes[i] / stride)); break; } } } } } // apply physics AccelData accel = {.x = 0, .y = 0, .z = 0}; accel_service_peek(&accel); uint16_t absx = accel.x < 0 ? -accel.x : accel.x; uint16_t absy = accel.y < 0 ? -accel.y : accel.y; uint16_t span = (absx + absy + 10) * SPEED; for (uint16_t i = 0, j = rand(), k = rand(), l = rand(); i < span; i++, j++, k++, l++) { uint16_t index = j % NUM_FLAKES; uint16_t next = flakes[index]; int16_t sideway = k % 3 == 0 ? l % 5 - 2 : 0; int16_t accx = accel.x + accel.y * sideway; int16_t accy = accel.y - accel.x * sideway; absx = accx < 0 ? -accx : accx; absy = accy < 0 ? -accy : accy; if (absx > absy || k % absy < absx) { if (accx > 0) { next++; } else { next--; } } if (absy > absx || l % absx < absy) { if (accy > 0) { next -= stride; } else { next += stride; } } if (next < max && next % stride < width && get_pixel(ctx, next) == GColorBlack) { graphics_context_set_stroke_color(ctx, GColorBlack); graphics_draw_pixel(ctx, GPoint(flakes[index] % stride, flakes[index] / stride)); graphics_context_set_stroke_color(ctx, GColorWhite); graphics_draw_pixel(ctx, GPoint(next % stride, next / stride)); flakes[index] = next; } } if (!timer) timer = app_timer_register(UPDATE_MS, timer_callback, NULL); } static void handle_accel(AccelData *accel_data, uint32_t num_samples) { // or else I will crash } static void accel_tap_handler(AccelAxisType axis, int32_t direction) { do_shake = true; } static void root_update_callback(Layer *me, GContext* ctx) { // hack to prevent screen cleaning } static void window_load(Window *window) { Layer *window_layer = window_get_root_layer(window); layer_set_update_proc(window_layer, root_update_callback); GRect bounds = layer_get_bounds(window_layer); layer = layer_create(bounds); layer_set_update_proc(layer, layer_update_callback); layer_add_child(window_layer, layer); uint16_t width = bounds.size.w; uint16_t height = bounds.size.h; uint16_t stride = (bounds.size.w + 31) / 32 * 32; for (uint16_t i = 0; i < NUM_FLAKES; i++) { flakes[i] = rand() % height * stride + rand() % width; } }
static void main_window_load(Window *window) { Layer *window_layer = window_get_root_layer(window); GRect window_bounds = layer_get_bounds(window_layer); title_layer = text_layer_create( GRect(0, 0,window_bounds.size.w, window_bounds.size.h)); text_layer_set_text_alignment(title_layer, GTextAlignmentCenter); text_layer_set_text(title_layer, "FloodWatch"); text_layer_set_text_color(title_layer, GColorBlack); text_layer_set_background_color(title_layer, GColorClear); text_layer_set_font(title_layer, fonts_get_system_font(FONT_KEY_ROBOTO_CONDENSED_21)); layer_add_child(window_layer, text_layer_get_layer(title_layer)); region_layer = text_layer_create( GRect(0, 20,window_bounds.size.w, window_bounds.size.h)); text_layer_set_text_alignment(region_layer, GTextAlignmentCenter); text_layer_set_text(region_layer, "Jakarta - Timur"); text_layer_set_text_color(region_layer, GColorWhite); text_layer_set_background_color(region_layer, GColorClear); text_layer_set_font(region_layer, fonts_get_system_font(FONT_KEY_GOTHIC_24)); layer_add_child(window_layer, text_layer_get_layer(region_layer)); s_scroll_layer = scroll_layer_create(window_bounds); scroll_layer_set_click_config_onto_window(s_scroll_layer, window); scroll_layer_set_shadow_hidden(s_scroll_layer, true); layer_add_child(window_layer, scroll_layer_get_layer(s_scroll_layer)); // Get the ContentIndicator from the ScrollLayer s_indicator = scroll_layer_get_content_indicator(s_scroll_layer); // Create two Layers to draw the arrows s_indicator_up_layer = layer_create(GRect(window_bounds.origin.x, window_bounds.origin.y, window_bounds.size.w, STATUS_BAR_LAYER_HEIGHT)); s_indicator_down_layer = layer_create(GRect(0, window_bounds.size.h - STATUS_BAR_LAYER_HEIGHT, window_bounds.size.w, STATUS_BAR_LAYER_HEIGHT)); layer_add_child(window_layer, s_indicator_up_layer); layer_add_child(window_layer, s_indicator_down_layer); // Configure the properties of each indicator const ContentIndicatorConfig up_config = (ContentIndicatorConfig) { .layer = s_indicator_up_layer, .times_out = false, .alignment = GAlignCenter, .colors = { .foreground = GColorBlack, .background = GColorLightGray } }; content_indicator_configure_direction(s_indicator, ContentIndicatorDirectionUp, &up_config); const ContentIndicatorConfig down_config = (ContentIndicatorConfig) { .layer = s_indicator_down_layer, .times_out = false, .alignment = GAlignCenter, .colors = { .foreground = GColorBlack, .background = GColorLightGray } }; content_indicator_configure_direction(s_indicator, ContentIndicatorDirectionDown, &down_config); reports_layer = text_layer_create(GRect(0, 50, window_bounds.size.w, 2000)); text_layer_set_text(reports_layer, reports); text_layer_set_text_alignment(reports_layer, GTextAlignmentCenter); text_layer_set_font(reports_layer, fonts_get_system_font(FONT_KEY_GOTHIC_18_BOLD)); text_layer_set_text_color(region_layer, GColorBlack); text_layer_set_background_color(region_layer, GColorClear); scroll_layer_add_child(s_scroll_layer, text_layer_get_layer(reports_layer)); GSize text_size = text_layer_get_content_size(reports_layer); layer_set_frame(text_layer_get_layer(reports_layer), GRect(0, 50, window_bounds.size.w, text_size.h)); scroll_layer_set_content_size(s_scroll_layer, text_size); }
static void bg_update_proc(Layer *layer, GContext *ctx) { graphics_context_set_fill_color(ctx, GColorBlack); graphics_fill_rect(ctx, layer_get_bounds(layer), 0, GCornerNone); }
static void init_location_search(Window *window) { Layer *window_layer = window_get_root_layer(window); GRect bounds = layer_get_bounds(window_layer); label_layer = text_layer_create((GRect) { .origin = { 0, 90 }, .size = { bounds.size.w, 100 } });
/*Update Drawing Handler*/ static void hands_update_proc(Layer *layer, GContext *ctx) { graphics_context_set_antialiased(ctx, true); int16_t scale = _12HScaleFactor*60; if ( clock_is_24h_style() ) { scale = _24HScaleFactor*60; } GRect bounds = layer_get_bounds(layer); GPoint center = grect_center_point(&bounds); GPoint secondHand; GPoint hourHand1, hourHand2; time_t now = time(NULL); struct tm* t = localtime(&now); int16_t ms = time_ms(NULL, NULL); const int16_t second_hand_length = PBL_IF_ROUND_ELSE((bounds.size.w / 2) - 19, (bounds.size.w / 2) - 2); const int16_t hour_tick_length = PBL_IF_ROUND_ELSE((bounds.size.w / 2) - 28, bounds.size.w / 2); //const int16_t hour_hand_length = PBL_IF_ROUND_ELSE((bounds.size.w / 2) - 60, bounds.size.w / 2); calculate_pointer_end((t->tm_sec*100)+ms/10, second_hand_length, ¢er, &secondHand, 60*100, 0); // minute/hour hand graphics_context_set_fill_color(ctx, GColorWhite); graphics_context_set_stroke_color(ctx, GColorBlack); gpath_rotate_to(s_minute_arrow, TRIG_MAX_ANGLE * t->tm_min / 60); gpath_draw_filled(ctx, s_minute_arrow); gpath_draw_outline(ctx, s_minute_arrow); //graphics_draw_line(ctx, minuteHand, center); graphics_context_set_stroke_color(ctx, GColorWhite); //gpath_rotate_to(s_hour_arrow, (TRIG_MAX_ANGLE * (((t->tm_hour % 12) * 6) + (t->tm_min / 10))) / (12 * 6)); gpath_rotate_to(s_hour_arrow, (TRIG_MAX_ANGLE * (t->tm_hour*60+t->tm_min ))/ scale); gpath_draw_filled(ctx, s_hour_arrow); gpath_draw_outline(ctx, s_hour_arrow); // draw hour lines int hours = clock_is_24h_style() ? _24HScaleFactor : _12HScaleFactor; for (int h = 0; h < hours; h++) { calculate_pointer_end(h, hour_tick_length, ¢er, &hourHand1, hours, 0); if (h % 3 == 0) { calculate_pointer_end(h, hour_tick_length-11, ¢er, &hourHand2, hours, 0); } else { calculate_pointer_end(h, hour_tick_length-7, ¢er, &hourHand2, hours, 0); } graphics_context_set_fill_color(ctx, GColorWhite); graphics_context_set_stroke_color(ctx, GColorWhite); graphics_draw_line(ctx, hourHand1, hourHand2); } // draw second ticks for (int i = 0; i < t->tm_sec; i++) { calculate_pointer_end(i, second_hand_length, ¢er, &secondHand, 60, 0); graphics_context_set_fill_color(ctx, GColorWhite); graphics_fill_rect(ctx, GRect(secondHand.x, secondHand.y, 3, 3), 0, GCornerNone); } // dot in the middle graphics_context_set_fill_color(ctx, GColorBlack); graphics_fill_rect(ctx, GRect(bounds.size.w / 2 - 1, bounds.size.h / 2 - 1, 3, 3), 0, GCornerNone); }
text_layer_init(&text_event_start_date_layer, GRect(0, 36, window.layer.bounds.size.w, 21)); text_layer_set_text_color(&text_event_start_date_layer, GColorWhite); text_layer_set_background_color(&text_event_start_date_layer, GColorClear); text_layer_set_font(&text_event_start_date_layer, fonts_get_system_font(FONT_KEY_GOTHIC_18_BOLD)); layer_add_child(&window.layer, &text_event_start_date_layer.layer); // Location text_layer_init(&text_event_location_layer, GRect(0, 54, window.layer.bounds.size.w, 21)); text_layer_set_text_color(&text_event_location_layer, GColorWhite); text_layer_set_background_color(&text_event_location_layer, GColorClear); text_layer_set_font(&text_event_location_layer, fonts_get_system_font(FONT_KEY_GOTHIC_18)); layer_add_child(&window.layer, &text_event_location_layer.layer); // Battery GRect frame; frame.origin.x = layer_get_bounds(&window.layer).size.w - 31; frame.origin.y = 6; frame.size.w = 24; frame.size.h = 12; layer_init(&battery_layer, frame); battery_layer.update_proc = &battery_layer_update_callback; layer_add_child(&window.layer, &battery_layer); battery_status.state = 0; battery_status.level = -1; // Bluetooth GRect frameb; frameb.origin.x = layer_get_bounds(&window.layer).size.w - 50; frameb.origin.y = 6;
static void draw_astro(Layer *layer, GContext *ctx) { if (astro_initialized) { // draw dawn & dusk lines (background) GRect bounds = layer_get_bounds(layer); const GPoint center = grect_center_point(&bounds); GPathInfo horizon_info = { .num_points = 5, .points = (GPoint []) {{bounds.origin.x, center.y - (bounds.size.w * sin_lookup(sunrise_angle) / (2 * cos_lookup(sunrise_angle)))}, {center.x, center.y}, {bounds.size.w, center.y - (bounds.size.w * sin_lookup(sunset_angle) / (2 * cos_lookup(sunset_angle)))}, {bounds.size.w, bounds.size.h}, {bounds.origin.x, bounds.size.h} } }; GPath *horizon = NULL; horizon = gpath_create(&horizon_info); graphics_context_set_fill_color(ctx, GColorBlack); graphics_context_set_stroke_color(ctx, GColorBlack); gpath_draw_filled(ctx, horizon); gpath_draw_outline(ctx, horizon); // draw sun and moon rays graphics_draw_ray(ctx, layer, center, sun_angle, SUN_THICKNESS, SUN_STROKE, SUN_FILL); graphics_draw_ray(ctx, layer, center, moon_angle, MOON_THICKNESS, MOON_STROKE, MOON_FILL); // draw planets GPath *venus = NULL; GPath *mars = NULL; graphics_context_set_fill_color(ctx, GColorWhite); graphics_context_set_stroke_color(ctx, GColorBlack); venus = gpath_create(&VENUS_PATH_INFO); gpath_move_to(venus, GPoint(center.x + VENUS_RADIUS * cos_lookup(venus_angle) / TRIG_MAX_RATIO, center.y + VENUS_RADIUS * sin_lookup(venus_angle) / TRIG_MAX_RATIO)); gpath_draw_filled(ctx, venus); gpath_draw_outline(ctx, venus); mars = gpath_create(&VENUS_PATH_INFO); gpath_move_to(mars, GPoint(center.x + MARS_RADIUS * cos_lookup(mars_angle) / TRIG_MAX_RATIO, center.y + MARS_RADIUS * sin_lookup(mars_angle) / TRIG_MAX_RATIO)); gpath_rotate_to(mars, TRIG_MAX_ANGLE / 2); gpath_draw_filled(ctx, mars); gpath_draw_outline(ctx, mars); GRect jupiter = GRect(center.x + JUPITER_RADIUS * cos_lookup(jupiter_angle) / TRIG_MAX_RATIO, center.y + JUPITER_RADIUS * sin_lookup(jupiter_angle) / TRIG_MAX_RATIO, JUPITER_SIZE * 2, JUPITER_SIZE * 2); graphics_fill_rect(ctx, jupiter, 0, 0); graphics_draw_rect(ctx, jupiter); } } static void draw_time(Layer *layer, GContext *ctx) { // draw the time in an analog clock at the center GRect bounds = layer_get_bounds(layer); const GPoint center = grect_center_point(&bounds); time_t now = time(NULL); struct tm *t = localtime(&now); int secondMarkers = t->tm_sec / 2; int i; graphics_context_set_fill_color(ctx, GColorWhite); graphics_fill_circle(ctx, center, HMS_RADIUS); graphics_context_set_fill_color(ctx, GColorBlack); // draw the seconds if (secondMarkers % 30 != 0) { if (secondMarkers <= 15) { for (i=1; i<=secondMarkers; i++) { int angle = i * 4; GPoint marker = GPoint(center.x + SECOND_RADIUS * sin_lookup(angle * angle_180 / 30) / TRIG_MAX_RATIO, center.y - SECOND_RADIUS * cos_lookup(angle * angle_180 / 30) / TRIG_MAX_RATIO); graphics_fill_circle(ctx, marker, SECOND_THICKNESS); } } else { for (i=(secondMarkers % 15 + 1); i<=15; i++) { int angle = i * 4; GPoint marker = GPoint(center.x + SECOND_RADIUS * sin_lookup(angle * angle_180 / 30) / TRIG_MAX_RATIO, center.y - SECOND_RADIUS * cos_lookup(angle * angle_180 / 30) / TRIG_MAX_RATIO); graphics_fill_circle(ctx, marker, SECOND_THICKNESS); } } } // draw hour hand graphics_draw_arc_cw(ctx, center, HOUR_RADIUS, HOUR_THICKNESS, -angle_90, ((t->tm_hour * angle_180 / 6) - angle_90), GColorBlack); // draw minute hand graphics_draw_arc_cw(ctx, center, MINUTE_RADIUS, MINUTE_THICKNESS, -angle_90, ((t->tm_min * angle_180 / 30) - angle_90), GColorBlack); }
static void pad_update_proc(Layer *this_layer, GContext *ctx) { //Background graphics_context_set_fill_color(ctx, GColorBlack); graphics_fill_rect(ctx, layer_get_bounds(s_pad_layer), 0, GCornerNone); pos += (spd*.7); //Paddle bounds if(pos <= 0) { pos = 0; } else if(pos >= 105) { pos = 105; } //Paddle graphics_context_set_fill_color(ctx, GColorWhite); graphics_fill_rect(ctx, GRect(10, pos , 7, 45), 0, GCornerNone); //Ball bounce off right if(bpos.x >= 130) { bspd.x = bspd.x * -1; score += 1; //Score static char sco[32]; snprintf(sco, sizeof(sco), "Score %i", score); text_layer_set_text(s_scr, sco); } //Ball bounce off top or bot if(bpos.y <= 5 || bpos.y >= 140) { bspd.y = bspd.y * -1; } //Change in speed if(bpos.x >= 16 && bpos.x < 20) { if(abs(bpos.y + 5 - (pos+23)) < 23) { if(abs(bpos.y - pos - 11) <12) { if(bspd.y < 10) { bspd.y += 1; } else { bspd.y = 10; } } else if(abs(bpos.y - pos + 11) < 12) { if(bspd.y > -10) { bspd.y -= 1; } else { bspd.y = -10; } } bspd.x *= -1; } if(bpos.x <= 5) { bspd.x = bspd.x * -1; bpos.x += bspd.x; layer_mark_dirty(s_pad_layer); score -= 1; static char sco[32]; snprintf(sco, sizeof(sco), "Score %i", score); text_layer_set_text(s_scr, sco); } } /* if(bpos.x < 5) //Suppose to vibrate { vibes_short_pulse(); }*/ //Change in HighScore bpos.x += bspd.x; bpos.y += bspd.y; //The ball graphics_fill_rect(ctx, GRect(bpos.x, bpos.y, 10, 10), 0, GCornerNone); }
static void line_layer_update_callback(Layer *layer, GContext* ctx) { graphics_context_set_fill_color(ctx, GColorWhite); graphics_fill_rect(ctx, layer_get_bounds(layer), 0, GCornerNone); }
static void anim_update_proc(Layer *layer, GContext *ctx) { int x = layer_get_bounds(layer).size.w / 2 ; graphics_context_set_fill_color(ctx, GColorWhite); graphics_fill_circle(ctx, GPoint(x,x) ,x -1); //layer_mark_dirty(s_box2_layer); }
static void icon_update_proc(Layer *layer, GContext *ctx) { GRect bounds = layer_get_bounds(layer); GRect bitmap_bounds = gbitmap_get_bounds(immergo_bitmap); graphics_context_set_compositing_mode(ctx, GCompOpSet); graphics_draw_bitmap_in_rect(ctx, immergo_bitmap, (GRect){.origin = bounds.origin, .size = bitmap_bounds.size});
static void window_load(Window *window) { Layer *window_layer = window_get_root_layer(window); GRect bounds = layer_get_bounds(window_layer); text_layer = text_layer_create((GRect) { .origin = { 0, 72 }, .size = { bounds.size.w, 20 } });
static void main_window_load(Window *window) { // Get information about the Window Layer *window_layer = window_get_root_layer(window); GRect bounds = layer_get_bounds(window_layer); APP_LOG(APP_LOG_LEVEL_INFO, "Main window loading"); APP_LOG(APP_LOG_LEVEL_INFO, "battery time"); s_battery_layer = layer_create(GRect(PBL_IF_ROUND_ELSE(0, 20), PBL_IF_ROUND_ELSE(0, 154), PBL_IF_ROUND_ELSE(180, 104), PBL_IF_ROUND_ELSE(180, 2))); s_weather_layer = text_layer_create(GRect(0, PBL_IF_ROUND_ELSE(117, 120), bounds.size.w, 55)); s_time_layer = text_layer_create(GRect(0, PBL_IF_ROUND_ELSE(52, 46), bounds.size.w, 80)); s_date_layer = PBL_IF_BW_ELSE(text_layer_create(GRect(1, 2, bounds.size.w, 50)), text_layer_create(GRect(PBL_IF_ROUND_ELSE(42, 1), PBL_IF_ROUND_ELSE(15, 1), PBL_IF_ROUND_ELSE(97, 65), 55))); s_bt_icon_layer = PBL_IF_BW_ELSE(layer_create(GRect(60, 115, 30, 30)), layer_create(GRect(PBL_IF_ROUND_ELSE(75, 62), PBL_IF_ROUND_ELSE(135, 8), 30, 30))); int textcolor = persist_read_int(MESSAGE_KEY_TextColor); int background = persist_read_int(MESSAGE_KEY_BackgroundColor); GColor bg_color = GColorFromHEX(background); GColor text_color = GColorFromHEX(textcolor); window_set_background_color(s_main_window, bg_color); APP_LOG(APP_LOG_LEVEL_INFO, "Text Color is: %d", textcolor); APP_LOG(APP_LOG_LEVEL_INFO, "Background Color is: %d", background); // Battery Layer layer_set_update_proc(s_battery_layer, battery_update_proc); // Add Battery Layer to Window layer_add_child(window_get_root_layer(window), s_battery_layer); APP_LOG(APP_LOG_LEVEL_INFO, "reading key: celsius"); if (persist_read_bool(MESSAGE_KEY_Celsius)) { celsius = persist_read_int(MESSAGE_KEY_Celsius); } /* APP_LOG(APP_LOG_LEVEL_INFO, "reading key: customLocation"); if (persist_read_string(KEY_CUSTOM_LOCATION)) { customLocation = persist_read_string(KEY_CUSTOM_LOCATION); }*/ APP_LOG(APP_LOG_LEVEL_INFO, "weather time"); // Weather Layer text_layer_set_background_color(s_weather_layer, GColorClear); text_layer_set_text_color(s_weather_layer, text_color); //text_layer_set_text_color(s_weather_layer, GColorBlack); text_layer_set_text_alignment(s_weather_layer, GTextAlignmentCenter); PBL_IF_BW_ELSE(text_layer_set_text(s_weather_layer, ""), text_layer_set_text(s_weather_layer, "Loading...")); s_weather_font = PBL_IF_ROUND_ELSE(fonts_load_custom_font(resource_get_handle(RESOURCE_ID_SF_17)), fonts_load_custom_font(resource_get_handle(RESOURCE_ID_SF_20))); text_layer_set_font(s_weather_layer, s_weather_font); // Add Weather Layer to Window layer_add_child(window_get_root_layer(window), text_layer_get_layer(s_weather_layer)); APP_LOG(APP_LOG_LEVEL_INFO, "time layer"); // Time Layer s_time_font = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_SF_53)); text_layer_set_font(s_time_layer, s_time_font); text_layer_set_background_color(s_time_layer, GColorClear); text_layer_set_text_color(s_time_layer, text_color); APP_LOG(APP_LOG_LEVEL_INFO, "reading key: invert"); APP_LOG(APP_LOG_LEVEL_INFO, "reading key: 24h"); text_layer_set_text_alignment(s_time_layer, GTextAlignmentCenter); // Add Time Layer to Window layer_add_child(window_layer, text_layer_get_layer(s_time_layer)); APP_LOG(APP_LOG_LEVEL_INFO, "date time"); // Date Layer s_date_font = PBL_IF_BW_ELSE(fonts_load_custom_font(resource_get_handle(RESOURCE_ID_SF_20)), fonts_load_custom_font(resource_get_handle(RESOURCE_ID_SF_17))); text_layer_set_text_color(s_date_layer, text_color); //text_layer_set_text_color(s_date_layer, GColorBlack); text_layer_set_background_color(s_date_layer, GColorClear); text_layer_set_text_alignment(s_date_layer, GTextAlignmentCenter); text_layer_set_font(s_date_layer, s_date_font); APP_LOG(APP_LOG_LEVEL_INFO, "updating time"); // Add Date Layer to Window layer_add_child(window_get_root_layer(window), text_layer_get_layer(s_date_layer)); // Create the Bluetooth icon GBitmap APP_LOG(APP_LOG_LEVEL_INFO, "Reading Bluetooth color: %d", persist_read_bool(MESSAGE_KEY_Bluetooth)); if (persist_read_int(MESSAGE_KEY_Bluetooth) == 102) { s_bt_icon_bitmap = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_BT_ICON); } else { s_bt_icon_bitmap = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_BT_ICON_BLACK); } // Create the BitmapLayer to display the GBitmap s_bt_icon_layer = PBL_IF_BW_ELSE(layer_create(GRect(60, 115, 30, 30)), layer_create(GRect(PBL_IF_ROUND_ELSE(75, 62), PBL_IF_ROUND_ELSE(135, 8), 30, 30))); layer_set_update_proc(s_bt_icon_layer, layer_update_proc); //bitmap_layer_set_bitmap(s_bt_icon_layer, s_bt_icon_bitmap); layer_add_child(window_layer, s_bt_icon_layer); APP_LOG(APP_LOG_LEVEL_INFO, "steps time"); // Steps Layer // subscribe to health events int goal_num = persist_read_int(MESSAGE_KEY_Step_Goal); int steps = persist_read_int(MESSAGE_KEY_Goal_Color); GColor steps_color = GColorFromHEX(steps); s_num_label = text_layer_create(GRect(PBL_IF_ROUND_ELSE(67, 90), PBL_IF_ROUND_ELSE(37, 1), 50, 45)); text_layer_set_background_color(s_num_label, GColorClear); text_layer_set_text_color(s_num_label, text_color); int s_step_count = (int)health_service_sum_today(HealthMetricStepCount); if (goal_num == 0 || s_step_count < goal_num) { int textcolor = persist_read_int(MESSAGE_KEY_TextColor); GColor text_color = GColorFromHEX(textcolor); text_layer_set_text_color(s_num_label, text_color); } else { text_layer_set_text_color(s_num_label, steps_color); } //text_layer_set_text_color(s_num_label, GColorBlack); text_layer_set_text_alignment(s_num_label, PBL_IF_ROUND_ELSE(GTextAlignmentCenter, GTextAlignmentRight)); text_layer_set_font(s_num_label, fonts_load_custom_font(resource_get_handle(RESOURCE_ID_SF_17))); layer_add_child(window_get_root_layer(window), text_layer_get_layer(s_num_label)); if(health_service_events_subscribe(health_handler, NULL)) { // force initial steps display health_handler(HealthEventMovementUpdate, NULL); } else { APP_LOG(APP_LOG_LEVEL_ERROR, "Health not available!"); } // Show the correct state of the BT connection from the start bluetooth_callback(connection_service_peek_pebble_app_connection()); APP_LOG(APP_LOG_LEVEL_INFO, "Main window loaded"); update_time(); }
window = window_create(); window_set_window_handlers(window, (WindowHandlers) { .load = window_load, .unload = window_unload, }); window_stack_push(window, true); s_day_buffer[0] = '\0'; s_num_buffer[0] = '\0'; // init hand paths s_minute_arrow = gpath_create(&MINUTE_HAND_POINTS); s_hour_arrow = gpath_create(&HOUR_HAND_POINTS); Layer *window_layer = window_get_root_layer(window); GRect bounds = layer_get_bounds(window_layer); GPoint center = grect_center_point(&bounds); gpath_move_to(s_minute_arrow, center); gpath_move_to(s_hour_arrow, center); for (int i = 0; i < NUM_CLOCK_TICKS; ++i) { s_tick_paths[i] = gpath_create(&ANALOG_BG_POINTS[i]); } Star[0] = gpath_create(&FillGray); Star[1] = gpath_create(&FillBlack); Star[2] = gpath_create(&FillWhite); Star[3] = gpath_create(&FillCenter); for (int i = 0; i < 6; ++i){ HiLites[i] = gpath_create(&HiLitePts[i]); }
static void main_window_load(Window *window) { // Get information about the Window Layer *window_layer = window_get_root_layer(window); GRect bounds = layer_get_bounds(window_layer); // Create the TextLayer with specific bounds GRect(0, PBL_IF_ROUND_ELSE(58, 52), bounds.size.w, 50)); s_time_layer = text_layer_create( GRect(0, PBL_IF_ROUND_ELSE(10, 10), bounds.size.w, 50)); // Improve the layout to be more like a watchface text_layer_set_background_color(s_time_layer, textBackgroundColour); text_layer_set_text_color(s_time_layer, textColour); text_layer_set_text(s_time_layer, "00:00"); text_layer_set_text_alignment(s_time_layer, GTextAlignmentCenter); text_layer_set_font(s_time_layer, fonts_get_system_font(FONT_KEY_BITHAM_42_LIGHT )); // Add it as a child layer to the Window's root layer layer_add_child(window_layer, text_layer_get_layer(s_time_layer)); // Create date TextLayer s_date_layer = text_layer_create( GRect(0, PBL_IF_ROUND_ELSE(10, 70), bounds.size.w, 50)); //GColorBlack text_layer_set_background_color(s_date_layer, textBackgroundColour); text_layer_set_text_color(s_date_layer, textColour); text_layer_set_text(s_date_layer, "dd:mm:yyyy"); text_layer_set_text_alignment(s_date_layer, GTextAlignmentCenter); text_layer_set_font(s_date_layer, fonts_get_system_font(FONT_KEY_GOTHIC_14_BOLD)); // Add it as a child layer to the Window's root layer layer_add_child(window_layer, text_layer_get_layer(s_date_layer)); // Create temperature Layer s_weather_layer = text_layer_create( GRect(0, PBL_IF_ROUND_ELSE(125, 130), bounds.size.w, 30)); // Style the text text_layer_set_background_color(s_weather_layer, textBackgroundColour); text_layer_set_text_color(s_weather_layer, textColour); text_layer_set_text_alignment(s_weather_layer, GTextAlignmentCenter); text_layer_set_text(s_weather_layer, "hold on boss..."); text_layer_set_font(s_time_layer, fonts_get_system_font(FONT_KEY_BITHAM_42_LIGHT )); layer_add_child(window_get_root_layer(window), text_layer_get_layer(s_weather_layer)); // Sun Layer s_sun_layer = text_layer_create( GRect(0, PBL_IF_ROUND_ELSE(95, 95), bounds.size.w, 25)); text_layer_set_background_color(s_sun_layer, textBackgroundColour); text_layer_set_text_color(s_sun_layer, textColour); text_layer_set_text_alignment(s_sun_layer, GTextAlignmentCenter); text_layer_set_text(s_sun_layer, "<><><><><><>"); text_layer_set_font(s_sun_layer, fonts_get_system_font(FONT_KEY_GOTHIC_14_BOLD)); layer_add_child(window_get_root_layer(window), text_layer_get_layer(s_sun_layer)); // Create battery meter Layer s_battery_layer = layer_create(GRect(14, 54, 115, 2)); layer_set_update_proc(s_battery_layer, battery_update_proc); // Add to Window layer_add_child(window_get_root_layer(window), s_battery_layer); }