fixed a bug on Android keeping ticks rectangular

appinfo.json

@@ -4,7 +4,10 @@
         "colorh": 2,
         "colorm": 1,
         "colorp": 3,
-        "shadows": 4
+        "colort": 6,
+        "rectticks": 7,
+        "shadows": 4,
+        "ticks": 5
     },
     "capabilities": [
         "configurable"
@@ -22,7 +25,7 @@
         "chalk"
     ],
     "uuid": "ceeae81b-6b50-43b6-8bbb-6d6f6eb62b69",
-    "versionLabel": "1.2",
+    "versionLabel": "1.5",
     "watchapp": {
         "watchface": true
     }

src/js/pebble-js-app.js

@@ -3,7 +3,14 @@ Pebble.addEventListener('ready', function() {
 });
 
 Pebble.addEventListener('showConfiguration', function() {
-    var url='http://pebble.lastfuture.de/config/supersimple12/';
+    var watch;
+    if(Pebble.getActiveWatchInfo) {
+      watch = Pebble.getActiveWatchInfo();
+    }
+    var url='http://pebble.lastfuture.de/config/supersimple15/';
+    if (watch.platform != "chalk") {
+      url += "?rect=true";
+    }
     console.log('Showing configuration page: '+url);
     Pebble.openURL(url);
 });
