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.1
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.1" have entirely different histories.
master ... 1.1

18 changed files with 207 additions and 422 deletions
Show Stats Expand all files Collapse all files

32
.gitignore vendored
View File

@ -1,32 +0,0 @@
assets
config
bin
# Created by https://www.gitignore.io/api/osx
### OSX ###
.DS_Store
.AppleDouble
.LSOverride
# Icon must end with two \r
Icon
# Thumbnails
._*
# Files that might appear in the root of a volume
.DocumentRevisions-V100
.fseventsd
.Spotlight-V100
.TemporaryItems
.Trashes
.VolumeIcon.icns
# Directories potentially created on remote AFP share
.AppleDB
.AppleDesktop
Network Trash Folder
Temporary Items
.apdisk

12
appinfo.json
View File

@ -1,16 +1,9 @@
{ {
"appKeys": { "appKeys": {
"btvibe": 8,
"colorbg": 0, "colorbg": 0,
"colorh": 2, "colorh": 2,
"colorm": 1, "colorm": 1,
"colorp": 3, "colorp": 3
"colort": 6,
"invert": 9,
"rectticks": 7,
"shadows": 4,
"ticks": 5,
"whwidth": 10
}, },
"capabilities": [ "capabilities": [
"configurable" "configurable"
@ -24,12 +17,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.1",
"watchapp": { "watchapp": {
"watchface": true "watchface": true
} }

BIN
assets/basalt/screenshot.afphoto Normal file
View File

Binary file not shown.

BIN
assets/basalt/screenshot.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 4.3 KiB

BIN
assets/basalt/screenshot2.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 4.4 KiB

BIN
assets/basalt/screenshot3.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 4.3 KiB

BIN
assets/chalk/screenshot.afphoto Normal file
View File

Binary file not shown.

BIN
assets/chalk/screenshot.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 4.6 KiB

BIN
assets/chalk/screenshot2.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 4.9 KiB

BIN
assets/chalk/screenshot3.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 4.4 KiB

1
config/css/slate.min.css vendored Executable file
View File

File diff suppressed because one or more lines are too long

BIN
config/fonts/PFDinDisplayPro-Light.woff Executable file
View File

Binary file not shown.

BIN
config/fonts/ptsans-regular.woff Executable file
View File

Binary file not shown.

40
config/index.html Normal file
View File

@ -0,0 +1,40 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Super Simple Settings</title>
<link rel="stylesheet" href="css/slate.min.css">
<body>
<div class="item-container">
<div class="item-container-header">Color settings</div>
<div class="item-container-content">
<label class="item">
Background
<input id="color-bg" type="text" class="item-color item-color-normal" value="#000000">
</label>
<label class="item">
Minute Hand
<input id="color-m" type="text" class="item-color item-color-normal" value="#ffffff">
</label>
<label class="item">
Hour Hand
<input id="color-h" type="text" class="item-color item-color-normal" value="#ff0000">
</label>
<label class="item">
Center Peg
<input id="color-p" type="text" class="item-color item-color-normal" value="#555555">
</label>
</div>
</div>
<div class="item-container">
<div class="button-container">
<input id="send" type="button" class="item-button" value="SEND">
</div>
</div>
<script src="js/slate.min.js"></script>
<script src="js/main.js"></script>
</body>
</html>

63
config/js/main.js Normal file
View File

@ -0,0 +1,63 @@
(function() {
loadOptions();
submitHandler();
})();
function submitHandler() {
var $submitButton = $('#send');
$submitButton.on('click', function() {
console.log('Submit');
var return_to = getQueryParam('return_to', 'pebblejs://close#');
document.location = return_to + encodeURIComponent(JSON.stringify(getAndStoreConfigData()));
});
}
function loadOptions() {
var $colorbg = $('#color-bg');
var $colorm = $('#color-m');
var $colorh = $('#color-h');
var $colorp = $('#color-p');
if (localStorage.colorbg) {
$colorbg[0].value = localStorage.colorbg;
$colorm[0].value = localStorage.colorm;
$colorh[0].value = localStorage.colorh;
$colorp[0].value = localStorage.colorp;
}
}
function getAndStoreConfigData() {
var $colorbg = $('#color-bg');
var $colorm = $('#color-m');
var $colorh = $('#color-h');
var $colorp = $('#color-p');
var options = {
colorbg: $colorbg.val(),
colorm: $colorm.val(),
colorh: $colorh.val(),
colorp: $colorp.val(),
};
localStorage.colorbg = options.colorbg;
localStorage.colorm = options.colorm;
localStorage.colorh = options.colorh;
localStorage.colorp = options.colorp;
console.log('Got options: ' + JSON.stringify(options));
return options;
}
function getQueryParam(variable, defaultValue) {
var query = location.search.substring(1);
var vars = query.split('&');
for (var i = 0; i < vars.length; i++) {
var pair = vars[i].split('=');
if (pair[0] === variable) {
return decodeURIComponent(pair[1]);
}
}
return defaultValue || false;
}

2
config/js/slate.min.js vendored Executable file
View File

File diff suppressed because one or more lines are too long

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

@ -3,16 +3,7 @@ Pebble.addEventListener('ready', function() {
}); });
Pebble.addEventListener('showConfiguration', function() { Pebble.addEventListener('showConfiguration', function() {
var watch; var url='http://pebble.lastfuture.de/config/supersimple/';
if(Pebble.getActiveWatchInfo) {
watch = Pebble.getActiveWatchInfo();
}
var url='http://pebble.lastfuture.de/config/supersimple18/';
if (watch.platform == "basalt") {
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);
}); });
@ -25,14 +16,7 @@ Pebble.addEventListener('webviewclosed', function(e) {
colorbg: parseInt(configData.colorbg, 16), colorbg: parseInt(configData.colorbg, 16),
colorm: parseInt(configData.colorm, 16), colorm: parseInt(configData.colorm, 16),
colorh: parseInt(configData.colorh, 16), colorh: parseInt(configData.colorh, 16),
colorp: parseInt(configData.colorp, 16), colorp: parseInt(configData.colorp, 16)
shadows: 0+(configData.shadows === 'true'),
ticks: configData.ticks,
colort: parseInt(configData.colort, 16),
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() {

453
src/main.c
View File

@ -4,43 +4,18 @@
#define KEY_MINUTE_COLOR 1 #define KEY_MINUTE_COLOR 1
#define KEY_HOUR_COLOR 2 #define KEY_HOUR_COLOR 2
#define KEY_PEG_COLOR 3 #define KEY_PEG_COLOR 3
#define KEY_SHADOWS 4
#define KEY_TICKS 5
#define KEY_TICK_COLOR 6
#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 TICK_RADIUS 3 #define FINAL_RADIUS 88
#define HAND_MARGIN_M 16 #define HAND_WIDTH 7
#define HAND_MARGIN_H 42 #define DOT_RADIUS HAND_WIDTH/4
#define SHADOW_OFFSET 2 #define HAND_MARGIN_OUTER 10-(HAND_WIDTH/2)
#define HAND_MARGIN_INNER 0
#define ANIMATION_DURATION 750 #define ANIMATION_DURATION 600
#define ANIMATION_DELAY 0 #define ANIMATION_DELAY 150
static uint8_t shadowtable[] = {192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192, \
192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192, \
192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192, \
192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192, \
192,192,192,193,192,192,192,193,192,192,192,193,196,196,196,197, \
192,192,192,193,192,192,192,193,192,192,192,193,196,196,196,197, \
192,192,192,193,192,192,192,193,192,192,192,193,196,196,196,197, \
208,208,208,209,208,208,208,209,208,208,208,209,212,212,212,213, \
192,192,193,194,192,192,193,194,196,196,197,198,200,200,201,202, \
192,192,193,194,192,192,193,194,196,196,197,198,200,200,201,202, \
208,208,209,210,208,208,209,210,212,212,213,214,216,216,217,218, \
224,224,225,226,224,224,225,226,228,228,229,230,232,232,233,234, \
192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207, \
208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223, \
224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239, \
240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255};
// alpha should only be 0b??111111 where ?? = 00 (full shade), 01 (much shade), 10 (some shade), 11 (none shade)
static uint8_t alpha = 0b10111111;
typedef struct { typedef struct {
int hours; int hours;
@ -48,120 +23,45 @@ 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 s_radius = 0;
static bool s_animating = false, shadows = true, debug = false, rectticks = true, btvibe = false, invert = false; static bool s_animating = false;
static float anim_offset;
static GColor gcolorbg, gcolorm, gcolorh, gcolorp, gcolorshadow, gcolort; static GColor gcolorbg, gcolorm, gcolorh, gcolorp;
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);
Tuple *colorh_t = dict_find(iter, KEY_HOUR_COLOR); Tuple *colorh_t = dict_find(iter, KEY_HOUR_COLOR);
Tuple *colorp_t = dict_find(iter, KEY_PEG_COLOR); Tuple *colorp_t = dict_find(iter, KEY_PEG_COLOR);
Tuple *shadows_t = dict_find(iter, KEY_SHADOWS);
Tuple *ticknum_t = dict_find(iter, KEY_TICKS);
Tuple *colort_t = dict_find(iter, KEY_TICK_COLOR);
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];
}
if(colorm_t) {
int colorm = colorm_t->value->int32;
persist_write_int(KEY_MINUTE_COLOR, colorm);
gcolorm = GColorFromHEX(colorm);
}
if(colorh_t) {
int colorh = colorh_t->value->int32;
persist_write_int(KEY_HOUR_COLOR, colorh);
gcolorh = GColorFromHEX(colorh);
}
if(colorp_t) {
int colorp = colorp_t->value->int32;
persist_write_int(KEY_PEG_COLOR, colorp);
gcolorp = GColorFromHEX(colorp);
}
if(colort_t) {
int colort = colort_t->value->int32;
persist_write_int(KEY_TICK_COLOR, colort);
gcolort = GColorFromHEX(colort);
}
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) {
ticks = ticknum_t->value->uint8;
persist_write_int(KEY_TICKS, ticks);
} }
if(rectticks_t && rectticks_t->value->int8 > 0) { if(colorm_t) {
persist_write_bool(KEY_RECT_TICKS, true); int colorm = colorm_t->value->int32;
rectticks = true; persist_write_int(KEY_MINUTE_COLOR, colorm);
} else { gcolorm = GColorFromHEX(colorm);
persist_write_bool(KEY_RECT_TICKS, false);
rectticks = false;
} }
if(btvibe_t && btvibe_t->value->int8 > 0) { if(colorh_t) {
persist_write_bool(KEY_BT_VIBE, true); int colorh = colorh_t->value->int32;
btvibe = true; persist_write_int(KEY_HOUR_COLOR, colorh);
} else { gcolorh = GColorFromHEX(colorh);
persist_write_bool(KEY_BT_VIBE, false);
btvibe = false;
} }
if(whwidth_t) { if(colorp_t) {
whwidth = whwidth_t->value->uint8; int colorp = colorp_t->value->int32;
persist_write_int(KEY_HAND_WIDTH, whwidth); persist_write_int(KEY_PEG_COLOR, colorp);
} gcolorp = GColorFromHEX(colorp);
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 **************************/
@ -193,19 +93,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 s_last_time.hours = tick_time->tm_hour;
if (debug) { s_last_time.hours -= (s_last_time.hours > 12) ? 12 : 0;
/* s_last_time.minutes = tick_time->tm_min;
s_last_time.hours = 0;
s_last_time.minutes = tick_time->tm_sec;
*/
s_last_time.hours = 10;
s_last_time.minutes = 8;
} else {
s_last_time.hours = tick_time->tm_hour;
s_last_time.hours -= (s_last_time.hours > 12) ? 12 : 0;
s_last_time.minutes = tick_time->tm_min;
}
// Redraw // Redraw
if(s_canvas_layer) { if(s_canvas_layer) {
@ -213,143 +103,57 @@ static void tick_handler(struct tm *tick_time, TimeUnits changed) {
} }
} }
static void handle_bluetooth(bool connected) { static void update_proc(Layer *layer, GContext *ctx) {
if (btvibe && !connected) { // Color background?
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) {
// Progress through 60 minutes, out of 360 degrees
return ((minute * 360) / 60);
}
static int32_t get_angle_for_hour(int hour, int minute) {
// Progress through 12 hours, out of 360 degrees
return (((hour * 360) / 12)+(get_angle_for_minute(minute)/12));
}
static void bg_update_proc(Layer *layer, GContext *ctx) {
GRect bounds = layer_get_bounds(layer); GRect bounds = layer_get_bounds(layer);
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);
if (ticks > 0) {
graphics_context_set_fill_color(ctx, gcolort);
#if defined(PBL_RECT)
if (rectticks) {
int dist_v = 39;
int dist_h = 46;
int halfwidth = (bounds.size.w/2)-1;
int halfheight = (bounds.size.h/2)-1;
switch (ticks) {
case 12:
graphics_fill_circle(ctx, GPoint(halfwidth+dist_h, 4), TICK_RADIUS/2); // 1
graphics_fill_circle(ctx, GPoint(halfwidth-dist_h, 4), TICK_RADIUS/2); // 11
graphics_fill_circle(ctx, GPoint(halfwidth+dist_h, (bounds.size.h-5)), TICK_RADIUS/2); // 5
graphics_fill_circle(ctx, GPoint(halfwidth-dist_h, (bounds.size.h-5)), TICK_RADIUS/2); // 7
graphics_fill_circle(ctx, GPoint((bounds.size.w-5), halfheight-dist_v), TICK_RADIUS/2); // 2
graphics_fill_circle(ctx, GPoint((bounds.size.w-5), halfheight+dist_v), TICK_RADIUS/2); // 4
graphics_fill_circle(ctx, GPoint(4, halfheight-dist_v), TICK_RADIUS/2); // 10
graphics_fill_circle(ctx, GPoint(4, halfheight+dist_v), TICK_RADIUS/2); // 8
case 4:
graphics_fill_circle(ctx, GPoint(halfwidth, (bounds.size.h-3)), TICK_RADIUS); // 6
graphics_fill_circle(ctx, GPoint((bounds.size.w-3), halfheight), TICK_RADIUS); // 3
graphics_fill_circle(ctx, GPoint(2, halfheight), TICK_RADIUS); // 9
case 1:
default:
graphics_fill_circle(ctx, GPoint(halfwidth, 2), TICK_RADIUS); // 12
break;
}
} else {
#endif
GRect insetbounds = grect_inset(bounds, GEdgeInsets(2));
GRect insetbounds12 = grect_inset(bounds, GEdgeInsets(4));
for(int i = 0; i < ticks; i++) {
int hour_angle = (i * 360) / ticks;
if (ticks == 12 && i%3!=0) {
GPoint pos = gpoint_from_polar(insetbounds12, GOvalScaleModeFitCircle , DEG_TO_TRIGANGLE(hour_angle));
graphics_fill_circle(ctx, pos, TICK_RADIUS/2);
} else {
GPoint pos = gpoint_from_polar(insetbounds, GOvalScaleModeFitCircle , DEG_TO_TRIGANGLE(hour_angle));
graphics_fill_circle(ctx, pos, TICK_RADIUS);
}
}
#if defined(PBL_RECT)
}
#endif
}
}
static void update_proc(Layer *layer, GContext *ctx) { // Don't use current time while animating
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; Time mode_time = s_last_time;
// Adjust for minutes through the hour // Adjust for minutes through the hour
float hour_deg = get_angle_for_hour(mode_time.hours, mode_time.minutes); float hour_angle = TRIG_MAX_ANGLE * mode_time.hours / 12;
float minute_deg = get_angle_for_minute(mode_time.minutes); float minute_angle = TRIG_MAX_ANGLE * mode_time.minutes / 60;
hour_angle += (minute_angle / TRIG_MAX_ANGLE) * (TRIG_MAX_ANGLE / 12);
GPoint minute_hand_outer = gpoint_from_polar(bounds_mo, GOvalScaleModeFillCircle, DEG_TO_TRIGANGLE(minute_deg)); if (s_animating) {
GPoint hour_hand_outer = gpoint_from_polar(bounds_ho, GOvalScaleModeFillCircle, DEG_TO_TRIGANGLE(hour_deg)); hour_angle += anim_offset;
minute_angle -= anim_offset;
if(shadows) { }
graphics_context_set_stroke_color(ctx, gcolorshadow);
graphics_context_set_stroke_width(ctx, whwidth); // Plot hands
hour_hand_outer.y += SHADOW_OFFSET; GPoint minute_hand_outer = (GPoint) {
s_center.y += SHADOW_OFFSET; .x = (int16_t)(sin_lookup(TRIG_MAX_ANGLE * mode_time.minutes / 60) * (int32_t)(s_radius - HAND_MARGIN_OUTER) / TRIG_MAX_RATIO) + s_center.x,
graphics_draw_line(ctx, s_center, hour_hand_outer); .y = (int16_t)(-cos_lookup(TRIG_MAX_ANGLE * mode_time.minutes / 60) * (int32_t)(s_radius - HAND_MARGIN_OUTER) / TRIG_MAX_RATIO) + s_center.y,
minute_hand_outer.y += SHADOW_OFFSET+1; };
s_center.y += 1; GPoint minute_hand_inner = (GPoint) {
graphics_draw_line(ctx, s_center, minute_hand_outer); .x = (int16_t)(sin_lookup(TRIG_MAX_ANGLE * mode_time.minutes / 60) * (int32_t)HAND_MARGIN_INNER / TRIG_MAX_RATIO) + s_center.x,
hour_hand_outer.y -= SHADOW_OFFSET; .y = (int16_t)(-cos_lookup(TRIG_MAX_ANGLE * mode_time.minutes / 60) * (int32_t)HAND_MARGIN_INNER / TRIG_MAX_RATIO) + s_center.y,
minute_hand_outer.y -= SHADOW_OFFSET+1; };
s_center.y -= SHADOW_OFFSET+1; GPoint hour_hand_outer = (GPoint) {
.x = (int16_t)(sin_lookup(hour_angle) * (int32_t)(s_radius - HAND_MARGIN_OUTER - (0.3 * s_radius)) / TRIG_MAX_RATIO) + s_center.x,
.y = (int16_t)(-cos_lookup(hour_angle) * (int32_t)(s_radius - HAND_MARGIN_OUTER - (0.3 * s_radius)) / TRIG_MAX_RATIO) + s_center.y,
};
GPoint hour_hand_inner = (GPoint) {
.x = (int16_t)(sin_lookup(hour_angle) * (int32_t)HAND_MARGIN_INNER / TRIG_MAX_RATIO) + s_center.x,
.y = (int16_t)(-cos_lookup(hour_angle) * (int32_t)HAND_MARGIN_INNER / TRIG_MAX_RATIO) + s_center.y,
};
// Draw hands with positive length only
if((s_radius - HAND_MARGIN_OUTER) > HAND_MARGIN_INNER) {
if(s_radius > 2 * HAND_MARGIN_OUTER) {
graphics_context_set_stroke_color(ctx, gcolorh);
graphics_context_set_stroke_width(ctx, HAND_WIDTH);
graphics_draw_line(ctx, hour_hand_inner, hour_hand_outer);
}
if(s_radius > HAND_MARGIN_OUTER) {
graphics_context_set_stroke_color(ctx, gcolorm);
graphics_context_set_stroke_width(ctx, HAND_WIDTH);
graphics_draw_line(ctx, minute_hand_inner, minute_hand_outer);
}
} }
graphics_context_set_stroke_color(ctx, gcolorh);
graphics_context_set_stroke_width(ctx, whwidth);
graphics_draw_line(ctx, s_center, hour_hand_outer);
graphics_context_set_stroke_color(ctx, gcolorm);
graphics_context_set_stroke_width(ctx, whwidth);
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);
} }
@ -358,85 +162,38 @@ static void window_load(Window *window) {
GRect window_bounds = layer_get_bounds(window_layer); GRect window_bounds = layer_get_bounds(window_layer);
s_center = grect_center_point(&window_bounds); s_center = grect_center_point(&window_bounds);
s_center.x -= 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 {
gcolorbg = GColorBlack;
}
gcolorshadow = (GColor8) shadowtable[alpha & gcolorbg.argb];
if (persist_exists(KEY_MINUTE_COLOR)) {
int colorm = persist_read_int(KEY_MINUTE_COLOR);
gcolorm = GColorFromHEX(colorm);
} else {
gcolorm = GColorWhite;
}
if (persist_exists(KEY_HOUR_COLOR)) {
int colorh = persist_read_int(KEY_HOUR_COLOR);
gcolorh = GColorFromHEX(colorh);
} else {
gcolorh = GColorRed;
}
if (persist_exists(KEY_PEG_COLOR)) {
int colorp = persist_read_int(KEY_PEG_COLOR);
gcolorp = GColorFromHEX(colorp);
} else {
gcolorp = GColorDarkGray;
}
if (persist_exists(KEY_TICK_COLOR)) {
int colort = persist_read_int(KEY_TICK_COLOR);
gcolort = GColorFromHEX(colort);
} 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)) {
ticks = persist_read_int(KEY_TICKS);
} else { } else {
ticks = 0; gcolorbg=GColorBlack;
} }
if (persist_exists(KEY_RECT_TICKS)) { if (persist_exists(KEY_MINUTE_COLOR)) {
rectticks = persist_read_bool(KEY_RECT_TICKS); int colorm = persist_read_int(KEY_MINUTE_COLOR);
gcolorm = GColorFromHEX(colorm);
} else { } else {
rectticks = false; gcolorm=GColorWhite;
} }
if (persist_exists(KEY_BT_VIBE)) { if (persist_exists(KEY_HOUR_COLOR)) {
btvibe = persist_read_bool(KEY_BT_VIBE); int colorh = persist_read_int(KEY_HOUR_COLOR);
gcolorh = GColorFromHEX(colorh);
} else { } else {
btvibe = false; gcolorh=GColorRed;
} }
if (persist_exists(KEY_HAND_WIDTH)) { if (persist_exists(KEY_PEG_COLOR)) {
whwidth = persist_read_int(KEY_HAND_WIDTH); int colorp = persist_read_int(KEY_PEG_COLOR);
gcolorp = GColorFromHEX(colorp);
} else { } else {
whwidth = 7; gcolorp=GColorDarkGray;
} }
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);
} }
@ -447,25 +204,16 @@ static int anim_percentage(AnimationProgress dist_normalized, int max) {
} }
static void radius_update(Animation *anim, AnimationProgress dist_normalized) { static void radius_update(Animation *anim, AnimationProgress dist_normalized) {
animpercent = anim_percentage(dist_normalized, 100); s_radius = anim_percentage(dist_normalized, FINAL_RADIUS);
layer_mark_dirty(s_canvas_layer); layer_mark_dirty(s_canvas_layer);
} }
static void init() { static void init() {
srand(time(NULL)); srand(time(NULL));
// keep lit only in emulator
if (watch_info_get_model()==WATCH_INFO_MODEL_UNKNOWN) {
debug = true;
}
time_t t = time(NULL); time_t t = time(NULL);
struct tm *time_now = localtime(&t); struct tm *time_now = localtime(&t);
if (debug) { tick_handler(time_now, MINUTE_UNIT);
tick_handler(time_now, SECOND_UNIT);
} else {
tick_handler(time_now, MINUTE_UNIT);
}
s_main_window = window_create(); s_main_window = window_create();
window_set_window_handlers(s_main_window, (WindowHandlers) { window_set_window_handlers(s_main_window, (WindowHandlers) {
@ -474,21 +222,7 @@ static void init() {
}); });
window_stack_push(s_main_window, true); window_stack_push(s_main_window, true);
if (debug) { tick_timer_service_subscribe(MINUTE_UNIT, tick_handler);
tick_timer_service_subscribe(SECOND_UNIT, tick_handler);
} else {
tick_timer_service_subscribe(MINUTE_UNIT, tick_handler);
}
if (debug) {
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());
@ -510,3 +244,4 @@ int main() {
deinit(); deinit();
} }