static void init() { window = window_create(); window_set_background_color(window, GColorWhite); #ifdef PBL_SDK_2 window_set_fullscreen(window, true); #endif window_set_click_config_provider(window, click_config_provider); window_set_window_handlers(window, (WindowHandlers) { .load = main_window_load, .unload = main_window_unload, }); window_stack_push(window, true); platform_path = gpath_create(&platform_path_points); gpath_move_to(platform_path, GPoint(53, 156)); } static void deinit() { window_destroy(window); } int main(void) { init(); app_event_loop(); deinit(); return 0; }
static void line_layer_draw_callback(Layer *layer, GContext *ctx) { GRect bounds = layer_get_bounds(layer); graphics_draw_line(ctx, GPoint(0,0), GPoint(bounds.size.w,0)); }
void handle_init(AppContextRef ctx) { (void)ctx; window_init(&window, "KP Sun-Moon-Clock"); window_stack_push(&window, true /* Animated */); window_set_background_color(&window, GColorWhite); resource_init_current_app(&APP_RESOURCES); font_moon = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_MOON_PHASES_SUBSET_30)); layer_init(&graphics_sun_layer, window.layer.frame); graphics_sun_layer.update_proc = &graphics_sun_layer_update_callback; layer_add_child(&window.layer, &graphics_sun_layer); rotbmp_pair_init_container(RESOURCE_ID_IMAGE_WATCHFACE_WHITE, RESOURCE_ID_IMAGE_WATCHFACE_BLACK, &watchface_container); layer_add_child(&graphics_sun_layer, &watchface_container.layer.layer); watchface_container.layer.layer.frame.origin.x = (144/2) - (watchface_container.layer.layer.frame.size.w/2); watchface_container.layer.layer.frame.origin.y = (168/2) - (watchface_container.layer.layer.frame.size.h/2); text_layer_init(&text_time_layer, window.layer.frame); text_layer_set_text_color(&text_time_layer, GColorBlack); text_layer_set_background_color(&text_time_layer, GColorClear); layer_set_frame(&text_time_layer.layer, GRect(0, 35, 144, 30)); text_layer_set_font(&text_time_layer, fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_ROBOTO_CONDENSED_30))); layer_add_child(&window.layer, &text_time_layer.layer); rotbmp_pair_init_container(RESOURCE_ID_IMAGE_HOUR_WHITE, RESOURCE_ID_IMAGE_HOUR_BLACK, &bitmap_container); rotbmp_pair_layer_set_src_ic(&bitmap_container.layer, GPoint(9,56)); layer_add_child(&window.layer, &bitmap_container.layer.layer); text_layer_init(&moonLayer, GRect(0, 100, 144 /* width */, 168-115 /* height */)); text_layer_set_text_color(&moonLayer, GColorWhite); text_layer_set_background_color(&moonLayer, GColorClear); text_layer_set_font(&moonLayer, font_moon); text_layer_set_text_alignment(&moonLayer, GTextAlignmentCenter); handle_day(ctx, NULL); layer_add_child(&window.layer, &moonLayer.layer); PblTm t; get_time(&t); rotbmp_pair_layer_set_angle(&bitmap_container.layer, TRIG_MAX_ANGLE * get24HourAngle(t.tm_hour, t.tm_min)); bitmap_container.layer.layer.frame.origin.x = (144/2) - (bitmap_container.layer.layer.frame.size.w/2); bitmap_container.layer.layer.frame.origin.y = (168/2) - (bitmap_container.layer.layer.frame.size.h/2); //Day of Week text text_layer_init(&dow_layer, GRect(0, 0, 144, 127+26)); text_layer_set_text_color(&dow_layer, GColorWhite); text_layer_set_background_color(&dow_layer, GColorClear); text_layer_set_font(&dow_layer, fonts_get_system_font(FONT_KEY_GOTHIC_14_BOLD)); text_layer_set_text_alignment(&dow_layer, GTextAlignmentLeft); text_layer_set_text(&dow_layer, "xxx"); layer_add_child(&window.layer, &dow_layer.layer); //Day of the Month text text_layer_init(&dom_layer, GRect(0, 10, 144, 137+26)); text_layer_set_text_color(&dom_layer, GColorWhite); text_layer_set_background_color(&dom_layer, GColorClear); text_layer_set_font(&dom_layer, fonts_get_system_font(FONT_KEY_GOTHIC_24)); text_layer_set_text_alignment(&dom_layer, GTextAlignmentLeft); text_layer_set_text(&dom_layer, "00"); layer_add_child(&window.layer, &dom_layer.layer); //Month Text text_layer_init(&mon_layer, GRect(0, 0, 144, 127+26)); text_layer_set_text_color(&mon_layer, GColorWhite); text_layer_set_background_color(&mon_layer, GColorClear); text_layer_set_font(&mon_layer, fonts_get_system_font(FONT_KEY_GOTHIC_14_BOLD)); text_layer_set_text_alignment(&mon_layer, GTextAlignmentRight); text_layer_set_text(&mon_layer, "xxx"); layer_add_child(&window.layer, &mon_layer.layer); //Year Number text text_layer_init(&yon_layer, GRect(0, 10, 144, 137+26)); text_layer_set_text_color(&yon_layer, GColorWhite); text_layer_set_background_color(&yon_layer, GColorClear); text_layer_set_font(&yon_layer, fonts_get_system_font(FONT_KEY_GOTHIC_24)); text_layer_set_text_alignment(&yon_layer, GTextAlignmentRight); text_layer_set_text(&yon_layer, "00"); layer_add_child(&window.layer, &yon_layer.layer); //Sunrise Text text_layer_init(&text_sunrise_layer, window.layer.frame); text_layer_set_text_color(&text_sunrise_layer, GColorWhite); text_layer_set_background_color(&text_sunrise_layer, GColorClear); layer_set_frame(&text_sunrise_layer.layer, GRect(0, 145, 144, 30)); text_layer_set_font(&text_sunrise_layer, fonts_get_system_font(FONT_KEY_GOTHIC_18)); layer_add_child(&window.layer, &text_sunrise_layer.layer); //Sunset Text text_layer_init(&text_sunset_layer, window.layer.frame); text_layer_set_text_color(&text_sunset_layer, GColorWhite); text_layer_set_background_color(&text_sunset_layer, GColorClear); layer_set_frame(&text_sunset_layer.layer, GRect(0, 145, 144, 30)); text_layer_set_font(&text_sunset_layer, fonts_get_system_font(FONT_KEY_GOTHIC_18)); layer_add_child(&window.layer, &text_sunset_layer.layer); updateDayAndNightInfo(); }
// HORIZONTAL LINE // void update_background_callback(Layer *me, GContext* ctx) { graphics_context_set_stroke_color(ctx, GColorBlack); graphics_draw_line(ctx, GPoint(0, 83), GPoint(144, 83)); }
GPoint GraphDisplay::absoluteToGraphPoint(APoint a_point) const { //Scale, then translate return GPoint(absoluteToGraphXP(a_point.x), absoluteToGraphYP(a_point.y)); }
GPoint random_point_roughly_in_screen(int margin, int padding) { GRect window_bounds = layer_get_bounds(window_get_root_layer(window)); return GPoint(random_in_range(0-margin+padding, window_bounds.size.w+1+margin-padding), random_in_range(0-margin+padding, window_bounds.size.h+1+margin-padding)); }
bool ServiceDB::GetStationInfo(uint32 stationID, uint32 *systemID, uint32 *constellationID, uint32 *regionID, GPoint *position, GPoint *dockPosition, GVector *dockOrientation) { if( systemID == NULL && constellationID == NULL && regionID == NULL && position == NULL && dockPosition == NULL && dockOrientation == NULL ) return true; DBQueryResult res; if(!sDatabase.RunQuery(res, "SELECT" " solarSystemID," " constellationID," " regionID," " x, y, z," " dockEntryX, dockEntryY, dockEntryZ," " dockOrientationX, dockOrientationY, dockOrientationZ" " FROM staStations" " LEFT JOIN staStationTypes USING (stationTypeID)" " WHERE stationID = %u", stationID)) { _log(DATABASE__ERROR, "Failed to query info for station %u: %s.", stationID, res.error.c_str()); return false; } DBResultRow row; if(!res.GetRow(row)) { _log(DATABASE__ERROR, "Failed to query info for station %u: Station not found.", stationID); return false; } if(systemID != NULL) *systemID = row.GetUInt(0); if(constellationID != NULL) *constellationID = row.GetUInt(1); if(regionID != NULL) *regionID = row.GetUInt(2); if(position != NULL) *position = GPoint( row.GetDouble(3), row.GetDouble(4), row.GetDouble(5) ); if(dockPosition != NULL) *dockPosition = GPoint( row.GetDouble(3) + row.GetDouble(6), row.GetDouble(4) + row.GetDouble(7), row.GetDouble(5) + row.GetDouble(8) ); if(dockOrientation != NULL) { *dockOrientation = GVector( row.GetDouble(9), row.GetDouble(10), row.GetDouble(11) ); // as it's direction, it should be normalized dockOrientation->normalize(); } return true; }
void handle_init(AppContextRef ctx) { (void)ctx; window_init(&window, "Circling Hours"); window_stack_push(&window, true); window_set_background_color(&window, GColorBlack); resource_init_current_app(&APP_RESOURCES); first_run = "true"; hours_word.old_text = hours_word.text; bmp_init_container(RESOURCE_ID_IMAGE_HOUR_BG, &background_image_container); layer_add_child(&window.layer, &background_image_container.layer.layer); // font_minutes = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_ARIAL_BLACK_50)); // text_layer(&font_minutes_word, GRect(0, 40, 143, 100), font_minutes); /* add to resource_map.json: { "type":"font", "defName":"FONT_ARIAL_BLACK_50", "file":"fonts/Arial-Black.ttf" } */ // much less space needed because font is built in // font_minutes = fonts_get_system_font(FONT_KEY_GOTHAM_42_MEDIUM_NUMBERS); font_minutes = fonts_get_system_font(FONT_KEY_GOTHAM_42_BOLD); text_layer(&font_minutes_word, GRect(0, 58, 143, 50), font_minutes); text_layer_set_text_alignment(&font_minutes_word.layer, GTextAlignmentCenter); rotbmp_init_container(RESOURCE_ID_IMAGE_HOUR_1, &hour_image_container_1); rotbmp_init_container(RESOURCE_ID_IMAGE_HOUR_2, &hour_image_container_2); rotbmp_init_container(RESOURCE_ID_IMAGE_HOUR_3, &hour_image_container_3); rotbmp_init_container(RESOURCE_ID_IMAGE_HOUR_4, &hour_image_container_4); rotbmp_init_container(RESOURCE_ID_IMAGE_HOUR_5, &hour_image_container_5); rotbmp_init_container(RESOURCE_ID_IMAGE_HOUR_6, &hour_image_container_6); rotbmp_init_container(RESOURCE_ID_IMAGE_HOUR_7, &hour_image_container_7); rotbmp_init_container(RESOURCE_ID_IMAGE_HOUR_8, &hour_image_container_8); rotbmp_init_container(RESOURCE_ID_IMAGE_HOUR_9, &hour_image_container_9); rotbmp_init_container(RESOURCE_ID_IMAGE_HOUR_10, &hour_image_container_10); rotbmp_init_container(RESOURCE_ID_IMAGE_HOUR_11, &hour_image_container_11); rotbmp_init_container(RESOURCE_ID_IMAGE_HOUR_12, &hour_image_container_12); //GCompOpAssign, GCompOpAssignInverted, GCompOpOr, GCompOpAnd, GCompOpClear GCompOp mode = GCompOpAssign; hour_image_container_1.layer.compositing_mode = mode; hour_image_container_2.layer.compositing_mode = mode; hour_image_container_3.layer.compositing_mode = mode; hour_image_container_4.layer.compositing_mode = mode; hour_image_container_5.layer.compositing_mode = mode; hour_image_container_6.layer.compositing_mode = mode; hour_image_container_7.layer.compositing_mode = mode; hour_image_container_8.layer.compositing_mode = mode; hour_image_container_9.layer.compositing_mode = mode; hour_image_container_10.layer.compositing_mode = mode; hour_image_container_11.layer.compositing_mode = mode; hour_image_container_12.layer.compositing_mode = mode; //GPoint pointxy = GPoint(-73, -75); GPoint pointxy = GPoint(14, 70); rot_bitmap_set_src_ic(&hour_image_container_1.layer, pointxy); rot_bitmap_set_src_ic(&hour_image_container_2.layer, pointxy); rot_bitmap_set_src_ic(&hour_image_container_3.layer, pointxy); rot_bitmap_set_src_ic(&hour_image_container_4.layer, pointxy); rot_bitmap_set_src_ic(&hour_image_container_5.layer, pointxy); rot_bitmap_set_src_ic(&hour_image_container_6.layer, pointxy); rot_bitmap_set_src_ic(&hour_image_container_7.layer, pointxy); rot_bitmap_set_src_ic(&hour_image_container_8.layer, pointxy); rot_bitmap_set_src_ic(&hour_image_container_9.layer, pointxy); rot_bitmap_set_src_ic(&hour_image_container_10.layer, pointxy); rot_bitmap_set_src_ic(&hour_image_container_11.layer, pointxy); rot_bitmap_set_src_ic(&hour_image_container_12.layer, pointxy); layer_add_child(&window.layer, &hour_image_container_1.layer.layer); layer_add_child(&window.layer, &hour_image_container_2.layer.layer); layer_add_child(&window.layer, &hour_image_container_3.layer.layer); layer_add_child(&window.layer, &hour_image_container_4.layer.layer); layer_add_child(&window.layer, &hour_image_container_5.layer.layer); layer_add_child(&window.layer, &hour_image_container_6.layer.layer); layer_add_child(&window.layer, &hour_image_container_7.layer.layer); layer_add_child(&window.layer, &hour_image_container_8.layer.layer); layer_add_child(&window.layer, &hour_image_container_9.layer.layer); layer_add_child(&window.layer, &hour_image_container_10.layer.layer); layer_add_child(&window.layer, &hour_image_container_11.layer.layer); layer_add_child(&window.layer, &hour_image_container_12.layer.layer); update_hand_positions(); }
void handle_init(AppContextRef ctx) { (void)ctx; window_init(&window, "Brains Watch"); window_stack_push(&window, true); resource_init_current_app(&APP_RESOURCES); // rotbmp_pair_init_container(RESOURCE_ID_IMAGE_PANDA_WHITE, RESOURCE_ID_IMAGE_PANDA_BLACK, &bitmap_container); // Set up a layer for the static watch face background bmp_init_container(RESOURCE_ID_IMAGE_BACKGROUND, &background_image_container); layer_add_child(&window.layer, &background_image_container.layer.layer); dice = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_VISITOR_16)); text_layer_init(&date_layer, GRect(53, 105, 40, 40)); text_layer_set_text_alignment(&date_layer, GTextAlignmentCenter); text_layer_set_text_color(&date_layer, GColorBlack); text_layer_set_background_color(&date_layer, GColorClear); text_layer_set_font(&date_layer, dice); layer_add_child(&window.layer, &date_layer.layer); PblTm ti; get_time(&ti); string_format_time(date_text, sizeof(date_text), "%d", &ti); text_layer_set_text(&date_layer, date_text); // Set up a layer for the hour hand rotbmp_init_container(RESOURCE_ID_IMAGE_HOUR_HAND, &hour_hand_image_container); // hour_hand_image_container.layer.compositing_mode = GCompOpClear; rot_bitmap_set_src_ic(&hour_hand_image_container.layer, GPoint(3, 42)); layer_add_child(&window.layer, &hour_hand_image_container.layer.layer); // Set up a layer for the minute hand rotbmp_init_container(RESOURCE_ID_IMAGE_MINUTE_HAND, &minute_hand_image_container); // minute_hand_image_container.layer.compositing_mode = GCompOpClear; rot_bitmap_set_src_ic(&minute_hand_image_container.layer, GPoint(3, 58)); layer_add_child(&window.layer, &minute_hand_image_container.layer.layer); update_hand_positions(); // Setup the black and white circle in the centre of the watch face // (We use a bitmap rather than just drawing it because it means not having // to stuff around with working out the circle center etc.) rotbmp_pair_init_container(RESOURCE_ID_IMAGE_CENTER_CIRCLE_WHITE, RESOURCE_ID_IMAGE_CENTER_CIRCLE_BLACK, ¢er_circle_image_container); // TODO: Do this properly with a GRect(). // (144 = screen width, 168 = screen height) center_circle_image_container.layer.layer.frame.origin.x = (144/2) - (center_circle_image_container.layer.layer.frame.size.w/2); center_circle_image_container.layer.layer.frame.origin.y = (168/2) - (center_circle_image_container.layer.layer.frame.size.h/2); layer_add_child(&window.layer, ¢er_circle_image_container.layer.layer); layer_init(&second_display_layer, window.layer.frame); second_display_layer.update_proc = &second_display_layer_update_callback; layer_add_child(&window.layer, &second_display_layer); }
static void set_container_image(GBitmap **bmp_image, BitmapLayer *bmp_layer, const int resource_id, GPoint origin) { GBitmap *old_image = *bmp_image; *bmp_image = gbitmap_create_with_resource(resource_id); GRect frame = (GRect) { .origin = origin, .size = (*bmp_image)->bounds.size }; bitmap_layer_set_bitmap(bmp_layer, *bmp_image); layer_set_frame(bitmap_layer_get_layer(bmp_layer), frame); gbitmap_destroy(old_image); } static void update_hours(struct tm *tick_time) { if(appStarted && hourlyvibe) { //vibe! vibes_short_pulse(); } } static void update_minutes(struct tm *tick_time) { set_container_image(&time_digits_images[2], time_digits_layers[2], BIG_DIGIT_IMAGE_RESOURCE_IDS[tick_time->tm_min/10], GPoint(6, 6)); set_container_image(&time_digits_images[3], time_digits_layers[3], BIG_DIGIT_IMAGE_RESOURCE_IDS[tick_time->tm_min%10], GPoint(75, 6)); }
void moon_LayerUpdateProc(struct Layer *layer, GContext *ctx) { /* GPath shadow; GPathInfo shadow_points = { 5, (GPoint []) { {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, } }; */ int radius; int x, y, error; int mx, my; GPoint center; int edge; if(phase == 1) { graphics_context_set_fill_color(ctx, GColorBlack); graphics_fill_rect(ctx, GRect(0, 0, layer->frame.size.w, layer->frame.size.h), 0, GCornerNone); return; } if(phase == 15) return; graphics_context_set_fill_color(ctx, GColorWhite); center.x = layer->frame.size.w / 2; center.y = layer->frame.size.h / 2; radius = (layer->frame.size.w > layer->frame.size.h ? layer->frame.size.h / 2 : layer->frame.size.w / 2) - 4; // graphics_fill_circle(ctx, center, radius); graphics_context_set_stroke_color(ctx, GColorBlack); // circle algo from: http://en.wikipedia.org/wiki/Midpoint_circle_algorithm // Even though I studied it in school, it still feels like magic error = -radius; x = radius; y = 0; while ( x >= y) { if(phase < 15) { mx = x * (cos_lookup(TRIG_MAX_ANGLE * (phase / 28.0)) / (0xffff * 1.0)); my = y * (cos_lookup(TRIG_MAX_ANGLE * (phase / 28.0)) / (0xffff * 1.0)); edge = 0; } if(phase > 15) { mx = x * (cos_lookup(TRIG_MAX_ANGLE * ((phase - 15) / 32.0)) / (0xffff * 1.0)); my = y * (cos_lookup(TRIG_MAX_ANGLE * ((phase - 15) / 32.0)) / (0xffff * 1.0)); edge = layer->frame.size.w; } graphics_draw_line(ctx, GPoint(center.x + mx, center.y + y), GPoint(edge, center.y + y)); graphics_draw_line(ctx, GPoint(center.x + mx, center.y - y), GPoint(edge, center.y - y)); graphics_draw_line(ctx, GPoint(center.x + my, center.y + x), GPoint(edge, center.y + x)); graphics_draw_line(ctx, GPoint(center.x + my, center.y - x), GPoint(edge, center.y - x)); error += y; ++y; error += y; if( error >= 0) { error -= x; --x; error -= x; } } }
void handle_tick(AppContextRef ctx, PebbleTickEvent *e) { static GRect clipRect = { {0, 0}, {SCREENW, DIGIT_SIZE} }; int i, a, digit[4], x; get_time(&now); #if DRAW_SECONDS if (now.tm_min != last.tm_min) { #endif #if MINUTES_AT_HOUR_HAND now.tm_hour = now.tm_hour%12; digit[0] = now.tm_min/10; digit[1] = now.tm_min%10; #if WHITE_BACKGROUND bmpFill(&bitmap, GColorWhite); #else bmpFill(&bitmap, GColorBlack); #endif if (now.tm_hour < 6) { a = 30*(now.tm_hour-3) + now.tm_min/2; for (i=0;i<2;i++) { x = CX + 69 + (i-2)*(DIGIT_SIZE+DIGIT_SPACE); bmpSub(&digitBmp[digit[i]].bmp, &bitmap, digitBmp[digit[i]].bmp.bounds, GPoint(x, 0)); } clipRect.origin.x = CX + 69 - 2*(DIGIT_SIZE+DIGIT_SPACE); } else { a = 30*(now.tm_hour-9) + now.tm_min/2; for (i=0;i<2;i++) { x = CX - 69 + DIGIT_SPACE + i*(DIGIT_SIZE+DIGIT_SPACE); bmpSub(&digitBmp[digit[i]].bmp, &bitmap, digitBmp[digit[i]].bmp.bounds, GPoint(x, 0)); } clipRect.origin.x = CX - 69 + DIGIT_SPACE; } clipRect.size.w = 2*DIGIT_SIZE + DIGIT_SPACE; #else // MINUTES_AT_HOUR_HAND if (clock12) { now.tm_hour = now.tm_hour%12; if (now.tm_hour == 0) now.tm_hour = 12; } #if HOUR_AT_MINUTE_HAND digit[0] = now.tm_hour/10; digit[1] = now.tm_hour%10; #else // HOUR_AT_MINUTE_HAND digit[0] = now.tm_hour/10; digit[1] = now.tm_hour%10; digit[2] = now.tm_min/10; digit[3] = now.tm_min%10; #endif // HOUR_AT_MINUTE_HAND #if WHITE_BACKGROUND bmpFill(&bitmap, GColorWhite); #else bmpFill(&bitmap, GColorBlack); #endif if (now.tm_min < 30) { a = 6*(now.tm_min-15); #if HOUR_AT_MINUTE_HAND for (i=0; i<2; i++) { if (i != 0 || digit[i] != 0) { x = CX + 69 + (i-2)*(DIGIT_SIZE+DIGIT_SPACE); bmpSub(&digitBmp[digit[i]].bmp, &bitmap, digitBmp[digit[i]].bmp.bounds, GPoint(x, 0)); } } clipRect.origin.x = CX + 69 - 2*(DIGIT_SIZE+DIGIT_SPACE); #else // HOUR_AT_MINUTE_HAND for (i=0; i<4; i++) { if (i != 0 || digit[i] != 0) { x = CX-DIGIT_SIZE+(DIGIT_SIZE+DIGIT_SPACE)*i+(DIGIT_SPACE*(i>1)); bmpSub(&digitBmp[digit[i]].bmp, &bitmap, digitBmp[digit[i]].bmp.bounds, GPoint(x, 0)); } } clipRect.origin.x = CX - DIGIT_SIZE; #endif // HOUR_AT_MINUTE_HAND } else { a = 6*(now.tm_min-45); #if HOUR_AT_MINUTE_HAND for (i=0; i<2; i++) { if (i != 0 || digit[i] != 0) { if (digit[0] == 0) { x = CX+DIGIT_SPACE+1+DIGIT_SIZE-(DIGIT_SIZE+DIGIT_SPACE)*(5-i)-(DIGIT_SPACE*(i<2)); } else { x = CX+DIGIT_SPACE+1+DIGIT_SIZE-(DIGIT_SIZE+DIGIT_SPACE)*(4-i)-(DIGIT_SPACE*(i<2)); } bmpSub(&digitBmp[digit[i]].bmp, &bitmap, digitBmp[digit[i]].bmp.bounds, GPoint(x, 0)); } } clipRect.origin.x = CX - 4*DIGIT_SPACE - 3*DIGIT_SIZE + 1; #else // HOUR_AT_MINUTE_HAND for (i=0; i<4; i++) { if (i != 0 || digit[i] != 0) { if (digit[0] == 0) { x = CX+DIGIT_SPACE+1+DIGIT_SIZE-(DIGIT_SIZE+DIGIT_SPACE)*(5-i)-(DIGIT_SPACE*(i<2)); } else { x = CX+DIGIT_SPACE+1+DIGIT_SIZE-(DIGIT_SIZE+DIGIT_SPACE)*(4-i)-(DIGIT_SPACE*(i<2)); } bmpSub(&digitBmp[digit[i]].bmp, &bitmap, digitBmp[digit[i]].bmp.bounds, GPoint(x, 0)); } } clipRect.origin.x = CX - 4*DIGIT_SPACE - 3*DIGIT_SIZE + 1; #endif // HOUR_AT_MINUTE_HAND } clipRect.size.w = 4*(DIGIT_SIZE + DIGIT_SPACE); #endif // HOUR_AT_MINUTE_HAND bmpFill(&bitmap2, GColorBlack); #if WHITE_BACKGROUND bmpFillCircle(&bitmap2, center, radius-1, GColorWhite); #endif bmpRotate(&bitmap, &bitmap2, a, &clipRect, grect_center_point(&bitmap.bounds), GPoint(0,CX-bitmap.bounds.size.h/2)); bmpDrawArc(&bitmap2, center, radius, 2, 0, 360, GColorWhite); #if DRAW_SECONDS if (last.tm_hour != -1) { drawSec(&bitmap2, center, 267, 273, GColorBlack); } } else { la1 = (267+6*last.tm_sec)%360; la2 = la1+6; a1 = (267+6*now.tm_sec)%360; a2 = a1+6; drawSec(&bitmap2, center, la1, la2, GColorWhite); drawSec(&bitmap2, center, a1, a2, GColorBlack); } #endif layer_mark_dirty(&layer); last = now; }
static void draw_proc(Layer *layer, GContext *ctx) { srand(time(NULL)); // For screenshots GRect bounds = layer_get_bounds(layer); GPoint center = grect_center_point(&bounds); int lastMin = 0; if (SCREENSHOT_RUN) { lastMin = s_last_time.seconds; // For screenshots } else { lastMin = s_last_time.minutes; // For real } for (int m = 0; m <= 59; m++) { if (m <= lastMin) { graphics_context_set_fill_color(ctx, getDotMainColor()); } else { graphics_context_set_fill_color(ctx, getDotDarkColor()); } int v = DOT_DISTANCE; int numDots = s_dotArray[m]; if (m == lastMin || SCREENSHOT_RUN) { numDots = getNumDots(); s_dotArray[m] = numDots; } else if (numDots == 0 && m <= lastMin) { numDots = 1; } // For each dot for (int i = 0; i < numDots; i++) { // Draw dot for(int y = 0; y < 1; y++) { for(int x = 0; x < 1; x++) { GPoint point = (GPoint) { .x = (int16_t)(sin_lookup(TRIG_MAX_ANGLE * m / 60) * (int32_t)(v) / TRIG_MAX_RATIO) + center.x, .y = (int16_t)(-cos_lookup(TRIG_MAX_ANGLE * m / 60) * (int32_t)(v) / TRIG_MAX_RATIO) + center.y, }; graphics_fill_circle(ctx, GPoint(point.x + x, point.y + y), s_dotSize); } } // Draw next dot farther away v += DOT_SPACING; } } if (config_get(PERSIST_KEY_WEATHER) && hasWeather) { // Get weather "minute" int m = weatherTemp % 60; // Get weather dot color if (weatherTemp < 0) { graphics_context_set_fill_color(ctx, GColorCeleste); } else if (weatherTemp < 60) { graphics_context_set_fill_color(ctx, GColorMediumAquamarine); } else { graphics_context_set_fill_color(ctx, GColorOrange); } // Draw dot int v = DOT_DISTANCE - DOT_SPACING - 1; for(int y = 0; y < 1; y++) { for(int x = 0; x < 1; x++) { GPoint point = (GPoint) { .x = (int16_t)(sin_lookup(TRIG_MAX_ANGLE * m / 60) * (int32_t)(v) / TRIG_MAX_RATIO) + center.x, .y = (int16_t)(-cos_lookup(TRIG_MAX_ANGLE * m / 60) * (int32_t)(v) / TRIG_MAX_RATIO) + center.y, }; graphics_fill_circle(ctx, GPoint(point.x + x, point.y + y), s_dotSize); } } } } static void health_handler(HealthEventType event, void *context) { // Which type of event occured? switch(event) { case HealthEventSignificantUpdate: // APP_LOG(APP_LOG_LEVEL_INFO, "New HealthService HealthEventSignificantUpdate event"); break; case HealthEventMovementUpdate: APP_LOG(APP_LOG_LEVEL_INFO, "New HealthService HealthEventMovementUpdate event"); // Mark layer dirty so it updates layer_mark_dirty(s_canvas_layer); break; case HealthEventSleepUpdate: // APP_LOG(APP_LOG_LEVEL_INFO, "New HealthService HealthEventSleepUpdate event"); break; } } void comm_init() { app_message_register_inbox_received(in_recv_handler); // Register callbacks app_message_register_inbox_dropped(inbox_dropped_callback); app_message_register_outbox_failed(outbox_failed_callback); app_message_register_outbox_sent(outbox_sent_callback); app_message_open(app_message_inbox_size_maximum(), app_message_outbox_size_maximum()); }
static void update_plat() { layer_mark_dirty(window_get_root_layer(window)); gpath_move_to(platform_path, GPoint(platform_x_pos, 156)); }
void draw_particle(GContext* ctx, int i) { graphics_fill_circle(ctx, GPoint((int)particles[i].position.x, (int)particles[i].position.y), particles[i].size); }
static void disc_draw(GContext *ctx, Disc *disc) { graphics_context_set_fill_color(ctx, GColorWhite); graphics_fill_circle(ctx, GPoint(disc->pos.x, disc->pos.y), disc->radius); }
GPoint random_point_in_screen() { GRect window_bounds = layer_get_bounds(window_get_root_layer(window)); return GPoint(random_in_range(0, window_bounds.size.w+1), random_in_range(0, window_bounds.size.h+1)); }
/** * Iterate the game board and markup for found combinations **/ bool findMatches() { // One look for explosions bool matchesFound = false; // Double or singe black? Must be a switch if (s_switch.first.x != -1) { if (s_pieces[XYp(s_switch.first)].colour == kBlack && s_pieces[XYp(s_switch.second)].colour == kBlack) { // double black explode(kBOOM, s_switch.second.x, s_switch.second.y, 0); matchesFound = true; } else if (s_pieces[XYp(s_switch.first)].colour == kWhite && s_pieces[XYp(s_switch.second)].colour == kBlack) { //White black explode(kCross, s_switch.second.x, s_switch.second.y, 0); matchesFound = true; } else if (s_pieces[XYp(s_switch.first)].colour == kBlack && s_pieces[XYp(s_switch.second)].colour == kWhite) { //Black white explode(kCross, s_switch.second.x, s_switch.second.y, 0); matchesFound = true; } else if (s_pieces[XYp(s_switch.first)].colour == kBlack) { // Single black A explode(kMiniBoom, s_switch.second.x, s_switch.second.y, s_pieces[XYp(s_switch.second)].colour); s_pieces[XYp(s_switch.first)].exploded = true; matchesFound = true; } else if (s_pieces[XYp(s_switch.second)].colour == kBlack) { // Single black B explode(kMiniBoom, s_switch.first.x, s_switch.first.y, s_pieces[XYp(s_switch.first)].colour); s_pieces[XYp(s_switch.second)].exploded = true; matchesFound = true; } } // Markup the board for (int dir = 0; dir < 2; ++dir) { // x or y int xStop = 0, yStop = 0, max = 0; if (dir == 0) { // go along x, look in y yStop = 2; max = BOARD_PIECES_Y; } else { // go along y, look in x xStop = 2; max = BOARD_PIECES_X; } for (int x=0; x < BOARD_PIECES_X - xStop; ++x) { for (int y=0; y < BOARD_PIECES_Y - yStop; ++y) { // Find a run int runSize = 1, nextX, nextY; if (dir == 0) { nextX = x; nextY = y+1; } else { nextX = x+1; nextY = y; } Colour_t runColour = s_pieces[XY(x,y)].colour; while (1) { if (runColour == kWhite) runColour = s_pieces[XY(nextX,nextY)].colour; // If first colour(s) were white - need to update to know colour of run if ( s_pieces[XY(nextX,nextY)].colour == runColour) {} // Progress - Same colour else if ( s_pieces[XY(nextX,nextY)].colour == kWhite ) {} // Progress - Wildcard, white always matches else break; // Square is different colour - stop here ++runSize; // Square accepted if (dir == 0) { if (++nextY == max) break; // This is where the asymmetric grid bug was hiding before, only compare one } else { if (++nextX == max) break; } } if (runSize > 4) { explode(kColourBoom, 0, 0, runColour); // do colour BOOM matchesFound = true; } else if (runSize > 2) { if (runColour == kBlack) { // Special - three blacks? Very rare, but deserves a big explosion! Like an extended black-black match //APP_LOG(APP_LOG_LEVEL_DEBUG,"MATCH-3-or-4-BLACK!!!!"); if (dir == 0) for (int P=y; P < nextY; ++P) explode(kBOOM, x, P, 0); else for (int P=x; P < nextX; ++P) explode(kBOOM, P, y, 0); matchesFound = true; } else { //APP_LOG(APP_LOG_LEVEL_DEBUG,"MATCH-3-or-4"); runSize == 3 ? score(kMatch3, 0) : score(kMatch4, 0); if (dir == 0) for (int P=y; P < nextY; ++P) s_pieces[XY(x,P)].match++; // A piece can be matched up to twice else for (int P=x; P < nextX; ++P) s_pieces[XY(P,y)].match++; matchesFound = true; } } //Promote white if (runSize == 4) { // We promote the switched piece if user instagated, or the final piece if part of a cascade //APP_LOG(APP_LOG_LEVEL_DEBUG,"PROMOTE WHITE"); if (dir == 0) { for (int P=y; P < nextY; ++P) { if (isSwitch(x,P) || P == nextY-1) { s_pieces[XY(x,P)].promoteFlag = kWhite; break; } } } else { for (int P=x; P < nextX; ++P) { if (isSwitch(P,y) || P == nextX-1) { s_pieces[XY(P,y)].promoteFlag = kWhite; break; } } } } // Skip over the cells we've just dealed with (remember we're at the end of the loop so going to get a +1 anyway) if (dir == 0 && runSize > 2) y += (runSize-1); else if (dir == 1 && runSize > 2) x += (runSize-1); } } } // Promote black for (int x=0; x < BOARD_PIECES_X; ++x) { for (int y=0; y < BOARD_PIECES_Y; ++y) { if (s_pieces[XY(x,y)].match == kMatchedTwice) { score(kMatchT, 0); // This is a bonus on top of the 2x match-3 / match-4s s_pieces[XY(x,y)].promoteFlag = kBlack; // This can in theory overwrite a promote white command //APP_LOG(APP_LOG_LEVEL_DEBUG,"PROMOTE BLACK"); } } } //remember to unset switches so they don't trigger on iterations of this phase s_switch.first = GPoint(-1,-1); s_switch.second = GPoint(-1,-1); if (matchesFound == true) { // Remove and repeat, continue to cascade until no runs remain s_gameState = kFlashRemoved; if (s_currentRun < ANIM_FPS/3) ++s_currentRun; // This makes things faster if more matches are found } else { // No more runs s_gameState = kFindNextMove; // Let the comp try and find a valid move, if any } return false; // don't redraw, nothing graphical }
void meshGEdge::operator() (GEdge *ge) { #if defined(HAVE_ANN) FieldManager *fields = ge->model()->getFields(); BoundaryLayerField *blf = 0; Field *bl_field = fields->get(fields->getBoundaryLayerField()); blf = dynamic_cast<BoundaryLayerField*> (bl_field); #else bool blf = false; #endif ge->model()->setCurrentMeshEntity(ge); if(ge->geomType() == GEntity::DiscreteCurve) return; if(ge->geomType() == GEntity::BoundaryLayerCurve) return; if(ge->meshAttributes.method == MESH_NONE) return; if(CTX::instance()->mesh.meshOnlyVisible && !ge->getVisibility()) return; // look if we are doing the STL triangulation std::vector<MVertex*> &mesh_vertices = ge->mesh_vertices ; std::vector<MLine*> &lines = ge->lines ; deMeshGEdge dem; dem(ge); if(MeshExtrudedCurve(ge)) return; if (ge->meshMaster() != ge){ GEdge *gef = dynamic_cast<GEdge*> (ge->meshMaster()); if (gef->meshStatistics.status == GEdge::PENDING) return; Msg::Info("Meshing curve %d (%s) as a copy of %d", ge->tag(), ge->getTypeString().c_str(), ge->meshMaster()->tag()); copyMesh(gef, ge, ge->masterOrientation); ge->meshStatistics.status = GEdge::DONE; return; } Msg::Info("Meshing curve %d (%s)", ge->tag(), ge->getTypeString().c_str()); // compute bounds Range<double> bounds = ge->parBounds(0); double t_begin = bounds.low(); double t_end = bounds.high(); // first compute the length of the curve by integrating one double length; std::vector<IntPoint> Points; if(ge->geomType() == GEntity::Line && ge->getBeginVertex() == ge->getEndVertex() && //do not consider closed lines as degenerated (ge->position(0.5) - ge->getBeginVertex()->xyz()).norm() < CTX::instance()->geom.tolerance) length = 0.; // special case t avoid infinite loop in integration else length = Integration(ge, t_begin, t_end, F_One, Points, 1.e-8 * CTX::instance()->lc); ge->setLength(length); Points.clear(); if(length < CTX::instance()->mesh.toleranceEdgeLength){ ge->setTooSmall(true); } // Integrate detJ/lc du double a; int N; if(length == 0. && CTX::instance()->mesh.toleranceEdgeLength == 0.){ Msg::Warning("Curve %d has a zero length", ge->tag()); a = 0.; N = 1; } else if(ge->degenerate(0)){ a = 0.; N = 1; } else if(ge->meshAttributes.method == MESH_TRANSFINITE){ a = Integration(ge, t_begin, t_end, F_Transfinite, Points, CTX::instance()->mesh.lcIntegrationPrecision); N = ge->meshAttributes.nbPointsTransfinite; if(CTX::instance()->mesh.flexibleTransfinite && CTX::instance()->mesh.lcFactor) N /= CTX::instance()->mesh.lcFactor; } else{ if (CTX::instance()->mesh.algo2d == ALGO_2D_BAMG || blf){ a = Integration(ge, t_begin, t_end, F_Lc_aniso, Points, CTX::instance()->mesh.lcIntegrationPrecision); } else{ a = Integration(ge, t_begin, t_end, F_Lc, Points, CTX::instance()->mesh.lcIntegrationPrecision); } // we should maybe provide an option to disable the smoothing for (unsigned int i = 0; i < Points.size(); i++){ IntPoint &pt = Points[i]; SVector3 der = ge->firstDer(pt.t); pt.xp = der.norm(); } a = smoothPrimitive(ge, sqrt(CTX::instance()->mesh.smoothRatio), Points); N = std::max(ge->minimumMeshSegments() + 1, (int)(a + 1.99)); } // force odd number of points if blossom is used for recombination if((ge->meshAttributes.method != MESH_TRANSFINITE || CTX::instance()->mesh.flexibleTransfinite) && CTX::instance()->mesh.algoRecombine != 0){ if(CTX::instance()->mesh.recombineAll){ if (N % 2 == 0) N++; if (CTX::instance()->mesh.algoRecombine == 2) N = increaseN(N); } else{ std::list<GFace*> faces = ge->faces(); for(std::list<GFace*>::iterator it = faces.begin(); it != faces.end(); it++){ if((*it)->meshAttributes.recombine){ if (N % 2 == 0) N ++; if (CTX::instance()->mesh.algoRecombine == 2) N = increaseN(N); break; } } } } // printFandPrimitive(ge->tag(),Points); // if the curve is periodic and if the begin vertex is identical to // the end vertex and if this vertex has only one model curve // adjacent to it, then the vertex is not connecting any other // curve. So, the mesh vertex and its associated geom vertex are not // necessary at the same location GPoint beg_p, end_p; if(ge->getBeginVertex() == ge->getEndVertex() && ge->getBeginVertex()->edges().size() == 1){ end_p = beg_p = ge->point(t_begin); Msg::Debug("Meshing periodic closed curve"); } else{ MVertex *v0 = ge->getBeginVertex()->mesh_vertices[0]; MVertex *v1 = ge->getEndVertex()->mesh_vertices[0]; beg_p = GPoint(v0->x(), v0->y(), v0->z()); end_p = GPoint(v1->x(), v1->y(), v1->z()); } // do not consider the first and the last vertex (those are not // classified on this mesh edge) if(N > 1){ const double b = a / (double)(N - 1); int count = 1, NUMP = 1; IntPoint P1, P2; mesh_vertices.resize(N - 2); while(NUMP < N - 1) { P1 = Points[count - 1]; P2 = Points[count]; const double d = (double)NUMP * b; if((fabs(P2.p) >= fabs(d)) && (fabs(P1.p) < fabs(d))) { double dt = P2.t - P1.t; double dlc = P2.lc - P1.lc; double dp = P2.p - P1.p; double t = P1.t + dt / dp * (d - P1.p); SVector3 der = ge->firstDer(t); const double d = norm(der); double lc = d/(P1.lc + dlc / dp * (d - P1.p)); GPoint V = ge->point(t); mesh_vertices[NUMP - 1] = new MEdgeVertex(V.x(), V.y(), V.z(), ge, t, lc); NUMP++; } else { count++; } } mesh_vertices.resize(NUMP - 1); } for(unsigned int i = 0; i < mesh_vertices.size() + 1; i++){ MVertex *v0 = (i == 0) ? ge->getBeginVertex()->mesh_vertices[0] : mesh_vertices[i - 1]; MVertex *v1 = (i == mesh_vertices.size()) ? ge->getEndVertex()->mesh_vertices[0] : mesh_vertices[i]; lines.push_back(new MLine(v0, v1)); } if(ge->getBeginVertex() == ge->getEndVertex() && ge->getBeginVertex()->edges().size() == 1){ MVertex *v0 = ge->getBeginVertex()->mesh_vertices[0]; v0->x() = beg_p.x(); v0->y() = beg_p.y(); v0->z() = beg_p.z(); } ge->meshStatistics.status = GEdge::DONE; }
static void boardUpdateProc(Layer* this_layer, GContext *ctx) { GRect b = layer_get_bounds(this_layer); graphics_context_set_antialiased(ctx, 0); // Fill grey back (white on BW) graphics_context_set_fill_color(ctx, COLOR_FALLBACK(GColorLightGray, GColorWhite)); graphics_context_set_stroke_color(ctx, GColorBlack); graphics_fill_rect(ctx, b, 0, GCornersAll); // Frame highlight around currently selected square colours is gray w white highlight, BW is wite w black highight graphics_context_set_fill_color(ctx, COLOR_FALLBACK(GColorDarkGray, GColorWhite)); graphics_context_set_stroke_color(ctx, COLOR_FALLBACK(GColorWhite, GColorBlack)); GRect highlightR = GRect(s_cursor.x*PIECE_PIXELS, s_cursor.y*PIECE_PIXELS, PIECE_PIXELS+1, PIECE_PIXELS+1); graphics_fill_rect(ctx, highlightR, 0, GCornersAll); graphics_draw_rect(ctx, highlightR); // Draw all board shapes for (int x = 0; x < BOARD_PIECES_X; ++x) { for (int y = 0; y < BOARD_PIECES_Y; ++y) { int xy = XY(x,y); if (s_gameState == kFlashRemoved && (s_pieces[xy].match != kUnmatched || s_pieces[XY(x,y)].exploded == true)) { // Highlight squares which have just been matched GColor highlight = COLOR_FALLBACK(GColorRed, GColorBlack); if (s_pieces[xy].match == kMatchedTwice) highlight = COLOR_FALLBACK(GColorDarkCandyAppleRed, GColorBlack); graphics_context_set_fill_color(ctx, highlight); graphics_context_set_stroke_color(ctx, COLOR_FALLBACK(GColorBlack, GColorLightGray)); highlightR = GRect((s_pieces[xy].loc.x/SUB_PIXEL), (s_pieces[xy].loc.y/SUB_PIXEL), PIECE_PIXELS+1, PIECE_PIXELS+1); graphics_fill_rect(ctx, highlightR, 0, GCornersAll); graphics_draw_rect(ctx, highlightR); } // Draw the shape itself graphics_context_set_fill_color(ctx, COLOURS[ s_pieces[xy].colour ]); if (getShape( s_pieces[xy].colour ) != NULL) { static const bool bw = PBL_IF_BW_ELSE(true,false); if (bw == false && s_pieces[xy].colour == kBlack ) { graphics_context_set_stroke_color(ctx, GColorWhite); } else if (bw == true && (s_pieces[xy].match != kUnmatched || s_pieces[XY(x,y)].exploded == true) && COLOURS[ s_pieces[xy].colour ].argb != GColorWhite.argb ) { graphics_context_set_stroke_color(ctx, GColorWhite); } else { graphics_context_set_stroke_color(ctx, GColorBlack); } gpath_move_to(getShape( s_pieces[xy].colour ), GPoint(s_pieces[xy].loc.x/SUB_PIXEL, s_pieces[xy].loc.y/SUB_PIXEL)); gpath_draw_filled(ctx, getShape( s_pieces[xy].colour )); gpath_draw_outline(ctx, getShape( s_pieces[xy].colour )); } else { // White rectangle of debug - we should not have the case where we render a NULL square graphics_fill_rect(ctx, GRect((s_pieces[xy].loc.x/SUB_PIXEL)+2, (s_pieces[xy].loc.y/SUB_PIXEL)+2, PIECE_PIXELS-3, PIECE_PIXELS-3), 2, GCornersAll); } } } // Move Arrows if (s_flashArrows == true && s_gameState == kAwaitingDirection) { graphics_context_set_fill_color(ctx, GColorWhite); for (int d = 0; d < N_CARDINAL; ++d) { gpath_move_to(getArrow(d), GPoint(s_cursor.x * PIECE_PIXELS, s_cursor.y * PIECE_PIXELS)); gpath_draw_filled(ctx, getArrow(d)); gpath_draw_outline(ctx, getArrow(d)); } } // Cursor if (s_tiltMode > 0) { graphics_context_set_fill_color(ctx, GColorWhite); graphics_context_set_stroke_color(ctx, GColorBlack); graphics_fill_circle(ctx, GPoint(s_motionCursor.x/SUB_PIXEL,s_motionCursor.y/SUB_PIXEL), 3); graphics_draw_circle(ctx, GPoint(s_motionCursor.x/SUB_PIXEL,s_motionCursor.y/SUB_PIXEL), 3); } // Next move if (s_hintOn && s_availableMove.x != -1 && s_gameState == kIdle && s_hintStatus == true) { graphics_context_set_stroke_color(ctx, COLOR_FALLBACK(GColorDarkCandyAppleRed,GColorBlack) ); graphics_context_set_stroke_width(ctx, 3); graphics_draw_circle(ctx, GPoint(s_availableMove.x*PIECE_PIXELS + PIECE_PIXELS/2, s_availableMove.y*PIECE_PIXELS + PIECE_PIXELS/2), PIECE_PIXELS); graphics_context_set_stroke_width(ctx, 1); } // Redo border graphics_context_set_stroke_color(ctx, GColorBlack); graphics_draw_rect(ctx, b); }
void weather_set_icon(WeatherIcon icon) { set_container_image(&mWeatherIcon, mWeatherIconLayer, WEATHER_ICONS[icon], GPoint(9, 2)); //Reapply inverter setStyle(); }
void m_MenuLayerDrawRowCallback(GContext *ctx, const Layer *cell_layer, MenuIndex *cell_index, void *callback_context) { graphics_context_set_text_color(ctx, GColorBlack); if (md_unread(cell_index->row)) { graphics_text_draw(ctx, "U", fonts_get_system_font(FONT_KEY_GOTHIC_14), GRect(0,10,11,14), GTextOverflowModeTrailingEllipsis, GTextAlignmentLeft, NULL); } if (md_isNew(cell_index->row)) { graphics_text_draw(ctx, "N", fonts_get_system_font(FONT_KEY_GOTHIC_14), GRect(0,45-18,11,14), GTextOverflowModeTrailingEllipsis, GTextAlignmentLeft, NULL); } GFont fSender; int fSenderHeight; GFont fSubject; int fSubjectHeight; switch (md_inboxTextSize()) { case eSize_Small: fSender = fonts_get_system_font(FONT_KEY_GOTHIC_18_BOLD); fSubject = fonts_get_system_font(FONT_KEY_GOTHIC_14_BOLD); fSenderHeight = 18; fSubjectHeight = 16; break; case eSize_Large: fSender = fonts_get_system_font(FONT_KEY_GOTHIC_28_BOLD); fSubject = fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD); fSenderHeight = 28; fSubjectHeight = 26; break; case eSize_Regular: default: fSender = fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD); fSubject = fonts_get_system_font(FONT_KEY_GOTHIC_18_BOLD); fSenderHeight = 24; fSubjectHeight = 20; break; } graphics_text_draw(ctx, md_sender(cell_index->row), fSender, GRect(12,0,cell_layer->bounds.size.w - 12,fSenderHeight), GTextOverflowModeTrailingEllipsis, GTextAlignmentLeft, NULL); graphics_text_draw(ctx, md_subject(cell_index->row), fSubject, GRect(12,fSenderHeight + 1,cell_layer->bounds.size.w - 12,fSubjectHeight), GTextOverflowModeTrailingEllipsis, GTextAlignmentLeft, NULL); if (md_isDeleted(cell_index->row)) { int SenlinePos = fSenderHeight + fSenderHeight/2; int SublinePos = (fSubjectHeight/3) *2; graphics_context_set_stroke_color(ctx, GColorBlack); graphics_draw_line(ctx, GPoint(12, SenlinePos), GPoint(cell_layer->bounds.size.w - 12, SenlinePos)); graphics_draw_line(ctx, GPoint(12, SenlinePos + 1), GPoint(cell_layer->bounds.size.w - 12, SenlinePos + 1)); graphics_draw_line(ctx, GPoint(12, SublinePos), GPoint(cell_layer->bounds.size.w - 12, SublinePos)); graphics_draw_line(ctx, GPoint(12, SublinePos+1), GPoint(cell_layer->bounds.size.w - 12, SublinePos + 1)); } //menu_cell_basic_draw(ctx, cell_layer, md_sender(cell_index->row), md_subject(cell_index->row), // &N_IMG.bmp // icon, tod // ); /* menu_cell_basic_draw(ctx, cell_layer, "Foo", "Bar", 0 // icon, todo ); */ }
GPoint GRect::CenterPoint() const { return GPoint((xMin + xMax)/2, (yMin + yMax)/2); }
//cross product GPoint GPoint::cross(const GPoint &them) const { return(GPoint(y * them.z - z * them.y, z * them.x - x * them.z, x * them.y - y * them.x)); }
//Hippo Command, I put my pants on backwards! void handle_init(void) { APP_LOG(APP_LOG_LEVEL_DEBUG, "INIT MEMORY: %u bytes used, %u bytes free", (unsigned) heap_bytes_used(), (unsigned) heap_bytes_free()); // TODO: restore this once done profiling #ifndef LOCK_SHIP srand(time(NULL)); load_holomesh(rand() % c_craft_info_count); #else load_holomesh(LOCK_SHIP); #endif APP_LOG(APP_LOG_LEVEL_DEBUG, "UI MEMORY: %u bytes used, %u bytes free", (unsigned) heap_bytes_used(), (unsigned) heap_bytes_free()); my_window = window_create(); window_set_background_color(my_window, GColorBlack); GRect logoRect = GRect(0, 12, c_viewportWidth, c_viewportWidth); logoLayer = bitmap_layer_create(logoRect); bitmap_layer_set_bitmap(logoLayer, logoBitmap); layer_add_child(window_get_root_layer(my_window), bitmap_layer_get_layer(logoLayer)); // Fonts g_font_sw = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_14)); g_font_sw_symbol = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_SYMBOL_14)); g_font_time = fonts_get_system_font(FONT_KEY_GOTHIC_28_BOLD); g_font_info = fonts_get_system_font(FONT_KEY_GOTHIC_14); // Paint layer frameBufferLayer = bitmap_layer_create(GRect(0, 0, c_viewportWidth, c_viewportHeight)); layer_add_child(window_get_root_layer(my_window), bitmap_layer_get_layer(frameBufferLayer)); frameBufferBitmap = gbitmap_create_blank_with_palette( GSize(c_viewportWidth, c_viewportHeight), GBitmapFormat2BitPalette, c_palette, false); bitmap_layer_set_bitmap(frameBufferLayer, frameBufferBitmap); bitmap_layer_set_compositing_mode(frameBufferLayer, GCompOpSet); paint(); GRect layerSize = GRect(0, 0, c_viewportWidth, c_viewportHeight); // Two small text layers textLayer = text_layer_create(layerSize); text_layer_set_background_color(textLayer, GColorClear); text_layer_set_text_color(textLayer, GColorYellow); text_layer_set_font(textLayer, g_font_sw); layer_add_child(window_get_root_layer(my_window), text_layer_get_layer(textLayer)); //Jet Force Push-up, you silly-billy. textLayerSym = text_layer_create(layerSize); text_layer_set_background_color(textLayerSym, GColorClear); text_layer_set_text_color(textLayerSym, GColorYellow); text_layer_set_font(textLayerSym, g_font_sw_symbol); layer_set_hidden(text_layer_get_layer(textLayerSym), true); layer_add_child(window_get_root_layer(my_window), text_layer_get_layer(textLayerSym)); //Hippo Command, I also put my watch on backwards! // Info text layer infoTextLayer = text_layer_create(layerSize); text_layer_set_background_color(infoTextLayer, GColorClear); text_layer_set_text_color(infoTextLayer, GColorYellow); text_layer_set_font(infoTextLayer, g_font_info); layer_add_child(window_get_root_layer(my_window), text_layer_get_layer(infoTextLayer)); // Time GSize timeSize = graphics_text_layout_get_content_size( "00:00 AM", g_font_time, layerSize, 0, GTextAlignmentLeft); GRect timeRect = { GPoint(DT_EDGE_PAD, c_viewportHeight - timeSize.h), GSize(c_viewportWidth, timeSize.h) }; timeLayer = text_layer_create(timeRect); text_layer_set_background_color(timeLayer, GColorClear); text_layer_set_text_color(timeLayer, GColorYellow); text_layer_set_font(timeLayer, g_font_time); //text_layer_set_text(timeLayer, "23:45 AM"); layer_add_child(window_get_root_layer(my_window), text_layer_get_layer(timeLayer)); // Date dateLayer = text_layer_create(layerSize); text_layer_set_background_color(dateLayer, GColorClear); text_layer_set_text_color(dateLayer, GColorYellow); text_layer_set_font(dateLayer, g_font_info); layer_add_child(window_get_root_layer(my_window), text_layer_get_layer(dateLayer)); time_t t = time(NULL); update_time_display(localtime(&t)); update_date_display(localtime(&t)); update_title_and_info(); APP_LOG(APP_LOG_LEVEL_DEBUG, "FINAL MEMORY: %u bytes used, %u bytes free", (unsigned) heap_bytes_used(), (unsigned) heap_bytes_free()); window_stack_push(my_window, true); tick_timer_service_subscribe(SECOND_UNIT | MINUTE_UNIT, tick_handler); g_timer = app_timer_register(c_refreshTimer, animation_timer_trigger, NULL); accel_data_service_subscribe(c_accelSampleCount, accel_data_handler); accel_service_set_sampling_rate(ACCEL_SAMPLING_25HZ); }
GPoint operator-(const GPoint &v1, const GPoint &v2) { return(GPoint(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z)); }
static void time_update_proc(Layer *layer, GContext *ctx) { time_t now = time(NULL); struct tm *t = localtime(&now); bool saving = false; bool pm = t->tm_hour >= 12; if (s_ps_start_time-1 > s_ps_end_time) { if (t->tm_hour >= s_ps_start_time-1 || t->tm_hour <= s_ps_end_time) saving = true; } else { if (t->tm_hour >= s_ps_start_time-1 && t->tm_hour <= s_ps_end_time) saving = true; } int first = t->tm_sec - 30; if (first < -1) first = -1; int second = t->tm_sec; if (second > 30) second = 30; switch (s_second_bar) { case SETTING_SECOND_FILL_COLOR: first = 30; second = 30; break; case SETTING_SECOND_FILL_BLACK: first = -1; second = -1; break; case SETTING_SECOND_FILL_COLOR_WHEN_SAVING: if (saving) { first = 30; second = 30; } break; case SETTING_SECOND_FILL_BLACK_WHEN_SAVING: if (saving) { first = -1; second = -1; } break; case SETTING_SECOND_AS_AM_PM: second = pm ? -1 : 30; first = pm ? 30 : -1; break; } if (s_ps_start_time == 0) saving = false; // min char *buffer = malloc(3); for (int i = -2; i < 5; i++) { snprintf(buffer, 3, "%02d", (t->tm_min + i + 60)%60); if (i == 0) graphics_context_set_text_color(ctx, GColorFromRGB(s_minute_r, s_minute_g, s_minute_b)); else graphics_context_set_text_color(ctx, GColorDarkGray); graphics_draw_text(ctx, buffer, fonts_get_system_font(FONT_KEY_LECO_32_BOLD_NUMBERS), GRect(75-i*39+(saving?0:(39*t->tm_sec/60)),74,40,38), GTextOverflowModeWordWrap, GTextAlignmentCenter, NULL); } // sec if (s_second_rate > 0 && !saving) { for (int i = -2; i < 5; i++) { float progress = 0; if (s_second_rate > 1) { progress = s_msecond/1000.0; } if (t->tm_sec != s_last_second) { s_msecond = 0; s_last_second = t->tm_sec; } snprintf(buffer, 3, "%02d", (t->tm_sec + i + 60)%60); if (i == 0) graphics_context_set_text_color(ctx, GColorFromRGB(s_second_r, s_second_g, s_second_b)); else graphics_context_set_text_color(ctx, GColorDarkGray); graphics_draw_text(ctx, buffer, fonts_get_system_font(FONT_KEY_LECO_20_BOLD_NUMBERS), GRect(75-i*26+(26*progress),120,40,20), GTextOverflowModeWordWrap, GTextAlignmentCenter, NULL); } graphics_context_set_stroke_color(ctx, GColorDarkGray); graphics_draw_line(ctx, GPoint(0,121), GPoint(144,121)); graphics_draw_line(ctx, GPoint(0,143), GPoint(144,143)); } // hour graphics_context_set_fill_color(ctx, GColorBlack); graphics_fill_rect(ctx, GRect(23,12,46,142), 0, GCornerNone); graphics_context_set_fill_color(ctx, GColorBlack); graphics_fill_rect(ctx, GRect(23,12,46,142), 0, GCornerNone); for (int i = -4; i < 6; i++) { if (s_12hour) snprintf(buffer, 3, "%02d", (t->tm_hour + i == 12) ? 12 : (t->tm_hour + i + 12)%12); else snprintf(buffer, 3, "%02d", (t->tm_hour + i + 24)%24); if (i == 0) graphics_context_set_text_color(ctx, GColorFromRGB(s_hour_r, s_hour_g, s_hour_b)); else graphics_context_set_text_color(ctx, GColorDarkGray); graphics_draw_text(ctx, buffer, fonts_get_system_font(FONT_KEY_LECO_36_BOLD_NUMBERS), GRect(21,65-i*27+(saving?0:(27*t->tm_min/60)),50,36), GTextOverflowModeWordWrap, GTextAlignmentCenter, NULL); } if (s_second_bar != SETTING_SECOND_AS_AM_PM && s_12hour) { graphics_context_set_fill_color(ctx, GColorBlack); graphics_fill_rect(ctx, GRect(12,80,5,26), 0, GCornerNone); graphics_context_set_fill_color(ctx, GColorFromRGB(s_hour_r, s_hour_g, s_hour_b)); if (pm) graphics_fill_rect(ctx, GRect(12,93,5,13), 0, GCornerNone); else graphics_fill_rect(ctx, GRect(12,80,5,13), 0, GCornerNone); } free(buffer); // SEC graphics_context_set_stroke_color(ctx, GColorFromRGB(s_second_bar_r, s_second_bar_g, s_second_bar_b)); graphics_draw_line(ctx, GPoint(29,61), GPoint(29+second,61)); graphics_draw_line(ctx, GPoint(34,116), GPoint(34+first,116)); graphics_context_set_stroke_color(ctx, GColorBlack); graphics_draw_line(ctx, GPoint(30+second,61), GPoint(60,61)); graphics_draw_line(ctx, GPoint(35+first,116), GPoint(65,116)); }
void update_display(PblTm *current_time) { unsigned short display_hour = get_display_hour(current_time->tm_hour); // TODO: Remove leading zero? set_container_image(&time_digits_images[0], IMAGE_RESOURCE_IDS[display_hour/10], GPoint(-5, 91)); set_container_image(&time_digits_images[1], IMAGE_RESOURCE_IDS[display_hour%10], GPoint(18, 68)); set_container_image(&time_colon_image, RESOURCE_ID_IMAGE_COLON, GPoint(40,42)); set_container_image(&time_digits_images[2], IMAGE_RESOURCE_IDS[current_time->tm_min/10], GPoint(54, 34)); set_container_image(&time_digits_images[3], IMAGE_RESOURCE_IDS[current_time->tm_min%10], GPoint(77, 11)); if (!clock_is_24h_style()) { if (display_hour/10 == 0) { layer_remove_from_parent(&time_digits_images[0].layer.layer); rotbmp_deinit_container(&time_digits_images[0]); } } }
GPoint GObject::getLocation() const { return GPoint(x, y); }
/* * Function: draw_graph_part_base * ---------------------------------------------------------------------------- * Draws the graph curve part between the current weekday and the next day. * * ctx: the drawing context * bounds_size_h: the drawing bounds height * s_day: string for the current weekday label * day0: the current weekday * day1: the next weekday * builder: the GPathBuilder used to create the curve * day_shift: used to calculate how many days day0 and day1 should be shifted * by. * When this is not equal to 0 it is used change at what x- * coordinates the days should use. * first_time: Is this the first/initial call to this function? * ---------------------------------------------------------------------------- */ void draw_graph_part_base(GContext *ctx, int bounds_size_h, char* s_day, int day0, int day1, GPathBuilder *builder, int day_shift, bool first_time) { if (day0 > 6) {day0 -= 7;} if (day1 > 6) {day1 -= 7;} int mood0 = storage_get_mood(day0); int mood1 = storage_get_mood(day1); if (s_num_moods > 10) { // If the number of moods is greater than 10 we need to re-calculate the // moods to keep them within the 0 - 10 range of the graph. // Shift the moods to keep them above or equal to 0: // - If Minimum Mood is less than 0 then the absolute min value is added // to the moods ("minus minus equals pluss") // - If the Minimum Mood is greater then 0 then the min value is // subtracted from the moods mood0 = mood0 - s_mood_min; // Shift to positive mood1 = mood1 - s_mood_min; // Shift to positive // Divide the mmods by a 10nth of Number of Moods. This ensures that the // moods always are within the 0 - 10 range of the graph. mood0 = mood0 / (s_num_moods / 10); // divide by 10nth of num moods mood1 = mood1 / (s_num_moods / 10); // divide by 10nth of num moods } if (day_shift != 0) { day0 += day_shift; day1 += day_shift; if (day0 < 0) { day0 += 7; } else if (day0 > 6) { day0 -= 7; } if (day1 < 0) { day1 += 7; } else if (day1 > 6) { day1 -= 7; } } GPoint p0 = GPoint(s_day_points[day0], s_mood_points[mood0]); GPoint p1 = GPoint(s_day_points[day1], s_mood_points[mood1]); APP_LOG(APP_LOG_LEVEL_DEBUG, "x(%d) = %d", day0, p0.x); #ifdef PBL_PLATFORM_APLITE // On Original Pebble (Aplite) the graph is only drawn with separate lines // and not as a bezier curve // This is due to the aplite platform only supports drawing closed paths // (non-open) graphics_draw_line(ctx, p0, p1); #elif PBL_PLATFORM_BASALT // On Pebble Time (Basalt) the graph is drawn as a bezier curve // Calculations to find bezier curve control points int c_x = (p0.x + p1.x) / 2; // Mid-point between p0 and p1 int c_y = (p0.y + p1.y) / 2; // Mid-point between p0 and p1 int a_x = (p0.x + c_x) / 2; // Mid-point between p0 and c // Find the control point based on that are furthest from the mid-point // y-axis int a_y = math_int_find_bezier_control_point(c_y, 100); int b_x = (p1.x + c_x) / 2; // Mid-point between p1 and c GPoint p_a = GPoint(a_x, a_y); // 1st control point between p0 and mid-point GPoint p_b = GPoint(b_x, a_y); // 2nd control point between mid-point and p1 if (first_time == true) { // Move the builder to the starting point gpath_builder_move_to_point(builder, p0); } gpath_builder_curve_to_point(builder, p1, p_b, p_a); #endif // Draw the day labels at bottom draw_graph_part_day(ctx, bounds_size_h, s_day, day0); }