805 lines
30 KiB
C
805 lines
30 KiB
C
#include "scheduler.h"
|
|
#include "triangles.h"
|
|
#include <pebble.h>
|
|
#include <stdlib.h>
|
|
|
|
// layer-age
|
|
static Window *s_window;
|
|
static Window *s_drop_window;
|
|
static Layer *s_top_bar_layer;
|
|
static Layer *s_bottom_bar_layer;
|
|
static TextLayer *s_counter_txt_layer;
|
|
//// setter
|
|
static BitmapLayer *s_clock_bmp_layer;
|
|
static BitmapLayer *s_check_bmp_layer;
|
|
static TextLayer *s_setter_txt_layer;
|
|
static Layer *s_setter_highlight_layer;
|
|
//// alarm
|
|
static Layer *s_graph_layer;
|
|
static TextLayer *s_theta_txt_layer;
|
|
static TextLayer *s_parenthesis_txt_layer;
|
|
static Layer *s_drop_bg_function_layer;
|
|
static Layer *s_drop_bg_over_layer;
|
|
static Layer *s_drop_bg_under_layer;
|
|
static TextLayer *s_drop_txt_function_layer;
|
|
static TextLayer *s_drop_txt_over_layer;
|
|
static TextLayer *s_drop_txt_under_layer;
|
|
static Layer *s_division_layer;
|
|
static Layer *s_alarm_highlight_layer;
|
|
static MenuLayer *s_drop_menu_layer;
|
|
static RightTriangleLayer *s_triangle_layer;
|
|
static TextLayer *s_side_a_txt_layer;
|
|
static TextLayer *s_side_b_txt_layer;
|
|
static TextLayer *s_side_c_txt_layer;
|
|
|
|
// fonts
|
|
GFont s_font_lecoish_small;
|
|
//// setter
|
|
GFont s_font_lecoish_big;
|
|
//// alarm
|
|
GFont s_font_mansalva_big;
|
|
GFont s_font_mansalva_small;
|
|
|
|
// bitmaps
|
|
//// setter
|
|
static GBitmap *s_clock_bmp;
|
|
static GBitmap *s_check_bmp;
|
|
|
|
// global vars
|
|
static GColor s_setter_highlight_color;
|
|
static uint8_t s_highlight_pos = 0;
|
|
//// setter
|
|
//// alarm
|
|
static uint8_t s_solution_indices[3] = {8, 8, 8};
|
|
static uint8_t s_selected_indices[3] = {9, 9, 9};
|
|
static uint8_t s_stopwatch_time[2] = {0, 0};
|
|
|
|
// constants
|
|
static const uint8_t s_edge_bar_height = ((PBL_DISPLAY_HEIGHT / 7) * 2);
|
|
static const GRect s_top_bar_grect = GRect(0, 0, PBL_DISPLAY_WIDTH, s_edge_bar_height);
|
|
static const GRect s_bottom_bar_grect = GRect(0, PBL_DISPLAY_HEIGHT - s_edge_bar_height, PBL_DISPLAY_WIDTH, s_edge_bar_height);
|
|
static const GColor s_primary_color = GColorJaegerGreen;
|
|
#define STORAGE_KEY_ALARM_HOUR 0
|
|
#define STORAGE_KEY_ALARM_MINUTE 1
|
|
//// alarm
|
|
static const uint8_t s_drop_height = 22;
|
|
static const GRect s_drop_function_grect = GRect(PBL_IF_ROUND_ELSE(55, 45), s_bottom_bar_grect.origin.y + ((s_bottom_bar_grect.size.h / 2) - PBL_IF_ROUND_ELSE(s_drop_height - 1, s_drop_height / 2)), 50, s_drop_height);
|
|
static const GRect s_drop_over_grect = GRect(s_drop_function_grect.origin.x + 78, s_drop_function_grect.origin.y - 13, s_drop_function_grect.size.w + 1, s_drop_function_grect.size.h);
|
|
static const GRect s_drop_under_grect = GRect(s_drop_over_grect.origin.x, s_drop_over_grect.origin.y + s_drop_over_grect.size.h + 5, s_drop_function_grect.size.w, s_drop_over_grect.size.h);
|
|
static const char *s_sin_arr[2] = {"sin¯¹", "csc¯¹"};
|
|
static const char *s_cos_arr[2] = {"cos¯¹", "sec¯¹"};
|
|
static const char *s_tan_arr[2] = {"tan¯¹", "cot¯¹"};
|
|
static const char *s_sin;
|
|
static const char *s_cos;
|
|
static const char *s_tan;
|
|
|
|
// alarm drop menu options
|
|
static const char *s_options_function[3];
|
|
static char *s_options_over[2];
|
|
static char *s_options_under[2];
|
|
|
|
/////////////////////////////////
|
|
|
|
static bool schedule_alarm(bool is_fallback) {
|
|
time_t target;
|
|
WakeupId status;
|
|
|
|
if (is_fallback) {
|
|
target = time(NULL) + 15;
|
|
status = wakeup_schedule_simple_robust(target, 15, true);
|
|
} else {
|
|
time_t now = time(NULL);
|
|
struct tm target_tm = *localtime(&now);
|
|
target_tm.tm_hour = the_time.HourWIP;
|
|
target_tm.tm_min = the_time.MinuteWIP;
|
|
target_tm.tm_sec = 0;
|
|
target = mktime(&target_tm);
|
|
if (target <= now) {
|
|
target += SECONDS_PER_DAY;
|
|
}
|
|
wakeup_cancel_all(); // only cancel for main alarm (fallback alarm has short lifetime)
|
|
status = wakeup_schedule_simple_robust(target, SECONDS_PER_MINUTE, is_fallback);
|
|
}
|
|
if (status < 0) {
|
|
return false; // TODO show failure window - user must acknowledge this window to close it
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static void top_bar_layer_update_proc(Layer *layer, GContext *ctx) {
|
|
graphics_context_set_fill_color(ctx, s_primary_color);
|
|
graphics_fill_rect(ctx, layer_get_bounds(layer), 0, GCornerNone);
|
|
}
|
|
|
|
static void bottom_bar_layer_update_proc(Layer *layer, GContext *ctx) {
|
|
graphics_context_set_fill_color(ctx, (s_highlight_pos == 2 ? s_setter_highlight_color : s_primary_color));
|
|
graphics_fill_rect(ctx, layer_get_bounds(layer), 0, GCornerNone);
|
|
}
|
|
|
|
static void add_bar_layers_to_window(Layer *window_layer, bool small_top) {
|
|
if (small_top) {
|
|
s_top_bar_layer = layer_create(GRect(s_top_bar_grect.origin.x, s_top_bar_grect.origin.y, s_top_bar_grect.size.w, s_top_bar_grect.size.h / 2));
|
|
} else {
|
|
s_top_bar_layer = layer_create(s_top_bar_grect);
|
|
}
|
|
layer_set_update_proc(s_top_bar_layer, top_bar_layer_update_proc);
|
|
layer_add_child(window_layer, s_top_bar_layer);
|
|
s_bottom_bar_layer = layer_create(s_bottom_bar_grect);
|
|
layer_set_update_proc(s_bottom_bar_layer, bottom_bar_layer_update_proc);
|
|
layer_add_child(window_layer, s_bottom_bar_layer);
|
|
}
|
|
|
|
////////////////////// ALARM //////////////////////
|
|
|
|
static void alarm_seconds_handler(struct tm *tick_time, TimeUnits units_changed) {
|
|
// update stopwatch
|
|
if (s_stopwatch_time[1] == 59) {
|
|
s_stopwatch_time[1] = 0;
|
|
s_stopwatch_time[0]++;
|
|
} else {
|
|
s_stopwatch_time[1]++;
|
|
}
|
|
static char s_stopwatch_buffer[9];
|
|
snprintf(s_stopwatch_buffer, sizeof(s_stopwatch_buffer), "%02u:%02u", s_stopwatch_time[0], s_stopwatch_time[1]);
|
|
text_layer_set_text(s_counter_txt_layer, s_stopwatch_buffer);
|
|
|
|
uint32_t vibe_segments[5] = {s_triangle_layer->angle_A * 2, 200, s_triangle_layer->angle_B * 2, 200, s_triangle_layer->angle_C * 2};
|
|
VibePattern pat = {
|
|
.durations = vibe_segments,
|
|
.num_segments = ARRAY_LENGTH(vibe_segments),
|
|
};
|
|
vibes_enqueue_custom_pattern(pat);
|
|
}
|
|
|
|
static void graph_layer_update_proc(Layer *layer, GContext *ctx) {
|
|
GRect bounds = layer_get_bounds(layer);
|
|
static const uint8_t s_pixel_gap = PBL_DISPLAY_WIDTH / 20;
|
|
graphics_context_set_stroke_color(ctx, GColorElectricBlue);
|
|
for (int i = s_pixel_gap; i < PBL_DISPLAY_WIDTH; i += s_pixel_gap) {
|
|
graphics_draw_line(ctx, GPoint(0, i), GPoint(bounds.size.w, i)); // horizontal line
|
|
graphics_draw_line(ctx, GPoint(i, 0), GPoint(i, bounds.size.h)); // vertical line
|
|
}
|
|
}
|
|
|
|
static void drop_layer_update_proc(Layer *layer, GContext *ctx) {
|
|
graphics_context_set_fill_color(ctx, GColorWhite);
|
|
graphics_fill_rect(ctx, layer_get_bounds(layer), 5, GCornersAll);
|
|
}
|
|
|
|
static void division_layer_update_proc(Layer *layer, GContext *ctx) {
|
|
GRect bounds = layer_get_bounds(layer);
|
|
graphics_context_set_stroke_color(ctx, GColorWhite);
|
|
graphics_draw_line(ctx, GPoint(bounds.origin.x, bounds.origin.y), GPoint(bounds.origin.x + bounds.size.w, bounds.origin.y));
|
|
}
|
|
|
|
static void alarm_highlight_layer_update_proc(Layer *layer, GContext *ctx) {
|
|
graphics_context_set_stroke_color(ctx, GColorRed);
|
|
graphics_context_set_stroke_width(ctx, 3);
|
|
graphics_draw_rect(ctx, layer_get_bounds(layer));
|
|
}
|
|
|
|
static uint16_t menu_get_num_rows(MenuLayer *menu_layer, uint16_t section_index, void *context) {
|
|
if (s_highlight_pos == 0) {
|
|
return 3;
|
|
} else {
|
|
return 2;
|
|
}
|
|
}
|
|
|
|
static void menu_draw_row(GContext *ctx, const Layer *cell_layer, MenuIndex *cell_index, void *context) {
|
|
switch (s_highlight_pos) {
|
|
case 0:
|
|
menu_cell_basic_draw(ctx, cell_layer, s_options_function[cell_index->row], NULL, NULL);
|
|
break;
|
|
case 1:
|
|
menu_cell_basic_draw(ctx, cell_layer, s_options_over[cell_index->row], NULL, NULL);
|
|
break;
|
|
case 2:
|
|
menu_cell_basic_draw(ctx, cell_layer, s_options_under[cell_index->row], NULL, NULL);
|
|
}
|
|
}
|
|
|
|
static void menu_select(MenuLayer *menu_layer, MenuIndex *cell_index, void *context) {
|
|
switch (s_highlight_pos) {
|
|
case 0:
|
|
text_layer_set_text(s_drop_txt_function_layer, s_options_function[cell_index->row]);
|
|
break;
|
|
case 1:
|
|
text_layer_set_text(s_drop_txt_over_layer, s_options_over[cell_index->row]);
|
|
break;
|
|
case 2:
|
|
text_layer_set_text(s_drop_txt_under_layer, s_options_under[cell_index->row]);
|
|
}
|
|
s_selected_indices[s_highlight_pos] = cell_index->row;
|
|
window_stack_remove(s_drop_window, true);
|
|
}
|
|
|
|
// when the user presses select, call this to load a menu;
|
|
// this function will determine the type of menu to load by checking the highlight position;
|
|
// once the user presses select in this menu, the result is written to a text layer and the menu is exited
|
|
static void drop_menu_window_load(Window *window) {
|
|
Layer *window_layer = window_get_root_layer(window);
|
|
s_drop_menu_layer = menu_layer_create(layer_get_bounds(window_layer));
|
|
menu_layer_set_callbacks(s_drop_menu_layer, NULL, (MenuLayerCallbacks){
|
|
.get_num_rows = menu_get_num_rows,
|
|
.draw_row = menu_draw_row,
|
|
.select_click = menu_select,
|
|
});
|
|
menu_layer_set_click_config_onto_window(s_drop_menu_layer, window);
|
|
layer_add_child(window_layer, menu_layer_get_layer(s_drop_menu_layer));
|
|
}
|
|
|
|
static void drop_menu_window_unload(Window *window) {
|
|
menu_layer_destroy(s_drop_menu_layer);
|
|
s_drop_menu_layer = NULL;
|
|
}
|
|
|
|
static void live_wakeup_handler_for_alarm(WakeupId id, int32_t reason) {
|
|
if (reason == 1) { // if fallback alarm, re-schedule it
|
|
schedule_alarm(true); // output is not captured, as it is not actionable
|
|
}
|
|
}
|
|
|
|
static void alarm_window_load() {
|
|
wakeup_service_subscribe(live_wakeup_handler_for_alarm);
|
|
|
|
Layer *window_layer = window_get_root_layer(s_window);
|
|
|
|
// change highlight color to avoid changing color of bottom bar
|
|
s_setter_highlight_color = s_primary_color;
|
|
|
|
// graph paper bg
|
|
s_graph_layer = layer_create(GRect(0, 0, PBL_DISPLAY_WIDTH, PBL_DISPLAY_HEIGHT));
|
|
layer_set_update_proc(s_graph_layer, graph_layer_update_proc);
|
|
layer_add_child(window_layer, s_graph_layer);
|
|
|
|
// top&bottom bars
|
|
add_bar_layers_to_window(window_layer, true);
|
|
|
|
// theta text
|
|
s_font_mansalva_small = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_MANSALVA_REGULAR_22));
|
|
s_theta_txt_layer = text_layer_create(GRect(PBL_IF_ROUND_ELSE(0, 8), s_bottom_bar_grect.origin.y + PBL_IF_ROUND_ELSE(50, 16), PBL_DISPLAY_WIDTH, 26));
|
|
text_layer_set_text_alignment(s_theta_txt_layer, PBL_IF_ROUND_ELSE(GTextAlignmentCenter, GTextAlignmentLeft));
|
|
text_layer_set_background_color(s_theta_txt_layer, GColorClear);
|
|
text_layer_set_text_color(s_theta_txt_layer, GColorWhite);
|
|
text_layer_set_font(s_theta_txt_layer, s_font_mansalva_small);
|
|
text_layer_set_text(s_theta_txt_layer, PBL_IF_ROUND_ELSE("= θ", "θ ="));
|
|
layer_add_child(window_layer, text_layer_get_layer(s_theta_txt_layer));
|
|
|
|
// drop backgrounds
|
|
//// function
|
|
s_drop_bg_function_layer = layer_create(s_drop_function_grect);
|
|
layer_set_update_proc(s_drop_bg_function_layer, drop_layer_update_proc);
|
|
layer_add_child(window_layer, s_drop_bg_function_layer);
|
|
//// over
|
|
s_drop_bg_over_layer = layer_create(s_drop_over_grect);
|
|
layer_set_update_proc(s_drop_bg_over_layer, drop_layer_update_proc);
|
|
layer_add_child(window_layer, s_drop_bg_over_layer);
|
|
//// under
|
|
s_drop_bg_under_layer = layer_create(s_drop_under_grect);
|
|
layer_set_update_proc(s_drop_bg_under_layer, drop_layer_update_proc);
|
|
layer_add_child(window_layer, s_drop_bg_under_layer);
|
|
|
|
// drop text (blank by default)
|
|
//// function
|
|
s_drop_txt_function_layer = text_layer_create(GRect(s_drop_function_grect.origin.x, s_drop_function_grect.origin.y - 3, s_drop_function_grect.size.w, s_drop_function_grect.size.h));
|
|
text_layer_set_background_color(s_drop_txt_function_layer, GColorClear);
|
|
text_layer_set_font(s_drop_txt_function_layer, s_font_mansalva_small);
|
|
text_layer_set_text_alignment(s_drop_txt_function_layer, GTextAlignmentCenter);
|
|
layer_add_child(window_layer, text_layer_get_layer(s_drop_txt_function_layer));
|
|
//// over
|
|
s_drop_txt_over_layer = text_layer_create(GRect(s_drop_over_grect.origin.x, s_drop_over_grect.origin.y - 3, s_drop_over_grect.size.w, s_drop_over_grect.size.h));
|
|
text_layer_set_background_color(s_drop_txt_over_layer, GColorClear);
|
|
text_layer_set_font(s_drop_txt_over_layer, s_font_mansalva_small);
|
|
text_layer_set_text_alignment(s_drop_txt_over_layer, GTextAlignmentCenter);
|
|
layer_add_child(window_layer, text_layer_get_layer(s_drop_txt_over_layer));
|
|
//// under
|
|
s_drop_txt_under_layer = text_layer_create(GRect(s_drop_under_grect.origin.x, s_drop_under_grect.origin.y - 3, s_drop_under_grect.size.w, s_drop_under_grect.size.h));
|
|
text_layer_set_background_color(s_drop_txt_under_layer, GColorClear);
|
|
text_layer_set_font(s_drop_txt_under_layer, s_font_mansalva_small);
|
|
text_layer_set_text_alignment(s_drop_txt_under_layer, GTextAlignmentCenter);
|
|
layer_add_child(window_layer, text_layer_get_layer(s_drop_txt_under_layer));
|
|
|
|
// parenthesis text
|
|
s_font_mansalva_big = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_MANSALVA_REGULAR_50));
|
|
s_parenthesis_txt_layer = text_layer_create(GRect(s_drop_function_grect.origin.x + s_drop_function_grect.size.w + 2, s_bottom_bar_grect.origin.y - PBL_IF_ROUND_ELSE(12, 5), 200, 60));
|
|
text_layer_set_background_color(s_parenthesis_txt_layer, GColorClear);
|
|
text_layer_set_text_color(s_parenthesis_txt_layer, GColorWhite);
|
|
text_layer_set_font(s_parenthesis_txt_layer, s_font_mansalva_big);
|
|
text_layer_set_text(s_parenthesis_txt_layer, "( )");
|
|
layer_add_child(window_layer, text_layer_get_layer(s_parenthesis_txt_layer));
|
|
|
|
// division layer
|
|
s_division_layer = layer_create(GRect(s_drop_function_grect.origin.x + s_drop_function_grect.size.w + 25, s_drop_function_grect.origin.y + s_drop_function_grect.size.h / 2, 57, 1));
|
|
layer_set_update_proc(s_division_layer, division_layer_update_proc);
|
|
layer_add_child(window_layer, s_division_layer);
|
|
|
|
// highlighter
|
|
s_alarm_highlight_layer = layer_create(s_drop_function_grect);
|
|
layer_set_update_proc(s_alarm_highlight_layer, alarm_highlight_layer_update_proc);
|
|
layer_add_child(window_layer, s_alarm_highlight_layer);
|
|
|
|
// triangle
|
|
static const uint8_t s_small_top_bar_height = s_top_bar_grect.size.h / 2;
|
|
s_triangle_layer = right_triangle_layer_create(GRect(0, s_small_top_bar_height, PBL_DISPLAY_WIDTH, PBL_DISPLAY_HEIGHT - s_small_top_bar_height - s_bottom_bar_grect.size.h), GColorBlack);
|
|
layer_add_child(window_layer, s_triangle_layer->layer);
|
|
|
|
// triangle measurements text layers
|
|
uint16_t bc_y = (PBL_DISPLAY_HEIGHT / 2) - s_small_top_bar_height;
|
|
//// side_a
|
|
s_side_a_txt_layer = text_layer_create(GRect(0, s_bottom_bar_grect.origin.y - 26, PBL_DISPLAY_WIDTH, 26));
|
|
text_layer_set_background_color(s_side_a_txt_layer, GColorClear);
|
|
text_layer_set_font(s_side_a_txt_layer, s_font_mansalva_small);
|
|
text_layer_set_text_alignment(s_side_a_txt_layer, GTextAlignmentCenter);
|
|
layer_add_child(window_layer, text_layer_get_layer(s_side_a_txt_layer));
|
|
//// side_b
|
|
s_side_b_txt_layer = text_layer_create(GRect(-4, bc_y, PBL_DISPLAY_WIDTH, 26));
|
|
text_layer_set_background_color(s_side_b_txt_layer, GColorClear);
|
|
text_layer_set_font(s_side_b_txt_layer, s_font_mansalva_small);
|
|
text_layer_set_text_alignment(s_side_b_txt_layer, GTextAlignmentRight);
|
|
layer_add_child(window_layer, text_layer_get_layer(s_side_b_txt_layer));
|
|
//// side_c
|
|
s_side_c_txt_layer = text_layer_create(GRect(4, bc_y, PBL_DISPLAY_WIDTH, 26));
|
|
text_layer_set_background_color(s_side_c_txt_layer, GColorClear);
|
|
text_layer_set_font(s_side_c_txt_layer, s_font_mansalva_small);
|
|
layer_add_child(window_layer, text_layer_get_layer(s_side_c_txt_layer));
|
|
//// display 2 side lengths to the user
|
|
static char side_a_buffer[8], side_b_buffer[8], side_c_buffer[8];
|
|
uint8_t ignored_side = rand() % 3;
|
|
uint8_t sin_index = rand() % 2;
|
|
uint8_t cos_index = rand() % 2;
|
|
uint8_t tan_index = rand() % 2;
|
|
switch (ignored_side) {
|
|
case 0:
|
|
snprintf(side_b_buffer, sizeof(side_b_buffer), "%u", s_triangle_layer->side_b);
|
|
snprintf(side_c_buffer, sizeof(side_c_buffer), "%u", s_triangle_layer->side_c);
|
|
s_options_over[0] = side_b_buffer;
|
|
s_options_over[1] = side_c_buffer;
|
|
s_options_under[0] = side_b_buffer;
|
|
s_options_under[1] = side_c_buffer;
|
|
|
|
// store solution
|
|
s_solution_indices[0] = 2; // tan/cot
|
|
if (s_triangle_layer->theta_angle_is_left) {
|
|
if (tan_index == 0) { // tan
|
|
s_solution_indices[1] = 0; // b (opposite)
|
|
s_solution_indices[2] = 1; // c (adjacent)
|
|
} else { // cot
|
|
s_solution_indices[1] = 1; // c (adjacent)
|
|
s_solution_indices[2] = 0; // b (opposite)
|
|
}
|
|
} else {
|
|
if (tan_index == 0) { // tan
|
|
s_solution_indices[1] = 1; // c (opposite)
|
|
s_solution_indices[2] = 0; // b (adjacent)
|
|
} else { // cot
|
|
s_solution_indices[1] = 0; // b (adjacent)
|
|
s_solution_indices[2] = 1; // c (opposite)
|
|
}
|
|
}
|
|
|
|
break;
|
|
case 1:
|
|
snprintf(side_a_buffer, sizeof(side_a_buffer), "%u", s_triangle_layer->side_a);
|
|
snprintf(side_c_buffer, sizeof(side_c_buffer), "%u", s_triangle_layer->side_c);
|
|
s_options_over[0] = side_a_buffer;
|
|
s_options_over[1] = side_c_buffer;
|
|
s_options_under[0] = side_a_buffer;
|
|
s_options_under[1] = side_c_buffer;
|
|
|
|
// store solution
|
|
if (s_triangle_layer->theta_angle_is_left) {
|
|
s_solution_indices[0] = 1; // cos/sec
|
|
if (cos_index == 0) { // cos
|
|
s_solution_indices[1] = 1; // c (adjacent)
|
|
s_solution_indices[2] = 0; // a (hypotenuse)
|
|
} else { // sec
|
|
s_solution_indices[1] = 0; // a (hypotenuse)
|
|
s_solution_indices[2] = 1; // c (adjacent)
|
|
}
|
|
} else {
|
|
s_solution_indices[0] = 0; // sin/csc
|
|
if (sin_index == 0) { // sin
|
|
s_solution_indices[1] = 1; // c (opposite)
|
|
s_solution_indices[2] = 0; // a (hypotenuse)
|
|
} else { // csc
|
|
s_solution_indices[1] = 0; // a (hypotenuse)
|
|
s_solution_indices[2] = 1; // c (opposite)
|
|
}
|
|
}
|
|
|
|
break;
|
|
case 2:
|
|
snprintf(side_a_buffer, sizeof(side_a_buffer), "%u", s_triangle_layer->side_a);
|
|
snprintf(side_b_buffer, sizeof(side_b_buffer), "%u", s_triangle_layer->side_b);
|
|
s_options_over[0] = side_a_buffer;
|
|
s_options_over[1] = side_b_buffer;
|
|
s_options_under[0] = side_a_buffer;
|
|
s_options_under[1] = side_b_buffer;
|
|
|
|
// store solution
|
|
if (s_triangle_layer->theta_angle_is_left) {
|
|
s_solution_indices[0] = 0; // sin/csc
|
|
if (sin_index == 0) { // sin
|
|
s_solution_indices[1] = 1; // b (opposite)
|
|
s_solution_indices[2] = 0; // a (hypotenuse)
|
|
} else { // csc
|
|
s_solution_indices[1] = 0; // a (hypotenuse)
|
|
s_solution_indices[2] = 1; // b (opposite)
|
|
}
|
|
} else {
|
|
s_solution_indices[0] = 1;
|
|
if (cos_index == 0) { // cos
|
|
s_solution_indices[1] = 1; // b (adjacent)
|
|
s_solution_indices[2] = 0; // a (hypotenuse)
|
|
} else { // sec
|
|
s_solution_indices[1] = 0; // a (hypotenuse)
|
|
s_solution_indices[2] = 1; // b (adjacent)
|
|
}
|
|
}
|
|
}
|
|
text_layer_set_text(s_side_a_txt_layer, side_a_buffer);
|
|
text_layer_set_text(s_side_b_txt_layer, side_b_buffer);
|
|
text_layer_set_text(s_side_c_txt_layer, side_c_buffer);
|
|
|
|
// drop menus
|
|
//// determine trigonometric function options
|
|
s_sin = s_sin_arr[sin_index];
|
|
s_cos = s_cos_arr[cos_index];
|
|
s_tan = s_tan_arr[tan_index];
|
|
//// set up menu options
|
|
s_options_function[0] = s_sin;
|
|
s_options_function[1] = s_cos;
|
|
s_options_function[2] = s_tan;
|
|
//// create drop window
|
|
s_drop_window = window_create(); // TODO destroy on window unload?
|
|
window_set_window_handlers(
|
|
s_drop_window,
|
|
(WindowHandlers){.unload = drop_menu_window_unload});
|
|
|
|
// stopwatch
|
|
s_counter_txt_layer = text_layer_create(GRect(0, (s_small_top_bar_height / 2) - PBL_IF_ROUND_ELSE(6, 10), PBL_DISPLAY_WIDTH, s_small_top_bar_height));
|
|
text_layer_set_background_color(s_counter_txt_layer, GColorClear);
|
|
text_layer_set_text_color(s_counter_txt_layer, GColorWhite);
|
|
text_layer_set_text_alignment(s_counter_txt_layer, GTextAlignmentCenter);
|
|
text_layer_set_font(s_counter_txt_layer, s_font_lecoish_small);
|
|
text_layer_set_text(s_counter_txt_layer, "00:00");
|
|
layer_add_child(window_layer, text_layer_get_layer(s_counter_txt_layer));
|
|
|
|
schedule_alarm(true); // output is not captured, as it is not actionable
|
|
tick_timer_service_subscribe(SECOND_UNIT, alarm_seconds_handler);
|
|
}
|
|
|
|
static void alarm_window_unload() {
|
|
tick_timer_service_unsubscribe();
|
|
text_layer_destroy(s_counter_txt_layer);
|
|
window_destroy(s_drop_window);
|
|
text_layer_destroy(s_side_a_txt_layer);
|
|
text_layer_destroy(s_side_b_txt_layer);
|
|
text_layer_destroy(s_side_c_txt_layer);
|
|
right_triangle_layer_destroy(s_triangle_layer);
|
|
layer_destroy(s_alarm_highlight_layer);
|
|
layer_destroy(s_division_layer);
|
|
text_layer_destroy(s_parenthesis_txt_layer);
|
|
text_layer_destroy(s_drop_txt_under_layer);
|
|
text_layer_destroy(s_drop_txt_over_layer);
|
|
text_layer_destroy(s_drop_txt_function_layer);
|
|
layer_destroy(s_drop_bg_under_layer);
|
|
layer_destroy(s_drop_bg_over_layer);
|
|
layer_destroy(s_drop_bg_function_layer);
|
|
text_layer_destroy(s_theta_txt_layer);
|
|
layer_destroy(s_bottom_bar_layer);
|
|
layer_destroy(s_top_bar_layer);
|
|
layer_destroy(s_graph_layer);
|
|
fonts_unload_custom_font(s_font_mansalva_big);
|
|
fonts_unload_custom_font(s_font_mansalva_small);
|
|
}
|
|
|
|
static void set_alarm_highlighter_frame() {
|
|
switch (s_highlight_pos) {
|
|
case 0:
|
|
layer_set_frame(s_alarm_highlight_layer, s_drop_function_grect);
|
|
break;
|
|
case 1:
|
|
layer_set_frame(s_alarm_highlight_layer, s_drop_over_grect);
|
|
break;
|
|
case 2:
|
|
layer_set_frame(s_alarm_highlight_layer, s_drop_under_grect);
|
|
}
|
|
}
|
|
|
|
static void alarm_up_click_handler(void *recognizer, void *ctx) {
|
|
if (s_highlight_pos == 0) {
|
|
s_highlight_pos = 3;
|
|
} else {
|
|
s_highlight_pos--;
|
|
}
|
|
set_alarm_highlighter_frame();
|
|
}
|
|
|
|
static void alarm_down_click_handler(void *recognizer, void *ctx) {
|
|
if (s_highlight_pos == 3) {
|
|
s_highlight_pos = 0;
|
|
} else {
|
|
s_highlight_pos++;
|
|
}
|
|
set_alarm_highlighter_frame();
|
|
}
|
|
|
|
static void alarm_select_click_handler(void *recognizer, void *ctx) {
|
|
drop_menu_window_load(s_drop_window);
|
|
window_stack_push(s_drop_window, true);
|
|
}
|
|
|
|
static void alarm_select_hold_handler(void *recognizer, void *ctx) {
|
|
// check solution
|
|
for (int i = 0; i < 3; ++i) {
|
|
if (s_selected_indices[i] != s_solution_indices[i]) {
|
|
return; // TODO pop-up telling the user they are wrong
|
|
}
|
|
}
|
|
|
|
bool success = schedule_alarm(false);
|
|
if (success) {
|
|
// TODO confirmation window
|
|
window_stack_pop_all(true);
|
|
}
|
|
}
|
|
|
|
static void alarm_click_config_provider(void *ctx) {
|
|
window_single_click_subscribe(BUTTON_ID_BACK, NULL);
|
|
window_single_click_subscribe(BUTTON_ID_UP, alarm_up_click_handler);
|
|
window_single_click_subscribe(BUTTON_ID_DOWN, alarm_down_click_handler);
|
|
window_single_click_subscribe(BUTTON_ID_SELECT, alarm_select_click_handler);
|
|
window_long_click_subscribe(BUTTON_ID_SELECT, 2500, alarm_select_hold_handler, NULL);
|
|
}
|
|
|
|
static void push_alarm_window() {
|
|
window_set_window_handlers(
|
|
s_window,
|
|
(WindowHandlers){.load = alarm_window_load, .unload = alarm_window_unload});
|
|
window_set_click_config_provider(s_window, alarm_click_config_provider);
|
|
window_stack_push(s_window, false);
|
|
}
|
|
|
|
////////////////////// SETTER //////////////////////
|
|
|
|
static void setter_seconds_handler(struct tm *tick_time, TimeUnits units_changed) {
|
|
struct tm now_tm = *tick_time;
|
|
|
|
// build the target time today
|
|
struct tm target_tm = now_tm;
|
|
target_tm.tm_hour = the_time.HourSet;
|
|
target_tm.tm_min = the_time.MinuteSet;
|
|
target_tm.tm_sec = 0;
|
|
|
|
time_t now = mktime(&now_tm);
|
|
time_t target = mktime(&target_tm);
|
|
|
|
if (target <= now) {
|
|
target += SECONDS_PER_DAY;
|
|
}
|
|
|
|
int32_t diff = (int32_t)(target - now);
|
|
|
|
uint8_t hours = diff / 3600;
|
|
uint8_t minutes = (diff % 3600) / 60;
|
|
uint8_t seconds = diff % 60;
|
|
|
|
static char s_countdown_buffer[12];
|
|
snprintf(s_countdown_buffer, sizeof(s_countdown_buffer), "%02u:%02u:%02u", hours, minutes, seconds);
|
|
text_layer_set_text(s_counter_txt_layer, s_countdown_buffer);
|
|
}
|
|
|
|
static void update_countdown_display() {
|
|
time_t now = time(NULL);
|
|
setter_seconds_handler(localtime(&now), SECOND_UNIT);
|
|
}
|
|
|
|
static void update_setter_display() {
|
|
static char s_setter_buffer[PBL_IF_ROUND_ELSE(10, 14)];
|
|
snprintf(s_setter_buffer, sizeof(s_setter_buffer), PBL_IF_ROUND_ELSE("%02u : %02u", "%02u : %02u"), the_time.HourWIP, the_time.MinuteWIP);
|
|
text_layer_set_text(s_setter_txt_layer, s_setter_buffer);
|
|
}
|
|
|
|
static void setter_highlight_layer_update_proc(Layer *layer, GContext *ctx) {
|
|
GRect fill_area = layer_get_bounds(layer);
|
|
fill_area.size.w = PBL_DISPLAY_WIDTH / 2;
|
|
switch (s_highlight_pos) {
|
|
case 2:
|
|
return; // do not draw highlight
|
|
case 1:
|
|
// draw highlight on minutes site
|
|
fill_area.origin.x = fill_area.size.w;
|
|
break;
|
|
}
|
|
graphics_context_set_fill_color(ctx, s_setter_highlight_color);
|
|
graphics_fill_rect(ctx, fill_area, 0, GCornerNone);
|
|
}
|
|
|
|
static void setter_up_click_handler(void *recognizer, void *ctx) {
|
|
switch (s_highlight_pos) {
|
|
case 0:
|
|
if (the_time.HourWIP == 23) {
|
|
the_time.HourWIP = 0;
|
|
} else {
|
|
the_time.HourWIP++;
|
|
}
|
|
break;
|
|
case 1:
|
|
if (the_time.MinuteWIP == 59) {
|
|
the_time.MinuteWIP = 0;
|
|
} else {
|
|
the_time.MinuteWIP++;
|
|
}
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
update_setter_display();
|
|
}
|
|
|
|
static void setter_down_click_handler(void *recognizer, void *ctx) {
|
|
switch (s_highlight_pos) {
|
|
case 0:
|
|
if (the_time.HourWIP == 0) {
|
|
the_time.HourWIP = 23;
|
|
} else {
|
|
the_time.HourWIP--;
|
|
}
|
|
break;
|
|
case 1:
|
|
if (the_time.MinuteWIP == 0) {
|
|
the_time.MinuteWIP = 59;
|
|
} else {
|
|
the_time.MinuteWIP--;
|
|
}
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
update_setter_display();
|
|
}
|
|
|
|
static void setter_select_click_handler(void *recognizer, void *ctx) {
|
|
if (s_highlight_pos == 2) {
|
|
bool success = schedule_alarm(false);
|
|
if (!success) {
|
|
return; // early return to avoid indicating alarm was set when it was not
|
|
}
|
|
|
|
// persist
|
|
persist_write_int(STORAGE_KEY_ALARM_HOUR, the_time.HourSet);
|
|
persist_write_int(STORAGE_KEY_ALARM_MINUTE, the_time.MinuteSet);
|
|
|
|
// update countdown immediately
|
|
update_countdown_display();
|
|
|
|
// move selection back to start
|
|
s_highlight_pos = 0;
|
|
} else {
|
|
s_highlight_pos++;
|
|
}
|
|
layer_mark_dirty(s_setter_highlight_layer);
|
|
layer_mark_dirty(s_bottom_bar_layer);
|
|
}
|
|
|
|
static void setter_back_click_handler(void *recognizer, void *ctx) {
|
|
if (s_highlight_pos == 0) {
|
|
window_stack_pop_all(true);
|
|
} else {
|
|
s_highlight_pos--;
|
|
}
|
|
layer_mark_dirty(s_setter_highlight_layer);
|
|
layer_mark_dirty(s_bottom_bar_layer);
|
|
}
|
|
|
|
static void setter_click_config_provider(void *ctx) {
|
|
window_single_repeating_click_subscribe(BUTTON_ID_UP, 60, setter_up_click_handler);
|
|
window_single_repeating_click_subscribe(BUTTON_ID_DOWN, 60, setter_down_click_handler);
|
|
window_single_click_subscribe(BUTTON_ID_SELECT, setter_select_click_handler);
|
|
window_single_click_subscribe(BUTTON_ID_BACK, setter_back_click_handler);
|
|
}
|
|
|
|
static void live_wakeup_handler_for_setter(WakeupId id, int32_t reason) {
|
|
window_stack_pop_all(false);
|
|
push_alarm_window();
|
|
}
|
|
|
|
static void setter_window_load() {
|
|
wakeup_service_subscribe(live_wakeup_handler_for_setter);
|
|
|
|
s_setter_highlight_color = GColorMediumAquamarine;
|
|
Layer *window_layer = window_get_root_layer(s_window);
|
|
|
|
// top&bottom bars
|
|
add_bar_layers_to_window(window_layer, false);
|
|
|
|
// clock icon
|
|
s_clock_bmp = gbitmap_create_with_resource(RESOURCE_ID_CLOCK35);
|
|
s_clock_bmp_layer = bitmap_layer_create(GRect(PBL_IF_ROUND_ELSE(0, 14), PBL_IF_ROUND_ELSE(6, 0), s_top_bar_grect.size.w, s_top_bar_grect.size.h));
|
|
bitmap_layer_set_bitmap(s_clock_bmp_layer, s_clock_bmp);
|
|
bitmap_layer_set_alignment(s_clock_bmp_layer, PBL_IF_ROUND_ELSE(GAlignTop, GAlignLeft));
|
|
bitmap_layer_set_compositing_mode(s_clock_bmp_layer, GCompOpSet);
|
|
layer_add_child(window_layer, bitmap_layer_get_layer(s_clock_bmp_layer));
|
|
|
|
// check icon
|
|
s_check_bmp = gbitmap_create_with_resource(RESOURCE_ID_CHECK);
|
|
s_check_bmp_layer = bitmap_layer_create(s_bottom_bar_grect);
|
|
bitmap_layer_set_bitmap(s_check_bmp_layer, s_check_bmp);
|
|
bitmap_layer_set_compositing_mode(s_check_bmp_layer, GCompOpSet);
|
|
layer_add_child(window_layer, bitmap_layer_get_layer(s_check_bmp_layer));
|
|
|
|
// countdown
|
|
s_counter_txt_layer = text_layer_create(GRect(PBL_IF_ROUND_ELSE(0, 39), (s_top_bar_grect.size.h / 2) + PBL_IF_ROUND_ELSE(10, -10), PBL_IF_ROUND_ELSE(s_top_bar_grect.size.w, s_top_bar_grect.size.w - 39), 32));
|
|
text_layer_set_text_alignment(s_counter_txt_layer, GTextAlignmentCenter);
|
|
text_layer_set_text_color(s_counter_txt_layer, GColorWhite);
|
|
text_layer_set_background_color(s_counter_txt_layer, GColorClear);
|
|
text_layer_set_font(s_counter_txt_layer, s_font_lecoish_small);
|
|
layer_add_child(window_layer, text_layer_get_layer(s_counter_txt_layer));
|
|
update_countdown_display();
|
|
|
|
// highlighter
|
|
s_setter_highlight_layer = layer_create(GRect(0, s_top_bar_grect.size.h, PBL_DISPLAY_WIDTH, PBL_DISPLAY_HEIGHT - (2 * s_top_bar_grect.size.h)));
|
|
layer_set_update_proc(s_setter_highlight_layer, setter_highlight_layer_update_proc);
|
|
layer_add_child(window_layer, s_setter_highlight_layer);
|
|
|
|
// setter
|
|
s_font_lecoish_big = fonts_load_custom_font(resource_get_handle(PBL_IF_ROUND_ELSE(RESOURCE_ID_FONT_LECOISH_MONO_BOLD_60, RESOURCE_ID_FONT_LECOISH_MONO_BOLD_40)));
|
|
s_setter_txt_layer = text_layer_create(GRect(0, (PBL_DISPLAY_HEIGHT / 2) - PBL_IF_ROUND_ELSE(30, 20), PBL_DISPLAY_WIDTH, PBL_IF_ROUND_ELSE(60, 40)));
|
|
text_layer_set_text_alignment(s_setter_txt_layer, GTextAlignmentCenter);
|
|
text_layer_set_background_color(s_setter_txt_layer, GColorClear);
|
|
text_layer_set_font(s_setter_txt_layer, s_font_lecoish_big);
|
|
layer_add_child(window_layer, text_layer_get_layer(s_setter_txt_layer));
|
|
update_setter_display();
|
|
|
|
tick_timer_service_subscribe(SECOND_UNIT, setter_seconds_handler);
|
|
}
|
|
|
|
static void setter_window_unload() {
|
|
tick_timer_service_unsubscribe();
|
|
text_layer_destroy(s_setter_txt_layer);
|
|
layer_destroy(s_setter_highlight_layer);
|
|
text_layer_destroy(s_counter_txt_layer);
|
|
bitmap_layer_destroy(s_check_bmp_layer);
|
|
bitmap_layer_destroy(s_clock_bmp_layer);
|
|
gbitmap_destroy(s_check_bmp);
|
|
gbitmap_destroy(s_clock_bmp);
|
|
layer_destroy(s_bottom_bar_layer);
|
|
layer_destroy(s_top_bar_layer);
|
|
fonts_unload_custom_font(s_font_lecoish_big);
|
|
}
|
|
|
|
static void init() {
|
|
s_window = window_create();
|
|
s_font_lecoish_small = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_LECOISH_MONO_BOLD_20));
|
|
the_time.HourWIP = persist_read_int(STORAGE_KEY_ALARM_HOUR);
|
|
the_time.MinuteWIP = persist_read_int(STORAGE_KEY_ALARM_MINUTE);
|
|
the_time.HourSet = the_time.HourWIP;
|
|
the_time.MinuteSet = the_time.MinuteWIP;
|
|
|
|
switch (launch_reason()) {
|
|
case APP_LAUNCH_PHONE: // DEBUG, REMOVE PRIOR TO RELEASE!
|
|
case APP_LAUNCH_WAKEUP:
|
|
push_alarm_window();
|
|
break;
|
|
default:
|
|
window_set_window_handlers(
|
|
s_window,
|
|
(WindowHandlers){.load = setter_window_load, .unload = setter_window_unload});
|
|
window_set_click_config_provider(s_window, setter_click_config_provider);
|
|
window_stack_push(s_window, false);
|
|
};
|
|
}
|
|
|
|
static void deinit() {
|
|
fonts_unload_custom_font(s_font_lecoish_small);
|
|
window_destroy(s_window);
|
|
}
|
|
|
|
int main(void) {
|
|
init();
|
|
app_event_loop();
|
|
deinit();
|
|
}
|