alina
/
Pebble-Time-Watchface-Super-Simple
mirror of https://github.com/alinanorakari/Pebble-Time-Watchface-Super-Simple.git
1
0
Fork 0
Code Releases Activity

Compare commits

base: alina:master
Branches Tags
alina:master
alina:1.7
alina:1.6
alina:1.5
alina:1.4
alina:1.3
alina:1.0
alina:0.9
alina:1.1
alina:1.2
..
compare: alina:1.6
Branches Tags
alina:master
alina:1.7
alina:1.6
alina:1.5
alina:1.4
alina:1.3
alina:1.0
alina:0.9
alina:1.1
alina:1.2

No commits in common. "master" and "1.6" have entirely different histories.
master ... 1.6

3 changed files with 130 additions and 236 deletions
Show Stats Expand all files Collapse all files

8
appinfo.json
View File

@ -1,16 +1,13 @@
{ {
"appKeys": { "appKeys": {
"btvibe": 8,
"colorbg": 0, "colorbg": 0,
"colorh": 2, "colorh": 2,
"colorm": 1, "colorm": 1,
"colorp": 3, "colorp": 3,
"colort": 6, "colort": 6,
"invert": 9,
"rectticks": 7, "rectticks": 7,
"shadows": 4, "shadows": 4,
"ticks": 5, "ticks": 5
"whwidth": 10
}, },
"capabilities": [ "capabilities": [
"configurable" "configurable"
@ -24,12 +21,11 @@
"sdkVersion": "3", "sdkVersion": "3",
"shortName": "Super Simple", "shortName": "Super Simple",
"targetPlatforms": [ "targetPlatforms": [
"aplite",
"basalt", "basalt",
"chalk" "chalk"
], ],
"uuid": "ceeae81b-6b50-43b6-8bbb-6d6f6eb62b69", "uuid": "ceeae81b-6b50-43b6-8bbb-6d6f6eb62b69",
"versionLabel": "1.8", "versionLabel": "1.6",
"watchapp": { "watchapp": {
"watchface": true "watchface": true
} }

11
src/js/pebble-js-app.js
View File

@ -7,11 +7,9 @@ Pebble.addEventListener('showConfiguration', function() {
if(Pebble.getActiveWatchInfo) { if(Pebble.getActiveWatchInfo) {
watch = Pebble.getActiveWatchInfo(); watch = Pebble.getActiveWatchInfo();
} }
var url='http://pebble.lastfuture.de/config/supersimple18/'; var url='http://pebble.lastfuture.de/config/supersimple15/';
if (watch.platform == "basalt") { if (watch.platform != "chalk") {
url += "?rect=true"; url += "?rect=true";
} else if (watch.platform == "aplite") {
url += "?rect=true&bw=true";
} }
console.log('Showing configuration page: '+url); console.log('Showing configuration page: '+url);
Pebble.openURL(url); Pebble.openURL(url);
@ -29,10 +27,7 @@ Pebble.addEventListener('webviewclosed', function(e) {
shadows: 0+(configData.shadows === 'true'), shadows: 0+(configData.shadows === 'true'),
ticks: configData.ticks, ticks: configData.ticks,
colort: parseInt(configData.colort, 16), colort: parseInt(configData.colort, 16),
rectticks: 0+(configData.rectticks === 'true'), rectticks: 0+(configData.rectticks === 'true')
btvibe: 0+(configData.btvibe === 'true'),
invert: 0+(configData.invert === 'true'),
whwidth: configData.whwidth,
}, function() { }, function() {
console.log('Send successful!'); console.log('Send successful!');
}, function() { }, function() {

341
src/main.c
View File

@ -8,13 +8,12 @@
#define KEY_TICKS 5 #define KEY_TICKS 5
#define KEY_TICK_COLOR 6 #define KEY_TICK_COLOR 6
#define KEY_RECT_TICKS 7 #define KEY_RECT_TICKS 7
#define KEY_BT_VIBE 8
#define KEY_INVERT 9
#define KEY_HAND_WIDTH 10
#define ANTIALIASING true #define ANTIALIASING true
#define HAND_WIDTH 7
#define TICK_RADIUS 3 #define TICK_RADIUS 3
#define DOT_RADIUS HAND_WIDTH/4
#define HAND_MARGIN_M 16 #define HAND_MARGIN_M 16
#define HAND_MARGIN_H 42 #define HAND_MARGIN_H 42
#define SHADOW_OFFSET 2 #define SHADOW_OFFSET 2
@ -48,33 +47,15 @@ typedef struct {
} Time; } Time;
static Window *s_main_window; static Window *s_main_window;
static Layer *bg_canvas_layer, *s_canvas_layer; static Layer *s_canvas_layer;
static GPoint s_center; static GPoint s_center;
static Time s_last_time; static Time s_last_time;
static int animpercent = 0, ticks = 0, whwidth = 7; static int animpercent = 0, ticks;
static bool s_animating = false, shadows = true, debug = false, rectticks = true, btvibe = false, invert = false; static bool s_animating = false, shadows = true, debug = false, rectticks = true;
static GColor gcolorbg, gcolorm, gcolorh, gcolorp, gcolorshadow, gcolort; static GColor gcolorbg, gcolorm, gcolorh, gcolorp, gcolorshadow, gcolort;
static void handle_bw_colors() {
if (!invert) {
gcolorbg = GColorBlack;
gcolorm = GColorWhite;
gcolorh = GColorWhite;
gcolorp = GColorBlack;
gcolort = GColorWhite;
shadows = false;
} else {
gcolorbg = GColorWhite;
gcolorm = GColorBlack;
gcolorh = GColorBlack;
gcolorp = GColorWhite;
gcolort = GColorBlack;
shadows = false;
}
}
static void inbox_received_handler(DictionaryIterator *iter, void *context) { static void inbox_received_handler(DictionaryIterator *iter, void *context) {
Tuple *colorbg_t = dict_find(iter, KEY_BG_COLOR); Tuple *colorbg_t = dict_find(iter, KEY_BG_COLOR);
Tuple *colorm_t = dict_find(iter, KEY_MINUTE_COLOR); Tuple *colorm_t = dict_find(iter, KEY_MINUTE_COLOR);
@ -84,58 +65,44 @@ static void inbox_received_handler(DictionaryIterator *iter, void *context) {
Tuple *ticknum_t = dict_find(iter, KEY_TICKS); Tuple *ticknum_t = dict_find(iter, KEY_TICKS);
Tuple *colort_t = dict_find(iter, KEY_TICK_COLOR); Tuple *colort_t = dict_find(iter, KEY_TICK_COLOR);
Tuple *rectticks_t = dict_find(iter, KEY_RECT_TICKS); Tuple *rectticks_t = dict_find(iter, KEY_RECT_TICKS);
Tuple *btvibe_t = dict_find(iter, KEY_BT_VIBE);
Tuple *invert_t = dict_find(iter, KEY_INVERT);
Tuple *whwidth_t = dict_find(iter, KEY_HAND_WIDTH);
#if defined(PBL_COLOR) if(colorbg_t) {
if(colorbg_t) { int colorbg = colorbg_t->value->int32;
int colorbg = colorbg_t->value->int32; persist_write_int(KEY_BG_COLOR, colorbg);
persist_write_int(KEY_BG_COLOR, colorbg); gcolorbg = GColorFromHEX(colorbg);
gcolorbg = GColorFromHEX(colorbg); gcolorshadow = (GColor8) shadowtable[alpha & gcolorbg.argb];
gcolorshadow = (GColor8) shadowtable[alpha & gcolorbg.argb]; }
} if(colorm_t) {
if(colorm_t) { int colorm = colorm_t->value->int32;
int colorm = colorm_t->value->int32; persist_write_int(KEY_MINUTE_COLOR, colorm);
persist_write_int(KEY_MINUTE_COLOR, colorm); gcolorm = GColorFromHEX(colorm);
gcolorm = GColorFromHEX(colorm); }
} if(colorh_t) {
if(colorh_t) { int colorh = colorh_t->value->int32;
int colorh = colorh_t->value->int32; persist_write_int(KEY_HOUR_COLOR, colorh);
persist_write_int(KEY_HOUR_COLOR, colorh); gcolorh = GColorFromHEX(colorh);
gcolorh = GColorFromHEX(colorh); }
} if(colorp_t) {
if(colorp_t) { int colorp = colorp_t->value->int32;
int colorp = colorp_t->value->int32; persist_write_int(KEY_PEG_COLOR, colorp);
persist_write_int(KEY_PEG_COLOR, colorp); gcolorp = GColorFromHEX(colorp);
gcolorp = GColorFromHEX(colorp); }
} if(shadows_t && shadows_t->value->int8 > 0) {
if(colort_t) { persist_write_bool(KEY_SHADOWS, true);
int colort = colort_t->value->int32; shadows = true;
persist_write_int(KEY_TICK_COLOR, colort); } else {
gcolort = GColorFromHEX(colort); persist_write_bool(KEY_SHADOWS, false);
} shadows = false;
if(shadows_t && shadows_t->value->int8 > 0) { }
persist_write_bool(KEY_SHADOWS, true);
shadows = true;
} else {
persist_write_bool(KEY_SHADOWS, false);
shadows = false;
}
#elif defined(PBL_BW)
if(invert_t && invert_t->value->int8 > 0) {
persist_write_bool(KEY_INVERT, true);
invert = true;
} else {
persist_write_bool(KEY_INVERT, false);
invert = false;
}
handle_bw_colors();
#endif
if(ticknum_t) { if(ticknum_t) {
ticks = ticknum_t->value->uint8; ticks = ticknum_t->value->uint8;
persist_write_int(KEY_TICKS, ticks); persist_write_int(KEY_TICKS, ticks);
} }
if(colort_t) {
int colort = colort_t->value->int32;
persist_write_int(KEY_TICK_COLOR, colort);
gcolort = GColorFromHEX(colort);
}
if(rectticks_t && rectticks_t->value->int8 > 0) { if(rectticks_t && rectticks_t->value->int8 > 0) {
persist_write_bool(KEY_RECT_TICKS, true); persist_write_bool(KEY_RECT_TICKS, true);
rectticks = true; rectticks = true;
@ -143,25 +110,9 @@ static void inbox_received_handler(DictionaryIterator *iter, void *context) {
persist_write_bool(KEY_RECT_TICKS, false); persist_write_bool(KEY_RECT_TICKS, false);
rectticks = false; rectticks = false;
} }
if(btvibe_t && btvibe_t->value->int8 > 0) {
persist_write_bool(KEY_BT_VIBE, true);
btvibe = true;
} else {
persist_write_bool(KEY_BT_VIBE, false);
btvibe = false;
}
if(whwidth_t) {
whwidth = whwidth_t->value->uint8;
persist_write_int(KEY_HAND_WIDTH, whwidth);
}
if(bg_canvas_layer) {
layer_mark_dirty(bg_canvas_layer);
}
if(s_canvas_layer) { if(s_canvas_layer) {
layer_mark_dirty(s_canvas_layer); layer_mark_dirty(s_canvas_layer);
} }
vibes_short_pulse();
} }
/*************************** AnimationImplementation **************************/ /*************************** AnimationImplementation **************************/
@ -194,13 +145,9 @@ static void animate(int duration, int delay, AnimationImplementation *implementa
static void tick_handler(struct tm *tick_time, TimeUnits changed) { static void tick_handler(struct tm *tick_time, TimeUnits changed) {
// Store time // Store time
// dummy time in emulator // dummy time in emulator
if (debug) { if (watch_info_get_model()==WATCH_INFO_MODEL_UNKNOWN) {
/*
s_last_time.hours = 0; s_last_time.hours = 0;
s_last_time.minutes = tick_time->tm_sec; s_last_time.minutes = tick_time->tm_sec;
*/
s_last_time.hours = 10;
s_last_time.minutes = 8;
} else { } else {
s_last_time.hours = tick_time->tm_hour; s_last_time.hours = tick_time->tm_hour;
s_last_time.hours -= (s_last_time.hours > 12) ? 12 : 0; s_last_time.hours -= (s_last_time.hours > 12) ? 12 : 0;
@ -213,17 +160,6 @@ static void tick_handler(struct tm *tick_time, TimeUnits changed) {
} }
} }
static void handle_bluetooth(bool connected) {
if (btvibe && !connected) {
static uint32_t const segments[] = { 200, 200, 50, 150, 200 };
VibePattern pat = {
.durations = segments,
.num_segments = ARRAY_LENGTH(segments),
};
vibes_enqueue_custom_pattern(pat);
}
}
static int32_t get_angle_for_minute(int minute) { static int32_t get_angle_for_minute(int minute) {
// Progress through 60 minutes, out of 360 degrees // Progress through 60 minutes, out of 360 degrees
return ((minute * 360) / 60); return ((minute * 360) / 60);
@ -234,16 +170,56 @@ static int32_t get_angle_for_hour(int hour, int minute) {
return (((hour * 360) / 12)+(get_angle_for_minute(minute)/12)); return (((hour * 360) / 12)+(get_angle_for_minute(minute)/12));
} }
static void bg_update_proc(Layer *layer, GContext *ctx) { static void update_proc(Layer *layer, GContext *ctx) {
GRect bounds = layer_get_bounds(layer); GRect bounds = layer_get_bounds(layer);
GRect bounds_h = bounds;
bounds_h.size.w = bounds_h.size.h;
bounds_h.origin.x -= (bounds_h.size.w-bounds.size.w)/2;
int maxradius = bounds_h.size.w;
if (bounds_h.size.h < maxradius) { maxradius = bounds_h.size.h; }
maxradius /= 2;
int animradius = maxradius-((maxradius*animpercent)/100);
#if defined(PBL_RECT)
int platform_margin_m = (HAND_MARGIN_M/1.5);
#elif defined(PBL_ROUND)
int platform_margin_m = HAND_MARGIN_M;
#endif
int outer_m = animradius+platform_margin_m;
int outer_h = animradius+HAND_MARGIN_H;
if (outer_m < platform_margin_m) {
outer_m = platform_margin_m;
}
if (outer_h < HAND_MARGIN_H) {
outer_h = HAND_MARGIN_H;
}
if (outer_m > maxradius) {
outer_m = maxradius;
}
if (outer_h > maxradius) {
outer_h = maxradius;
}
GRect bounds_mo = grect_inset(bounds_h, GEdgeInsets(outer_m));
GRect bounds_ho = grect_inset(bounds_h, GEdgeInsets(outer_h));
graphics_context_set_fill_color(ctx, gcolorbg); graphics_context_set_fill_color(ctx, gcolorbg);
graphics_fill_rect(ctx, bounds, 0, GCornerNone); graphics_fill_rect(ctx, bounds, 0, GCornerNone);
graphics_context_set_antialiased(ctx, ANTIALIASING); graphics_context_set_antialiased(ctx, ANTIALIASING);
// Use current time while animating
Time mode_time = s_last_time;
// Adjust for minutes through the hour
float hour_deg = get_angle_for_hour(mode_time.hours, mode_time.minutes);
float minute_deg = get_angle_for_minute(mode_time.minutes);
GPoint minute_hand_outer = gpoint_from_polar(bounds_mo, GOvalScaleModeFillCircle, DEG_TO_TRIGANGLE(minute_deg));
GPoint hour_hand_outer = gpoint_from_polar(bounds_ho, GOvalScaleModeFillCircle, DEG_TO_TRIGANGLE(hour_deg));
if (ticks > 0) { if (ticks > 0) {
graphics_context_set_fill_color(ctx, gcolort); graphics_context_set_fill_color(ctx, gcolort);
#if defined(PBL_RECT) #if defined(PBL_RECT)
if (rectticks) { if (rectticks) {
int dist_v = 39; int dist_v = 41;
int dist_h = 46; int dist_h = 46;
int halfwidth = (bounds.size.w/2)-1; int halfwidth = (bounds.size.w/2)-1;
int halfheight = (bounds.size.h/2)-1; int halfheight = (bounds.size.h/2)-1;
@ -284,54 +260,10 @@ static void bg_update_proc(Layer *layer, GContext *ctx) {
} }
#endif #endif
} }
}
static void update_proc(Layer *layer, GContext *ctx) {
GRect bounds = layer_get_bounds(layer);
GRect bounds_h = bounds;
bounds_h.size.w = bounds_h.size.h;
bounds_h.origin.x -= (bounds_h.size.w-bounds.size.w)/2;
int maxradius = bounds_h.size.w;
if (bounds_h.size.h < maxradius) { maxradius = bounds_h.size.h; }
maxradius /= 2;
int animradius = maxradius-((maxradius*animpercent)/100);
#if defined(PBL_RECT)
int platform_margin_m = (HAND_MARGIN_M/1.5);
#elif defined(PBL_ROUND)
int platform_margin_m = HAND_MARGIN_M;
#endif
int outer_m = animradius+platform_margin_m;
int outer_h = animradius+HAND_MARGIN_H;
if (outer_m < platform_margin_m) {
outer_m = platform_margin_m;
}
if (outer_h < HAND_MARGIN_H) {
outer_h = HAND_MARGIN_H;
}
if (outer_m > maxradius) {
outer_m = maxradius;
}
if (outer_h > maxradius) {
outer_h = maxradius;
}
GRect bounds_mo = grect_inset(bounds_h, GEdgeInsets(outer_m));
GRect bounds_ho = grect_inset(bounds_h, GEdgeInsets(outer_h));
graphics_context_set_antialiased(ctx, ANTIALIASING);
// Use current time while animating
Time mode_time = s_last_time;
// Adjust for minutes through the hour
float hour_deg = get_angle_for_hour(mode_time.hours, mode_time.minutes);
float minute_deg = get_angle_for_minute(mode_time.minutes);
GPoint minute_hand_outer = gpoint_from_polar(bounds_mo, GOvalScaleModeFillCircle, DEG_TO_TRIGANGLE(minute_deg));
GPoint hour_hand_outer = gpoint_from_polar(bounds_ho, GOvalScaleModeFillCircle, DEG_TO_TRIGANGLE(hour_deg));
if(shadows) { if(shadows) {
graphics_context_set_stroke_color(ctx, gcolorshadow); graphics_context_set_stroke_color(ctx, gcolorshadow);
graphics_context_set_stroke_width(ctx, whwidth); graphics_context_set_stroke_width(ctx, HAND_WIDTH);
hour_hand_outer.y += SHADOW_OFFSET; hour_hand_outer.y += SHADOW_OFFSET;
s_center.y += SHADOW_OFFSET; s_center.y += SHADOW_OFFSET;
graphics_draw_line(ctx, s_center, hour_hand_outer); graphics_draw_line(ctx, s_center, hour_hand_outer);
@ -343,13 +275,13 @@ static void update_proc(Layer *layer, GContext *ctx) {
s_center.y -= SHADOW_OFFSET+1; s_center.y -= SHADOW_OFFSET+1;
} }
graphics_context_set_stroke_color(ctx, gcolorh); graphics_context_set_stroke_color(ctx, gcolorh);
graphics_context_set_stroke_width(ctx, whwidth); graphics_context_set_stroke_width(ctx, HAND_WIDTH);
graphics_draw_line(ctx, s_center, hour_hand_outer); graphics_draw_line(ctx, s_center, hour_hand_outer);
graphics_context_set_stroke_color(ctx, gcolorm); graphics_context_set_stroke_color(ctx, gcolorm);
graphics_context_set_stroke_width(ctx, whwidth); graphics_context_set_stroke_width(ctx, HAND_WIDTH);
graphics_draw_line(ctx, s_center, minute_hand_outer); graphics_draw_line(ctx, s_center, minute_hand_outer);
graphics_context_set_fill_color(ctx, gcolorp); graphics_context_set_fill_color(ctx, gcolorp);
graphics_fill_circle(ctx, s_center, whwidth/4); graphics_fill_circle(ctx, s_center, DOT_RADIUS);
} }
@ -361,82 +293,59 @@ static void window_load(Window *window) {
s_center.x -= 1; s_center.x -= 1;
s_center.y -= 1; s_center.y -= 1;
#if defined(PBL_COLOR) if (persist_exists(KEY_BG_COLOR)) {
if (persist_exists(KEY_BG_COLOR)) { int colorbg = persist_read_int(KEY_BG_COLOR);
int colorbg = persist_read_int(KEY_BG_COLOR); gcolorbg = GColorFromHEX(colorbg);
gcolorbg = GColorFromHEX(colorbg); } else {
} else { gcolorbg = GColorBlack;
gcolorbg = GColorBlack; }
} gcolorshadow = (GColor8) shadowtable[alpha & gcolorbg.argb];
gcolorshadow = (GColor8) shadowtable[alpha & gcolorbg.argb]; if (persist_exists(KEY_MINUTE_COLOR)) {
if (persist_exists(KEY_MINUTE_COLOR)) { int colorm = persist_read_int(KEY_MINUTE_COLOR);
int colorm = persist_read_int(KEY_MINUTE_COLOR); gcolorm = GColorFromHEX(colorm);
gcolorm = GColorFromHEX(colorm); } else {
} else { gcolorm = GColorWhite;
gcolorm = GColorWhite; }
} if (persist_exists(KEY_HOUR_COLOR)) {
if (persist_exists(KEY_HOUR_COLOR)) { int colorh = persist_read_int(KEY_HOUR_COLOR);
int colorh = persist_read_int(KEY_HOUR_COLOR); gcolorh = GColorFromHEX(colorh);
gcolorh = GColorFromHEX(colorh); } else {
} else { gcolorh = GColorRed;
gcolorh = GColorRed; }
} if (persist_exists(KEY_PEG_COLOR)) {
if (persist_exists(KEY_PEG_COLOR)) { int colorp = persist_read_int(KEY_PEG_COLOR);
int colorp = persist_read_int(KEY_PEG_COLOR); gcolorp = GColorFromHEX(colorp);
gcolorp = GColorFromHEX(colorp); } else {
} else { gcolorp = GColorDarkGray;
gcolorp = GColorDarkGray; }
} if (persist_exists(KEY_SHADOWS)) {
if (persist_exists(KEY_TICK_COLOR)) { shadows = persist_read_bool(KEY_SHADOWS);
int colort = persist_read_int(KEY_TICK_COLOR); } else {
gcolort = GColorFromHEX(colort); shadows = false;
} else { }
gcolort = GColorWhite;
}
if (persist_exists(KEY_SHADOWS)) {
shadows = persist_read_bool(KEY_SHADOWS);
} else {
shadows = false;
}
#elif defined(PBL_BW)
if (persist_exists(KEY_INVERT)) {
invert = persist_read_bool(KEY_INVERT);
} else {
invert = false;
}
handle_bw_colors();
#endif
if (persist_exists(KEY_TICKS)) { if (persist_exists(KEY_TICKS)) {
ticks = persist_read_int(KEY_TICKS); ticks = persist_read_int(KEY_TICKS);
} else { } else {
ticks = 0; ticks = 0;
} }
if (persist_exists(KEY_TICK_COLOR)) {
int colort = persist_read_int(KEY_TICK_COLOR);
gcolort = GColorFromHEX(colort);
} else {
gcolort = GColorWhite;
}
if (persist_exists(KEY_RECT_TICKS)) { if (persist_exists(KEY_RECT_TICKS)) {
rectticks = persist_read_bool(KEY_RECT_TICKS); rectticks = persist_read_bool(KEY_RECT_TICKS);
} else { } else {
rectticks = false; rectticks = false;
} }
if (persist_exists(KEY_BT_VIBE)) {
btvibe = persist_read_bool(KEY_BT_VIBE);
} else {
btvibe = false;
}
if (persist_exists(KEY_HAND_WIDTH)) {
whwidth = persist_read_int(KEY_HAND_WIDTH);
} else {
whwidth = 7;
}
bg_canvas_layer = layer_create(window_bounds);
s_canvas_layer = layer_create(window_bounds); s_canvas_layer = layer_create(window_bounds);
layer_set_update_proc(bg_canvas_layer, bg_update_proc);
layer_set_update_proc(s_canvas_layer, update_proc); layer_set_update_proc(s_canvas_layer, update_proc);
layer_add_child(window_layer, bg_canvas_layer); layer_add_child(window_layer, s_canvas_layer);
layer_add_child(bg_canvas_layer, s_canvas_layer);
} }
static void window_unload(Window *window) { static void window_unload(Window *window) {
layer_destroy(bg_canvas_layer);
layer_destroy(s_canvas_layer); layer_destroy(s_canvas_layer);
} }
@ -484,12 +393,6 @@ static void init() {
light_enable(true); light_enable(true);
} }
handle_bluetooth(connection_service_peek_pebble_app_connection());
connection_service_subscribe((ConnectionHandlers) {
.pebble_app_connection_handler = handle_bluetooth
});
app_message_register_inbox_received(inbox_received_handler); app_message_register_inbox_received(inbox_received_handler);
app_message_open(app_message_inbox_size_maximum(), app_message_outbox_size_maximum()); app_message_open(app_message_inbox_size_maximum(), app_message_outbox_size_maximum());