void hour_display_layer_update_callback(Layer *me, GContext* ctx) {
PblTm t;
get_time(&t);
unsigned int angle = (t.tm_hour % 12) * 30;
GPoint center = grect_center_point(&me->frame);
// hour background black
graphics_context_set_fill_color(ctx, GColorBlack);
graphics_fill_circle(ctx, center, 52);
// hour sector white
graphics_context_set_fill_color(ctx, GColorWhite);
gpath_rotate_to(&hour_segment_path, (TRIG_MAX_ANGLE / 360) * angle);
gpath_draw_filled(ctx, &hour_segment_path);
// rounding hour "sector"
graphics_context_set_stroke_color(ctx, GColorBlack);
graphics_draw_circle(ctx, center, 50);
graphics_draw_circle(ctx, center, 49);
graphics_draw_circle(ctx, center, 48);
graphics_draw_circle(ctx, center, 47);
/*
graphics_context_set_fill_color(ctx, GColorBlack);
graphics_fill_circle(ctx, center, 25);
*/
}
void minute_display_layer_update_callback(Layer *me, GContext* ctx) {
PblTm t;
get_time(&t);
unsigned int angle = t.tm_min * 6;
unsigned int hr_angle = (t.tm_min / 5) *30;
GPoint center = grect_center_point(&me->frame);
// minute background white
graphics_context_set_fill_color(ctx, GColorWhite);
graphics_fill_circle(ctx, center, 72);
// five minute sector black
graphics_context_set_fill_color(ctx, GColorBlack);
gpath_rotate_to(&minute5_segment_path, (TRIG_MAX_ANGLE / 360) * hr_angle);
gpath_draw_filled(ctx, &minute5_segment_path);
// minute sector white
graphics_context_set_fill_color(ctx, GColorWhite);
gpath_rotate_to(&minute_segment_path, (TRIG_MAX_ANGLE / 360) * angle);
gpath_draw_filled(ctx, &minute_segment_path);
// minute markers black
graphics_context_set_stroke_color(ctx, GColorBlack);
for (unsigned int i = 0; i < 360; i+=30) {
gpath_rotate_to(&minute_marker_path, (TRIG_MAX_ANGLE / 360) * i);
gpath_draw_outline(ctx, &minute_marker_path);
}
// black out outer ring
graphics_context_set_stroke_color(ctx, GColorBlack);
graphics_draw_circle(ctx, center, 73);
graphics_draw_circle(ctx, center, 74);
}
static void hands_update_proc(Layer *layer, GContext *ctx) {
GRect bounds = layer_get_bounds(layer);
GPoint center = grect_center_point(&bounds);
const int16_t second_hand_length = PBL_IF_ROUND_ELSE((bounds.size.w / 2) - 19, bounds.size.w / 2);
time_t now = time(NULL);
struct tm *t = localtime(&now);
// minute/hour hand
// 時
graphics_context_set_stroke_color(ctx, s_backColor);
graphics_context_set_fill_color(ctx, s_hourHandColor);
gpath_rotate_to(s_hour_arrow, (TRIG_MAX_ANGLE * (((t->tm_hour % 12) * 6) + (t->tm_min / 10))) / (12 * 6));
gpath_draw_filled(ctx, s_hour_arrow);
// 分
graphics_context_set_fill_color(ctx, s_backColor);
gpath_rotate_to(s_minute_arrow, (TRIG_MAX_ANGLE * (t->tm_min * 10 + (t->tm_sec/6)) / (60 * 10)));
graphics_context_set_stroke_width(ctx, 2);
graphics_context_set_stroke_color(ctx, s_minuteHandColor);
gpath_draw_outline(ctx, s_minute_arrow);
// 秒
int32_t second_angle = TRIG_MAX_ANGLE * t->tm_sec / 60;
GPoint second_hand = {
.x = (int16_t)(sin_lookup(second_angle) * (int32_t)second_hand_length / TRIG_MAX_RATIO) + center.x,
.y = (int16_t)(-cos_lookup(second_angle) * (int32_t)second_hand_length / TRIG_MAX_RATIO) + center.y,
};
if (s_show_seconds_hand){
// second hand
graphics_context_set_stroke_width(ctx, 3);
graphics_context_set_stroke_color(ctx, s_secondHandColor);
graphics_draw_line(ctx, second_hand, center);
graphics_context_set_stroke_width(ctx, 1);
graphics_context_set_stroke_color(ctx, s_backColor);
graphics_draw_line(ctx, second_hand, center);
}
// dot in the middle
// 黒に設定
graphics_context_set_fill_color(ctx, s_backColor);
// 円を塗り潰し
graphics_fill_circle(ctx, center, 7);
// 線の色を白に設定
graphics_context_set_stroke_color(ctx, s_secondHandColor);
graphics_context_set_stroke_width(ctx, 1);
graphics_draw_circle(ctx, center, 7);
graphics_draw_circle(ctx, center, 1);
}
static void date_update_proc(Layer *layer, GContext *ctx) {
time_t now = time(NULL);
struct tm *t = localtime(&now);
strftime(s_day_buffer, sizeof(s_day_buffer), "%a", t);
text_layer_set_text(s_day_label, s_day_buffer);
strftime(s_num_buffer, sizeof(s_num_buffer), "%d", t);
text_layer_set_text(s_num_label, s_num_buffer);
}
// Layer representing the pet pebble
void draw_pet_pebble(Layer *layer, GContext *ctx) {
PetPebbleState pet_state = current_pet_state();
GPoint BODY_CENTER = GPoint(90, 120);
int EYES_HEIGHT = 115;
int EYE_LEFT_CENTER = 80;
int EYE_RIGHT_CENTER = 100;
uint16_t radius = 30;
// Draw the pet pebble body
graphics_context_set_stroke_color(ctx, GColorCobaltBlue);
graphics_context_set_fill_color(ctx, GColorCyan);
graphics_context_set_stroke_width(ctx, 5);
graphics_draw_circle(ctx, BODY_CENTER, radius);
graphics_fill_circle(ctx, BODY_CENTER, radius);
// Draw the pet pebble eyes
graphics_context_set_stroke_color(ctx, GColorBlack);
graphics_context_set_fill_color(ctx, GColorBlack);
graphics_context_set_stroke_width(ctx, 2);
radius = 2;
if (pet_state == SLEEPING) {
graphics_draw_line(ctx,
GPoint(EYE_LEFT_CENTER-5, EYES_HEIGHT),
GPoint(EYE_LEFT_CENTER+5, EYES_HEIGHT));
graphics_draw_line(ctx,
GPoint(EYE_RIGHT_CENTER-5, EYES_HEIGHT),
GPoint(EYE_RIGHT_CENTER+5, EYES_HEIGHT));
} else {
graphics_draw_circle(
ctx, GPoint(EYE_LEFT_CENTER, EYES_HEIGHT),radius);
graphics_draw_circle(
ctx, GPoint(EYE_RIGHT_CENTER, EYES_HEIGHT), radius);
}
// Draw the pet pebble mouth
if (pet_state == SLEEPING) {
graphics_draw_circle(ctx,
GPoint((EYE_LEFT_CENTER+EYE_RIGHT_CENTER)/2, EYES_HEIGHT+13), 5);
// Draw "Zzzz" to show that the pet pebble is asleep
graphics_draw_text(ctx, "Zzzz",
fonts_get_system_font(FONT_KEY_ROBOTO_CONDENSED_21),
GRect(EYE_RIGHT_CENTER+20, EYES_HEIGHT-40, EYE_RIGHT_CENTER+60, EYES_HEIGHT-20),
GTextOverflowModeTrailingEllipsis, GTextAlignmentLeft, NULL);
} else {
GRect rect_bounds = GRect(EYE_LEFT_CENTER,
EYES_HEIGHT+10, EYE_RIGHT_CENTER-EYE_LEFT_CENTER, 5);
int32_t angle_start = DEG_TO_TRIGANGLE(85);
int32_t angle_end = DEG_TO_TRIGANGLE(275);
graphics_draw_arc(ctx, rect_bounds,
GOvalScaleModeFillCircle, angle_start, angle_end);
}
}
void draw_round_bar(GContext *ctx, GPoint l_p, GPoint r_p, int height) {
graphics_fill_circle(ctx, l_p, height/2);
graphics_draw_circle(ctx, l_p, height/2);
graphics_fill_circle(ctx, r_p, height/2);
graphics_draw_circle(ctx, r_p, height/2);
GRect bar = {
.origin = {l_p.x, 0},
.size = {r_p.x - l_p.x, height}
};
static void canvas_update_proc(Layer *layer, GContext *ctx) {
// Custom drawing happens here!
Layer *window_layer = window_get_root_layer(s_main_window);
GRect bounds = layer_get_bounds(window_layer);
int x,y;
int left=bounds.size.w/10+2;
int right=bounds.size.w-left;
int adjusted_steps=steps/(target_steps/5);
uint16_t radius = bounds.size.w/8;
if(adjusted_steps>4) adjusted_steps=4;
printf("adj steps %d", adjusted_steps);
y=bounds.size.h/2;
x=left;
GPoint center = GPoint(x, y);
graphics_context_set_stroke_width(ctx, 2);
graphics_context_set_stroke_color(ctx, GColorInchworm);
graphics_draw_circle(ctx, center, radius);
// Draw the outline of a circle
for(int i=0;i<adjusted_steps;i++)
{
x=x+((right-left)/6);
center = GPoint(x, y);
graphics_draw_circle(ctx, center, radius);
}
// Fill a circle
GPoint p1 = GPoint(center.x-radius, center.y-radius+4);
GPoint p2 = GPoint(center.x+radius, center.y-radius+4);
graphics_context_set_fill_color(ctx, GColorInchworm);
graphics_fill_circle(ctx, center, radius);
graphics_context_set_stroke_color(ctx, GColorBlack);
graphics_context_set_stroke_width(ctx, 1);
graphics_context_set_fill_color(ctx, GColorBlack);
for(int i=0;i<2*radius;i+=4)
{
p1.y=center.y-radius+i;
p2.y=center.y-radius+i;
graphics_draw_line(ctx, p1, p2);
}
radius=radius/4;
graphics_fill_circle(ctx, center, radius);
}
// Draw the lizard by calling from the layer redraw proc
void draw_lizard(GContext* ctx) {
GPath *lizard_path = gpath_create(&lizard_points);
GPath *bug_path = gpath_create(&bug_points);
//gpath_rotate_to(lizard_path, TRIG_MAX_ANGLE / 360 * 20);
gpath_move_to(lizard_path, GPoint(10, 0));
graphics_context_set_fill_color(ctx, GColorGreen);
gpath_draw_filled(ctx, lizard_path);
graphics_context_set_stroke_color(ctx, GColorBlack);
gpath_draw_outline(ctx, lizard_path);
graphics_context_set_fill_color(ctx, GColorBlack);
gpath_draw_filled(ctx, bug_path);
GPoint center = {
.x = 41,
.y = 59
};
graphics_fill_circle(ctx, center, 3);
graphics_draw_circle(ctx, center, 8);
graphics_draw_line(ctx, GPoint(6, 73), GPoint(16, 72));
graphics_context_set_text_color(ctx, GColorRed);
graphics_draw_text(ctx,
"Lizzy",
fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD),
GRect(0,120,144,140),
GTextOverflowModeTrailingEllipsis, GTextAlignmentCenter, NULL);
}
// Only need to draw the lizard
static void drawing_layer_update_callback(Layer *me, GContext *ctx) {
draw_lizard(ctx);
}
void layer_ring_update_callback(Layer *layer, GContext* ctx) {
time_t tt = time(NULL);
struct tm *t = localtime(&tt);
unsigned int angle = 0;
if (t->tm_min != 0) {
angle = ( t->tm_min + 1 ) * 6;
}
GRect bounds = layer_get_bounds(layer);
GPoint center = grect_center_point(&bounds);
graphics_context_set_fill_color(ctx, s_color_ring_1);
graphics_fill_circle(ctx, center, 73);
graphics_context_set_fill_color(ctx, s_color_ring_2);
for(; angle < 355; angle += 6) {
gpath_rotate_to(s_path_ring_segment, (TRIG_MAX_ANGLE / 360) * angle);
gpath_draw_filled(ctx, s_path_ring_segment);
}
graphics_context_set_stroke_color(ctx, s_color_bg_out);
graphics_context_set_stroke_width(ctx, 4);
graphics_draw_circle(ctx, center, 73);
}
static void canvas_update_proc(Layer *layer, GContext *ctx) {
// Custom drawing happens here!
Layer *window_layer = window_get_root_layer(s_main_window);
GRect bounds = layer_get_bounds(window_layer);
int x,y;
int midpoint_x=bounds.size.w/2;
int midpoint_y=bounds.size.h/2;
int adjusted_minutes=90-minutes*6;
x=midpoint_x+cos(3.14*adjusted_minutes/180)*(3*midpoint_x/5);
y=midpoint_y-sin(3.14*adjusted_minutes/180)*(3*midpoint_y/5);
GPoint center = GPoint(x, y);
uint16_t radius = midpoint_x/4;
// Draw the outline of a circle
graphics_context_set_stroke_color(ctx, GColorCadetBlue);
graphics_draw_circle(ctx, center, radius);
// Fill a circle
graphics_context_set_fill_color(ctx, GColorCadetBlue);
graphics_fill_circle(ctx, center, radius);
radius=radius/4;
center = GPoint(x-6, y-6);
graphics_context_set_fill_color(ctx, GColorCeleste);
graphics_fill_circle(ctx, center, radius);
}
static void hands_layer_update_callback(Layer *layer, GContext* ctx) {
GPoint center = GPoint(CENTER_X, CENTER_Y);
// hours and minutes
// int32_t hour_angle = TRIG_MAX_ANGLE * (now->tm_hour * 5 + now->tm_min / 12) / 60;
int32_t hour_angle = (TRIG_MAX_ANGLE * (((hour % 12) * 6) + (min / 10))) / (12 * 6);
int32_t min_angle = TRIG_MAX_ANGLE * min / 60;
gpath_rotate_to(hour_path, hour_angle);
gpath_rotate_to(hour_in_path, hour_angle);
gpath_rotate_to(min_path, min_angle);
graphics_context_set_fill_color(ctx, GColorWhite);
graphics_context_set_stroke_color(ctx, GColorBlack);
gpath_draw_filled(ctx, hour_path);
gpath_draw_outline(ctx, hour_path);
graphics_context_set_fill_color(ctx, GColorBlack);
gpath_draw_filled(ctx, hour_in_path);
graphics_context_set_fill_color(ctx, GColorWhite);
graphics_draw_circle(ctx, center, DOTS_SIZE+4);
gpath_draw_filled(ctx, min_path);
gpath_draw_outline(ctx, min_path);
graphics_fill_circle(ctx, center, DOTS_SIZE+3);
// center dot
graphics_context_set_fill_color(ctx, GColorBlack);
graphics_fill_circle(ctx, center, DOTS_SIZE);
}
// Draw the vertically stacked spots that indicate how many devices there are and which one is selected
static void spots_draw(Layer *layer, GContext *ctx) {
GRect rect = layer_get_frame(layer);
graphics_context_set_stroke_color(ctx, GColorWhite);
graphics_context_set_fill_color(ctx, GColorWhite);
for (int y = 0; y < g_device_count; y++) {
#ifdef PBL_ROUND
GPoint spot = gpoint_from_polar(GRect(rect.origin.x+((rect.size.w-DEV_LAYER_WIDTH)/4),
rect.origin.y+((rect.size.h-DEV_LAYER_HEIGHT)/4),
rect.size.w-((rect.size.w-DEV_LAYER_WIDTH)/2),
rect.size.h-((rect.size.h-DEV_LAYER_HEIGHT)/2)), GOvalScaleModeFitCircle,
DEG_TO_TRIGANGLE(270+
((((SPOT_RADIUS*2)*g_device_count)+(SPOT_SPACING*(g_device_count-1)))/2) -
(y*((SPOT_RADIUS*2)+SPOT_SPACING)+3)));
#else
GPoint spot = GPoint((rect.size.w/2),
(rect.size.h/2)-((((SPOT_RADIUS*2)*g_device_count)+(SPOT_SPACING*(g_device_count-1)))/2) +
(y*((SPOT_RADIUS*2)+SPOT_SPACING)+3));
#endif
if (g_device_selected == y)
graphics_fill_circle(ctx, spot, SPOT_RADIUS);
else
graphics_draw_circle(ctx, spot, SPOT_RADIUS);
}
}
// ------------------------------------------------------------------------ //
// Drawing Functions
// ------------------------------------------------------------------------ //
static void graphics_layer_update(Layer *me, GContext *ctx) {
static char text[100]; //Buffer to hold text
// Draw text box
GRect textframe = GRect(25-2, 28+2, 90+4, 27+2); // Text Box Position and Size: x, y, w, h
graphics_context_set_fill_color(ctx, GColorBlack);
graphics_fill_rect(ctx, textframe, 0, GCornerNone); //Black Filled Rectangle
graphics_context_set_stroke_color(ctx, GColorWhite);
graphics_draw_rect(ctx, textframe); //White Rectangle Border
// Fill it with text
textframe = GRect(25, 28, 90, 27); // Text Box Position and Size: x, y, w, h
graphics_draw_text(ctx, "Strength:\nTime:", fonts_get_system_font(FONT_KEY_GOTHIC_14), textframe, GTextOverflowModeWordWrap, GTextAlignmentLeft, NULL); //Write Text
snprintf(text, sizeof(text), "%d\n%ld", tap.strength, (long)(tap.timestamp&0x7FFFFFFF)); // What text to draw
graphics_draw_text(ctx, text, fonts_get_system_font(FONT_KEY_GOTHIC_14), textframe, GTextOverflowModeWordWrap, GTextAlignmentRight, NULL); //Write Text
// Draw Plus and Tap Circle
graphics_context_set_stroke_color(ctx, GColorWhite); // Line Color
graphics_draw_line(ctx, GPoint(cursor.x-10, cursor.y), GPoint(cursor.x+10, cursor.y));
graphics_draw_line(ctx, GPoint(cursor.x, cursor.y-10), GPoint(cursor.x, cursor.y+10));
//graphics_draw_circle(ctx, GPoint(tap.x, tap.y), tap.length); // Draw the tap (commented out since now we draw the 8 previous taps below)
for(uint8_t i=0; i<NUMBER_OF_CIRCLES; i++)
if(circles[i].r<100) // Make sure we didn't somehow make a giant circle
graphics_draw_circle(ctx, GPoint(circles[i].x, circles[i].y), circles[i].r);
}
static void canvas_update_proc(Layer *layer, GContext *ctx) {
int rect_width = text_layer_get_content_size(s_date_layer).w + 10;
GRect rect_bounds = GRect(((180 - rect_width) / 2), 110, rect_width, 25);
graphics_context_set_fill_color(ctx, settings.SecondaryColor);
int corner_radius = 5;
graphics_fill_rect(ctx, rect_bounds, corner_radius, GCornersAll);
GPoint circle_center = GPoint(90, 90);
uint16_t circle_radius = 75;
graphics_context_set_stroke_color(ctx, settings.SecondaryColor);
graphics_context_set_stroke_width(ctx, 1);
graphics_draw_circle(ctx, circle_center, circle_radius);
graphics_context_set_stroke_width(ctx, 3);
uint16_t outer_circle_radius = 80;
graphics_draw_circle(ctx, circle_center, outer_circle_radius);
}
static void draw_mark(int x, int y, int width, int height, void *vp)
{
graphics_draw_circle(canvas, x, y, 10, 0xff00ff);
graphics_draw_line(canvas, x - 15, y, x + 15, y, 0x00ffff);
graphics_draw_line(canvas, x, y - 15, x, y + 15, 0x00ffff);
graphics_draw_string(canvas, 50, 110, cal1, NULL, 0xffffff, 0);
graphics_set_visible_canvas(display, canvas);
}
void centre_layer_update_proc(Layer *centre_layer, GContext* ctx){
//fill circle
graphics_context_set_fill_color(ctx, GColorWhite);
graphics_fill_circle(ctx, (GPoint){72, 84}, 7);
//stroke circle
graphics_context_set_stroke_color(ctx, GColorBlack);
graphics_draw_circle(ctx, (GPoint){72, 84}, 7);
}
static void mainForegroundUpdateProc(Layer* this_layer, GContext *ctx) {
GRect b = layer_get_bounds(this_layer);
#ifdef PBL_ROUND
b.size.h -= 16; // Because of the time at the top, default position is too low on a round screen
#endif
// Draw the three lives
GPoint lives = GPoint( b.size.w/2 - PIECE_PIXELS, b.size.h - 6);
for (int L=0; L<3; ++L) {
GColor in;
GColor out;
if (s_score.lives >= (3 - L)) {
if (L == 0) { in = COLOR_FALLBACK(GColorMintGreen, GColorWhite); out = COLOR_FALLBACK(GColorDarkGreen, GColorBlack); }
else if (L == 1) { in = COLOR_FALLBACK(GColorRajah, GColorWhite); out = COLOR_FALLBACK(GColorWindsorTan, GColorBlack); }
else { in = COLOR_FALLBACK(GColorMelon, GColorWhite); out = COLOR_FALLBACK(GColorDarkCandyAppleRed, GColorBlack); }
} else {
in = COLOR_FALLBACK(GColorLightGray, GColorBlack);
out = COLOR_FALLBACK(GColorDarkGray, GColorBlack);
}
GPoint p = lives;
p.x += PIECE_PIXELS * L;
graphics_context_set_stroke_color(ctx, out);
graphics_context_set_fill_color(ctx, in);
graphics_context_set_stroke_width(ctx, 3);
graphics_fill_circle(ctx, p, 3);
graphics_draw_circle(ctx, p, 3);
// Animation?
if (s_spentLifeAnimRadius > 0 && s_score.lives == (3 - L)) {
graphics_context_set_stroke_width(ctx, 5);
graphics_context_set_stroke_color(ctx, COLOR_FALLBACK(in,out));
graphics_draw_circle(ctx, p, s_spentLifeAnimRadius / SUB_PIXEL );
}
}
// Draw the game over message
if (s_gameOverMessage == true) {
static const char txtGame[] = "GAME";
static const char txtOver[] = "OVER";
b.origin.y += 30;
draw3DText(ctx, b, fonts_get_system_font(FONT_KEY_BITHAM_42_BOLD), txtGame, 1, GTextAlignmentCenter, true, GColorWhite, GColorBlack);
b.origin.y += 40;
draw3DText(ctx, b, fonts_get_system_font(FONT_KEY_BITHAM_42_BOLD), txtOver, 1, GTextAlignmentCenter, true, GColorWhite, GColorBlack);
}
}
static void paint_clock(ClockIcon *aIcon, GContext *aCtx, GRect r, GPoint aCenter, int32_t aRadius, bool aAnimating, bool aZoomedIn) {
// background
if (aAnimating) {
graphics_context_set_stroke_color(aCtx, GColorWhite);
for (int32_t i = 0; i < 60; ++i) {
int32_t len1 = aRadius;
int32_t len2 = (i % 5 == 0)
? CLOCK_HOUR_MARK_START_LENGTH(aRadius)
: CLOCK_MIN_MARK_START_LENGTH(aRadius);
int32_t angle = TRIG_MAX_ANGLE * i / 60.f;
draw_angle_line(aCtx, aCenter, angle, len1, len2,
(i % 5 == 0) ? LineWidth2 : LineWidth1);
}
graphics_context_set_fill_color(aCtx, GColorWhite);
graphics_context_set_stroke_color(aCtx, GColorWhite);
} else {
graphics_context_set_fill_color(aCtx, GColorWhite);
graphics_fill_circle(aCtx, aCenter, aRadius);
graphics_context_set_fill_color(aCtx, GColorBlack);
graphics_context_set_stroke_color(aCtx, GColorBlack);
}
clock_icon_data *data = layer_get_data(aIcon);
int32_t h = data->h;
int32_t m = data->m;
int32_t s = data->s;
// hour hand
draw_clock_hand(aCtx, aCenter, aRadius, aZoomedIn,
CLOCK_HOUR_HAND_LENGTH(aRadius),
TRIG_MAX_ANGLE * (h + m / 60.f) / 12.f);
// minutes hand
draw_clock_hand(aCtx, aCenter, aRadius, aZoomedIn,
CLOCK_MIN_HAND_LENGTH(aRadius),
TRIG_MAX_ANGLE * (m + s / 60.f) / 60.f);
if (aZoomedIn) {
graphics_draw_circle(aCtx, aCenter, CLOCK_CENTER_RADIUS - 1);
}
if (!aAnimating && !aZoomedIn && !clock_icon_shows_second_hand()) {
// don't draw second hand if preffed off.
return;
}
// seconds hand
int32_t secLength = CLOCK_SEC_HAND_LENGTH(aRadius);
int32_t secAngle = TRIG_MAX_ANGLE * s / 60.f;
#ifdef PBL_COLOR
graphics_context_set_stroke_color(aCtx, GColorChromeYellow);
#endif
if (aZoomedIn) {
draw_angle_line(aCtx, aCenter, secAngle, CLOCK_CENTER_RADIUS, secLength, LineWidth1);
} else {
draw_angle_line(aCtx, aCenter, secAngle, 0, secLength, LineWidth1);
}
}
static void draw_shape(GContext* ctx, int shape, int32_t angle, bool hour) {
if (shape < 3) {
graphics_draw_circle(ctx, center_point, hour ? HOUR_RADIUS : MINUTE_RADIUS);
} else {
GPathInfo* path_info = (hour ? HOUR_SHAPES : MINUTE_SHAPES) + shape - 3;
GPath* path = gpath_create(path_info);
gpath_rotate_to(path, angle);
gpath_move_to(path, center_point);
gpath_draw_outline(ctx, path);
}
}
static void graph_layer_update_callback(Layer *me, GContext *ctx) {
const GRect frame = layer_get_frame(me);
graphics_context_set_fill_color(ctx, GColorWhite);
if (!is_measuring() && calibrations_count < 3) {
text_calibrate_initial[74] = '0' + (3 - calibrations_count);
graphics_draw_text(ctx, text_calibrate_initial, font_tiny, GRect(3, 0, frame.size.w - 3, frame.size.h), GTextOverflowModeWordWrap, GTextAlignmentLeft, NULL);
return;
}
// graph area boundaries
graphics_fill_rect(ctx, GRect(0, 0, frame.size.w, 1), 0, GCornerNone);
graphics_fill_rect(ctx, GRect(frame.size.w - 1, 0, 1, frame.size.h), 0, GCornerNone);
int count = calibrations_count;
if (is_measuring())
count++;
Measurement *m;
float maxWeight = 1, minFreq = calibrations[0].freq, maxFreq = 0.01, minAmp = calibrations[0].amp, maxAmp = 0.01;
for (int i = 0; i < count; i++) {
m = &calibrations[i];
if (m->weight > maxWeight)
maxWeight = m->weight;
if (m->freq < minFreq) minFreq = m->freq;
if (m->freq > maxFreq) maxFreq = m->freq;
if (m->amp < minAmp) minAmp = m->amp;
if (m->amp > maxAmp) maxAmp = m->amp;
}
// draw current measure circle
graphics_context_set_stroke_color(ctx, GColorWhite);
for (int i = 0; i < count; i++) {
m = &calibrations[i];
uint16_t r = 5 * m->weight / maxWeight;
if (r < 1) r = 1;
int16_t x = (5 + (m->freq - minFreq) * (frame.size.w - 10) / (maxFreq - minFreq));
int16_t y = (frame.size.h - 5 - (m->amp - minAmp) * (frame.size.h - 10) / (maxAmp - minAmp));
if (i == calibrations_count || m->weight == weight)
graphics_fill_circle(ctx, GPoint(x, y), r);
else
graphics_draw_circle(ctx, GPoint(x, y), r);
}
// draw lines of constant weight for steps of 50g
if (calibrations_count >= 3) {
draw_calibration_line(ctx, frame, weight, false, minFreq, maxFreq, minAmp, maxAmp);
float w = 0;
do {
if (!draw_calibration_line(ctx, frame, w, true, minFreq, maxFreq, minAmp, maxAmp))
break;
w += 50;
} while (w <= 1000);
}
}
void minutes_proc(Layer *layer, GContext *ctx){
for(int j = c_enabled; j > 0; j--){
if(pulse_enabled_c){
graphics_context_set_stroke_color(ctx, GColorWhite);
graphics_fill_circle(ctx, GPoint(circle_coords[0][j], circle_coords[1][j]), ci_value);
graphics_draw_circle(ctx, GPoint(circle_coords[0][j], circle_coords[1][j]), ci_value+1);
}
else{
graphics_fill_circle(ctx, GPoint(circle_coords[0][j], circle_coords[1][j]), 3);
}
}
}
void display_layer_update_callback(Layer *me, GContext* ctx) {
(void)me;
PblTm t;
graphics_context_set_fill_color(ctx, GColorWhite);
graphics_context_set_stroke_color(ctx, GColorWhite);
GPoint center;
center.x = DISPLAY_W/2;
center.y = DISPLAY_H/2;
graphics_draw_circle(ctx,center,DISPLAY_W/2);
}
static void score_layer_update(Layer *layer,GContext *ctx){
const uint8_t RADIUS = 60;
const uint8_t THICKNESS = 10;
graphics_context_set_stroke_color(ctx, GColorDarkGray);
graphics_context_set_stroke_width(ctx,THICKNESS);
GRect r = layer_get_bounds(layer);
GPoint center = grect_center_point(&r);
graphics_draw_circle(ctx,center,RADIUS);
graphics_draw_arc(ctx,center,RADIUS+ (THICKNESS/2),THICKNESS,angle_270,angle_90,GColorDukeBlue);
}
void path_layer_update_callback(Layer *me, GContext *ctx) {
(void)me;
graphics_context_set_stroke_color(ctx, GColorBlack);
GPoint p0, p1;
if (nb_points < 2) {
return;
}
for (int i = 0; i < ((nb_points > NUM_POINTS ? NUM_POINTS : nb_points) - 1); i++) {
p0 = pts[(NUM_POINTS+cur_point-i) % NUM_POINTS];
p1 = pts[(NUM_POINTS+cur_point-i-1) % NUM_POINTS];
p0.x = (XINI + (p0.x * SCREEN_W / (map_scale/10))) % MAP_VSIZE_X;
p0.y = (YINI - (p0.y * SCREEN_W / (map_scale/10))) % MAP_VSIZE_Y;
p1.x = (XINI + (p1.x * SCREEN_W / (map_scale/10))) % MAP_VSIZE_X;
p1.y = (YINI - (p1.y * SCREEN_W / (map_scale/10))) % MAP_VSIZE_Y;
graphics_draw_line(
ctx,
p0,
p1
);
}
for (int i = 0; i < s_live.nb; i++) {
p0.x = (XINI + (s_live.friends[i].xpos * SCREEN_W / (map_scale/10))) % MAP_VSIZE_X;
p0.y = (YINI - (s_live.friends[i].ypos * SCREEN_W / (map_scale/10))) % MAP_VSIZE_Y;
graphics_draw_pixel(ctx, p0);
graphics_draw_circle(ctx, p0, 3);
if (i == 0) {
#if DEBUG
snprintf(s_data.debug2, sizeof(s_data.debug2),
"%d|%d\n"
"%d|%d\n"
"%d|%d\n"
"%d|%d\n",
s_live.friends[i].xpos,s_live.friends[i].ypos,
p0.x,p0.y,
pathFrame.origin.x,pathFrame.origin.y,
s_live.friends[i].name_frame.origin.x,s_live.friends[i].name_frame.origin.y
);
#endif
}
}
}
static void game_layer_update_proc(Layer *layer, GContext *ctx)
{
// Draw the apple
graphics_context_set_stroke_color(ctx, GColorBlack);
graphics_draw_circle(ctx, GPoint(apple->x,apple->y), APPLE_SIZE);
// Draw the snake
snake_section_t *current_section = snake->head;
while (current_section) {
graphics_context_set_fill_color(ctx, GColorBlack);
graphics_fill_circle(ctx, GPoint(current_section->x,current_section->y), SNAKE_BODY_WIDTH);
current_section = current_section->next;
}
}
void circle_proc(Layer *layer, GContext *ctx){
graphics_context_set_stroke_color(ctx, GColorBlack);
graphics_context_set_fill_color(ctx, GColorBlack);
int i;
for(i = 0; i < 4; i++){
int fix = 17+(30*i);
graphics_draw_circle(ctx, GPoint(fix, CIRCLE_HEIGHT), CIRCLE_RADIUS);
}
int k;
for(k = 0; k < circles_filled; k++){
int fix = 17+(30*k);
graphics_fill_circle(ctx, GPoint(fix, CIRCLE_HEIGHT), CIRCLE_RADIUS);
}
}
static void maze_layer_update_callback(Layer *layer, GContext *ctx) {
for(int i = 0; i < mazeWidth; i++){
for(int j = 0; j < mazeHeight; j++){
int currentPos = getPOS(j, i, mazeWidth);
if(maze[currentPos].r == 1) {
graphics_draw_line(ctx, GPoint(corridorSize*(i + 1), corridorSize*j), GPoint(corridorSize*(i + 1), corridorSize*(j + 1)));
}
if(maze[currentPos].b == 1) {
graphics_draw_line(ctx, GPoint(corridorSize*i, corridorSize*(j + 1)), GPoint(corridorSize*(i + 1), corridorSize*(j + 1)));
}
}
}
graphics_draw_circle(ctx, GPoint((mazeWidth-1)*corridorSize+corridorSize/2,
(mazeHeight-1)*corridorSize+corridorSize/2), corridorSize/2-1);
}
void battery_layer_update(Layer *me, GContext *ctx)
{
int8_t spacer = 7; // pixels
int8_t start_x = spacer * MAX_DOTS;
graphics_context_set_fill_color(ctx, GColorWhite);
graphics_context_set_stroke_color(ctx, GColorWhite);
for (int i=0; i<MAX_DOTS; i++) {
if (i<dots) {
graphics_fill_circle(ctx, GPoint(start_x-(i*spacer), 4), 2);
} else {
graphics_draw_circle(ctx, GPoint(start_x-(i*spacer), 4), 2);
}
}
}
void draw_face_layer(Layer* l, GContext* ctx)
{
GColor foreground_color = gcolor_legible_over(s_background_color);
GRect bounds = layer_get_frame(l);
GPoint center = GPoint(bounds.size.w / 2, bounds.size.h / 2);
int height = bounds.size.h - 2;
int width = bounds.size.w - 2;
graphics_context_set_stroke_color(ctx, foreground_color);
graphics_context_set_fill_color(ctx, s_complementary_color);
graphics_context_set_text_color(ctx, foreground_color);
graphics_draw_circle(ctx, center, 6);
graphics_fill_circle(ctx, center, 5);
// draw 4 ticks
GRect zero_box;
zero_box.size.w = 30;
zero_box.size.h = 12;
zero_box.origin.x = width / 2 - 12;
zero_box.origin.y = height - 20;
graphics_draw_text(ctx, "0", s_time_font, zero_box, GTextOverflowModeFill, GTextAlignmentCenter, NULL);
zero_box.origin.y = height / 2 - 12;
zero_box.origin.x = 2;
graphics_draw_text(ctx, "6", s_time_font, zero_box, GTextOverflowModeFill, GTextAlignmentLeft, NULL);
zero_box.origin.x = width / 2 - 10;
zero_box.origin.y = 0;
graphics_draw_text(ctx, "12", s_time_font, zero_box, GTextOverflowModeFill, GTextAlignmentCenter, NULL);
zero_box.origin.y = height / 2 - 10;
zero_box.origin.x = width - 30;
graphics_draw_text(ctx, "18", s_time_font, zero_box, GTextOverflowModeFill, GTextAlignmentRight, NULL);
graphics_context_set_fill_color(ctx, s_complementary_color);
int circle_inset = PBL_IF_ROUND_ELSE(6, 2);
int circle_radius = MIN(width / 2 - circle_inset, height / 2 - circle_inset);
for (int i = 0; i < 24; ++i) {
if (i % 6 == 0) {
continue;
}
int angle = i * TRIG_MAX_ANGLE / 24;
int y = (-cos_lookup(angle) * circle_radius / TRIG_MAX_RATIO);
int x = (sin_lookup(angle) * circle_radius / TRIG_MAX_RATIO);
GPoint pt = GPoint(x + center.x, y + center.y);
graphics_fill_circle(ctx, pt, 2);
}
}
static void draw_digit(Layer *layer, GContext *ctx,
int col, int bits, int val)
{
const GRect bounds = layer_get_bounds(layer);
const int16_t x_coord = col_offset + RADIUS + (2 * RADIUS + col_spacing) * col;
GPoint point;
int i;
for (i = 0; i < bits; i++) {
point = GPoint(x_coord, bounds.size.h - RADIUS * (3 * i + 2));
if (val & 1)
graphics_fill_circle(ctx, point, RADIUS);
else
graphics_draw_circle(ctx, point, RADIUS);
val >>= 1;
}
}
void update_graph(struct Layer* layer, GContext* ctx) {
graphics_context_set_fill_color(ctx, BG_COLOR);
graphics_fill_rect(ctx, FULL_SCREEN, 0, GCornerNone);
float hourpos = 12 - (hours + minutes / 60.0f);
float minpos = (minutes) / 5.0f;
graphics_context_set_stroke_color(ctx, TIME_COLOR);
graphics_draw_line(ctx, GPoint((int)(18 + 9 * minpos), 22), GPoint((int)(18 + 9 * minpos), 146));
graphics_draw_line(ctx, GPoint(10, (int)(30 + 9 * hourpos)), GPoint(134, (int)(30 + 9 * hourpos)));
graphics_draw_circle(ctx, GPoint((int)(18 + 9 * minpos), (int)(30 + 9 * hourpos)), 2);
graphics_context_set_stroke_color(ctx, TEXT_COLOR);
for (int i = 0; i < 13; i++)
for (int j = 0; j < 13; j++)
graphics_draw_pixel(ctx, GPoint(18 + 9 * i, 30 + 9 * j));
graphics_draw_rect(ctx, GRect(9, 21, 126, 126));
}