@@ -17,7 +24,10 @@ Pebble.addEventListener('webviewclosed', function(e) {
             colorm: parseInt(configData.colorm, 16),
             colorh: parseInt(configData.colorh, 16),
             colorp: parseInt(configData.colorp, 16),
-            shadows: configData.shadows === true
+            shadows: configData.shadows === 'true',
+            ticks: configData.ticks,
+            colort: parseInt(configData.colort, 16),
+            rectticks: configData.rectticks === 'true'
         }, function() {
             console.log('Send successful!');
         }, function() {

src/main.c

@@ -5,36 +5,38 @@
 #define KEY_HOUR_COLOR         2
 #define KEY_PEG_COLOR          3
 #define KEY_SHADOWS            4
-
+#define KEY_TICKS              5
+#define KEY_TICK_COLOR         6
+#define KEY_RECT_TICKS         7
 
 #define ANTIALIASING true
 
-#define FINAL_RADIUS       88
-#define HAND_WIDTH         7
-#define DOT_RADIUS         HAND_WIDTH/4
-#define HAND_MARGIN_OUTER  10-(HAND_WIDTH/2)
-#define HAND_MARGIN_INNER  0
-#define SHADOW_OFFSET      2
+#define HAND_WIDTH             7
+#define TICK_RADIUS            3
+#define DOT_RADIUS             HAND_WIDTH/4
+#define HAND_MARGIN_M          16
+#define HAND_MARGIN_H          42
+#define SHADOW_OFFSET          2
 
-#define ANIMATION_DURATION 600
-#define ANIMATION_DELAY    150
+#define ANIMATION_DURATION     750
+#define ANIMATION_DELAY        0
 
 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};
+                                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;
@@ -49,11 +51,10 @@ static Layer *s_canvas_layer;
 
 static GPoint s_center;
 static Time s_last_time;
-static int s_radius = 0;
-static bool s_animating = false, shadows = false;
-static float anim_offset;
+static int animpercent = 0, ticks;
+static bool s_animating = false, shadows = true, debug = false, rectticks = true;
 
-static GColor gcolorbg, gcolorm, gcolorh, gcolorp, gcolorshadow;
+static GColor gcolorbg, gcolorm, gcolorh, gcolorp, gcolorshadow, gcolort;
 
 static void inbox_received_handler(DictionaryIterator *iter, void *context) {
   Tuple *colorbg_t = dict_find(iter, KEY_BG_COLOR);
@@ -61,6 +62,9 @@ static void inbox_received_handler(DictionaryIterator *iter, void *context) {
   Tuple *colorh_t = dict_find(iter, KEY_HOUR_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);
     
   if(colorbg_t) {
     int colorbg = colorbg_t->value->int32;
@@ -90,6 +94,22 @@ static void inbox_received_handler(DictionaryIterator *iter, void *context) {
     persist_write_bool(KEY_SHADOWS, false);
     shadows = false;
   }
+  if(ticknum_t) {
+    ticks = ticknum_t->value->uint8;
+    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->int32 > 0) {
+    persist_write_bool(KEY_RECT_TICKS, true);
+    rectticks = true;
+  } else {
+    persist_write_bool(KEY_RECT_TICKS, false);
+    rectticks = false;
+  }
   if(s_canvas_layer) {
     layer_mark_dirty(s_canvas_layer);
   }
@@ -124,9 +144,15 @@ static void animate(int duration, int delay, AnimationImplementation *implementa
 
 static void tick_handler(struct tm *tick_time, TimeUnits changed) {
   // Store time
-  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;
+  // dummy time in emulator
+  if (watch_info_get_model()==WATCH_INFO_MODEL_UNKNOWN) {
+    s_last_time.hours = 0;
+    s_last_time.minutes = tick_time->tm_sec;
+  } 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
   if(s_canvas_layer) {
@@ -134,72 +160,124 @@ static void tick_handler(struct tm *tick_time, TimeUnits changed) {
   }
 }
 
+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 update_proc(Layer *layer, GContext *ctx) {
-  // Color background?
   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_fill_rect(ctx, bounds, 0, GCornerNone);
   graphics_context_set_antialiased(ctx, ANTIALIASING);
 
-  // Don't use current time while animating
+  // Use current time while animating
   Time mode_time = s_last_time;
 
   // Adjust for minutes through the hour
-  float hour_angle = TRIG_MAX_ANGLE * mode_time.hours / 12;
-  float minute_angle = TRIG_MAX_ANGLE * mode_time.minutes / 60;
-  hour_angle += (minute_angle / TRIG_MAX_ANGLE) * (TRIG_MAX_ANGLE / 12);
-  if (s_animating) {
-	  hour_angle += anim_offset;
-	  minute_angle -= anim_offset;
+  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) {
+    graphics_context_set_fill_color(ctx, gcolort);
+    #if defined(PBL_RECT)
+      if (rectticks) {
+        int dist_v = 41;
+        int dist_h = 44;
+        switch (ticks) {
+          case 12:
+            graphics_fill_circle(ctx, GPoint((bounds.size.w/2)+dist_h, 4), TICK_RADIUS/2); // 1
+            graphics_fill_circle(ctx, GPoint((bounds.size.w/2)-dist_h, 4), TICK_RADIUS/2); // 11
+            graphics_fill_circle(ctx, GPoint((bounds.size.w/2)+dist_h, (bounds.size.h-5)), TICK_RADIUS/2); // 5
+            graphics_fill_circle(ctx, GPoint((bounds.size.w/2)-dist_h, (bounds.size.h-5)), TICK_RADIUS/2); // 7
+            graphics_fill_circle(ctx, GPoint((bounds.size.w-5), (bounds.size.h/2)-dist_v), TICK_RADIUS/2); // 2
+            graphics_fill_circle(ctx, GPoint((bounds.size.w-5), (bounds.size.h/2)+dist_v), TICK_RADIUS/2); // 4
+            graphics_fill_circle(ctx, GPoint(4, (bounds.size.h/2)-dist_v), TICK_RADIUS/2); // 10
+            graphics_fill_circle(ctx, GPoint(4, (bounds.size.h/2)+dist_v), TICK_RADIUS/2); // 8
+          case 4:
+            graphics_fill_circle(ctx, GPoint((bounds.size.w/2), (bounds.size.h-3)), TICK_RADIUS); // 6
+            graphics_fill_circle(ctx, GPoint((bounds.size.w-3), (bounds.size.h/2)), TICK_RADIUS); // 3
+            graphics_fill_circle(ctx, GPoint(2, (bounds.size.h/2)), TICK_RADIUS); // 9
+          case 1:
+          default:
+            graphics_fill_circle(ctx, GPoint((bounds.size.w/2), 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
   }
 
-  // Plot hands
-  GPoint minute_hand_outer = (GPoint) {
-    .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,
-    .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,
-  };
-  GPoint minute_hand_inner = (GPoint) {
-    .x = (int16_t)(sin_lookup(TRIG_MAX_ANGLE * mode_time.minutes / 60) * (int32_t)HAND_MARGIN_INNER / TRIG_MAX_RATIO) + s_center.x,
-    .y = (int16_t)(-cos_lookup(TRIG_MAX_ANGLE * mode_time.minutes / 60) * (int32_t)HAND_MARGIN_INNER / TRIG_MAX_RATIO) + s_center.y,
-  };
-  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
-  //gcolorshadow gcolorh gcolorm
-  if((s_radius - HAND_MARGIN_OUTER) > HAND_MARGIN_INNER) {
-    if(shadows) {
-        if(s_radius > 2 * HAND_MARGIN_OUTER) {
-          graphics_context_set_stroke_color(ctx, gcolorshadow);
-          graphics_context_set_stroke_width(ctx, HAND_WIDTH);
-          hour_hand_inner.y += SHADOW_OFFSET; hour_hand_outer.y += SHADOW_OFFSET;
-          graphics_draw_line(ctx, hour_hand_inner, hour_hand_outer);
-          hour_hand_inner.y -= SHADOW_OFFSET; hour_hand_outer.y -= SHADOW_OFFSET;
-        }
-        if(s_radius > HAND_MARGIN_OUTER) {
-          graphics_context_set_stroke_color(ctx, gcolorshadow);
-          graphics_context_set_stroke_width(ctx, HAND_WIDTH);
-          minute_hand_inner.y += SHADOW_OFFSET+1; minute_hand_outer.y += SHADOW_OFFSET+1;
-          graphics_draw_line(ctx, minute_hand_inner, minute_hand_outer);
-          minute_hand_inner.y -= SHADOW_OFFSET+1; minute_hand_outer.y -= SHADOW_OFFSET+1;
-        }
-    }
-    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);
-    }
+  if(shadows) {
+    graphics_context_set_stroke_color(ctx, gcolorshadow);
+    graphics_context_set_stroke_width(ctx, HAND_WIDTH);
+    hour_hand_outer.y += SHADOW_OFFSET;
+    s_center.y += SHADOW_OFFSET;
+    graphics_draw_line(ctx, s_center, hour_hand_outer);
+    minute_hand_outer.y += SHADOW_OFFSET+1;
+    s_center.y += 1;
+    graphics_draw_line(ctx, s_center, minute_hand_outer);
+    hour_hand_outer.y -= SHADOW_OFFSET;
+    minute_hand_outer.y -= SHADOW_OFFSET+1;
+    s_center.y -= SHADOW_OFFSET+1;
   }
+  graphics_context_set_stroke_color(ctx, gcolorh);
+  graphics_context_set_stroke_width(ctx, HAND_WIDTH);
+  graphics_draw_line(ctx, s_center, hour_hand_outer);
+  graphics_context_set_stroke_color(ctx, gcolorm);
+  graphics_context_set_stroke_width(ctx, HAND_WIDTH);
+  graphics_draw_line(ctx, s_center, minute_hand_outer);
   graphics_context_set_fill_color(ctx, gcolorp);
   graphics_fill_circle(ctx, s_center, DOT_RADIUS);
 
@@ -210,6 +288,8 @@ static void window_load(Window *window) {
   GRect window_bounds = layer_get_bounds(window_layer);
 
   s_center = grect_center_point(&window_bounds);
+  s_center.x -= 1;
+  s_center.y -= 1;
     
   if (persist_exists(KEY_BG_COLOR)) {
     int colorbg = persist_read_int(KEY_BG_COLOR);
@@ -241,6 +321,22 @@ static void window_load(Window *window) {
   } else {
     shadows = false;
   }
+  if (persist_exists(KEY_TICKS)) {
+    ticks = persist_read_int(KEY_TICKS);
+  } else {
+    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)) {
+    rectticks = persist_read_bool(KEY_RECT_TICKS);
+  } else {
+    rectticks = false;
+  }
 
   s_canvas_layer = layer_create(window_bounds);
   layer_set_update_proc(s_canvas_layer, update_proc);
@@ -258,18 +354,25 @@ static int anim_percentage(AnimationProgress dist_normalized, int max) {
 }
 
 static void radius_update(Animation *anim, AnimationProgress dist_normalized) {
-  s_radius = anim_percentage(dist_normalized, FINAL_RADIUS);
+  animpercent = anim_percentage(dist_normalized, 100);
   layer_mark_dirty(s_canvas_layer);
 }
 
 static void init() {
   srand(time(NULL));
-    
-  //light_enable(true);
+  
+  // keep lit only in emulator
+  if (watch_info_get_model()==WATCH_INFO_MODEL_UNKNOWN) {
+    debug = true;
+  }
 
   time_t t = time(NULL);
   struct tm *time_now = localtime(&t);
-  tick_handler(time_now, MINUTE_UNIT);
+  if (debug) {
+    tick_handler(time_now, SECOND_UNIT);
+  } else {
+    tick_handler(time_now, MINUTE_UNIT);
+  }
 
   s_main_window = window_create();
   window_set_window_handlers(s_main_window, (WindowHandlers) {
@@ -278,7 +381,15 @@ static void init() {
   });
   window_stack_push(s_main_window, true);
 
-  tick_timer_service_subscribe(MINUTE_UNIT, tick_handler);
+  if (debug) {
+    tick_timer_service_subscribe(SECOND_UNIT, tick_handler);
+  } else {
+    tick_timer_service_subscribe(MINUTE_UNIT, tick_handler);
+  }
+  
+  if (debug) {
+    light_enable(true);
+  }
     
   app_message_register_inbox_received(inbox_received_handler);
   app_message_open(app_message_inbox_size_maximum(), app_message_outbox_size_maximum());