static void set_invert() {
if (!inverter_layer) {
inverter_layer = inverter_layer_create(GRect(0, 0, 144, 168));
layer_add_child(window_get_root_layer(window), inverter_layer_get_layer(inverter_layer));
layer_mark_dirty(inverter_layer_get_layer(inverter_layer));
}
}
void handle_init() {
autoconfig_init();
window = window_create();
window_set_background_color(window, GColorWhite);
window_stack_push(window, true);
app_message_register_inbox_received(in_received_handler);
Layer *window_layer = window_get_root_layer(window);
GRect bounds = layer_get_frame(window_layer);
for (int i = 0; i < TOTAL_IMAGE_SLOTS; i++) {
bitmaps[i] = NULL;
image_containers[i] = bitmap_layer_create(GRect(
((i % 4) * 36),
((i / 4) * 70)+15,
36,70));
layer_add_child(window_layer, bitmap_layer_get_layer(image_containers[i]));
}
inverter_layer = inverter_layer_create (bounds);
layer_set_hidden(inverter_layer_get_layer(inverter_layer), !getInverted());
layer_add_child(window_layer, inverter_layer_get_layer(inverter_layer));
tick_timer_service_subscribe(MINUTE_UNIT, handle_minute_tick);
}
void setup_frame(void){
Layer *window_layer = window_get_root_layer(window);
sine_layer = bitmap_layer_create(GRect(0, 84, 144, 64));
sine_thin = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_SINE_THIN);
sine_thick = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_SINE);
layer_add_child(window_layer, bitmap_layer_get_layer(sine_layer));
horizon_layer = inverter_layer_create(horizon_pos);
layer_add_child(window_layer, inverter_layer_get_layer(horizon_layer));
layer_set_hidden(inverter_layer_get_layer(horizon_layer), true);
horizon_line_layer = layer_create(horizon_pos);
layer_set_update_proc(horizon_line_layer, horizon_line_update_callback);
layer_add_child(window_layer, horizon_line_layer);
layer_set_hidden(horizon_line_layer, true);
current_hor_layer = horizon_line_layer;
sun_layer = layer_create(sun_pos);
layer_set_update_proc(sun_layer, draw_sun);
layer_add_child(window_layer, sun_layer);
layer_set_hidden(sun_layer, true);
}
void options_data_received(DictionaryIterator* data)
{
vibrateEnabledStatus = dict_find(data, 1)->value->uint8;
uint8_t oldInverterEnabledStatus = inverterEnabledStatus;
inverterEnabledStatus = dict_find(data, 2)->value->uint8;
if (vibrateEnabledStatus == 1){
mainMenuOptionItems[0].subtitle = "Enabled";
} else {
mainMenuOptionItems[0].subtitle = "Disabled";
}
if (inverterEnabledStatus == 1){
mainMenuOptionItems[1].subtitle = "Enabled";
} else {
mainMenuOptionItems[1].subtitle = "Disabled";
}
if(oldInverterEnabledStatus != inverterEnabledStatus){
if(inverterEnabledStatus == 1){
layer_add_child(topLayer, inverter_layer_get_layer(inverter_layer));
} else{
layer_remove_from_parent(inverter_layer_get_layer(inverter_layer));
}
}
if(menuLayer != NULL)
menu_layer_reload_data((struct MenuLayer *)menuLayer);
}
void handle_init(void) {
// Create a window and text layer
window = window_create();
text_layer = text_layer_create(GRect(0, TIME_HEIGHT, 144, 168 - TIME_HEIGHT));
show_seconds = persist_read_bool(KEY_SHOW_SECONDS);
invert_face = persist_read_bool(KEY_INVERT);
metric_units = persist_read_bool(KEY_UNITS);
latitude[0] = 0;
longitude[0] = 0;
location[0] = 0;
weather[0] = 0;
// Set the text, font, and text alignment
//text_layer_set_text(text_layer, "");
// http://www.openweathermap.org/current
// https://developer.getpebble.com/blog/2013/07/24/Using-Pebble-System-Fonts/
// https://github.com/JvetS/PebbleSimulator/blob/master/PebbleSimulator/pebble_fonts.h
text_layer_set_font(text_layer, fonts_get_system_font(FONT_KEY_GOTHIC_14));
// https://developer.getpebble.com/2/api-reference/group___graphics_types.html
text_layer_set_text_alignment(text_layer, GTextAlignmentLeft);
// Add the text layer to the window
layer_add_child(window_get_root_layer(window), text_layer_get_layer(text_layer));
// date_layer = text_layer_create(GRect(0, 112, 144, 56));
// text_layer_set_text_alignment(date_layer, GTextAlignmentCenter);
// text_layer_set_font(date_layer, fonts_get_system_font(FONT_KEY_BITHAM_42_BOLD));
// layer_add_child(window_get_root_layer(window), text_layer_get_layer(date_layer));
time_layer = text_layer_create(GRect(0, 0, 144, TIME_HEIGHT));
text_layer_set_text_alignment(time_layer, GTextAlignmentCenter);
text_layer_set_font(time_layer, fonts_get_system_font(FONT_PRO_32));
layer_add_child(window_get_root_layer(window), text_layer_get_layer(time_layer));
inverter_layer = inverter_layer_create(GRect(0, 0, 144, 168));
layer_add_child(window_get_root_layer(window), inverter_layer_get_layer(inverter_layer));
layer_set_hidden(inverter_layer_get_layer(inverter_layer), invert_face);
battery_state_service_subscribe(handle_battery_change);
handle_battery_change(battery_state_service_peek());
bluetooth_connection_service_subscribe(handle_bluetooth_change);
handle_bluetooth_change(bluetooth_connection_service_peek());
app_message_register_inbox_received(in_received_handler);
app_message_open(app_message_inbox_size_maximum(), app_message_outbox_size_maximum());
time_t current_time = time(0);
handle_timechanges(localtime(¤t_time), SECOND_UNIT);
tick_timer_service_subscribe(SECOND_UNIT, handle_timechanges);
// Push the window
window_stack_push(window, true);
// App Logging!
//APP_LOG(APP_LOG_LEVEL_DEBUG, "Hello World from the applogs!");
}
void thread_window_load(Window *window)
{
struct ThreadData *thread = GetSelectedThread();
thread_scroll_layer = scroll_layer_create(window_frame);
scroll_layer_set_shadow_hidden(thread_scroll_layer, true);
scroll_layer_set_click_config_onto_window(thread_scroll_layer, window);
scroll_layer_set_content_size(thread_scroll_layer, GSize(window_frame.size.w, 0));
scroll_layer_set_content_offset(thread_scroll_layer, GPoint(0, 0), false);
ScrollLayerCallbacks scrollOverride =
{
.click_config_provider = &thread_click_config,
.content_offset_changed_handler = &thread_offset_changed_handler
};
scroll_layer_set_callbacks(thread_scroll_layer, scrollOverride);
thread_title_layer = layer_create(GRect(0, 0, window_frame.size.w, 22));
layer_set_update_proc(thread_title_layer, thread_title_layer_update_proc);
scroll_layer_add_child(thread_scroll_layer, thread_title_layer);
layer_add_child(window_get_root_layer(window), scroll_layer_get_layer(thread_scroll_layer));
thread_view_comments_layer = text_layer_create(GRect(0, 0, window_frame.size.w, LOAD_COMMENTS_HEIGHT));
text_layer_set_text(thread_view_comments_layer, "View Comments");
text_layer_set_font(thread_view_comments_layer, GetBiggerFont());
text_layer_set_text_alignment(thread_view_comments_layer, GTextAlignmentCenter);
scroll_layer_add_child(thread_scroll_layer, text_layer_get_layer(thread_view_comments_layer));
thread_inverter_hidden = true;
thread_inverter_layer = inverter_layer_create(GRect(0, 0, window_frame.size.w, LOAD_COMMENTS_HEIGHT));
layer_set_hidden(inverter_layer_get_layer(thread_inverter_layer), true);
scroll_layer_add_child(thread_scroll_layer, inverter_layer_get_layer(thread_inverter_layer));
if(thread->type == 1)
{
// we are an image
thread_body_layer = NULL;
thread_bitmap_layer = bitmap_layer_create(GRect(0, 22, window_frame.size.w, window_frame.size.h));
scroll_layer_add_child(thread_scroll_layer, bitmap_layer_get_layer(thread_bitmap_layer));
scroll_layer_set_content_size(thread_scroll_layer, GSize(window_frame.size.w, 22 + window_frame.size.h + 10));
thread_update_comments_position();
}
else
{
//current_thread.image = NULL;
thread_bitmap_layer = NULL;
thread_body_layer = text_layer_create(GRect(0, 22, window_frame.size.w, 10000));
text_layer_set_font(thread_body_layer, GetFont());
scroll_layer_add_child(thread_scroll_layer, text_layer_get_layer(thread_body_layer));
}
}
// Updates the position of the inverter bar
static void inverter_timer_callback(void *data)
{
to_rect = layer_get_frame(inverter_layer_get_layer(static_inverter_layer));
if (to_rect.size.h < BARWIDTH && to_rect.origin.y == 12 + BARWIDTH) to_rect.size.h++;
else to_rect.origin.y++;
if (to_rect.origin.y > 69 + BARWIDTH) to_rect.size.h--;
if (to_rect.origin.y > 98 + BARWIDTH) to_rect.origin.y = 12 + BARWIDTH;
layer_set_frame(inverter_layer_get_layer(static_inverter_layer), to_rect);
layer_mark_dirty((Layer *) tv_bitmap);
inverter_timer = app_timer_register(INVERTER_TIMEOUT, inverter_timer_callback, 0);
}
void set_invert_color(bool invert) {
if (invert && inverter_layer != NULL) {
Layer *window_layer = window_get_root_layer(window);
inverter_layer = inverter_layer_create(GRect(0, 0, 144, 168));
layer_add_child(window_layer, inverter_layer_get_layer(inverter_layer));
} else if (!invert && inverter_layer == NULL) { // Doesnt invert
Layer *window_layer = window_get_root_layer(window);
inverter_layer = inverter_layer_create(GRect(0, 0, 144, 40));
layer_add_child(window_layer, inverter_layer_get_layer(inverter_layer));
}
// No action required
}
static void thread_offset_changed_handler(ScrollLayer *scroll_layer, void *context)
{
GPoint offset = scroll_layer_get_content_offset(scroll_layer);
bool hide = (scroll_layer_size.h + offset.y - window_frame.size.h) > THREAD_WINDOW_HEIGHT;
if(thread_inverter_hidden != hide)
{
thread_inverter_hidden = hide;
layer_set_hidden(inverter_layer_get_layer(thread_inverter_layer), thread_inverter_hidden);
if(!hide)
{
layer_set_frame(inverter_layer_get_layer(thread_inverter_layer), layer_get_frame(text_layer_get_layer(thread_view_comments_layer)));
}
}
}
static void setupBackground() {
if (backgroundBlack) {
if (inverterLayer) {
layer_remove_from_parent(inverter_layer_get_layer(inverterLayer));
inverter_layer_destroy(inverterLayer);
inverterLayer = NULL;
}
} else {
if (inverterLayer == NULL) {
Layer *root_layer = window_get_root_layer(window);
inverterLayer = inverter_layer_create(layer_get_frame(root_layer));
layer_add_child(root_layer, inverter_layer_get_layer(inverterLayer));
}
}
}
void change_background(bool invert_format) {
if (invert_format && trekinverter_layer == NULL) {
// Add inverter layer
Layer *window_layer = window_get_root_layer(window);
trekinverter_layer = inverter_layer_create(GRect(0, 0, 144, 168));
layer_add_child(window_layer, inverter_layer_get_layer(trekinverter_layer));
} else if (!invert_format && trekinverter_layer != NULL) {
// Remove Inverter layer
layer_remove_from_parent(inverter_layer_get_layer(trekinverter_layer));
inverter_layer_destroy(trekinverter_layer);
trekinverter_layer = NULL;
}
// No action required
}
void set_invert_color(bool invert) {
if (invert && inverter_layer == NULL) {
// Add inverter layer
Layer *window_layer = window_get_root_layer(window);
inverter_layer = inverter_layer_create(GRect(0, 0, 144, 168));
layer_add_child(window_layer, inverter_layer_get_layer(inverter_layer));
} else if (!invert && inverter_layer != NULL) {
// Remove Inverter layer
layer_remove_from_parent(inverter_layer_get_layer(inverter_layer));
inverter_layer_destroy(inverter_layer);
inverter_layer = NULL;
}
// No action required
}
void doDataInvert(int field) // Fixed up due to loss of inverter_layer
{
GRect a = layer_get_frame(text_layer_get_layer(s_data_layer[screens[currentScreen].field_layer_map[field]]));
a.origin.y += a.size.h / 4;
a.size.h -= a.size.h/4 ;
#ifdef PBL_COLOR
int fd = keyTitles[screens[currentScreen].field_data_map[field]].key;
if (fd == KEY_LAY_BURN || fd == KEY_LINE_BURN) { // Set BURN fields green when negative
text_layer_set_text_color(s_data_layer[screens[currentScreen].field_layer_map[field]], greenTextColour);
}
else { // All other fields invert (sort of!!)
// layer_remove_from_parent(text_layer_get_layer(dataInverterPT[field]));
layer_set_frame(text_layer_get_layer(dataInverterPT[field]), a);
layer_set_hidden(text_layer_get_layer(dataInverterPT[field]), false);
text_layer_set_background_color(dataInverterPT[field], negativeBackgroundColour);
// layer_insert_above_sibling(text_layer_get_layer(dataInverterPT[field]), text_layer_get_layer(s_data_layer[screens[currentScreen].field_layer_map[field]]));
text_layer_set_text_color(s_data_layer[screens[currentScreen].field_layer_map[field]], negativeTextColour);
}
#else // On old Pebble, just invert
layer_set_bounds(inverter_layer_get_layer(dataInverter[field]), a);
#endif
// To revert
// layer_set_bounds(inverter_layer_get_layer(inverter), GRect(0,0,0,0));
}
// Initialise UI
static void init(void)
{
srand(time(NULL));
inverter_timer = app_timer_register(INVERTER_TIMEOUT, inverter_timer_callback, 0);
time_timer = app_timer_register(TIME_TIMEOUT, update_time, 0);
window = window_create();
window_set_fullscreen(window, true);
window_stack_push(window, false);
// Assign resources
s_res_tv_image = gbitmap_create_with_resource(RESOURCE_ID_TV_IMAGE);
s_res_static_1_image = gbitmap_create_with_resource(RESOURCE_ID_STATIC_2_IMAGE);
s_res_bitham_42_bold = fonts_get_system_font(FONT_KEY_BITHAM_42_BOLD);
s_res_gothic_14 = fonts_get_system_font(FONT_KEY_GOTHIC_14);
// tv_bitmap
tv_bitmap = bitmap_layer_create(GRect(0,0,144,168));
bitmap_layer_set_bitmap(tv_bitmap, s_res_tv_image);
bitmap_layer_set_background_color(tv_bitmap, GColorClear);
bitmap_layer_set_compositing_mode(tv_bitmap, GCompOpAssign);
layer_add_child(window_get_root_layer(window), (Layer *) tv_bitmap);
// static_1_bitmap
static_1_bitmap = bitmap_layer_create(GRect(14, 42, 115, 87));
bitmap_layer_set_bitmap(static_1_bitmap, s_res_static_1_image);
bitmap_layer_set_compositing_mode(static_1_bitmap, GCompOpOr);
layer_add_child(window_get_root_layer(window), (Layer *)static_1_bitmap);
// inverter_layer
static_inverter_layer = inverter_layer_create(GRect(14, 42, 115, 0));
layer_add_child(window_get_root_layer(window), (Layer *)static_inverter_layer);
layer_set_hidden(inverter_layer_get_layer(static_inverter_layer), false);
// Screen On layer
screen_on_layer = text_layer_create(GRect(14, 42, 115, 87));
text_layer_set_background_color(screen_on_layer, GColorWhite);
layer_set_hidden(text_layer_get_layer(screen_on_layer), true);
layer_add_child(window_get_root_layer(window), text_layer_get_layer(screen_on_layer));
// ch_layer
ch_layer = text_layer_create(GRect(102, 46, 24, 14));
text_layer_set_background_color(ch_layer, GColorClear);
text_layer_set_text(ch_layer, "Ch 3");
text_layer_set_font(ch_layer, s_res_gothic_14);
layer_add_child(window_get_root_layer(window), text_layer_get_layer(ch_layer));
// time_layer
clock_copy_time_string(buffer, 12);
time_layer = text_layer_create(GRect(0, 56, 144, 42));
text_layer_set_background_color(time_layer, GColorClear);
text_layer_set_text(time_layer, buffer);
text_layer_set_text_alignment(time_layer, GTextAlignmentCenter);
text_layer_set_font(time_layer, s_res_bitham_42_bold);
layer_set_hidden(text_layer_get_layer(time_layer), true);
layer_add_child(window_get_root_layer(window), (Layer *)time_layer);
accel_tap_service_subscribe(tap_handler); // Subcribe to the tap event service
}
static void main_window_load(Window *window) {
//get root layer of window
Layer *window_layer = window_get_root_layer(window);
//get window dimensions
GRect bounds = layer_get_bounds(window_layer);
//add drawing layers
s_clock_layer_outer = layer_create(GRect(EDGE, EDGE, bounds.size.w - (EDGE * 2), bounds.size.h - (EDGE * 2)));
layer_set_update_proc(s_clock_layer_outer, draw_clock_layer_outer);
layer_add_child(window_layer, s_clock_layer_outer);
s_clock_layer_center = layer_create(GRect(EDGE, EDGE, bounds.size.w - (EDGE * 2), bounds.size.h - (EDGE * 2)));
layer_set_update_proc(s_clock_layer_center, draw_clock_layer_center);
layer_add_child(window_layer, s_clock_layer_center);
s_clock_layer_inner = layer_create(GRect(EDGE, EDGE, bounds.size.w - (EDGE * 2), bounds.size.h - (EDGE * 2)));
layer_set_update_proc(s_clock_layer_inner, draw_clock_layer_inner);
layer_add_child(window_layer, s_clock_layer_inner);
//init text time layer
GSize max_size = graphics_text_layout_get_content_size(
"00:00",
fonts_get_system_font(FONT_KEY_GOTHIC_14),
GRect(0, 0, bounds.size.w, bounds.size.h),
GTextOverflowModeTrailingEllipsis,
GTextAlignmentCenter
);
s_text_time = text_layer_create(GRect(
(bounds.size.w / 2) - (max_size.w / 2),
(bounds.size.h / 2) - (max_size.h / 2),
max_size.w,
max_size.h)
);
text_layer_set_background_color(s_text_time, GColorClear);
text_layer_set_text_color(s_text_time, GColorBlack);
text_layer_set_font(s_text_time, fonts_get_system_font(FONT_KEY_GOTHIC_14));
text_layer_set_text_alignment(s_text_time, GTextAlignmentCenter);
layer_add_child(window_layer, text_layer_get_layer(s_text_time));
toggle_text_time();
//init inverter layer
s_layer_invert = inverter_layer_create(GRect(0, 0, bounds.size.w, bounds.size.h));
layer_add_child(window_layer, inverter_layer_get_layer(s_layer_invert));
invert_face();
//store clock layer bounds
s_clock_bounds = layer_get_bounds(s_clock_layer_outer);
s_clock_center = grect_center_point(&s_clock_bounds);
//init hand paths
s_hand_path_outer = gpath_create(&OUTER_HAND_POINTS);
gpath_move_to(s_hand_path_outer, s_clock_center);
s_hand_path_center = gpath_create(&CENTER_HAND_POINTS);
gpath_move_to(s_hand_path_center, s_clock_center);
s_hand_path_inner = gpath_create(&INNER_HAND_POINTS);
gpath_move_to(s_hand_path_inner, s_clock_center);
}
// Setup the scroll layer on window load
// We do this here in order to be able to get the max used text size
static void window_load(Window *window) {
Layer *window_layer = window_get_root_layer(window);
GRect bounds = layer_get_frame(window_layer);
GRect max_text_bounds = GRect(0, 0, bounds.size.w, 2000);
// Initialize the scroll layer
scroll_layer = scroll_layer_create(bounds);
// This binds the scroll layer to the window so that up and down map to scrolling
// You may use scroll_layer_set_callbacks to add or override interactivity
scroll_layer_set_click_config_onto_window(scroll_layer, window);
// Initialize the text layer
text_layer = text_layer_create(max_text_bounds);
text_layer_set_text(text_layer, scroll_text);
// Change the font to a nice readable one
// This is system font; you can inspect pebble_fonts.h for all system fonts
// or you can take a look at feature_custom_font to add your own font
text_layer_set_font(text_layer, fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD));
// Trim text layer and scroll content to fit text box
GSize max_size = text_layer_get_content_size(text_layer);
text_layer_set_size(text_layer, max_size);
scroll_layer_set_content_size(scroll_layer, GSize(bounds.size.w, max_size.h + vert_scroll_text_padding));
// Add the layers for display
scroll_layer_add_child(scroll_layer, text_layer_get_layer(text_layer));
// The inverter layer will highlight some text
inverter_layer = inverter_layer_create(GRect(0, 28, bounds.size.w, 28));
scroll_layer_add_child(scroll_layer, inverter_layer_get_layer(inverter_layer));
layer_add_child(window_layer, scroll_layer_get_layer(scroll_layer));
}
static void in_received_handler(DictionaryIterator *iter, void *context) {
// Let Pebble Autoconfig handle received settings
autoconfig_in_received_handler(iter, context);
// Update display with new values
layer_set_hidden(inverter_layer_get_layer(inverter_layer), !getInverted());
}
void handle_init(void) {
//This is just some "Hello, World" stuff:
static char* hello_text;
//hello_text = "Hello, 22";
int percentage = battery_state_service_peek().charge_percent;
snprintf (hello_text, 10, "Hello. %d", percentage);
my_window = window_create();
Layer *window_layer = window_get_root_layer(my_window);
GRect window_frame = layer_get_bounds(window_layer);
text_layer = text_layer_create(GRect(0, 0, 144, 20));
text_layer_set_text(text_layer, hello_text);
layer_add_child(window_layer, text_layer_get_layer(text_layer));
//This is the layer with the bluetooth connection status:
int status_x = window_frame.size.w - 12;
int status_y = 0;
//status_layer = create_status_layer(window_frame);
status_layer = create_status_layer(status_x, status_y, PHONE_STATUS_BLACK);
layer_add_child(window_layer, bitmap_layer_get_layer(status_layer));
//This is the layer with the battery status:
GRect battery_bar_rect = GRect(0,0,10,100);
int battery_bar_shape = BATTERY_BAR_VERTICAL;
battery_layer = create_battery_layer(battery_bar_rect, battery_bar_shape);
layer_add_child(window_layer, inverter_layer_get_layer(battery_layer));
//This is some testing on how to move and resize things:
window_set_click_config_provider(my_window, my_click_handler);
//Finally, display the window:
window_stack_push(my_window, true);
}
static void remove_invert() {
if (inverter_layer != NULL) {
layer_remove_from_parent(inverter_layer_get_layer(inverter_layer));
inverter_layer_destroy(inverter_layer);
inverter_layer = NULL;
}
}
void handle_init(void) {
my_window = window_create();
week_day_layer = text_layer_create(GRect(0, 10, 144, 42));
text_layer_set_background_color(week_day_layer, GColorClear);
layer_add_child(window_get_root_layer(my_window), text_layer_get_layer(week_day_layer));
day_of_month_layer = text_layer_create(GRect(0,42,144,95));
text_layer_set_background_color(day_of_month_layer, GColorClear);
layer_add_child(window_get_root_layer(my_window), text_layer_get_layer(day_of_month_layer));
month_layer = text_layer_create(GRect(0,110,144,58));
text_layer_set_background_color(month_layer, GColorClear);
layer_add_child(window_get_root_layer(my_window), text_layer_get_layer(month_layer));
time_t now = time(NULL);
set_strings(localtime(&now));
render();
inverter_layer = inverter_layer_create(GRect(0, 0, 144, 168));
layer_add_child(window_get_root_layer(my_window), inverter_layer_get_layer(inverter_layer));
window_stack_push(my_window, true);
tick_timer_service_subscribe(DAY_UNIT, handle_time_change);
}
void set_day_layer(int day)
{
int startX = 20;
switch(day)
{
case 1: startX = 20; break;
case 2: startX = 35; break;
case 3: startX = 50; break;
case 4: startX = 65; break;
case 5: startX = 80; break;
case 6: startX = 95; break;
case 0: startX = 110; break;
}
// Create Layer
//Monday
draw_day(20,"M");
draw_day(35,"T");
draw_day(50,"W");
draw_day(65,"T");
draw_day(80,"F");
draw_day(95,"S");
draw_day(110,"S");
//Add Inverted Layer
i_date_layer = inverter_layer_create(GRect (startX, dayY, dayW, dayH)); //(x,y,w,h) (x,y,144*168)
layer_add_child(window_get_root_layer(window), inverter_layer_get_layer(i_date_layer));
}
void window_load(Window *me) {
Layer *window_layer = window_get_root_layer(me);
switch (current_level) {
case 0:
case 1:
if (current_level == 1)
for (int i = 0; i < item_count; i++)
memset(item_names[i], 0, TITLE_SIZE);
menu_layer[current_level] = menu_layer_create(layer_get_bounds(window_layer));
menu_layer_set_callbacks(menu_layer[current_level], NULL, (MenuLayerCallbacks){
.get_cell_height = menu_get_cell_height_callback,
.get_num_rows = menu_get_num_rows_callback,
.draw_row = menu_draw_row_callback,
.select_click = menu_select_callback,
});
menu_layer_set_click_config_onto_window(menu_layer[current_level], me);
layer_set_hidden(menu_layer_get_layer(menu_layer[current_level]), true);
layer_add_child(window_layer, menu_layer_get_layer(menu_layer[current_level]));
break;
case 2:
messageheader_layer = text_layer_create(GRect(0, 0, 144, INT16_MAX));
messageseparator_layer = inverter_layer_create(GRect(0, 0, 144, INT16_MAX));
messagetext_layer = text_layer_create(GRect(0, 0, 144, INT16_MAX));
message_layer = scroll_layer_create(layer_get_bounds(window_layer));
scroll_layer_add_child(message_layer, text_layer_get_layer(messageheader_layer));
scroll_layer_add_child(message_layer, inverter_layer_get_layer(messageseparator_layer));
scroll_layer_add_child(message_layer, text_layer_get_layer(messagetext_layer));
scroll_layer_set_callbacks(message_layer, (ScrollLayerCallbacks){
.click_config_provider = message_click_config_provider
});
static void prv_draw_slider_settle(Layer *layer, GContext *ctx) {
SelectionLayerData *data = layer_get_data(layer);
int starting_x_offset = 0;
for (int i = 0; i < data->num_cells; i++) {
if (data->selected_cell_idx == i) {
break;
}
starting_x_offset += data->cell_widths[i] + data->cell_padding;
}
int x_offset = starting_x_offset;
if (data->slide_is_forward) {
x_offset += data->cell_widths[data->selected_cell_idx];
}
int current_width = (data->cell_padding * data->slide_settle_anim_progress) / 100;
if (!data->slide_is_forward) {
x_offset -= current_width;
}
GRect rect = GRect(x_offset, 0, current_width, layer_get_bounds(layer).size.h);
#ifdef PBL_COLOR
graphics_context_set_fill_color(ctx, data->active_background_color);
graphics_fill_rect(ctx, rect, 1, GCornerNone);
#else
if (data->slide_is_forward) {
rect.origin.x -= data->cell_widths[data->selected_cell_idx];
rect.size.w += data->cell_widths[data->selected_cell_idx];
}
else
rect.size.w += data->cell_widths[data->selected_cell_idx];
layer_set_frame(inverter_layer_get_layer(data->inverter), rect);
#endif
}
static void set_battery(BatteryChargeState state) {
// Set battery percent layer, account for bug where state.charge_percent never gets above 90
if(state.is_plugged && !state.is_charging && state.charge_percent == 90)
snprintf(percent_str, sizeof(percent_str), "100%%");
else
snprintf(percent_str, sizeof(percent_str), "%d%%", (int)state.charge_percent);
text_layer_set_text(percent_layer, percent_str);
// Set battery fill layer
layer_set_frame(
inverter_layer_get_layer(battfill_layer),
GRect(8, 136, state.charge_percent/5, 16)
);
// Show or hide charging icon
if(state.is_plugged)
layer_set_hidden(bitmap_layer_get_layer(charge_layer), false);
else
layer_set_hidden(bitmap_layer_get_layer(charge_layer), true);
// Show or hide battery indicator
if(state.is_plugged || state.charge_percent <= 20)
show_battery();
else
hide_battery();
}
void show_menu()
{
mainMenuSection[0].title = "Menu";
mainMenuSection[0].items = mainMenuItems;
mainMenuSection[1].title = "Options";
mainMenuSection[1].items = mainMenuOptionItems;
mainMenuSection[1].num_items = 2;
if(isNotificationListenerSupported == 1){
mainMenuSection[0].num_items = 2;
mainMenuItems[0].title = "Active";
mainMenuItems[0].icon = currentIcon;
mainMenuItems[0].callback = menu_picked;
mainMenuItems[1].title = "History";
mainMenuItems[1].icon = historyIcon;
mainMenuItems[1].callback = menu_picked;
} else {
mainMenuSection[0].num_items = 1;
mainMenuItems[0].title = "History";
mainMenuItems[0].icon = historyIcon;
mainMenuItems[0].callback = menu_picked;
}
mainMenuOptionItems[0].title = "Vibration";
if (vibrateEnabledStatus == 1){
mainMenuOptionItems[0].subtitle = "Enabled";
} else {
mainMenuOptionItems[0].subtitle = "Disabled";
}
mainMenuOptionItems[0].icon = NULL;
mainMenuOptionItems[0].callback = option_picked;
mainMenuOptionItems[1].title = "Inverted Color";
if (inverterEnabledStatus == 1){
mainMenuOptionItems[1].subtitle = "Enabled";
} else {
mainMenuOptionItems[1].subtitle = "Disabled";
}
mainMenuOptionItems[1].icon = NULL;
mainMenuOptionItems[1].callback = option_picked;
Layer* topLayer = window_get_root_layer(menuWindow);
if (menuLayer != NULL) layer_remove_from_parent((Layer *) menuLayer);
menuLayer = simple_menu_layer_create(GRect(0, 0, 144, 156), menuWindow, mainMenuSection, 2, NULL);
layer_add_child(topLayer, (Layer *) menuLayer);
layer_set_hidden((Layer *) menuLoadingLayer, true);
layer_set_hidden((Layer *) menuLayer, false);
layer_set_hidden((Layer *) quitTitle, true);
layer_set_hidden((Layer *) quitText, true);
if(inverterEnabledStatus)
layer_add_child(topLayer, inverter_layer_get_layer(inverter_layer));
}
int main(void) {
autoconfig_init();
app_message_register_inbox_received(in_received_handler);
center = GPoint(72, 74);
window = window_create();
window_stack_push(window, true);
window_set_background_color(window, GColorBlack);
Layer *window_layer = window_get_root_layer(window);
GRect bounds = layer_get_frame(window_layer);
layer = layer_create(bounds);
layer_set_update_proc(layer, update_layer_callback);
layer_add_child(window_layer, layer);
inverter_layer = inverter_layer_create(bounds);
layer_set_hidden(inverter_layer_get_layer(inverter_layer), !getInverted());
layer_add_child(window_layer, inverter_layer_get_layer(inverter_layer));
custom_font = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_UNSTEADY_OVERSTEER_22));
image = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_PATTERN);
time_t now = time(NULL);
struct tm *tick_time = localtime(&now);
handle_minute_tick(tick_time, MINUTE_UNIT);
tick_timer_service_subscribe(MINUTE_UNIT, handle_minute_tick);
bluetooth_connection_service_subscribe(bluetooth_connection_handler);
bluetooth_connected = bluetooth_connection_service_peek();
app_event_loop();
layer_destroy(layer);
inverter_layer_destroy(inverter_layer);
window_destroy(window);
gbitmap_destroy(image);
fonts_unload_custom_font(custom_font);
tick_timer_service_unsubscribe();
bluetooth_connection_service_unsubscribe();
autoconfig_deinit();
}
static void main_window_load(Window *window) {
// Create GBitmap, then set to created BitmapLayer
s_background_bitmap = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_DOCTOR_WHO_LOGO);
s_background_layer = bitmap_layer_create(GRect(0, 0, 140, 82));
bitmap_layer_set_bitmap(s_background_layer, s_background_bitmap);
bitmap_layer_set_background_color(s_background_layer, GColorBlack);
bitmap_layer_set_compositing_mode(s_background_layer, GCompOpAssignInverted);
// Create time TextLayer
s_time_layer = text_layer_create(GRect(0, 54, 144, 56));
text_layer_set_background_color(s_time_layer, GColorClear);
text_layer_set_text_color(s_time_layer, GColorWhite);
text_layer_set_text(s_time_layer, "00:00");
// Create date TextLayer
s_date_layer = text_layer_create(GRect(0, 110, 144, 30));
text_layer_set_background_color(s_date_layer, GColorClear);
text_layer_set_text_color(s_date_layer, GColorWhite);
text_layer_set_text(s_date_layer, "Thu Aug 23");
// Improve the layout to be more like a watchface
// Create GFont
s_time_font = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_DOCTOR_WHO_56));
s_date_font = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_DOCTOR_WHO_30));
// Apply to TextLayer
text_layer_set_font(s_time_layer, s_time_font);
text_layer_set_font(s_date_layer, s_date_font);
text_layer_set_text_alignment(s_time_layer, GTextAlignmentCenter);
text_layer_set_text_alignment(s_date_layer, GTextAlignmentCenter);
// Inverter Layer
inverter_layer = inverter_layer_create(GRect(0,0,144,168));
layer_add_child(window_get_root_layer(window), inverter_layer_get_layer(inverter_layer));
// Add it as a child layer to the Window's root layer
layer_add_child(inverter_layer_get_layer(inverter_layer), bitmap_layer_get_layer(s_background_layer));
layer_add_child(inverter_layer_get_layer(inverter_layer), text_layer_get_layer(s_time_layer));
layer_add_child(inverter_layer_get_layer(inverter_layer), text_layer_get_layer(s_date_layer));
//layer_set_hidden(inverter_layer_get_layer(inverter_layer), false);
// Make sure the time is displayed from the start
update_time();
}
static void ftLoad(Window *window) {
//APP_LOG(APP_LOG_LEVEL_DEBUG, "Enter ftLoad()");
setCommonLoad("Finish Time");
// Hours
ftHoursLayer = text_layer_create(ftHoursGRect);
text_layer_set_text_alignment(ftHoursLayer, GTextAlignmentCenter);
text_layer_set_font(ftHoursLayer, fonts_get_system_font(FONT_KEY_GOTHIC_28));
text_layer_set_background_color(ftHoursLayer, GColorWhite);
text_layer_set_text_color(ftHoursLayer, GColorBlack);
ftSetHoursDisplay();
layer_add_child(text_layer_get_layer(setDataLayer), text_layer_get_layer(ftHoursLayer));
ftHoursInverterLayer = inverter_layer_create(ftHoursGRect);
layer_add_child(text_layer_get_layer(setDataLayer), inverter_layer_get_layer(ftHoursInverterLayer));
layer_set_hidden(inverter_layer_get_layer(ftHoursInverterLayer), false);
// Colon ":"
ftColonLayer = text_layer_create(ftColonGRect);
text_layer_set_text_alignment(ftColonLayer, GTextAlignmentCenter);
text_layer_set_font(ftColonLayer, fonts_get_system_font(FONT_KEY_GOTHIC_28));
text_layer_set_background_color(ftColonLayer, GColorWhite);
text_layer_set_text_color(ftColonLayer, GColorBlack);
text_layer_set_text(ftColonLayer, ":");
layer_add_child(text_layer_get_layer(setDataLayer), text_layer_get_layer(ftColonLayer));
// Minutes
ftMinsLayer = text_layer_create(ftMinsGRect);
text_layer_set_text_alignment(ftMinsLayer, GTextAlignmentCenter);
text_layer_set_font(ftMinsLayer, fonts_get_system_font(FONT_KEY_GOTHIC_28));
text_layer_set_background_color(ftMinsLayer, GColorWhite);
text_layer_set_text_color(ftMinsLayer, GColorBlack);
ftSetMinsDisplay();
layer_add_child(text_layer_get_layer(setDataLayer), text_layer_get_layer(ftMinsLayer));
ftMinsInverterLayer = inverter_layer_create(ftMinsGRect);
layer_add_child(text_layer_get_layer(setDataLayer), inverter_layer_get_layer(ftMinsInverterLayer));
layer_set_hidden(inverter_layer_get_layer(ftMinsInverterLayer), true);
// Set integer field to be updated.
setFieldNbr = 1;
//APP_LOG(APP_LOG_LEVEL_DEBUG, "about to set ft_click_config_provider()");
window_set_click_config_provider(setWindow, (ClickConfigProvider) ft_click_config_provider);
}
static void rdLoad(Window *window) {
//APP_LOG(APP_LOG_LEVEL_DEBUG, "Enter rdLoad()");
setCommonLoad("Race Distance");
// Units
rdIntegerLayer = text_layer_create(rdIntegerGRect);
text_layer_set_text_alignment(rdIntegerLayer, GTextAlignmentCenter);
text_layer_set_font(rdIntegerLayer, fonts_get_system_font(FONT_KEY_GOTHIC_28));
text_layer_set_background_color(rdIntegerLayer, GColorWhite);
text_layer_set_text_color(rdIntegerLayer, GColorBlack);
rdSetIntegerDisplay();
layer_add_child(text_layer_get_layer(setDataLayer), text_layer_get_layer(rdIntegerLayer));
rdIntegerInverterLayer = inverter_layer_create(rdIntegerGRect);
layer_add_child(text_layer_get_layer(setDataLayer), inverter_layer_get_layer(rdIntegerInverterLayer));
layer_set_hidden(inverter_layer_get_layer(rdIntegerInverterLayer), false);
// Decimal point "."
rdDecimalPointLayer = text_layer_create(rdIntegerDecimalPointGRect);
text_layer_set_text_alignment(rdDecimalPointLayer, GTextAlignmentCenter);
text_layer_set_font(rdDecimalPointLayer, fonts_get_system_font(FONT_KEY_GOTHIC_28));
text_layer_set_background_color(rdDecimalPointLayer, GColorWhite);
text_layer_set_text_color(rdDecimalPointLayer, GColorBlack);
text_layer_set_text(rdDecimalPointLayer, ".");
layer_add_child(text_layer_get_layer(setDataLayer), text_layer_get_layer(rdDecimalPointLayer));
// Tenths
rdTenthsLayer = text_layer_create(rdTenthsGRect);
text_layer_set_text_alignment(rdTenthsLayer, GTextAlignmentCenter);
text_layer_set_font(rdTenthsLayer, fonts_get_system_font(FONT_KEY_GOTHIC_28));
text_layer_set_background_color(rdTenthsLayer, GColorWhite);
text_layer_set_text_color(rdTenthsLayer, GColorBlack);
rdSetTenthsDisplay();
layer_add_child(text_layer_get_layer(setDataLayer), text_layer_get_layer(rdTenthsLayer));
rdTenthsInverterLayer = inverter_layer_create(rdTenthsGRect);
layer_add_child(text_layer_get_layer(setDataLayer), inverter_layer_get_layer(rdTenthsInverterLayer));
layer_set_hidden(inverter_layer_get_layer(rdTenthsInverterLayer), true);
// Set integer field to be updated.
setFieldNbr = 1;
//APP_LOG(APP_LOG_LEVEL_DEBUG, "about to set rd_click_config_provider()");
window_set_click_config_provider(setWindow, (ClickConfigProvider) rd_click_config_provider);
}
static void backButtonName(ClickRecognizerRef recognizer, void *ctx)
{
if (position > 0) {
position--;
layer_set_frame(inverter_layer_get_layer(sInverterLayer), grectNameLayerForInverterLayer());
} else {
window_stack_remove(sWindow, true);
}
}
