void init(void) {
window = window_create();
window_stack_push(window, true);
s_time_layer = text_layer_create(GRect(0, 15, 144, 40));
text_layer_set_background_color(s_time_layer, GColorBlack);
text_layer_set_text_color(s_time_layer, GColorWhite);
text_layer_set_text(s_time_layer, "00:00:00");
text_layer_set_text_alignment(s_time_layer, GTextAlignmentCenter);
text_layer_set_font(s_time_layer, fonts_get_system_font(FONT_KEY_ROBOTO_CONDENSED_21));
layer_add_child(window_get_root_layer(window), (Layer *)s_time_layer);
//Somebody set us up the CLOCK
time_t now = time(NULL);
struct tm *tick_time = localtime(&now);
handle_tick(tick_time, SECOND_UNIT);
//tick_timer_service_subscribe(SECOND_UNIT, handle_tick);
Layer *window_layer = window_get_root_layer(window);
layer_set_update_proc(window_layer, bg_update_proc);
// Register AppMessage handlers
//app_message_register_inbox_received(in_received_handler);
//app_message_register_inbox_dropped(in_dropped_handler);
//app_message_register_outbox_failed(out_failed_handler);
//app_message_open(app_message_inbox_size_maximum(), app_message_outbox_size_maximum());
//send_message();
}
void window_load(Window *window) {
Layer *window_layer = window_get_root_layer(window);
arrow_bar_layer = layer_create(GRect(0, 64, 144, 36));
layer_set_update_proc( arrow_bar_layer, (LayerUpdateProc) update_arrow_bar_layer_bg );
layer_add_child( window_layer, arrow_bar_layer);
bmp_plus_white = gbitmap_create_with_resource( RESOURCE_ID_IMAGE_BUTTON_PLUS_WHITE );
bmp_plus_black = gbitmap_create_with_resource( RESOURCE_ID_IMAGE_BUTTON_PLUS_BLACK );
bmp_minus_white = gbitmap_create_with_resource( RESOURCE_ID_IMAGE_BUTTON_MINUS_WHITE );
bmp_minus_black = gbitmap_create_with_resource( RESOURCE_ID_IMAGE_BUTTON_MINUS_BLACK );
bmp_arrow_up = gbitmap_create_with_resource( RESOURCE_ID_IMAGE_ARROW_UP );
bmp_arrow_down = gbitmap_create_with_resource( RESOURCE_ID_IMAGE_ARROW_DOWN );
button_top_white = bitmap_layer_create( GRect(119, 0, 26, 26) );
button_top_black = bitmap_layer_create( GRect(119, 0, 26, 26) );
button_bottom_white = bitmap_layer_create( GRect(119, 127, 26, 26) );
button_bottom_black = bitmap_layer_create( GRect(119, 127, 26, 26) );
button_arrow = bitmap_layer_create( GRect(53, 70, 20, 21) );
set_button_arrow();
set_button_graphic( window_layer, button_top_white, button_top_black, bmp_plus_white, bmp_plus_black );
set_button_graphic( window_layer, button_bottom_white, button_bottom_black, bmp_minus_white, bmp_minus_black );
counter_lbl_top = text_layer_create( GRect(0, 10, 124, 46) );
counter_lbl_bottom = text_layer_create( GRect(0, 100, 124, 46) );
init_counter_lbl( window_layer, counter_lbl_top );
init_counter_lbl( window_layer, counter_lbl_bottom );
populate_counter_labels( );
window_set_background_color(window, GColorBlack);
}
/*
* Function: window_load
* ----------------------------------------------------------------------------
* Overview window load handler.
* Creates and inits the needed layers and sets the mood.
*
* window: the window that has been loaded
* ----------------------------------------------------------------------------
*/
static void window_load(Window *window) {
Layer *window_layer = window_get_root_layer(window);
GRect bounds = layer_get_bounds(window_layer);
// Create Mood avg + median info Text Layer
s_text_layer = text_layer_create(GRect(0, 0, bounds.size.w, TOP_TEXT_H));
text_layer_set_text_alignment(s_text_layer, GTextAlignmentCenter);
text_layer_set_font(s_text_layer,
fonts_get_system_font(FONT_KEY_GOTHIC_28_BOLD));
layer_add_child(window_layer, (Layer *)s_text_layer);
set_mood();
s_mood_min = storage_read_int(KEY_MOOD_MIN, NUM_MOOD_MIN);
s_mood_max = storage_read_int(KEY_MOOD_MAX, NUM_MOOD_MAX);
s_mood_step = storage_read_int(KEY_MOOD_STEP, NUM_MOOD_STEP);
s_num_moods = (abs(s_mood_min) + s_mood_max);
// Create Graph Canvas Layer
s_canvas_layer = layer_create(GRect(0, TOP_TEXT_H, bounds.size.w,
bounds.size.h-TOP_TEXT_H));
layer_add_child(window_layer, s_canvas_layer);
// Set the Graph Layer update_proc
layer_set_update_proc(s_canvas_layer, canvas_update_proc);
}
static ProgressBarLayer * progress_bar_layer_create(int y_pos) {
ProgressBarLayer *progress_bar_layer = layer_create_with_data(GRect(6, y_pos, PBAR_WIDTH, PBAR_HEIGHT), sizeof(ProgressData));
layer_set_update_proc(progress_bar_layer, progress_bar_layer_update);
layer_mark_dirty(progress_bar_layer);
return progress_bar_layer;
}
void show_watchface(void) {
initialise_ui();
s_res_charging = gbitmap_create_with_resource(RESOURCE_ID_CHARGING);
s_res_battery_20 = gbitmap_create_with_resource(RESOURCE_ID_BATTERY_20);
s_res_battery_40 = gbitmap_create_with_resource(RESOURCE_ID_BATTERY_40);
s_res_battery_60 = gbitmap_create_with_resource(RESOURCE_ID_BATTERY_60);
s_res_battery_80 = gbitmap_create_with_resource(RESOURCE_ID_BATTERY_80);
s_res_battery_100 = gbitmap_create_with_resource(RESOURCE_ID_BATTERY_100);
layer_set_update_proc(sCalendarLayer, calendar_layer_update_callback);
tick_timer_service_subscribe(MINUTE_UNIT, handle_minute_tick);
battery_state_service_subscribe(handle_battery);
bluetooth_connection_service_subscribe(handle_bluetooth);
sTimer = NULL;
btStatus = bluetooth_connection_service_peek();
handle_battery(battery_state_service_peek());
currentTime = get_time();
update_time_text();
update_date_text();
layer_mark_dirty(sCalendarLayer);
window_set_window_handlers(s_window, (WindowHandlers) {
.unload = handle_window_unload,
});
static Layer* selection_layer_init(SelectionLayerData *selection_layer_, GRect frame, int num_cells) {
Layer *layer = layer_create_with_data(frame, sizeof(SelectionLayerData));
SelectionLayerData *selection_layer_data = layer_get_data(layer);
if (num_cells > MAX_SELECTION_LAYER_CELLS) {
num_cells = MAX_SELECTION_LAYER_CELLS;
}
// Set layer defaults
*selection_layer_data = (SelectionLayerData) {
.active_background_color = DEFAULT_ACTIVE_COLOR,
.inactive_background_color = DEFAULT_INACTIVE_COLOR,
.num_cells = num_cells,
.cell_padding = DEFAULT_CELL_PADDING,
.selected_cell_idx = DEFAULT_SELECTED_INDEX,
.font = fonts_get_system_font(DEFAULT_FONT),
.is_active = true,
};
for (int i = 0; i < num_cells; i++) {
selection_layer_data->cell_widths[i] = 0;
}
layer_set_frame(layer, frame);
layer_set_clips(layer, false);
layer_set_update_proc(layer, (LayerUpdateProc)prv_draw_selection_layer);
return layer;
}
Layer* selection_layer_create(GRect frame, int num_cells) {
SelectionLayerData *selection_layer_data = NULL;
return selection_layer_init(selection_layer_data, frame, num_cells);
}
/*
* Call back function when message comes in.
* Add short vibrate when message comes in.
*/
void in_received_handler(DictionaryIterator *received, void *context) {
// incoming message received
// looks for key #0 in the incoming message
int key = 0;
Tuple *text_tuple = dict_find(received, key);
if (text_tuple) {
if (text_tuple->value) {
// put it in this global variable
char *message = text_tuple->value->cstring;
if (message[strlen(message) - 1] == ',') {
strcpy(msg, message);
layer_set_update_proc(canvas_layer, layer_graph_update_callback);
layer_mark_dirty(canvas_layer);
}
else {
show_message(message);
}
}
else
show_message("Not Getting Response from Server :(");
}
else {
show_message("Not Getting Response from Server :(");
}
vibes_short_pulse();
}
void handle_init(AppContextRef ctx) {
Layer *rootLayer;
int i;
window_init(&window, "Minimalist");
window_stack_push(&window, true /* Animated */);
window_set_background_color(&window, GColorBlack);
clock12 = !clock_is_24h_style();
resource_init_current_app(&APP_RESOURCES);
for (i=0; i<NUM_IMAGES; i++) {
heap_bitmap_init(&digitBmp[i], digitId[i]);
#if WHITE_BACKGROUND
bmpNegative(&digitBmp[i].bmp);
#endif
}
rootLayer = window_get_root_layer(&window);
layer_init(&layer, GRect(0,0,SCREENW,SCREENH));
layer_set_update_proc(&layer, &update_display);
layer_add_child(rootLayer, &layer);
handle_tick(ctx, NULL);
//layer_mark_dirty(&layer);
}
static void main_window_load(Window *window) {
Layer *window_layer = window_get_root_layer(window);
GRect bounds = layer_get_bounds(window_layer);
s_time_layer = text_layer_create(GRect(0, PBL_IF_ROUND_ELSE(61, 55), bounds.size.w, 50));
text_layer_set_background_color(s_time_layer, GColorClear);
text_layer_set_text(s_time_layer, "00:00");
text_layer_set_text_alignment(s_time_layer, GTextAlignmentCenter);
layer_add_child(window_layer, text_layer_get_layer(s_time_layer));
s_step_count_layer = text_layer_create(GRect(0, PBL_IF_ROUND_ELSE(45, 40), bounds.size.w, 40));
text_layer_set_text_alignment(s_step_count_layer, GTextAlignmentCenter);
text_layer_set_background_color(s_step_count_layer, GColorClear);
layer_add_child(window_layer, text_layer_get_layer(s_step_count_layer));
s_dayt_layer = text_layer_create(GRect(0, PBL_IF_ROUND_ELSE(106, 100), bounds.size.w, 40));
text_layer_set_text_alignment(s_dayt_layer, GTextAlignmentCenter);
text_layer_set_background_color(s_dayt_layer, GColorClear);
layer_add_child(window_layer, text_layer_get_layer(s_dayt_layer));
setLayerTextColors();
setLayerFonts();
s_canvas_layer = layer_create(bounds);
layer_set_update_proc(s_canvas_layer, draw_proc);
layer_add_child(window_layer, s_canvas_layer);
}
void init_graph(Window *window) {
// Create Graph Layer
s_graph_layer = layer_create(GRect(2, 60, BOX_WIDTH, BOX_HEIGHT));
layer_add_child(window_get_root_layer(window), s_graph_layer);
layer_set_hidden(s_graph_layer, true);
// Create Status Layer
s_status_layer = layer_create(GRect(-120, 120, 120, 47));
layer_add_child(window_get_root_layer(window), s_status_layer);
snprintf(statusbuffer, 30, "Totalt: 0\nUser: 0");
s_graph_path_ptr = gpath_create(&GRAPH_PATH_INFO);
layer_set_update_proc(s_graph_layer, graph_layer_update_callback);
layer_set_update_proc(s_status_layer, status_layer_update_callback);
}
void load_weather(Window *window) {
s_weather_layer = text_layer_create(GRect(0,0,144,50));
//text_layer_set_text_color(s_weather_layer, GColorWhite);
text_layer_set_text_color(s_weather_layer, default_color);
text_layer_set_text_alignment(s_weather_layer, GTextAlignmentCenter);
text_layer_set_background_color(s_weather_layer, GColorClear);
text_layer_set_font(s_weather_layer, fonts_get_system_font(FONT_KEY_GOTHIC_14));
s_weather_temp_min = text_layer_create(GRect(126,34,144,50));
text_layer_set_text_color(s_weather_temp_min, default_color);
text_layer_set_background_color(s_weather_temp_min, GColorClear);
text_layer_set_font(s_weather_temp_min, fonts_get_system_font(FONT_KEY_GOTHIC_14));
s_weather_temp_max = text_layer_create(GRect(126,23,144,50));
text_layer_set_text_color(s_weather_temp_max, default_color);
text_layer_set_background_color(s_weather_temp_max, GColorClear);
text_layer_set_font(s_weather_temp_max, fonts_get_system_font(FONT_KEY_GOTHIC_14));
s_weather_icon_layer = bitmap_layer_create(GRect(100, -8, 50, 50));
//bitmap_layer_set_background_color(s_weather_icon_layer, GColorWhite);
bitmap_layer_set_compositing_mode(s_weather_icon_layer, GCompOpSet);
s_weather_icon_draw_layer = layer_create(GRect(118, 1, 25, 25));
layer_set_update_proc(s_weather_icon_draw_layer, update_weather_cmd_img_proc);
weather_display_refresh();
layer_add_child(window_get_root_layer(window), text_layer_get_layer(s_weather_layer));
layer_add_child(window_get_root_layer(window), text_layer_get_layer(s_weather_temp_max));
layer_add_child(window_get_root_layer(window), text_layer_get_layer(s_weather_temp_min));
layer_add_child(window_get_root_layer(window), bitmap_layer_get_layer(s_weather_icon_layer));
layer_add_child(window_get_root_layer(window), s_weather_icon_draw_layer);
}
static void window_load(Window *window) {
Layer *window_layer = window_get_root_layer(window);
// GRect bounds = layer_get_bounds(window_layer);
deco_layer = layer_create(GRect(0, 0, 144, 8));
layer_set_update_proc(deco_layer, deco_layer_onupdate);
arrow_image = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_ARROW_24);
image_layer = bitmap_layer_create(GRect(12, 20, 24, 24));
bitmap_layer_set_bitmap(image_layer, arrow_image);
text_layer = text_layer_create(GRect(16, 113, 128, 24));
text_layer_set_background_color(text_layer, METRO_APP_BACK_COLOR);
text_layer_set_text_color(text_layer, METRO_APP_TEXT_COLOR);
text_font = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_OSWALD_LIGHT_18));
text_layer_set_font(text_layer, text_font);
time_layer = text_layer_create(GRect(16, 58, 128, 48));
text_layer_set_background_color(time_layer, METRO_APP_BACK_COLOR);
text_layer_set_text_color(time_layer, METRO_APP_TEXT_COLOR);
time_font = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_OSWALD_REGULAR_48));
text_layer_set_font(time_layer, time_font);
layer_add_child(window_layer, deco_layer);
layer_add_child(window_layer, bitmap_layer_get_layer(image_layer));
layer_add_child(window_layer, text_layer_get_layer(text_layer));
layer_add_child(window_layer, text_layer_get_layer(time_layer));
}
static void init(void)
{
memset(&time_digits_layers, 0, sizeof(time_digits_layers));
memset(&time_digits_images, 0, sizeof(time_digits_images));
const int inbound_size = 64;
const int outbound_size = 64;
app_message_open(inbound_size, outbound_size);
window = window_create();
if (window == NULL)
{
return;
}
window_set_background_color(window, GColorBlack);
canvas = layer_create(GRect(0, 0, 144, 168));
layer_set_update_proc(canvas, (LayerUpdateProc) render);
layer_add_child(window_get_root_layer(window), canvas);
window_stack_push(window, true);
Layer *window_layer = window_get_root_layer(window);
load_settings();
// Open AppMessage connection
app_message_register_inbox_received(inbox_received_handler);
app_message_open(128, 128);
//owm_weather_init(5ba77aab84470992ddc7e49e4985aeab);
//events_app_message_open();
//owm_weather_fetch();
handle_weather();
handle_battery(battery_state_service_peek());
battery_state_service_subscribe(handle_battery);
// Create time and date layers
GRect dummy_frame = { {0, 0}, {0, 0} };
for (int i = 0; i < TOTAL_TIME_DIGITS; i++)
{
time_digits_layers[i] = bitmap_layer_create(dummy_frame);
layer_add_child(window_layer, bitmap_layer_get_layer(time_digits_layers[i]));
}
mFont = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_20));
mDayText = malloc(mDayTextSize);
mWeatherText = malloc(mWeatherTextSize);
mBatteryText = malloc(mBatteryTextSize);
// Avoids a blank screen on watch start.
time_t now = time(NULL);
struct tm *tick_time = localtime(&now);
handle_tick(tick_time, DAY_UNIT + HOUR_UNIT + MINUTE_UNIT);
tick_timer_service_subscribe(MINUTE_UNIT, handle_tick);
}
void handle_init() {
// Configure window
window = window_create();
window_stack_push(window, true /* Animated */);
window_set_background_color(window, BKGD_COLOR);
window_set_fullscreen(window, true);
Layer *window_layer = window_get_root_layer(window);
// Dynamic allocation of assets
minuteFrame = GRect(53, 16, 40, 40);
minuteLayer = text_layer_create(minuteFrame);
hourLayer = bitmap_layer_create(GRect(0, 0, 144, 148));
batteryLogoLayer = bitmap_layer_create(GRect(65, 151, 10, 15));
batteryPercentLayer = text_layer_create(GRect(78, 150, 30, 167-150));
dateLayer = text_layer_create(GRect(3, 150, 38, 167-150));
dayLayer = text_layer_create(GRect(141-30, 150, 30, 167-150));
text_layer_set_text_alignment(dayLayer, GTextAlignmentRight);
bottomBarLayer = layer_create(GRect(1, 149, 142, 18));
// Setup minute layer
text_layer_set_text_color(minuteLayer, TEXT_COLOR);
text_layer_set_background_color(minuteLayer, GColorClear);
text_layer_set_font(minuteLayer, fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_MINUTE_38)));
// Setup date & day layer
text_layer_set_text_color(dateLayer, TEXT_COLOR);
text_layer_set_background_color(dateLayer, GColorClear);
text_layer_set_text_color(dayLayer, TEXT_COLOR);
text_layer_set_background_color(dayLayer, GColorClear);
// Setup battery layers
text_layer_set_text_color(batteryPercentLayer, TEXT_COLOR);
text_layer_set_background_color(batteryPercentLayer, GColorClear);
// Setup line layer
layer_set_update_proc(bottomBarLayer, bottom_bar_layer_update_callback);
// Add layers into hierachy
layer_add_child(bitmap_layer_get_layer(hourLayer), text_layer_get_layer(minuteLayer));
layer_add_child(window_layer, bitmap_layer_get_layer(hourLayer));
layer_add_child(window_layer, bottomBarLayer);
layer_add_child(window_layer, bitmap_layer_get_layer(batteryLogoLayer));
layer_add_child(window_layer, text_layer_get_layer(batteryPercentLayer));
layer_add_child(window_layer, text_layer_get_layer(dateLayer));
layer_add_child(window_layer, text_layer_get_layer(dayLayer));
// Avoids a blank screen on watch start.
time_t tick_time = time(NULL);
display_time(localtime(&tick_time));
handle_battery(battery_state_service_peek());
handle_bluetooth(bluetooth_connection_service_peek());
tick_timer_service_subscribe(MINUTE_UNIT, &handle_minute_tick);
battery_state_service_subscribe(&handle_battery);
bluetooth_connection_service_subscribe(&handle_bluetooth);
initialized = true;
}
DimLayer* dim_layer_create(GRect frame)
{
DimLayer* new_dim_layer = layer_create_with_data(frame, sizeof(DimLayerData));
layer_set_update_proc(new_dim_layer, dim_layer_update_proc);
dim_layer_set_dim_mode(new_dim_layer, DimModeBright);
return new_dim_layer;
}
void bitmap_layer_init(BitmapLayer *image, GRect frame) {
layer_init ((Layer*)image,frame);
layer_set_update_proc((Layer*)image,bitmap_layer_update_func);
image->bitmap=0;
image->background_color=GColorClear;
image->alignment=GAlignCenter;
image->compositing_mode=GCompOpAssign;
}
// Setup the drawing layer to be drawn when the layer is created
static void window_load(Window *window) {
Layer *window_layer = window_get_root_layer(window);
GRect frame = layer_get_frame(window_layer);
drawing_layer = layer_create(frame);
layer_set_update_proc(drawing_layer, drawing_layer_update_callback);
layer_add_child(window_layer, drawing_layer);
}
static void main_window_load(Window *window) {
setup_bitmaps();
window_set_background_color(window, GColorBlack);
Layer *root = window_get_root_layer(window);
GRect bounds = layer_get_bounds(root);
scale_layer = layer_create(GRect(0,0, bounds.size.w, bounds.size.h));
layer_set_update_proc(scale_layer, update_scale);
layer_add_child(root, scale_layer);
hand_layer = layer_create(GRect(0, 0, bounds.size.w, bounds.size.h));
layer_set_update_proc(hand_layer, update_hands);
layer_add_child(root, hand_layer);
}
void rotbmp_pair_layer_init (RotBmpPairLayer* layer,GRect frame) {
layer_init((Layer*)layer,frame);
rotbmp_layer_init (&layer->white_layer,frame); //the white and black layers are not added as childs
rotbmp_layer_init (&layer->black_layer,frame);
layer->white_layer.compositing_mode=GCompOpOr;
layer->black_layer.compositing_mode=GCompOpClear;
layer_set_update_proc ((Layer*)layer,rotbmp_pair_layer_update_func);
}
Layer * create_direction_layer(GRect bounds) {
Layer *layer = layer_create_with_data(GRect(0, 20, bounds.size.w, 30), sizeof(Arrow));
layer_set_update_proc(layer, redraw_direction_arrow);
arrow_path = gpath_create(&ARROW_PATH_INFO);
GRect layer_bounds = layer_get_bounds(layer);
gpath_move_to(arrow_path, grect_center_point(&layer_bounds));
return layer;
}
Layer* battery_init() {
s_battery_layer = layer_create(GRect(5, 5, 20, 20));
layer_set_update_proc(s_battery_layer, draw_battery);
s_battery_path = gpath_create(&BATTERY_PATH_INFO);
return s_battery_layer;
}
static void window_load(Window *window) {
Layer *window_layer = window_get_root_layer(window);
layer_set_update_proc(window_layer, update_procs[0]);
s_window_size = layer_get_bounds(window_layer).size;
// start update loop
update_animation(NULL);
}
static void window_load(Window *window) {
Layer *window_layer = window_get_root_layer(window);
GRect window_bounds = layer_get_bounds(window_layer);
s_canvas_layer = layer_create(window_bounds);
layer_set_update_proc(s_canvas_layer, update_proc);
layer_add_child(window_layer, s_canvas_layer);
}
static void main_window_load(Window *window) {
// Create circle layer
s_circle_layer = layer_create(GRect(0, 0, 144, 168));
layer_set_update_proc(s_circle_layer, update_proc);
layer_add_child(window_get_root_layer(window), s_circle_layer);
}
static void main_window_load(Window *window) {
window_set_background_color(window, GColorBlack);
GRect bounds = layer_get_bounds(window_get_root_layer(window));
s_canvas_layer = layer_create(bounds);
layer_set_update_proc(s_canvas_layer, canvas_update_proc);
layer_add_child(window_get_root_layer(window), s_canvas_layer);
}
static void initialise_ui(void) {
s_window = window_create();
window_set_background_color(s_window, GColorBlack);
IF_A(window_set_fullscreen(s_window, true));
s_res_img_standby = gbitmap_create_with_resource(RESOURCE_ID_IMG_STANDBY);
s_res_img_settings = gbitmap_create_with_resource(RESOURCE_ID_IMG_SETTINGS);
s_res_roboto_bold_subset_49 = fonts_get_system_font(FONT_KEY_ROBOTO_BOLD_SUBSET_49);
s_res_gothic_18_bold = fonts_get_system_font(FONT_KEY_GOTHIC_18_BOLD);
// action_layer
action_layer = action_bar_layer_create();
action_bar_layer_add_to_window(action_layer, s_window);
action_bar_layer_set_background_color(action_layer, GColorWhite);
action_bar_layer_set_icon(action_layer, BUTTON_ID_UP, s_res_img_standby);
action_bar_layer_set_icon(action_layer, BUTTON_ID_DOWN, s_res_img_settings);
layer_set_frame(action_bar_layer_get_layer(action_layer), GRect(124, 0, 20, 168));
IF_B(layer_set_bounds(action_bar_layer_get_layer(action_layer), GRect(-5, 0, 30, 168)));
layer_add_child(window_get_root_layer(s_window), (Layer *)action_layer);
// clockbg_layer
clockbg_layer = text_layer_create(GRect(0, 60, 144, 50));
text_layer_set_background_color(clockbg_layer, GColorBlack);
text_layer_set_text_color(clockbg_layer, GColorClear);
text_layer_set_text(clockbg_layer, " ");
layer_add_child(window_get_root_layer(s_window), (Layer *)clockbg_layer);
// clock_layer
clock_layer = text_layer_create(GRect(0, 52, 144, 65));
text_layer_set_background_color(clock_layer, GColorClear);
text_layer_set_text_color(clock_layer, GColorWhite);
text_layer_set_text(clock_layer, "23:55");
text_layer_set_text_alignment(clock_layer, GTextAlignmentCenter);
text_layer_set_font(clock_layer, s_res_roboto_bold_subset_49);
layer_add_child(window_get_root_layer(s_window), (Layer *)clock_layer);
// onoff_layer
onoff_layer = text_layer_create(GRect(2, 2, 119, 56));
layer_set_update_proc(text_layer_get_layer(onoff_layer), draw_onoff);
layer_add_child(window_get_root_layer(s_window), (Layer *)onoff_layer);
// info_layer
info_layer = text_layer_create(GRect(2, 110, 119, 56));
layer_set_update_proc(text_layer_get_layer(info_layer), draw_info);
layer_add_child(window_get_root_layer(s_window), (Layer *)info_layer);
}
LoadingLayer* loading_layer_create(Window* window) {
LoadingLayer* layer = layer_create_with_data(layer_get_bounds(window_get_root_layer(window)), sizeof(LoadingData));
LoadingData* data = (LoadingData*)layer_get_data(layer);
data->message = NULL;
layer_set_update_proc(layer, update_loading_layer);
layer_add_child(window_get_root_layer(window), layer);
return layer;
}
void init_battery(Window *window) {
// Subscribe to battery status
//battery_state_service_subscribe(handle_battery);
// Create Battery layer
s_battery_layer = layer_create(GRect(120, 0, 24, 16));
layer_set_update_proc(s_battery_layer, battery_layer_update_callback);
layer_add_child(window_get_root_layer(window), s_battery_layer);
}
static void init(void) {
window = window_create();
window_layer = window_get_root_layer (window);
layer_set_update_proc(window_layer, my_layer_draw);
window_set_window_handlers(window, (WindowHandlers) {
.load = window_load,
.unload = window_unload,
});
static void main_window_load(Window *window) {
Layer *window_layer = window_get_root_layer(window);
graphics_layer = layer_create(layer_get_frame(window_layer));
layer_set_update_proc(graphics_layer, graphics_layer_update);
layer_add_child(window_layer, graphics_layer);
max_width = layer_get_bounds(graphics_layer).size.w - 1;
max_height = layer_get_bounds(graphics_layer).size.h - 1;
timer_callback(NULL); // Start the main loop!
}
