appinfo.json

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

src/js/pebble-js-app.js

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

src/main.c

@@ -8,13 +8,12 @@
 #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 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
@@ -48,33 +47,15 @@ typedef struct {
 } Time;
 
 static Window *s_main_window;
-static Layer *bg_canvas_layer, *s_canvas_layer;
+static Layer *s_canvas_layer;
 
 static GPoint s_center;
 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 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) {
   Tuple *colorbg_t = dict_find(iter, KEY_BG_COLOR);
   Tuple *colorm_t = dict_find(iter, KEY_MINUTE_COLOR);
@@ -84,11 +65,7 @@ static void inbox_received_handler(DictionaryIterator *iter, void *context) {
   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) {
     int colorbg = colorbg_t->value->int32;
     persist_write_int(KEY_BG_COLOR, colorbg);
@@ -110,58 +87,32 @@ static void inbox_received_handler(DictionaryIterator *iter, void *context) {
     persist_write_int(KEY_PEG_COLOR, colorp);
     gcolorp = GColorFromHEX(colorp);
   }
-    if(colort_t) {
+  if(shadows_t && shadows_t->value->int32 > 0) {
-      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(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(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) {
     layer_mark_dirty(s_canvas_layer);
   }
-  vibes_short_pulse();
 }
 
 /*************************** AnimationImplementation **************************/
@@ -194,13 +145,9 @@ static void animate(int duration, int delay, AnimationImplementation *implementa
 static void tick_handler(struct tm *tick_time, TimeUnits changed) {
   // Store time
   // dummy time in emulator
-  if (debug) {
+  if (watch_info_get_model()==WATCH_INFO_MODEL_UNKNOWN) {
-    /*
     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;
@@ -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) {
   // Progress through 60 minutes, out of 360 degrees
   return ((minute * 360) / 60);
@@ -234,58 +170,6 @@ static int32_t get_angle_for_hour(int hour, int minute) {
   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);
-  graphics_context_set_fill_color(ctx, gcolorbg);
-  graphics_fill_rect(ctx, bounds, 0, GCornerNone);
-  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) {
   GRect bounds = layer_get_bounds(layer);
   GRect bounds_h = bounds;
@@ -317,6 +201,8 @@ static void update_proc(Layer *layer, GContext *ctx) {
   }
   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);
 
   // Use current time while animating
@@ -329,9 +215,53 @@ static void update_proc(Layer *layer, GContext *ctx) {
   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
+  }
+
   if(shadows) {
     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;
     s_center.y += SHADOW_OFFSET;
     graphics_draw_line(ctx, s_center, hour_hand_outer);
@@ -343,13 +273,13 @@ static void update_proc(Layer *layer, GContext *ctx) {
     s_center.y -= SHADOW_OFFSET+1;
   }
   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_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_context_set_fill_color(ctx, gcolorp);
-  graphics_fill_circle(ctx, s_center, whwidth/4);
+  graphics_fill_circle(ctx, s_center, DOT_RADIUS);
 
 }
 
@@ -361,7 +291,6 @@ static void window_load(Window *window) {
   s_center.x -= 1;
   s_center.y -= 1;
     
-  #if defined(PBL_COLOR)
   if (persist_exists(KEY_BG_COLOR)) {
     int colorbg = persist_read_int(KEY_BG_COLOR);
     gcolorbg = GColorFromHEX(colorbg);
@@ -387,56 +316,34 @@ static void window_load(Window *window) {
   } else {
     gcolorp = GColorDarkGray;
   }
+  if (persist_exists(KEY_SHADOWS)) {
+    shadows = persist_read_bool(KEY_SHADOWS);
+  } 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_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 {
-    ticks = 0;
-  }
   if (persist_exists(KEY_RECT_TICKS)) {
     rectticks = persist_read_bool(KEY_RECT_TICKS);
   } else {
     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);
-  layer_set_update_proc(bg_canvas_layer, bg_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) {
-  layer_destroy(bg_canvas_layer);
   layer_destroy(s_canvas_layer);
 }
 
@@ -484,12 +391,6 @@ static void init() {
     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_open(app_message_inbox_size_maximum(), app_message_outbox_size_maximum());