示例#1
0
t_hexagon *create_hexagon_with_border(GPoint center, 
                                      int16_t side_width,
                                      GColor color,
                                      int16_t border_side_width,
                                      GColor border_color,
                                      int16_t border_size,
                                      Layer *parent_layer){
    int i;
    int offset;
    t_hexagon * hexagon = create_hexagon(center, side_width, color, parent_layer);
    
    struct _hexagon_layer_data *layer_data= hexagon_get_layer_data( hexagon->layer );
    
    GPoint *points = create_hexagonal_path( border_side_width );
    
    GPathInfo border_path_info = {
        .num_points = 6,
        .points = points
    };
    
    //We offset the border to center it.
    offset = side_width - border_side_width;
    for( i=0; i < 6; ++i){
        points[i].x += offset;
        points[i].y += (offset-1);
    }
    
    hexagon->border_points = points;
    
    layer_data->border_path = gpath_create( &border_path_info );
    layer_data->border_color = border_color;
    layer_data->border_width = border_size;
    
    return hexagon;
}

t_hexagon *create_hexagon(GPoint center, 
                          int16_t side_width, 
                          GColor color, 
                          Layer *parent_layer){
    
    t_hexagon * hexagon;
    GPath *path;
    GPoint *points;  
    
    points = create_hexagonal_path(side_width);
    
    GPathInfo path_info = {
        .num_points = 6,
        .points = points
    };
    
    hexagon = malloc( sizeof( t_hexagon ) );
    memset( hexagon, 0, sizeof(t_hexagon) );
    
    hexagon->layer = layer_create_with_data(
                        GRect(center.x - side_width,
                              center.y - HEX_HEIGHT(side_width),
                              side_width * 2,
                              HEX_HEIGHT(side_width) * 2),
                        sizeof(struct _hexagon_layer_data));
    
    hexagon->center = center;
    hexagon->side_width = side_width;
    hexagon->points = points;
    
    path = gpath_create( &path_info );
    
    struct _hexagon_layer_data *layer_data = hexagon_get_layer_data( hexagon->layer );
    memset(layer_data,0,sizeof(struct _hexagon_layer_data));
    
    layer_data->path = path;
    layer_data->color = color;
    
    layer_set_update_proc( hexagon->layer, hexagon_update_proc );
    layer_add_child(parent_layer, hexagon->layer);
    
    return hexagon;
}


void destroy_hexagon(t_hexagon *hexagon){
    struct _hexagon_layer_data *layer_data = hexagon_get_layer_data( hexagon->layer );
    
    gpath_destroy( layer_data->path );
    
    if( layer_data->border_path )
        gpath_destroy( layer_data->border_path );
    
    if(hexagon->legend)
        text_layer_destroy(hexagon->legend);
    if( hexagon->text )
        text_layer_destroy(hexagon->text);
    
    layer_destroy( hexagon->layer );
    free(hexagon->points);
    free(hexagon->border_points);
    free( hexagon );
}

void hexagon_set_color(t_hexagon *hexagon, GColor color){
    struct _hexagon_layer_data *layer_data = hexagon_get_layer_data( hexagon->layer );
    layer_data->color = color;
    layer_mark_dirty(hexagon->layer);
}

GColor hexagon_get_color(t_hexagon *hexagon){
    struct _hexagon_layer_data *layer_data = hexagon_get_layer_data( hexagon->layer );
    return layer_data->color;
}

void hexagon_set_border_color(t_hexagon *hexagon, GColor color){
    struct _hexagon_layer_data *layer_data = hexagon_get_layer_data( hexagon->layer );
    layer_data->border_color = color;
}

GColor hexagon_get_border_color(t_hexagon *hexagon){
    struct _hexagon_layer_data *layer_data = hexagon_get_layer_data( hexagon->layer );
    return layer_data->border_color;
}

void hexagon_init_text_layer(t_hexagon *hexagon,
        GRect frame, 
        GColor color, 
        const char *init_text, 
        GFont font){
    
    TextLayer *layer;
    layer = text_layer_create(frame);
    text_layer_set_background_color(layer, GColorClear);
    text_layer_set_text_color(layer, color);
    text_layer_set_text(layer, init_text);

    text_layer_set_font(layer, font);
    text_layer_set_text_alignment(layer, GTextAlignmentCenter);

    layer_add_child(hexagon->layer, text_layer_get_layer(layer));
    hexagon->text = layer;
    
}
示例#2
0
void handle_init(AppContextRef ctx) {
  (void)ctx;

  window_init(&window, "MainMenu");
  window_stack_push(&window, true /* Animated */);
  window_set_background_color(&window, GColorBlack);

  resource_init_current_app(&APP_RESOURCES);

  // Note: This needs to be "de-inited" in the application's
  //       deinit handler.
  bmp_init_container(RESOURCE_ID_IMAGE_CRICSCORER, &image_container);
  bmp_init_container(RESOURCE_ID_IMAGE_BUTTONS, &buttons_container);

  layer_add_child(&window.layer, &image_container.layer.layer);

  layer_init(&scoreBoard, window.layer.frame);
  layer_add_child(&window.layer, &scoreBoard);

  text_layer_init(&topLayer, GRect(5,0,144-24,20));
  text_layer_set_text_color(&topLayer, GColorBlack);
  text_layer_set_background_color(&topLayer, GColorWhite);
  text_layer_set_text_alignment(&topLayer, GTextAlignmentCenter);
  text_layer_set_font(&topLayer, fonts_get_system_font(FONT_KEY_GOTHIC_14_BOLD));
  text_layer_set_text(&topLayer, ":::Cricket Scorer:::");

  text_layer_init(&headerLayer, GRect(5,18,144-24,22));
  text_layer_set_text_color(&headerLayer, GColorBlack);
  text_layer_set_background_color(&headerLayer, GColorWhite);
  text_layer_set_text_alignment(&headerLayer, GTextAlignmentCenter);
  text_layer_set_font(&headerLayer, fonts_get_system_font(FONT_KEY_GOTHIC_18_BOLD));

  text_layer_init(&scoreLayer, GRect(5,40,144-19,50));
  text_layer_set_text_color(&scoreLayer, GColorWhite);
  text_layer_set_background_color(&scoreLayer, GColorBlack);
  text_layer_set_text_alignment(&scoreLayer, GTextAlignmentCenter);
  text_layer_set_font(&scoreLayer, fonts_get_system_font(FONT_KEY_GOTHAM_42_BOLD));

  text_layer_init(&statsLayer, GRect(5,90,144-24,40));
  text_layer_set_text_color(&statsLayer, GColorWhite);
  text_layer_set_background_color(&statsLayer, GColorBlack);
  text_layer_set_text_alignment(&statsLayer, GTextAlignmentCenter);
  text_layer_set_font(&statsLayer, fonts_get_system_font(FONT_KEY_GOTHIC_18_BOLD));

  text_layer_init(&historyLayer, GRect(5,128,144-24,34));
  text_layer_set_text_color(&historyLayer, GColorBlack);
  text_layer_set_background_color(&historyLayer, GColorWhite);
  text_layer_set_text_alignment(&historyLayer, GTextAlignmentCenter);
  text_layer_set_font(&historyLayer, fonts_get_system_font(FONT_KEY_GOTHIC_14));

  text_layer_init(&inputLayer, GRect(26, 60, 144-40 /* width */, 38 /* height */));
  text_layer_set_text_color(&inputLayer, GColorBlack);
  text_layer_set_background_color(&inputLayer, GColorWhite);
  text_layer_set_text_alignment(&inputLayer, GTextAlignmentCenter);
  text_layer_set_font(&inputLayer, fonts_get_system_font(FONT_KEY_GOTHIC_28_BOLD));

  layer_init(&buttonsLayer, GRect(144-14, 10, 14 /* width */, 136 /* height */));
  layer_add_child(&buttonsLayer, &buttons_container.layer.layer);

  layer_set_hidden(&scoreBoard, true);
  layer_set_hidden(&buttonsLayer, true);
  layer_set_hidden(&inputLayer.layer, true);
  layer_add_child(&scoreBoard, &buttonsLayer);
  layer_add_child(&scoreBoard, &topLayer.layer);
  layer_add_child(&scoreBoard, &headerLayer.layer);
  layer_add_child(&scoreBoard, &scoreLayer.layer);
  layer_add_child(&scoreBoard, &statsLayer.layer);
  layer_add_child(&scoreBoard, &historyLayer.layer);
  layer_add_child(&scoreBoard, &inputLayer.layer);

  // Attach our desired button functionality
  window_set_click_config_provider(&window, (ClickConfigProvider) click_config_provider);
}
示例#3
0
文件: xzion1.c 项目: xzion/pebbleface
// Watchface initialization
static void window_load(Window *window) {
	Layer *window_layer = window_get_root_layer(window);

	// Set Background color to Black (For testing only)
	window_set_background_color(window, GColorBlack);

	// Initialize Globals
	mincount = 0;
	use_uq_weather = true;
	batt_img = gbitmap_create_with_resource(RESOURCE_ID_BATT_100);
	cond_img = gbitmap_create_with_resource(RESOURCE_ID_COND_LOADING);

	GRect bounds = layer_get_bounds(window_layer);

	// For debugging
	static char boundtext[20];
	snprintf(boundtext, 20, "w=%d, h=%d\ntest", bounds.size.w, bounds.size.h);

	// Build the time layer
	time_layer = text_layer_create(GRect(0, -10, 122, 50));
	text_layer_set_text(time_layer, "TIME");
	//text_layer_set_font(time_layer, fonts_get_system_font(FONT_KEY_BITHAM_42_BOLD));
	text_layer_set_font(time_layer, fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_MYRIADB_44)));
	text_layer_set_text_alignment(time_layer, GTextAlignmentCenter);
	layer_add_child(window_layer, text_layer_get_layer(time_layer));

	// Build the ampm layer
	ampm_layer = text_layer_create(GRect(122, -4, 22, 44));
	text_layer_set_font(ampm_layer, fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_MYRIADB_20)));
	text_layer_set_text(ampm_layer, "A\nM");
	text_layer_set_text_alignment(ampm_layer, GTextAlignmentCenter);
	layer_add_child(window_layer, text_layer_get_layer(ampm_layer));

	// Build the date layer
	date_layer = text_layer_create(GRect(0, 42, 144, 27));
	text_layer_set_font(date_layer, fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_MYRIAD_20)));
	text_layer_set_text(date_layer, "Date");
	text_layer_set_text_alignment(date_layer, GTextAlignmentCenter);
	layer_add_child(window_layer, text_layer_get_layer(date_layer));  

	// Build the weather icon layer
	icon_layer = bitmap_layer_create(GRect(0, 73, 40, 40));
	bitmap_layer_set_background_color(icon_layer, GColorBlack);
	layer_add_child(window_layer, bitmap_layer_get_layer(icon_layer));

	// Build the temp layer
	temp_layer = text_layer_create(GRect(42, 71, 76, 43));
	text_layer_set_background_color(temp_layer, GColorClear);
	text_layer_set_text_color(temp_layer, GColorWhite);
	text_layer_set_font(temp_layer, fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_MYRIADB_32)));
	text_layer_set_text(temp_layer, "...");
	text_layer_set_text_alignment(temp_layer, GTextAlignmentCenter);
	layer_add_child(window_layer, text_layer_get_layer(temp_layer));

	// Build the battery layer
	batt_layer = bitmap_layer_create(GRect(120, 73, 24, 40));
	bitmap_layer_set_background_color(batt_layer, GColorBlack);
	layer_add_child(window_layer, bitmap_layer_get_layer(batt_layer));

	// Build the bitcoin price layer
	btc_layer = text_layer_create(GRect(0, 118, 144, 24));
	text_layer_set_font(btc_layer, fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_MYRIAD_18)));
	text_layer_set_text(btc_layer, "Loading...");
	text_layer_set_text_alignment(btc_layer, GTextAlignmentCenter);
	layer_add_child(window_layer, text_layer_get_layer(btc_layer));

	// Build the fitbit layer
	fitbit_layer = text_layer_create(GRect(0, 144, 144, 24));
	text_layer_set_font(fitbit_layer, fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_MYRIAD_16)));
	text_layer_set_text(fitbit_layer, "Loading...");
	text_layer_set_text_alignment(fitbit_layer, GTextAlignmentCenter);
	layer_add_child(window_layer, text_layer_get_layer(fitbit_layer));


	// Verify persistent storage for BTC daily value is setup
	check_bitcoin_persist();

	// Setup AppMessage
	app_message_init();

	// Subscribe to the minute tick
	tick_timer_service_subscribe(MINUTE_UNIT, handle_minute_tick);

	// Force initial tick to inialize values
	time_t then = time(NULL);
	struct tm *now = localtime(&then);
	handle_minute_tick(now, SECOND_UNIT | MINUTE_UNIT | HOUR_UNIT | DAY_UNIT | MONTH_UNIT | YEAR_UNIT);

	// Subscribed to battery change events
	battery_state_service_subscribe(handle_battery);

	// Force initial battery check
	handle_battery(battery_state_service_peek());

	// Subscribe to bluetooth change events
	bluetooth_connection_service_subscribe(handle_bluetooth);

	// Force initial bluetooth state check
	handle_bluetooth(bluetooth_connection_service_peek());

	/*
	// Build the debugging text layer
	text_layer = text_layer_create(GRect(2, 54, 140, 80));
	text_layer_set_background_color(text_layer, GColorBlack);
	text_layer_set_text_color(text_layer, GColorWhite);
	text_layer_set_text(text_layer, boundtext);
	text_layer_set_text_alignment(text_layer, GTextAlignmentCenter);
	layer_add_child(window_layer, text_layer_get_layer(text_layer));
	*/
}
示例#4
0
void handle_init(AppContextRef ctx) {
    
    (void)ctx;
    
    
    window_init(&window, "SimplicityPlus");
    window_stack_push(&window, true /* Animated */);
    window_set_background_color(&window, GColorBlack);
    
    resource_init_current_app(&APP_RESOURCES);
    
    // Day
    text_layer_init(&text_day_layer, window.layer.frame);
    text_layer_set_text_color(&text_day_layer, GColorWhite);
    text_layer_set_background_color(&text_day_layer, GColorClear);
    layer_set_frame(&text_day_layer.layer, GRect(6, 15, 144-6, 25));
    text_layer_set_font(&text_day_layer, fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_ROBOTO_CONDENSED_21)));
    text_layer_set_text_alignment(&text_day_layer, GTextAlignmentLeft);
    layer_add_child(&window.layer, &text_day_layer.layer);
    
    
    // Month and Date
    text_layer_init(&text_date_layer, window.layer.frame);
    text_layer_set_text_color(&text_date_layer, GColorWhite);
    text_layer_set_background_color(&text_date_layer, GColorClear);
    layer_set_frame(&text_date_layer.layer, GRect(6, 40, 144-6, 30));
    text_layer_set_font(&text_date_layer, fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_ROBOTO_CONDENSED_21)));
    text_layer_set_text_alignment(&text_date_layer, GTextAlignmentLeft);
    layer_add_child(&window.layer, &text_date_layer.layer);
    
    
    // Hour and Minute
    text_layer_init(&text_time_layer, window.layer.frame);
    text_layer_set_text_color(&text_time_layer, GColorWhite);
    text_layer_set_background_color(&text_time_layer, GColorClear);
    layer_set_frame(&text_time_layer.layer, GRect(6, 80, 144-6, 66));
    text_layer_set_font(&text_time_layer, fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_ROBOTO_BOLD_SUBSET_49)));
    text_layer_set_text_alignment(&text_time_layer, GTextAlignmentLeft);
    layer_add_child(&window.layer, &text_time_layer.layer);
    
    
    // Second
    text_layer_init(&text_time_second_layer, window.layer.frame);
    text_layer_set_text_color(&text_time_second_layer, GColorWhite);
    text_layer_set_background_color(&text_time_second_layer, GColorClear);
    layer_set_frame(&text_time_second_layer.layer, GRect(106, 128, 30, 30));
    text_layer_set_font(&text_time_second_layer, fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_ROBOTO_BOLD_SUBSET_21)));
    text_layer_set_text_alignment(&text_time_second_layer, GTextAlignmentLeft);
    layer_add_child(&window.layer, &text_time_second_layer.layer);
    
    // Apple's Logo
    layer_init(&image_layer, window.layer.frame);
    image_layer.update_proc = &image_layer_update_callback;
    layer_add_child(&window.layer, &image_layer);
    bmp_init_container(RESOURCE_ID_IMAGE_APPLE_LOGO, &image_container);
    
    // line
    layer_init(&line_layer, window.layer.frame);
    line_layer.update_proc = &line_layer_update_callback;
    layer_add_child(&window.layer, &line_layer);
    
}
示例#5
0
文件: main.c 项目: qypea/GlanceFace
void handle_init(void) {
   window = window_create();
   window_stack_push(window, true /* Animated */);
   window_set_background_color(window, GColorBlack);

   Layer *window_layer = window_get_root_layer(window);
   GRect bounds = layer_get_bounds(window_layer);

   int smallh = 21;
   int largeh = 51;
   int halfw = bounds.size.w / 2;
   int margin = 8;
   int offy = bounds.origin.y;

   // Date in upper-left
   text_date_layer = text_layer_create(
      GRect(bounds.origin.x,
            offy,
            halfw,
            smallh));
   text_layer_set_text_color(text_date_layer, GColorWhite);
   text_layer_set_background_color(text_date_layer, GColorClear);
   text_layer_set_font(text_date_layer,
                       fonts_get_system_font(FONT_KEY_ROBOTO_CONDENSED_21));
   layer_add_child(window_layer, text_layer_get_layer(text_date_layer));

   // Watch battery in upper-right
   text_watchbatt_layer = text_layer_create(
      GRect(bounds.origin.x + halfw,
            offy,
            halfw,
            smallh));
   text_layer_set_text_color(text_watchbatt_layer, GColorWhite);
   text_layer_set_background_color(text_watchbatt_layer, GColorClear);
   text_layer_set_font(text_watchbatt_layer,
                       fonts_get_system_font(FONT_KEY_ROBOTO_CONDENSED_21));
   text_layer_set_text_alignment(text_watchbatt_layer, GTextAlignmentRight);
   layer_add_child(window_layer, text_layer_get_layer(text_watchbatt_layer));

   offy = offy + smallh;

   // Time next
   text_time_layer = text_layer_create(
      GRect(bounds.origin.x + margin,
            offy,
            bounds.size.w - margin*2,
            largeh));
   text_layer_set_text_color(text_time_layer, GColorWhite);
   text_layer_set_background_color(text_time_layer, GColorClear);
   text_layer_set_text_alignment(text_time_layer, GTextAlignmentCenter);
   text_layer_set_font(text_time_layer,
                       fonts_get_system_font(FONT_KEY_ROBOTO_BOLD_SUBSET_49));
   layer_add_child(window_layer, text_layer_get_layer(text_time_layer));

   offy = offy + largeh + 2;

   // Separator
   GRect line_frame = GRect(bounds.origin.x + margin,
                            offy,
                            bounds.size.w - margin*2,
                            2);
   line_layer = layer_create(line_frame);
   layer_set_update_proc(line_layer, line_layer_update_callback);
   layer_add_child(window_layer, line_layer);

   offy = offy + 2;

   // Event in bottom half -1
   text_event_layer = text_layer_create(
      GRect(bounds.origin.x,
            offy,
            bounds.size.w,
            bounds.size.h - offy - smallh));
   text_layer_set_text_color(text_event_layer, GColorWhite);
   text_layer_set_background_color(text_event_layer, GColorClear);
   text_layer_set_overflow_mode(text_event_layer, GTextOverflowModeFill);
   text_layer_set_font(text_event_layer,
                       fonts_get_system_font(FONT_KEY_ROBOTO_CONDENSED_21));
   layer_add_child(window_layer, text_layer_get_layer(text_event_layer));


   // Location in bottom row
   text_location_layer = text_layer_create(
      GRect(bounds.origin.x,
            bounds.size.h - smallh,
            bounds.size.w,
            smallh));
   text_layer_set_text_color(text_location_layer, GColorWhite);
   text_layer_set_background_color(text_location_layer, GColorClear);
   text_layer_set_overflow_mode(text_location_layer, GTextOverflowModeFill);
   text_layer_set_font(text_location_layer,
                       fonts_get_system_font(FONT_KEY_ROBOTO_CONDENSED_21));
   layer_add_child(window_layer, text_layer_get_layer(text_location_layer));



   // Subscribe to date/time
   tick_timer_service_subscribe(MINUTE_UNIT, handle_minute_tick);

   // Subscribe to watchbatt
   battery_state_service_subscribe(handle_watchbatt_change);
   handle_watchbatt_change(battery_state_service_peek());

   // Subscribe to phone data
   const int inbound_size = 256;
   const int outbound_size = 16;
   app_message_open(inbound_size, outbound_size);
   Tuplet initial_values[] = {
       TupletCString(EVENT, "No event synced"),
       //TupletCString(EVENT, "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea"),
       TupletCString(LOCATION, ""),
   };
   app_sync_init(&sync, sync_buffer, sizeof(sync_buffer),
                 initial_values, ARRAY_LENGTH(initial_values),
                 sync_tuple_changed_callback,
                 sync_error_callback, NULL);

   app_sync_set(&sync, initial_values, ARRAY_LENGTH(initial_values));
}
示例#6
0
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,
			     &center_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, &center_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 update_proc(Layer *layer, GContext *ctx) {
  int padding;
  
  PBL_IF_ROUND_ELSE(padding = 16, padding = 12);
  
  HOURS_TRACK_RADIUS = (window_bounds.size.w - padding) / 2; //66
  HOURS_TRACK_STROKE = 2;
  
  MINUTES_TRACK_RADIUS = HOURS_TRACK_RADIUS - 10; //56
  MINUTES_TRACK_STROKE = 2;
  
  SECONDS_TRACK_RADIUS = HOURS_TRACK_RADIUS - 20; //46
  SECONDS_TRACK_STROKE = 2;
  
  SECONDS_HAND_RADIUS = 2;
  MINUTES_HAND_RADIUS = 3;
  HOURS_HAND_RADIUS = 4;
  
  // Color background
  graphics_context_set_fill_color(ctx, GColorBlack);
  graphics_fill_rect(ctx, window_bounds, 0, GCornerNone);
  
  //APP_LOG(APP_LOG_LEVEL_DEBUG, "bounds: %d %d %d %d", window_bounds.origin.x, window_bounds.origin.y, window_bounds.size.h, window_bounds.size.w );
  

  //set colour for tracks
  graphics_context_set_stroke_color(ctx, GColorWhite );

  graphics_context_set_antialiased(ctx, ANTIALIASING);

  // Don't use current time while animating
  Time mode_time = s_last_time;
  
  // generate position of hands
  
  GPoint second_hand = (GPoint) {
    .x = (int16_t)(sin_lookup(TRIG_MAX_ANGLE * mode_time.seconds / 60) * (int32_t)(SECONDS_TRACK_RADIUS) / TRIG_MAX_RATIO) + s_center.x,
    .y = (int16_t)(-cos_lookup(TRIG_MAX_ANGLE * mode_time.seconds / 60) * (int32_t)(SECONDS_TRACK_RADIUS) / TRIG_MAX_RATIO) + s_center.y,
  };
	
  float minutes, hours;	
	
  if (SWEEP_MINUTES == true) {
	minutes = mode_time.minutes + (float)mode_time.seconds / 60;
  } else {
	minutes = mode_time.minutes;
  }
	
  GPoint minute_hand = (GPoint) {
    .x = (int16_t)(sin_lookup(TRIG_MAX_ANGLE * minutes / 60) * (int32_t)(MINUTES_TRACK_RADIUS) / TRIG_MAX_RATIO) + s_center.x,
    .y = (int16_t)(-cos_lookup(TRIG_MAX_ANGLE * minutes/ 60) * (int32_t)(MINUTES_TRACK_RADIUS) / TRIG_MAX_RATIO) + s_center.y,
  };

  if( SWEEP_HOURS == true) {
    hours = mode_time.hours + (float)mode_time.minutes / 60;
  } else {
	hours = mode_time.hours; 
  }

  GPoint hour_hand = (GPoint) {
    .x = (int16_t)(sin_lookup(TRIG_MAX_ANGLE * hours / 12) * (int32_t)(HOURS_TRACK_RADIUS) / TRIG_MAX_RATIO) + s_center.x,
    .y = (int16_t)(-cos_lookup(TRIG_MAX_ANGLE * hours / 12) * (int32_t)(HOURS_TRACK_RADIUS) / TRIG_MAX_RATIO) + s_center.y,
  };
	
  graphics_context_set_fill_color(ctx, GColorWhite);
  
  GRect seconds_rect = GRect(s_center.x - SECONDS_TRACK_RADIUS, s_center.y - SECONDS_TRACK_RADIUS, SECONDS_TRACK_RADIUS * 2, SECONDS_TRACK_RADIUS * 2);
  
  GRect minutes_rect = GRect(s_center.x - MINUTES_TRACK_RADIUS, s_center.y - MINUTES_TRACK_RADIUS, MINUTES_TRACK_RADIUS * 2, MINUTES_TRACK_RADIUS * 2);
  
  GRect hours_rect = GRect(s_center.x - HOURS_TRACK_RADIUS, s_center.y - HOURS_TRACK_RADIUS, HOURS_TRACK_RADIUS * 2, HOURS_TRACK_RADIUS * 2);
  
 //----------------------------------
    
  int seconds_start_angle, seconds_end_angle;
  
  int seconds_delta = 12;
  int minutes_delta = 12;
  int hours_delta = 12;
	
  get_angles_60(mode_time.seconds, 0, seconds_delta, &seconds_start_angle, &seconds_end_angle);
  
  //----------------------------------
  
  //int minutes_angle = mode_time.minutes * 360 / 60;
  int minutes_start_angle, minutes_end_angle;
    
  get_angles_60(mode_time.minutes, (SWEEP_MINUTES == true) ? mode_time.seconds : 0, minutes_delta, &minutes_start_angle, &minutes_end_angle);
  //get_angles_60(mode_time.minutes, mode_time.seconds, minutes_delta, &minutes_start_angle, &minutes_end_angle);
  
  //----------------------------------
  
  //int hours_angle = mode_time.hours * 360 / 12;
  int hours_start_angle, hours_end_angle;

  get_angles_12(mode_time.hours,(SWEEP_HOURS == true) ? mode_time.minutes : 0, hours_delta, &hours_start_angle, &hours_end_angle);
  
  //APP_LOG(APP_LOG_LEVEL_DEBUG, "seconds: %d, start: %d, end: %d",  mode_time.seconds, seconds_start_angle, seconds_end_angle);
  
   //set colour for arcs and "hands"
    graphics_context_set_fill_color(ctx, GColorWhite );
    
  //draw seconds arc
  graphics_fill_radial(ctx, seconds_rect, GOvalScaleModeFitCircle, SECONDS_TRACK_STROKE,  DEG_TO_TRIGANGLE(seconds_start_angle), DEG_TO_TRIGANGLE(seconds_end_angle));
  
  //draw minutes arc
  graphics_fill_radial(ctx, minutes_rect, GOvalScaleModeFitCircle, MINUTES_TRACK_STROKE,  DEG_TO_TRIGANGLE(minutes_start_angle), DEG_TO_TRIGANGLE(minutes_end_angle));
  
  //draw hours arc
  graphics_fill_radial(ctx, hours_rect, GOvalScaleModeFitCircle, HOURS_TRACK_STROKE,  DEG_TO_TRIGANGLE(hours_start_angle), DEG_TO_TRIGANGLE(hours_end_angle));
  
  //draw minute hand
  graphics_fill_circle(ctx, minute_hand, MINUTES_HAND_RADIUS);
  
  //draw hour hand
  graphics_fill_circle(ctx, hour_hand, HOURS_HAND_RADIUS);
  
  //draw second hand
  graphics_context_set_fill_color(ctx, GColorRed );
  graphics_fill_circle(ctx, second_hand, SECONDS_HAND_RADIUS);
	
	update_time();
}

static void window_load(Window *window) {
  Layer *window_layer = window_get_root_layer(window);
  
  window_bounds = layer_get_bounds(window_layer);
  
  //APP_LOG(APP_LOG_LEVEL_DEBUG, "bounds: %d %d %d %d", window_bounds.origin.x, window_bounds.origin.y, window_bounds.size.h, window_bounds.size.w );

  s_center = grect_center_point(&window_bounds);
  
  s_canvas_layer = layer_create(window_bounds);
  layer_set_update_proc(s_canvas_layer, update_proc);
  layer_add_child(window_layer, s_canvas_layer);
	
// Create time TextLayer
  
  int font_height;
  
  PBL_IF_ROUND_ELSE(font_height = 45, font_height = 36); //fudge factor to get text vertically centred
  
  s_time_layer = text_layer_create(GRect(window_bounds.origin.x, (window_bounds.size.h-font_height)/2, window_bounds.size.w, font_height));
	
  //s_center.y - MINUTES_TRACK_RADIUS + 18 + 18;
		
  s_day_layer = text_layer_create(GRect(0, s_center.y - 18 - 18  , window_bounds.size.w, 18)); //need to calculate proper y-location
  s_month_layer = text_layer_create(GRect(0, s_center.y +36 , window_bounds.size.w, 18)); //need to calculate proper y-location
  
  text_layer_set_background_color(s_day_layer, GColorRed);
  text_layer_set_text_color(s_day_layer, GColorLightGray  );
  text_layer_set_text(s_day_layer, "00");
  
  text_layer_set_background_color(s_time_layer, GColorClear);
  text_layer_set_text_color(s_time_layer, GColorWhite);
  text_layer_set_text(s_time_layer, "00:00");
	
  text_layer_set_background_color(s_month_layer, GColorClear);
  text_layer_set_text_color(s_month_layer, GColorLightGray );
  text_layer_set_text(s_month_layer, "XXX");
  
  PBL_IF_ROUND_ELSE(s_custom_font = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_DOSIS_SEMIBOLD_40)), s_custom_font = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_DOSIS_SEMIBOLD_30)));

  text_layer_set_font(s_time_layer, s_custom_font);
  text_layer_set_text_alignment(s_time_layer, GTextAlignmentCenter);
	
  text_layer_set_font(s_day_layer, fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_DOSIS_SEMIBOLD_18)));
  text_layer_set_text_alignment(s_day_layer, GTextAlignmentCenter);

  text_layer_set_font(s_month_layer, fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_DOSIS_SEMIBOLD_18)));
  text_layer_set_text_alignment(s_month_layer, GTextAlignmentCenter);
  
  // Add it as a child layer to the Window's root layer
  layer_add_child(window_get_root_layer(window), text_layer_get_layer(s_time_layer));
  layer_add_child(window_get_root_layer(window), text_layer_get_layer(s_day_layer));
  layer_add_child(window_get_root_layer(window), text_layer_get_layer(s_month_layer));
	// Make sure the time is displayed from the start
  update_time();
}

static void window_unload(Window *window) {
  layer_destroy(s_canvas_layer);
  // Destroy TextLayer
  text_layer_destroy(s_time_layer);
  text_layer_destroy(s_day_layer);
  text_layer_destroy(s_month_layer);
  fonts_unload_custom_font(s_custom_font);
}

/*********************************** App **************************************/

static void init() {
  srand(time(NULL));

  time_t t = time(NULL);
  struct tm *time_now = localtime(&t);
  tick_handler(time_now, SECOND_UNIT);

  s_main_window = window_create();
  window_set_window_handlers(s_main_window, (WindowHandlers) {
    .load = window_load,
    .unload = window_unload,
  });
示例#8
0
文件: run.c 项目: manelto/steps
void inicio(void)
{
  // Create our app's base window
  window = window_create();
  window_stack_push(window, true);
  window_set_background_color(window, GColorBlack);

  Layer *root_layer = window_get_root_layer(window);
  GRect frame = layer_get_frame(root_layer);
  
  
  //parte accelerometer

  text_layer_1 = text_layer_create(GRect(0, 0, frame.size.w, 22));
  text_layer_2 = text_layer_create(GRect(0, 22, frame.size.w, 18));
  text_layer_set_text_color(text_layer_1, GColorWhite);
  text_layer_set_background_color(text_layer_1, GColorClear);
  text_layer_set_text_color(text_layer_2, GColorWhite);
  text_layer_set_background_color(text_layer_2, GColorClear);
  layer_add_child(root_layer, text_layer_get_layer(text_layer_1));
  layer_add_child(root_layer, text_layer_get_layer(text_layer_2));
 
  accel_data_service_subscribe(1, accel_handler);
  accel_service_set_sampling_rate(ACCEL_SAMPLING_25HZ);
 
  accel_tap_service_subscribe(tap_handler);
  //----------------------
  

  // Init the text layer used to show the time
  time_layer = text_layer_create(GRect(0, 40, frame.size.w /* width */, 35/* height */));
  text_layer_set_text_color(time_layer, GColorWhite);
  text_layer_set_background_color(time_layer, GColorClear);
  text_layer_set_font(time_layer, fonts_get_system_font(FONT_KEY_BITHAM_34_MEDIUM_NUMBERS));
  text_layer_set_text_alignment(time_layer, GTextAlignmentCenter);
  
  day_layer = text_layer_create(GRect(0, 75, frame.size.w /* width */, 30/* height */));
  text_layer_set_text_color(day_layer, GColorWhite);
  text_layer_set_background_color(day_layer, GColorClear);
  text_layer_set_font(day_layer, fonts_get_system_font(FONT_KEY_GOTHIC_28));
  text_layer_set_text_alignment(day_layer, GTextAlignmentCenter);

  connection_layer = text_layer_create(GRect(0, 98, /* width */ frame.size.w, 24 /* height */));
  text_layer_set_text_color(connection_layer, GColorWhite);
  text_layer_set_background_color(connection_layer, GColorClear);
  text_layer_set_font(connection_layer, fonts_get_system_font(FONT_KEY_GOTHIC_24));
  text_layer_set_text_alignment(connection_layer, GTextAlignmentCenter);
  handle_bluetooth(bluetooth_connection_service_peek());

  battery_layer = text_layer_create(GRect(0, 120, /* width */ frame.size.w, 34 /* height */));
  text_layer_set_text_color(battery_layer, GColorWhite);
  text_layer_set_background_color(battery_layer, GColorClear);
  text_layer_set_font(battery_layer, fonts_get_system_font(FONT_KEY_GOTHIC_24));
  text_layer_set_text_alignment(battery_layer, GTextAlignmentCenter);
  text_layer_set_text(battery_layer, "100% cargado");

  // Ensures time is displayed immediately (will break if NULL tick event accessed).
  // (This is why it's a good idea to have a separate routine to do the update itself.)
  time_t now = time(NULL);
  struct tm *current_time = localtime(&now);
  handle_second_tick(current_time, SECOND_UNIT);

  tick_timer_service_subscribe(SECOND_UNIT, &handle_second_tick);
  battery_state_service_subscribe(&handle_battery);
  bluetooth_connection_service_subscribe(&handle_bluetooth);

  layer_add_child(root_layer, text_layer_get_layer(time_layer));
  layer_add_child(root_layer, text_layer_get_layer(day_layer));
  layer_add_child(root_layer, text_layer_get_layer(connection_layer));
  layer_add_child(root_layer, text_layer_get_layer(battery_layer));
}
示例#9
0
void init() {
  memset(&time_digits_layers, 0, sizeof(time_digits_layers));
  memset(&time_digits_images, 0, sizeof(time_digits_images));
	
  const int inbound_size = 160;
  const int outbound_size = 160;
  app_message_open(inbound_size, outbound_size);  

  window = window_create();
  if (window == NULL) {
      return;
  }
	
    window_stack_push(window, true);
  
	background_color  = GColorBlack;
    window_set_background_color(window, background_color);
		
	Layer *window_layer = window_get_root_layer(window);

    GRect bounds = layer_get_frame(window_layer);
    path_layer = layer_create(bounds);
    layer_set_update_proc(path_layer, path_layer_update_callback);
    layer_add_child(window_layer, path_layer);

    // Pass the corresponding GPathInfo to initialize a GPath
    batt10 = gpath_create(&BATT10);
    batt20 = gpath_create(&BATT20);
    batt30 = gpath_create(&BATT30);
    batt40 = gpath_create(&BATT40);
    batt50 = gpath_create(&BATT50);
    batt60 = gpath_create(&BATT60);
    batt70 = gpath_create(&BATT70);
    batt80 = gpath_create(&BATT80);
    batt90 = gpath_create(&BATT90);
    batt100 = gpath_create(&BATT100);
  
	// Create time and date layers
    GRect dummy_frame = { {0, 0}, {0, 0} };
	
  for (int i = 0; i < TOTAL_TIME_DIGITS; ++i) {
    time_digits_layers[i] = bitmap_layer_create(dummy_frame);
    layer_add_child(window_layer, bitmap_layer_get_layer(time_digits_layers[i]));
  }

  time1_text_layer = text_layer_create(GRect(0, 64, 147, 30));
  text_layer_set_background_color(time1_text_layer, GColorClear);
  text_layer_set_text_color(time1_text_layer, GColorWhite);
  text_layer_set_text_alignment(time1_text_layer, GTextAlignmentCenter);
  text_layer_set_font(time1_text_layer, fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_HELVETICA_BOLD_24)));
  text_layer_set_text(time1_text_layer, time1_buffer);
  layer_add_child(window_get_root_layer(window), (Layer*) time1_text_layer);
  

  date_text_layer = text_layer_create(GRect(0, 128, 144, 20));
  text_layer_set_background_color(date_text_layer, GColorClear);
  text_layer_set_text_color(date_text_layer, GColorWhite);
  text_layer_set_text_alignment(date_text_layer, GTextAlignmentCenter);
  text_layer_set_font(date_text_layer, fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_HELVETICA_16)));
  text_layer_set_text(date_text_layer, date_buffer);
  layer_add_child(window_get_root_layer(window), (Layer*) date_text_layer);
  
  toggle_bluetooth(bluetooth_connection_service_peek());
  battery_state_service_subscribe(&update_battery_state);

  Tuplet initial_values[] = {
    TupletInteger(SWAP_KEY, persist_read_bool(SWAP_KEY)),
    TupletInteger(INVERT_KEY, persist_read_bool(INVERT_KEY)),
    TupletInteger(BLUETOOTHVIBE_KEY, persist_read_bool(BLUETOOTHVIBE_KEY)),
    TupletInteger(HOURLYVIBE_KEY, persist_read_bool(HOURLYVIBE_KEY)),
  };
  
  app_sync_init(&sync, sync_buffer, sizeof(sync_buffer), initial_values, ARRAY_LENGTH(initial_values),
      sync_tuple_changed_callback, NULL, NULL);
   
  appStarted = true;
  
  // Avoids a blank screen on watch start.
  time_t now = time(NULL);
  tick_handler(localtime(&now), DAY_UNIT + HOUR_UNIT + MINUTE_UNIT);
  tick_timer_service_subscribe(MINUTE_UNIT, (TickHandler) tick_handler);
	
  // update the battery on launch
  update_battery_state(battery_state_service_peek());
  bluetooth_connection_service_subscribe(bluetooth_connection_callback);
		
}
示例#10
0
static void main_window_load(Window *window) {
  Layer *window_layer = window_get_root_layer(window);
  GRect bounds = layer_get_bounds(window_layer);
  char y_offset_time_layer = PBL_IF_ROUND_ELSE(14, 8);
  char x_offset_battery_layer = PBL_IF_ROUND_ELSE(17, 17);
  char y_offset_battery_layer = PBL_IF_ROUND_ELSE((bounds.size.h / 2) - 11, bounds.size.h - 22);
  char x_offset_date_layer = PBL_IF_ROUND_ELSE(bounds.size.w - 62, bounds.size.w - 64);
  char y_offset_date_layer = PBL_IF_ROUND_ELSE((bounds.size.h / 2) - 12 , bounds.size.h - 15);
  char x_offset_weather_layer = PBL_IF_ROUND_ELSE(bounds.size.w - 65, bounds.size.w - 56);
  char y_offset_weather_layer = PBL_IF_ROUND_ELSE((bounds.size.h / 2) + 22, (bounds.size.h / 2) - 18);
  GColor color_blue = GColorFromHEX(0x007cb2);
  static char lastWeatherBuffer[32] = "--";
  persist_read_string(KEY_LAST_WEATHER_BUFFER, lastWeatherBuffer, 32);
                                                  
  layer_set_update_proc(window_layer, my_layer_draw);
    
  // Creacion del layer con las horas
  s_time_layer_hours = text_layer_create(
      GRect(0, y_offset_time_layer, (bounds.size.w / 2 - 4), 52));
  
  // Creacion del layer con los minutos
  s_time_layer_minutes = text_layer_create(
      GRect((bounds.size.w / 2) + 4, y_offset_time_layer, (bounds.size.w / 2) - 4, 52));

  // Creacion del layer para el nivel de bateria
  s_battery_layer = text_layer_create(
      GRect(x_offset_battery_layer, y_offset_battery_layer, 40, 18));
  
  // Creacion del layer para la fecha
  s_date_layer = text_layer_create(
      GRect(x_offset_date_layer, y_offset_date_layer, 64, PBL_IF_ROUND_ELSE(36, 18)));
  
  // Creacion del layer para mostrar el tiempo atmosferico
  s_weather_layer = text_layer_create(
    GRect(x_offset_weather_layer, y_offset_weather_layer, 72, 72));
  
  // Estilo del layer del tiempo atmosferico
  text_layer_set_background_color(s_weather_layer, GColorClear);
  text_layer_set_text_color(s_weather_layer, GColorWhite);
  text_layer_set_font(s_weather_layer, s_font_temperature);
  text_layer_set_text(s_weather_layer, lastWeatherBuffer);
  //xt_layer_set_text(s_weather_layer, "--");
  text_layer_set_text_alignment(s_weather_layer, GTextAlignmentCenter);
  
  // Estilo del layer con la hora
  text_layer_set_background_color(s_time_layer_hours, GColorClear);
  text_layer_set_text_color(s_time_layer_hours, color_blue);
  text_layer_set_text(s_time_layer_hours, "--");
  text_layer_set_font(s_time_layer_hours, s_font_time);
  text_layer_set_text_alignment(s_time_layer_hours, GTextAlignmentRight);
  
  // Estilo del layer con los minutos
  text_layer_set_background_color(s_time_layer_minutes, GColorClear);
  text_layer_set_text_color(s_time_layer_minutes, GColorWhite);
  text_layer_set_text(s_time_layer_minutes, "--");
  text_layer_set_font(s_time_layer_minutes, s_font_time);
  text_layer_set_text_alignment(s_time_layer_minutes, GTextAlignmentLeft);
  
  // Estilo del layer con el porcentaje de bateria
  text_layer_set_background_color(s_battery_layer, GColorClear);
  text_layer_set_text_color(s_battery_layer, color_blue);
  text_layer_set_text(s_battery_layer, "---");
  text_layer_set_font(s_battery_layer, fonts_get_system_font(FONT_KEY_GOTHIC_18_BOLD));
  text_layer_set_text_alignment(s_battery_layer, GTextAlignmentLeft);
  
  // Estilo del layer con la fecha
  text_layer_set_background_color(s_date_layer, GColorClear);
  text_layer_set_text_color(s_date_layer, GColorWhite);
  text_layer_set_text(s_date_layer, "---");
  text_layer_set_font(s_date_layer, s_font_date);
  text_layer_set_text_alignment(s_date_layer, GTextAlignmentCenter);

  GSize text_size = text_layer_get_content_size(s_time_layer_hours);

  // Adicion de los layers a la ventana principal
  layer_add_child(window_layer, text_layer_get_layer(s_time_layer_hours));
  layer_add_child(window_layer, text_layer_get_layer(s_time_layer_minutes));
  layer_add_child(window_layer, text_layer_get_layer(s_battery_layer));
  layer_add_child(window_layer, text_layer_get_layer(s_date_layer));
  layer_add_child(window_layer, text_layer_get_layer(s_weather_layer));
  
  #if defined(PBL_COLOR)
    // Se carga la imagen del escudo en color
    s_bitmap = gbitmap_create_with_resource(RESOURCE_ID_ESCUDO_PONFE);
    GSize image_size = gbitmap_get_bounds(s_bitmap).size;
    char image_offsetX = (bounds.size.w - image_size.w) / 2; 
    GRect image_frame = GRect(image_offsetX, text_size.h + y_offset_time_layer + 6, image_size.w, image_size.h);
    s_layer = bitmap_layer_create(image_frame);
  
    bitmap_layer_set_bitmap(s_layer, s_bitmap);
    bitmap_layer_set_compositing_mode(s_layer, GCompOpSet);
    bitmap_layer_set_alignment(s_layer, GAlignBottom);
 #elif defined(PBL_BW)
    // Se carga la imagen del escudo en blanco y negro
    s_bitmap_bw = gbitmap_create_with_resource(RESOURCE_ID_ESCUDO_BN);
    GSize image_size = gbitmap_get_bounds(s_bitmap_bw).size;
    char image_offsetX = (bounds.size.w - image_size.w) / 2; 
    GRect image_frame = GRect(image_offsetX, text_size.h + y_offset_time_layer + 6, image_size.w, image_size.h);
    s_layer = bitmap_layer_create(image_frame);
  
    bitmap_layer_set_bitmap(s_layer, s_bitmap_bw);
    bitmap_layer_set_compositing_mode(s_layer, GCompOpSet);
    bitmap_layer_set_alignment(s_layer, GAlignBottom);
  #endif
  
  // Create the Bluetooth icon GBitmap
  s_bitmap_bt = gbitmap_create_with_resource(RESOURCE_ID_BT_ICON);

  // Create the BitmapLayer to display the GBitmap
  s_layer_bt = bitmap_layer_create(GRect(PBL_IF_ROUND_ELSE(22, 8), PBL_IF_ROUND_ELSE((bounds.size.h / 2) + 18, bounds.size.h / 2), 24, 24));
  bitmap_layer_set_bitmap(s_layer_bt, s_bitmap_bt);
  bitmap_layer_set_compositing_mode(s_layer_bt, GCompOpSet);
  bitmap_layer_set_alignment(s_layer_bt, GAlignLeft);
  
  layer_add_child(window_layer, bitmap_layer_get_layer(s_layer_bt));
  layer_add_child(window_layer, bitmap_layer_get_layer(s_layer));
}
示例#11
0
static void main_window_load(Window *window) {
	
#if defined(PBL_BW)
    window_set_background_color(s_main_window, GColorWhite);
#elif defined(PBLE_COLOR)
  int red = persist_read_int(KEY_COLOR_RED);
  int green = persist_read_int(KEY_COLOR_GREEN);
  int blue = persist_read_int(KEY_COLOR_BLUE);
  
  GColor bg_color = GColorFromRGB(red, green, blue);
  window_set_background_color(s_main_window, bg_color);
#endif
  
  // Get the Window's root layer and the bounds
  GRect bounds = layer_get_bounds(window_get_root_layer(window));
  
  // Load the image
  #ifdef PBL_COLOR
    logo_bitmap = gbitmap_create_with_resource(RESOURCE_ID_LOGO);
  #else
    logo_bitmap = gbitmap_create_with_resource(RESOURCE_ID_LOGO_BW);
  #endif

// Create a BitmapLayer
logo_layer = bitmap_layer_create(bounds);

// Set the bitmap and center it
bitmap_layer_set_bitmap(logo_layer, logo_bitmap);
bitmap_layer_set_alignment(logo_layer, GAlignCenter);
bitmap_layer_set_compositing_mode(logo_layer, GCompOpSet);

// Add to the Window
layer_add_child(window_get_root_layer(window), bitmap_layer_get_layer(logo_layer));
	
	// Set font hour TextLayer
	s_hour_font = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_SYNC_BOLD_50));
	// Set font minutes TextLayer
	s_minutes_font = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_SYNC_BOLD_50));
	
	//Hour Layer
  #if defined(PBL_RECT) 
	  s_hour_layer = text_layer_create(GRect (0, 30, 144, 54));
  #elif defined(PBL_ROUND)
    s_hour_layer = text_layer_create(GRect (0, 35, 180, 54));
  #endif
	text_layer_set_background_color(s_hour_layer, GColorClear);
  text_layer_set_text_color(s_hour_layer, GColorBlack);
	text_layer_set_text(s_hour_layer, "00");
	
	//Minute Layer
	#if defined(PBL_RECT) 
    s_minutes_layer = text_layer_create(GRect (0, 74, 144, 54));
  #elif defined(PBL_ROUND) 
    s_minutes_layer = text_layer_create(GRect (0, 79, 180, 54));
  #endif
	text_layer_set_background_color(s_minutes_layer, GColorClear);
	text_layer_set_text_color(s_minutes_layer, GColorBlack);
	text_layer_set_text(s_minutes_layer, "00");
  
	//Make it look more like a watch
	text_layer_set_font(s_hour_layer, s_hour_font);
	text_layer_set_font(s_minutes_layer, s_minutes_font);
	text_layer_set_text_alignment(s_hour_layer, GTextAlignmentCenter);
	text_layer_set_text_alignment(s_minutes_layer, GTextAlignmentCenter);
	
	//Add hour, miuntes, and weather layers as child windows to the Window's root layer
	layer_add_child(window_get_root_layer(window), text_layer_get_layer(s_hour_layer));
	layer_add_child(window_get_root_layer(window), text_layer_get_layer(s_minutes_layer));
}
示例#12
0
static void window_load(Window *window) {
  Layer *root_layer = window_get_root_layer(window);

  // Create the Time text_layer
  time_layer = text_layer_create(GRect(0, 0, 144, 56));
  text_layer_set_background_color(time_layer, GColorBlack);
  text_layer_set_text_color(time_layer, GColorWhite);
  text_layer_set_text_alignment(time_layer, GTextAlignmentCenter);
  text_layer_set_font(time_layer,
                      fonts_get_system_font(FONT_KEY_ROBOTO_BOLD_SUBSET_49));
  layer_add_child(root_layer, text_layer_get_layer(time_layer));

  // Create the Wind Direction text_layer
  wind_direction_layer = text_layer_create(GRect(0, 56, 144, 28));
  text_layer_set_background_color(wind_direction_layer, GColorBlack);
  text_layer_set_text_color(wind_direction_layer, GColorWhite);
  text_layer_set_text_alignment(wind_direction_layer, GTextAlignmentCenter);
  text_layer_set_font(wind_direction_layer,
                      fonts_get_system_font(FONT_KEY_GOTHIC_28_BOLD ));
  layer_add_child(root_layer, text_layer_get_layer(wind_direction_layer));

  // Create the last_update text_layer
  last_update_layer = text_layer_create(GRect(0, 88, 144, 16));
  text_layer_set_background_color(last_update_layer, GColorBlack);
  text_layer_set_text_color(last_update_layer, GColorWhite);
  text_layer_set_text_alignment(last_update_layer, GTextAlignmentCenter);
  text_layer_set_text(last_update_layer, "_-_ -:-");
  text_layer_set_font(last_update_layer,
                      fonts_get_system_font(FONT_KEY_GOTHIC_14 ));
  layer_add_child(root_layer, text_layer_get_layer(last_update_layer));

  Layer *window_layer = root_layer;
  GRect frame = layer_get_frame(window_layer);

  rounded_layer = layer_create(frame);
  layer_set_update_proc(rounded_layer, rounded_layer_update_callback);
  layer_add_child(window_layer, rounded_layer);

  // Create the Wind text_layer
  wind_layer = text_layer_create(GRect(8, 112, 128, 24));
  text_layer_set_text_alignment(wind_layer, GTextAlignmentCenter);
  text_layer_set_font(wind_layer,
                      fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD ));
  layer_add_child(root_layer, text_layer_get_layer(wind_layer));

  // Create the temp_and_level text_layer
  temp_and_level_layer = text_layer_create(GRect(8, 136, 128, 24));
  text_layer_set_text_alignment(temp_and_level_layer, GTextAlignmentCenter);
  text_layer_set_font(temp_and_level_layer,
                      fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD));
  layer_add_child(root_layer, text_layer_get_layer(temp_and_level_layer));

  // Subscribe to tick_timer_service
  tick_timer_service_subscribe(MINUTE_UNIT, handle_timechanges);

  // Initialize app_message
  const int inbound_size = 128;
  const int outbound_size = 128;
  app_message_open(inbound_size, outbound_size);

  Tuplet initial_values[] = {
    TupletCString(WIND_DIRECTION_KEY, "-\u00B0 ---"),
    TupletCString(WIND_SPEED_KEY, "-kt -km/h"),
    TupletCString(TEMP_AND_LEVEL_KEY, "-\u00B0C | -m"),
    TupletCString(LAST_UPDATE_KEY, "_-_ -:-")
  };

  app_sync_init(&sync, sync_buffer, sizeof(sync_buffer), initial_values,
                ARRAY_LENGTH(initial_values),
    sync_tuple_changed_callback, sync_error_callback, NULL);

  send_cmd();

  window_set_background_color(window, GColorBlack);

  // Push the window
  window_stack_push(window, true);
}
void handle_init(void) {

  const int inbound_size = 64;
  const int outbound_size = 64;
  app_message_open(inbound_size, outbound_size);

  clock_window = window_create();
  window_set_fullscreen(clock_window, true);
  window_stack_push(clock_window, true /* Animated */);
  window_set_background_color(clock_window, GColorBlack);
  window_set_click_config_provider(clock_window, click_config_provider);

  Layer *window_layer = window_get_root_layer(clock_window);
  // Date: wkday. mm/dd/yy
  text_date_layer = text_layer_create(GRect(0, 92, 145, 100));
  text_layer_set_text_color(text_date_layer, GColorBlack);
  text_layer_set_background_color(text_date_layer, GColorWhite);
  text_layer_set_font(text_date_layer, fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_DROID_SERIF_20)));
  text_layer_set_text_alignment(text_date_layer, GTextAlignmentCenter);
  layer_add_child(window_layer, text_layer_get_layer(text_date_layer));

  // Time - 12hr
  text_time_layer = text_layer_create(GRect(0, 117, 145, 50));
  text_layer_set_text_color(text_time_layer, GColorBlack);
  text_layer_set_background_color(text_time_layer, GColorClear);
  text_layer_set_font(text_time_layer, fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_DROID_SERIF_42)));
  text_layer_set_text_alignment(text_time_layer, GTextAlignmentCenter);
  layer_add_child(window_layer, text_layer_get_layer(text_time_layer));

  // Percent charged battery display
  battery_layer = text_layer_create(GRect(0, 0, 144-0, 168-68));
  text_layer_set_text_color(battery_layer, GColorWhite);
  text_layer_set_background_color(battery_layer, GColorClear);
  text_layer_set_font(battery_layer, fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_DROID_SERIF_BOLD_15)));           //FONT_ROBOTO_CONDENSED_18)));
  text_layer_set_text_alignment(battery_layer, GTextAlignmentCenter);
  text_layer_set_text(battery_layer, "...checking...");
  layer_add_child(window_layer, text_layer_get_layer(battery_layer));

  // Bluetooth connection
  connection_layer = text_layer_create(GRect(0, 22, 145, 20));
  text_layer_set_text_color(connection_layer, GColorWhite);
  text_layer_set_background_color(connection_layer, GColorClear);
  text_layer_set_font(connection_layer, fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_DROID_SERIF_BOLD_15))); //FONT_ROBOTO_CONDENSED_18)));
  text_layer_set_text_alignment(connection_layer, GTextAlignmentCenter);
  text_layer_set_text(connection_layer, "");
  layer_add_child(window_layer, text_layer_get_layer(connection_layer));

  // black seperator bar
  bar_layer = text_layer_create(GRect(0, 118, 145, 3));
  text_layer_set_background_color(bar_layer, GColorBlack);
  layer_add_child(window_layer, text_layer_get_layer(bar_layer));

  tick_timer_service_subscribe(MINUTE_UNIT, handle_minute_tick);
  battery_state_service_subscribe(&handle_battery);
  bluetooth_connection_service_subscribe(&handle_bluetooth);

  // If bluetooth is disconnected, it will say so even if you leave watchface
  bool connected = bluetooth_connection_service_peek();
  if (!connected)
    text_layer_set_text(connection_layer, "BT: Disconnected");
}
示例#14
0
static bool get_holiday_text(int layer_id, char *text)
{
	if(current_day == now->tm_mday && is_holiday == false)
	{
		return false;
	}
	
	current_day = now->tm_mday;	
	is_holiday = false;
	
	if (now->tm_mon == JAN && now->tm_mday == 1) 
	{
		is_holiday = true; // New year's day
		
		if(layer_id == LAYER_MINUTE) snprintf(text, BUFFER_SIZE, "%s", "ngayon ay");
		else if(layer_id == LAYER_MODIFIER) snprintf(text, BUFFER_SIZE, "%s", "bagong");
		else if(layer_id == LAYER_HOUR) snprintf(text, BUFFER_SIZE, "%s", "taon!");
		else is_holiday = false;
	}
	else if (now->tm_mon == APR && now->tm_mday == 9)
	{
		is_holiday = true; // Day of valor
		
		if(layer_id == LAYER_MINUTE) snprintf(text, BUFFER_SIZE, "%s", "ngayon ay");
		else if(layer_id == LAYER_MODIFIER) snprintf(text, BUFFER_SIZE, "%s", "araw ng");
		else if(layer_id == LAYER_HOUR) snprintf(text, BUFFER_SIZE, "%s", "kagitingan!");
		else is_holiday = false;
	}
	else if (now->tm_mon == MAY && now->tm_mday == 1) 
	{
		is_holiday = true; // Labor day
		
		if(layer_id == LAYER_MINUTE) snprintf(text, BUFFER_SIZE, "%s", "ngayon ay");
		else if(layer_id == LAYER_MODIFIER) snprintf(text, BUFFER_SIZE, "%s", "araw ng");
		else if(layer_id == LAYER_HOUR) snprintf(text, BUFFER_SIZE, "%s", "manggagawa!");
		else is_holiday = false;
	}
	else if (now->tm_mon == JUN && now->tm_mday == 12)
	{
		is_holiday = true; // Independence day
		
		if(layer_id == LAYER_MINUTE) snprintf(text, BUFFER_SIZE, "%s", "ngayon ay");
		else if(layer_id == LAYER_MODIFIER) snprintf(text, BUFFER_SIZE, "%s", "araw ng");
		else if(layer_id == LAYER_HOUR) snprintf(text, BUFFER_SIZE, "%s", "kalayaan!");
		else is_holiday = false;
	}
	else if (now->tm_mon == AUG && now->tm_mday == 21)
	{
		is_holiday = true; // Ninoy Aquino's day
		
		if(layer_id == LAYER_MINUTE) snprintf(text, BUFFER_SIZE, "%s", "ngayon ay");
		else if(layer_id == LAYER_MODIFIER) snprintf(text, BUFFER_SIZE, "%s", "araw ni");
		else if(layer_id == LAYER_HOUR) snprintf(text, BUFFER_SIZE, "%s", "Ninoy!");
		else is_holiday = false;
	}
	else if (now->tm_mon == AUG && now->tm_mday == 26)
	{
		is_holiday = true; // National heroes day
		
		if(layer_id == LAYER_MINUTE) snprintf(text, BUFFER_SIZE, "%s", "ngayon ay");
		else if(layer_id == LAYER_MODIFIER) snprintf(text, BUFFER_SIZE, "%s", "araw ng mga");
		else if(layer_id == LAYER_HOUR) snprintf(text, BUFFER_SIZE, "%s", "bayani!");
		else is_holiday = false;
	}
	else if (now->tm_mon == NOV && now->tm_mday == 1)
	{
		is_holiday = true; // All saints day
		
		if(layer_id == LAYER_MINUTE) snprintf(text, BUFFER_SIZE, "%s", "ngayon ay");
		else if(layer_id == LAYER_MODIFIER) snprintf(text, BUFFER_SIZE, "%s", "araw ng mga");
		else if(layer_id == LAYER_HOUR) snprintf(text, BUFFER_SIZE, "%s", "santo!");
		else is_holiday = false;
	}
	else if (now->tm_mon == NOV && now->tm_mday == 2)
	{
		is_holiday = true; // All souls day
		
		if(layer_id == LAYER_MINUTE) snprintf(text, BUFFER_SIZE, "%s", "ngayon ay");
		else if(layer_id == LAYER_MODIFIER) snprintf(text, BUFFER_SIZE, "%s", "araw ng mga");
		else if(layer_id == LAYER_HOUR) snprintf(text, BUFFER_SIZE, "%s", "patay!");
		else is_holiday = false;
	}
	else if (now->tm_mon == NOV && now->tm_mday == 30)
	{
		is_holiday = true; // Bonifacio day
		
		if(layer_id == LAYER_MINUTE) snprintf(text, BUFFER_SIZE, "%s", "ngayon ay");
		else if(layer_id == LAYER_MODIFIER) snprintf(text, BUFFER_SIZE, "%s", "araw ni");
		else if(layer_id == LAYER_HOUR) snprintf(text, BUFFER_SIZE, "%s", "Bonifacio!");
		else is_holiday = false;
	}
	else if (now->tm_mon == DEC && now->tm_mday == 24) 
	{
		is_holiday = true; // Christmas eve
		
		if(layer_id == LAYER_MINUTE) snprintf(text, BUFFER_SIZE, "%s", "ngayon ay");
		else if(layer_id == LAYER_MODIFIER) snprintf(text, BUFFER_SIZE, "%s", "bisperas ng");
		else if(layer_id == LAYER_HOUR) snprintf(text, BUFFER_SIZE, "%s", "pasko!");
		else is_holiday = false;
	}
	else if (now->tm_mon == DEC && now->tm_mday == 25) 
	{
		is_holiday = true; // Christmas day
		
		if(layer_id == LAYER_MINUTE) snprintf(text, BUFFER_SIZE, "%s", "ngayon ay");
		else if(layer_id == LAYER_MODIFIER) snprintf(text, BUFFER_SIZE, "%s", "araw ng");
		else if(layer_id == LAYER_HOUR) snprintf(text, BUFFER_SIZE, "%s", "pasko!");
		else is_holiday = false;
	}
	else if (now->tm_mon == DEC && now->tm_mday == 30) 
	{
		is_holiday = true; // Rizal day
		
		if(layer_id == LAYER_MINUTE) snprintf(text, BUFFER_SIZE, "%s", "ngayon ay");
		else if(layer_id == LAYER_MODIFIER) snprintf(text, BUFFER_SIZE, "%s", "araw ni");
		else if(layer_id == LAYER_HOUR) snprintf(text, BUFFER_SIZE, "%s", "Rizal!");
		else is_holiday = false;
	}
	else if (now->tm_mon == DEC && now->tm_mday == 31) 
	{
		is_holiday = true; // New year's eve
		
		if(layer_id == LAYER_MINUTE) snprintf(text, BUFFER_SIZE, "%s", "ngayon ay");
		else if(layer_id == LAYER_MODIFIER) snprintf(text, BUFFER_SIZE, "%s", "bisperas ng");
		else if(layer_id == LAYER_HOUR) snprintf(text, BUFFER_SIZE, "%s", "bagong taon!");
		else is_holiday = false;
	}
	else if((now->tm_mon == MAR && now->tm_mday >= 19)
			|| (now->tm_mon == APR && now->tm_mday <= 25)) 
	{
		//calculate easter sunday and from there calculate maundy thursday and good friday
		//easter can never occur before March 22 or later than April 25
		//so this condition should cover from March 19 (earliest possible maundy thursday)
		
		int year = now->tm_year + 1900;
		int cen = year % 19;
		int leap = year % 4;
		int days = year % 7;
		int temp1 = (19 * cen + 24) % 30;
		int temp2 = (2 * leap + 4 * days + 6 * temp1 + 5) % 7;
		int easter = 22 + temp1 + temp2;
		
		struct tm easter_sun;
		//min easter = 22
		//max easter = 56
		if (easter > 31) 
		{
			easter_sun.tm_year = now->tm_year;
			easter_sun.tm_mon = APR;
			easter_sun.tm_mday = (easter - 31);
		}
		else
		{
			easter_sun.tm_year = now->tm_year;
			easter_sun.tm_mon = MAR;
			easter_sun.tm_mday = easter;
		}
		
		struct tm maundy_thu = 
		{
			.tm_year = easter_sun.tm_year,
			.tm_mon = (easter_sun.tm_mday - 3 >= 1) ? easter_sun.tm_mon : MAR,
			.tm_mday = (easter_sun.tm_mday - 3 >= 1) ? easter_sun.tm_mday - 3 : (31 + easter_sun.tm_mday - 3)
		};
		
		struct tm good_fri = 
		{
			.tm_year = easter_sun.tm_year,
			.tm_mon = (easter_sun.tm_mday - 2 >= 1) ? easter_sun.tm_mon : MAR,
			.tm_mday = (easter_sun.tm_mday - 2 >= 1) ? easter_sun.tm_mday - 2 : (31 + easter_sun.tm_mday - 2)
		};
		
		struct tm black_sat = 
		{
			.tm_year = easter_sun.tm_year,
			.tm_mon = (easter_sun.tm_mday - 1 >= 1) ? easter_sun.tm_mon : MAR,
			.tm_mday = (easter_sun.tm_mday - 1 >= 1) ? easter_sun.tm_mday - 1 : (31 + easter_sun.tm_mday - 1)
		};
		
		if(now->tm_mon == maundy_thu.tm_mon && now->tm_mday == maundy_thu.tm_mday)
		{
			is_holiday = true; // Maundy thursday
			
			if(layer_id == LAYER_MINUTE)
				snprintf(text, BUFFER_SIZE, "%s", "ngayon ay");
			else if(layer_id == LAYER_MODIFIER)
				snprintf(text, BUFFER_SIZE, "%s", "huwebes");
			else if(layer_id == LAYER_HOUR)
				snprintf(text, BUFFER_SIZE, "%s", "santo!");
			else
				is_holiday = false;
		}
		else if(now->tm_mon == good_fri.tm_mon && now->tm_mday == good_fri.tm_mday)
		{
			is_holiday = true; // Good friday
			
			if(layer_id == LAYER_MINUTE)
				snprintf(text, BUFFER_SIZE, "%s", "ngayon ay");
			else if(layer_id == LAYER_MODIFIER)
				snprintf(text, BUFFER_SIZE, "%s", "biyernes");
			else if(layer_id == LAYER_HOUR)
				snprintf(text, BUFFER_SIZE, "%s", "santo!");
			else
				is_holiday = false;
		}	
		else if(now->tm_mon == black_sat.tm_mon && now->tm_mday == black_sat.tm_mday)
		{
			is_holiday = true; // Black saturday
			
			if(layer_id == LAYER_MINUTE)
				snprintf(text, BUFFER_SIZE, "%s", "ngayon ay");
			else if(layer_id == LAYER_MODIFIER)
				snprintf(text, BUFFER_SIZE, "%s", "sabado");
			else if(layer_id == LAYER_HOUR)
				snprintf(text, BUFFER_SIZE, "%s", "de gloria!");
			else
				is_holiday = false;
		}
	}
	
	return is_holiday;
}

static bool check_text(layer_info *me, bool force_refresh)
{
	int h = now->tm_hour;
	int m = now->tm_min;

	bool first_half = m < get_count_up_cutover_value();
	if (first_half == false) 
	{
		h = (h + 1) % 24;

		//we moved the hour forward, so force a refresh of the text
		if(me->id == LAYER_HOUR) me->flag = 0;
	}
	
	if(force_refresh == true && me->id == LAYER_HOUR) me->flag = 0;

	int twelve_hour = h % 12;
	
	bool has_changed = true;
	bool is_holiday = false;
	bool include_holiday = get_include_holiday_value();
	
	me->font_size = FONT_MEDIUM;
	
	if (me->id == LAYER_MINUTE)
	{
		if (m == 0) 
		{
			if(include_holiday == true)
				is_holiday = get_holiday_text(me->id, me->text);
			
			if(is_holiday == false)
			{
				snprintf(me->text, BUFFER_SIZE, "%s", hour_text[twelve_hour]);
				me->font_size = FONT_SMALL;
			}
		}
		else if (first_half == true) snprintf(me->text, BUFFER_SIZE, "%d minuto", m);
		else snprintf(me->text, BUFFER_SIZE, "%d minuto", 60 - m);
	}
	else if(me->id == LAYER_MODIFIER)
	{
		if(m == 0 && me->flag != 1)
		{
			if(include_holiday == true)
				is_holiday = get_holiday_text(me->id, me->text);
			
			if(is_holiday == false)
				snprintf(me->text, BUFFER_SIZE, "%s", "na ng");
			
			me->flag = 1;
		}
		else if (m != 0 && first_half == true && me->flag != 2)
		{
			snprintf(me->text, BUFFER_SIZE, "makalipas ang");
			me->flag = 2;
			me->font_size = FONT_SMALL;
		}
		else if (m != 0 && first_half == false && me->flag != 3)
		{
			snprintf(me->text, BUFFER_SIZE, "bago mag");
			me->flag = 3;
		}
		else
		{
			has_changed = false;
		}
	}
	else if(me->id == LAYER_HOUR)
	{
		//"minute == 0" text only happens once per hour
		//and since the previous minute (minute == 59) is still under the same condition as the current hour,
		//we need to reset the flag to force a refresh on the text
		//this will then retrieve the "minute != 0" text	
		if(m == 0) me->flag = 0;
		
		if(h == 0 && me->flag != 1) 
		{
			if(m == 0) 
			{
				if(include_holiday == true)
					is_holiday = get_holiday_text(me->id, me->text);
			
				if(is_holiday == false)
					snprintf(me->text, BUFFER_SIZE, "%s", "hating gabi");
			}
			else
			{
				snprintf(me->text, BUFFER_SIZE, "%s ng hating gabi", hour_text[twelve_hour]);
				me->font_size = FONT_SMALL;
			}
			
			me->flag = 1;
		}
		else if(h > 0 && h < 6 && me->flag != 2) 
		{
			if(m == 0) 
			{
				if(include_holiday == true)
					is_holiday = get_holiday_text(me->id, me->text);
			
				if(is_holiday == false)
					snprintf(me->text, BUFFER_SIZE, "%s", "madaling araw");
			}
			else
			{
				snprintf(me->text, BUFFER_SIZE, "%s ng madaling araw", hour_text[twelve_hour]);
				me->font_size = FONT_SMALL;
			}
			
			me->flag = 2;
		}
		else if(h >= 6 && h < 12 && me->flag != 3)
		{
			if(m == 0) 
			{
				if(include_holiday == true)
					is_holiday = get_holiday_text(me->id, me->text);
			
				if(is_holiday == false)
					snprintf(me->text, BUFFER_SIZE, "%s", "umaga");
				else if(h == 9)
					vibes_double_pulse();
			}
			else 
			{
				snprintf(me->text, BUFFER_SIZE, "%s ng umaga", hour_text[twelve_hour]);
			}
			
			me->flag = 3;
		}
		else if(h == 12 && me->flag != 4)
		{
			if(m == 0) 
			{
				if(include_holiday == true)
					is_holiday = get_holiday_text(me->id, me->text);
			
				if(is_holiday == false)
					snprintf(me->text, BUFFER_SIZE, "%s", "tanghali");
				else
					vibes_double_pulse();
			}
			else 
			{
				snprintf(me->text, BUFFER_SIZE, "%s ng tanghali", hour_text[twelve_hour]);
			}
			
			me->flag = 4;
		}
		else if(h > 12 && h < 18 && me->flag != 5) 
		{
			if(m == 0) 
			{
				if(include_holiday == true)
					is_holiday = get_holiday_text(me->id, me->text);
			
				if(is_holiday == false)
					snprintf(me->text, BUFFER_SIZE, "%s", "hapon");
				else if(h == 15)
					vibes_double_pulse();
			}
			else
			{
				snprintf(me->text, BUFFER_SIZE, "%s ng hapon", hour_text[twelve_hour]);
				me->font_size = FONT_SMALL;
			}
			
			me->flag = 5;
		}
		else if(h >= 18 && h < 24 && me->flag != 6)
		{
			if(m == 0)
			{
				if(include_holiday == true)
					is_holiday = get_holiday_text(me->id, me->text);
			
				if(is_holiday == false)
					snprintf(me->text, BUFFER_SIZE, "%s", "gabi");
				else if(h == 18)
					vibes_double_pulse();
			}
			else
			{
				snprintf(me->text, BUFFER_SIZE, "%s ng gabi", hour_text[twelve_hour]);
			}
			
			me->flag = 6;
		}
		else
		{
			has_changed = false;
		}
		
		//also, the succeeding minute (minute == 1) is still under the same condition as minute == 0
		//so we need to reset the flag to force a refresh on the text
		//this will then retrieve the "minute != 0" text	
		if(m == 0) me->flag = 0;
	}
	else
	{
		snprintf(me->text, BUFFER_SIZE, "%s", "May problema");
		me->font_size = FONT_SMALL;
	}
	
	return has_changed || force_refresh;
}

static void layer_update(layer_info *me)
{
	if(get_invert_screen_value() == true)
	{
		text_layer_set_background_color(me->layer, GColorBlack);
		text_layer_set_text_color(me->layer, GColorWhite);
	}
	else
	{
		text_layer_set_background_color(me->layer, GColorWhite);
		text_layer_set_text_color(me->layer, GColorBlack);
	}
	
	text_layer_set_text(me->layer, me->text);
	text_layer_set_font(me->layer, fonts[me->font_size]);
	text_layer_set_overflow_mode(me->layer, GTextOverflowModeWordWrap);
	text_layer_set_text_alignment(me->layer, GTextAlignmentCenter);
}

static void show_splash()
{
	if (animation.is_animating == true) return;
	
	for (int i = 0; i < LAYER_COUNT; i++) 
	{
		layers[i].text = malloc(BUFFER_SIZE);
		snprintf(layers[i].text, BUFFER_SIZE, "%s", splash_text[i]);
		
		if(i == LAYER_MODIFIER) layers[i].font_size = FONT_LARGE;
		else layers[i].font_size = FONT_SMALLEST;
		
		layer_update(&layers[i]);
	}

	is_splash_showing = true;
	animation.current_flag = false;
	animation.index = 0;
	animation.is_animating = true;
	timer = app_timer_register(SPLASH_DELAY, handle_timer, NULL);
}

static struct tm *get_time_value()
{
	time_t temp;
	time(&temp);
	
	return localtime(&temp);
}
示例#15
0
static void main_window_load(Window *window) {
    
    
    // Create GBitmap, then set to created BitmapLayer
    s_background_bitmap = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_BACKGROUND);
    s_background_layer = bitmap_layer_create(GRect(0, 0, 144, 168));
    //bitmap_layer_set_bitmap(s_background_layer, s_background_bitmap);
    
    bitmap_layer_set_background_color(s_background_layer,GColorBlack);
    
    layer_add_child(window_get_root_layer(window), bitmap_layer_get_layer(s_background_layer));
    
    Layer *window_layer = window_get_root_layer(window);
    GRect window_bounds = layer_get_bounds(window_layer);
    
    
    s_current_session_layer = text_layer_create(GRect(5, 0, 144, 40));
    
    // Create time TextLayer
    //  s_time_layer = text_layer_create(GRect(0, 55, 144, 50));
    s_time_layer = text_layer_create(GRect(5, 52, 139, 50));
    
    
    s_upcoming_session_layer = text_layer_create(GRect(5, 130, 144, 40));
    
    text_layer_set_background_color(s_time_layer, GColorClear);
    text_layer_set_text_color(s_time_layer, GColorWhite);
    
    // Create GFont
    s_time_font = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_PERFECT_DOS_48));
    
    // Apply to TextLayer
    text_layer_set_font(s_time_layer, s_time_font);
    
    
    // Improve the layout to be more like a watchface
    // text_layer_set_font(s_time_layer, fonts_get_system_font(FONT_KEY_BITHAM_42_BOLD));
    text_layer_set_text_alignment(s_time_layer, GTextAlignmentCenter);
    
    
    
    
    text_layer_set_font(s_current_session_layer, fonts_get_system_font(FONT_KEY_GOTHIC_24));
    text_layer_set_overflow_mode(s_current_session_layer, GTextOverflowModeTrailingEllipsis);
    text_layer_set_text_color(s_current_session_layer, GColorWhite);
    text_layer_set_background_color(s_current_session_layer, GColorClear);
    
    layer_add_child(window_layer, text_layer_get_layer(s_current_session_layer));
    
    
    
    text_layer_set_font(s_upcoming_session_layer, fonts_get_system_font(FONT_KEY_GOTHIC_24));
    text_layer_set_text_color(s_upcoming_session_layer, GColorWhite);
    text_layer_set_overflow_mode(s_upcoming_session_layer, GTextOverflowModeTrailingEllipsis);
    text_layer_set_background_color(s_upcoming_session_layer, GColorClear);
    
    layer_add_child(window_layer, text_layer_get_layer(s_upcoming_session_layer));
    
    
    
    char *currentSession = "                                                     ";
    char *nextSession = "                                                     ";
  
    if (persist_exists(PERSIST_VALUE_1)) {
        persist_read_string(PERSIST_VALUE_1, currentSession, 30);
    }
    
    if (persist_exists(PERSIST_VALUE_2)) {
        persist_read_string(PERSIST_VALUE_2, nextSession,30);
    }
    
    Tuplet initial_values[] = {
        TupletCString(VALUE_1, currentSession),
        TupletCString(VALUE_2, nextSession),
    };
    
    app_sync_init(&sync, sync_buffer, sizeof(sync_buffer), initial_values, ARRAY_LENGTH(initial_values),
                  sync_tuple_changed_callback, sync_error_callback, NULL);
    
    
    
    
    // Add it as a child layer to the Window's root layer
    layer_add_child(window_get_root_layer(window), text_layer_get_layer(s_time_layer));
}
void weather_layer_create(GRect frame, Window *window)
{
  // Create a new layer with some extra space to save our custom Layer infos
  weather_layer = layer_create_with_data(frame, sizeof(WeatherLayerData));
  WeatherLayerData *wld = layer_get_data(weather_layer);

  large_font = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FUTURA_30));
  small_font = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FUTURA_17));

  wld->primary_icon_size = 45;
  wld->hourly_icon_size = 30;

  // Add background layer
  wld->temp_layer_background = text_layer_create(GRect(0, 0, 144, 80));
  text_layer_set_background_color(wld->temp_layer_background, GColorCyan);
  layer_add_child(weather_layer, text_layer_get_layer(wld->temp_layer_background));

  // Primary temperature layer
  wld->primary_temp_layer = text_layer_create(GRect(2, 38, 70, 35));
  text_layer_set_background_color(wld->primary_temp_layer, GColorClear);
  text_layer_set_text_alignment(wld->primary_temp_layer, GTextAlignmentCenter);
  text_layer_set_font(wld->primary_temp_layer, large_font);
  layer_add_child(weather_layer, text_layer_get_layer(wld->primary_temp_layer));

  
  wld->h1_time_layer = text_layer_create(GRect(68, 5, 30, 20));
  text_layer_set_text_color(wld->h1_time_layer, GColorBlack);
  text_layer_set_background_color(wld->h1_time_layer, GColorClear);
  text_layer_set_text_alignment(wld->h1_time_layer, GTextAlignmentCenter);
  layer_add_child(weather_layer, text_layer_get_layer(wld->h1_time_layer));

  wld->h1_temp_layer = text_layer_create(GRect(67, 47, 38, 20));
  text_layer_set_text_color(wld->h1_temp_layer, GColorBlack);
  text_layer_set_background_color(wld->h1_temp_layer, GColorClear);
  text_layer_set_text_alignment(wld->h1_temp_layer, GTextAlignmentCenter);
  text_layer_set_font(wld->h1_temp_layer, small_font);
  layer_add_child(weather_layer, text_layer_get_layer(wld->h1_temp_layer));
  
  // Hour1 bitmap layer
  wld->h1_icon_layer = bitmap_layer_create(GRect(68, 20, wld->hourly_icon_size, wld->hourly_icon_size));
  bitmap_layer_set_background_color(wld->h1_icon_layer, GColorClear);
  layer_add_child(weather_layer, bitmap_layer_get_layer(wld->h1_icon_layer));

  
  wld->h2_time_layer = text_layer_create(GRect(108, 5, 30, 20));
  text_layer_set_text_color(wld->h2_time_layer, GColorBlack);
  text_layer_set_background_color(wld->h2_time_layer, GColorClear);
  text_layer_set_text_alignment(wld->h2_time_layer, GTextAlignmentCenter);
  layer_add_child(weather_layer, text_layer_get_layer(wld->h2_time_layer));

  wld->h2_temp_layer = text_layer_create(GRect(106, 47, 38, 20));
  text_layer_set_text_color(wld->h2_temp_layer, GColorBlack);
  text_layer_set_background_color(wld->h2_temp_layer, GColorClear);
  text_layer_set_text_alignment(wld->h2_temp_layer, GTextAlignmentCenter);
  text_layer_set_font(wld->h2_temp_layer, small_font);
  layer_add_child(weather_layer, text_layer_get_layer(wld->h2_temp_layer));
   
  // Hour2 bitmap layer
  wld->h2_icon_layer = bitmap_layer_create(GRect(107, 20, wld->hourly_icon_size, wld->hourly_icon_size));
  bitmap_layer_set_background_color(wld->h2_icon_layer, GColorClear);
  layer_add_child(weather_layer, bitmap_layer_get_layer(wld->h2_icon_layer));

  // Primary bitmap layer
  wld->primary_icon_layer = bitmap_layer_create(PRIMARY_ICON_NORMAL_FRAME);
  bitmap_layer_set_background_color(wld->primary_icon_layer, GColorClear);
  layer_add_child(weather_layer, bitmap_layer_get_layer(wld->primary_icon_layer));

  wld->loading_layer = layer_create(GRect(43, 27, 50, 20));
  layer_set_update_proc(wld->loading_layer, weather_animate_update);
  layer_add_child(weather_layer, wld->loading_layer);

  wld->primary_icons = gbitmap_create_with_resource(RESOURCE_ID_ICON_45X45);
  wld->hourly_icons  = gbitmap_create_with_resource(RESOURCE_ID_ICON_30X30);

  wld->primary_icon = NULL;
  wld->h1_icon = NULL;
  wld->h2_icon = NULL;

  layer_add_child(window_get_root_layer(window), weather_layer);
}
示例#17
0
static void initialise_ui(void) {
  s_window = window_create();
  window_set_background_color(s_window, GColorBlack);
  window_set_fullscreen(s_window, true);
  
  s_res_background_image = gbitmap_create_with_resource(RESOURCE_ID_BACKGROUND_IMAGE);
  // s_bitmaplayer_1
  s_bitmaplayer_1 = bitmap_layer_create(GRect(0, 0, 144, 168));
  bitmap_layer_set_bitmap(s_bitmaplayer_1, s_res_background_image);
  layer_add_child(window_get_root_layer(s_window), (Layer *)s_bitmaplayer_1);
  
  //background_layer
  background_layer = layer_create(GRect(0,0,144,168));
  layer_set_update_proc(background_layer, background_update);
  layer_add_child(window_get_root_layer(s_window), (Layer*)background_layer);
  
  // s_layer_1
  s_layer_1 = layer_create(GRect(0, 0, 144, 168));
  layer_set_update_proc(s_layer_1, levels_update);
  layer_add_child(window_get_root_layer(s_window), (Layer *)s_layer_1);
  
  time_layer = text_layer_create(GRect(40,90,100,40));
  text_layer_set_text(time_layer, "141.12");
  #ifdef PBL_COLOR
    text_layer_set_text_color(time_layer, GColorElectricBlue);
  #else
    text_layer_set_text_color(time_layer, GColorWhite);
  #endif
  text_layer_set_background_color(time_layer, GColorClear);
  text_layer_set_text_alignment(time_layer, GTextAlignmentRight);
  text_layer_set_font(time_layer, fonts_load_custom_font(resource_get_handle(RESOURCE_ID_METAL_GEAR_17)));
  layer_add_child(window_get_root_layer(s_window), (Layer*)time_layer);
  
  charge_layer = text_layer_create(GRect(52,115,88,21));
  text_layer_set_text(charge_layer, "CHRG");
  #ifdef PBL_COLOR
    text_layer_set_background_color(charge_layer, GColorRed);
    text_layer_set_text_color(charge_layer, GColorBlack);
  #else
    text_layer_set_background_color(charge_layer, GColorWhite);
    text_layer_set_text_color(charge_layer, GColorBlack);
  #endif
  text_layer_set_text_alignment(charge_layer, GTextAlignmentCenter);
  text_layer_set_font(charge_layer, fonts_load_custom_font(resource_get_handle(RESOURCE_ID_METAL_GEAR_16)));
  layer_add_child(window_get_root_layer(s_window), (Layer*)charge_layer);
  layer_set_hidden((Layer*)charge_layer, true);
  
  bluetooth_layer = text_layer_create(GRect(16,10,100,40));
  text_layer_set_text(bluetooth_layer, "PTT");
  #ifdef PBL_COLOR
    text_layer_set_text_color(bluetooth_layer, GColorElectricBlue);
  #else
    text_layer_set_text_color(bluetooth_layer, GColorWhite);
  #endif
  text_layer_set_background_color(bluetooth_layer, GColorClear);
  text_layer_set_font(bluetooth_layer, fonts_load_custom_font(resource_get_handle(RESOURCE_ID_METAL_GEAR_13)));
  layer_add_child(window_get_root_layer(s_window), (Layer*)bluetooth_layer);
  
  level1 = gpath_create(&LEVEL_1_POINTS);
  level2 = gpath_create(&LEVEL_2_POINTS);
  level3 = gpath_create(&LEVEL_3_POINTS);
  level4 = gpath_create(&LEVEL_4_POINTS);
  level5 = gpath_create(&LEVEL_5_POINTS);
  level6 = gpath_create(&LEVEL_6_POINTS);
  
  handle_battery(battery_state_service_peek());
  handle_bluetooth(bluetooth_connection_service_peek());
}
示例#18
0
// Program initializer
void init(void){
  // Create a window and text layer
  window = window_create();
  window_set_background_color(window, GColorBlack);
  
  // Read settings
  if (persist_exists(KEY_MILITARY_TIME)) {
    militaryTime = persist_read_bool(KEY_MILITARY_TIME);
  }
  
  if (persist_exists(KEY_TEMPC)) {
    tempC = persist_read_bool(KEY_TEMPC);
  }
  
  if (persist_exists(KEY_DATEDDMM)) {
    dateDDMM = persist_read_bool(KEY_DATEDDMM);
  }
  
  // Initialize font for time
  s_orbitron_font_36 = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_ORBITRON_LIGHT_36));
  s_orbitron_font_20 = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_ORBITRON_LIGHT_20));
  s_orbitron_font_15 = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_ORBITRON_LIGHT_15));
  
  // Initialize time angles decorations
  s_time_angles_bmp = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_TIME_ANGLES);
  s_seconds_arows_layer = bitmap_layer_create(GRect(0, 56, 144, 38));
  bitmap_layer_set_bitmap(s_seconds_arows_layer, s_time_angles_bmp);
  layer_add_child(window_get_root_layer(window), bitmap_layer_get_layer(s_seconds_arows_layer));
  
  // Initialize secnods arows decorations
  s_time_angles_bmp = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_SECOND_AROWS1);
  s_time_angles_layer = bitmap_layer_create(GRect(43, 107, 55, 5));
  bitmap_layer_set_bitmap(s_time_angles_layer, s_time_angles_bmp);
  layer_add_child(window_get_root_layer(window), bitmap_layer_get_layer(s_time_angles_layer));
  
  // Initialize hours layers
  init_text_layer(&hours_1st_layer, GRect(4, 54, 32, 36), s_orbitron_font_36);
  init_text_layer(&hours_2nd_layer, GRect(35, 54, 32, 36), s_orbitron_font_36);
  
  init_text_layer(&minutes_1st_layer, GRect(75, 54, 32, 36), s_orbitron_font_36);
  init_text_layer(&minutes_2nd_layer, GRect(105, 54, 32, 36), s_orbitron_font_36);
  
  init_text_layer(&seconds_1st_layer, GRect(53, 95, 18, 20), s_orbitron_font_20);
  init_text_layer(&seconds_2nd_layer, GRect(71, 95, 18, 20), s_orbitron_font_20);
  
  init_text_layer(&date_1st_layer, GRect(6, 140, 18, 20), s_orbitron_font_20);
  init_text_layer(&date_2nd_layer, GRect(19, 140, 28, 20), s_orbitron_font_20);
  
  init_text_layer(&date_delimiter_layer, GRect(35, 140, 28, 20), s_orbitron_font_20);
      
  init_text_layer(&date_3rd_layer, GRect(57, 140, 18, 20), s_orbitron_font_20);
  init_text_layer(&date_4th_layer, GRect(75, 140, 18, 20), s_orbitron_font_20);
  
  init_text_layer(&day_of_week_layer, GRect(98, 140, 40, 20), s_orbitron_font_20);

  // Initialize weather layer
  s_weather_layer = text_layer_create(GRect(0, -2, 144, 25));
  text_layer_set_background_color(s_weather_layer, GColorClear);
  text_layer_set_text_color(s_weather_layer, GColorWhite);
  text_layer_set_text_alignment(s_weather_layer, GTextAlignmentCenter);
  text_layer_set_font(s_weather_layer, s_orbitron_font_20);
  text_layer_set_text(s_weather_layer, "Loading...");
  layer_add_child(window_get_root_layer(window), text_layer_get_layer(s_weather_layer));
   weatherCountdown = weatherCountdownInit; // Time to re-read weather values
  
  // Initialize battery lightning
  s_battery_lightning_bmp = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_BATTERY_LIGHTNING);
  s_battery_lightning_layer = bitmap_layer_create(GRect(40, 39, 17, 14));
  bitmap_layer_set_bitmap(s_battery_lightning_layer, s_battery_lightning_bmp);
  layer_add_child(window_get_root_layer(window), bitmap_layer_get_layer(s_battery_lightning_layer));

  // Initialize battery layer
  s_battery_info_layer = text_layer_create(GRect(60, 36, 47, 25));
  text_layer_set_background_color(s_battery_info_layer, GColorClear);
  text_layer_set_text_color(s_battery_info_layer, GColorWhite);
  text_layer_set_text_alignment(s_battery_info_layer, GTextAlignmentLeft);
  text_layer_set_font(s_battery_info_layer, s_orbitron_font_15);
  text_layer_set_text(s_battery_info_layer, "--%");
  
  layer_add_child(window_get_root_layer(window), text_layer_get_layer(s_battery_info_layer));
  
  // To launch time changing handler
  time_t now = time(NULL);
  handle_timechanges(localtime(&now), SECOND_UNIT);
  
  // Subscribe to time changing events
  tick_timer_service_subscribe(SECOND_UNIT, handle_timechanges);
  
  // Push the window
  window_stack_push(window, true);

  // Register callbacks for messages system AppMessage
  app_message_register_inbox_received(inbox_received_callback);
  app_message_register_inbox_dropped(inbox_dropped_calback);
  app_message_register_outbox_failed(outbox_failed_callback);
  app_message_register_outbox_sent(outbox_sent_callback);
  
  // Register battery state callback
  battery_state_service_subscribe(battery_callback);
  battery_callback(battery_state_service_peek()); // get initial value
  
  // Open AppMessage
  app_message_open(app_message_inbox_size_maximum(), app_message_outbox_size_maximum());
}
示例#19
0
void init() {

	// Window
	window = window_create();
	window_stack_push(window, true /* Animated */);
	window_layer = window_get_root_layer(window);

	// Background image
	background_image_container = gbitmap_create_with_resource(
			RESOURCE_ID_IMAGE_BACKGROUND);
	background_layer = layer_create(GRECT_FULL_WINDOW);
	layer_set_update_proc(background_layer, &draw_background_callback);
	layer_add_child(window_layer, background_layer);

	// Date setup
	date_layer = text_layer_create(GRect(27, 115, 90, 21));
	text_layer_set_text_color(date_layer, GColorWhite);
	text_layer_set_text_alignment(date_layer, GTextAlignmentCenter);
	text_layer_set_background_color(date_layer, GColorClear);
	text_layer_set_font(date_layer, fonts_get_system_font(FONT_KEY_GOTHIC_18));
	layer_add_child(window_layer, text_layer_get_layer(date_layer));

  init_double_time();
	draw_date();
  update_double_time();

	// Status setup
	icon_battery = gbitmap_create_with_resource(RESOURCE_ID_BATTERY_ICON);
	icon_battery_charge = gbitmap_create_with_resource(RESOURCE_ID_BATTERY_CHARGE);
	icon_bt = gbitmap_create_with_resource(RESOURCE_ID_BLUETOOTH);

	BatteryChargeState initial = battery_state_service_peek();
	battery_level = initial.charge_percent;
	battery_plugged = initial.is_plugged;
	battery_layer = layer_create(GRect(5,132,24,12)); //24*12
	layer_set_update_proc(battery_layer, &battery_layer_update_callback);
	layer_add_child(window_layer, battery_layer);

	bt_ok = bluetooth_connection_service_peek();
	bt_layer = layer_create(GRect(9,147,9,12)); //9*12
	layer_set_update_proc(bt_layer, &bt_layer_update_callback);
	layer_add_child(window_layer, bt_layer);

	// Hands setup
	hour_display_layer = layer_create(GRECT_FULL_WINDOW);
	layer_set_update_proc(hour_display_layer,
			&hour_display_layer_update_callback);
	layer_add_child(window_layer, hour_display_layer);

	hour_hand_path = gpath_create(&HOUR_HAND_PATH_POINTS);
	gpath_move_to(hour_hand_path, grect_center_point(&GRECT_FULL_WINDOW));

	minute_display_layer = layer_create(GRECT_FULL_WINDOW);
	layer_set_update_proc(minute_display_layer,
			&minute_display_layer_update_callback);
	layer_add_child(window_layer, minute_display_layer);

	minute_hand_path = gpath_create(&MINUTE_HAND_PATH_POINTS);
	gpath_move_to(minute_hand_path, grect_center_point(&GRECT_FULL_WINDOW));

	center_display_layer = layer_create(GRECT_FULL_WINDOW);
	layer_set_update_proc(center_display_layer,
			&center_display_layer_update_callback);
	layer_add_child(window_layer, center_display_layer);

	second_display_layer = layer_create(GRECT_FULL_WINDOW);
	layer_set_update_proc(second_display_layer,
			&second_display_layer_update_callback);
	layer_add_child(window_layer, second_display_layer);

	// Configurable inverse
#ifdef INVERSE
	full_inverse_layer = inverter_layer_create(GRECT_FULL_WINDOW);
	layer_add_child(window_layer, inverter_layer_get_layer(full_inverse_layer));
#endif

}
示例#20
0
static void main_window_load(Window *window) {
  
  //APP_LOG(APP_LOG_LEVEL_ERROR, "In Main_window_load");
  // Use system font, apply it and add to Window
  s_3_font = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_PTN_64));
  s_2_font = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_PTN_59));
  s_4_font = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_PTN_50));
  s_6_font = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_PTN_47));
 
  
  s_title_font = fonts_get_system_font(FONT_KEY_GOTHIC_14);
  s_large_title_font = fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD);
  s_medium_title_font = fonts_get_system_font(FONT_KEY_GOTHIC_18_BOLD);

  inverter = inverter_layer_create(GRect(0,0,144,168));
  layer_set_bounds(inverter_layer_get_layer(inverter),GRectZero);
  
  flash = inverter_layer_create(GRect(2,7,7,7));
  
  int jj;
  for (jj = 0; jj < 6; jj++) {
  dataInverter[jj] = inverter_layer_create(GRect(0,0,144,168));
  layer_set_bounds(inverter_layer_get_layer(dataInverter[jj]),GRectZero);  
  }
  
  // Create Display RectAngles
  
  // Six data fields & their titles
  #define SIX_FIELD_INDEX 0
  #define SIX_FIELD_MAX 5
  s_data_layer[0] = text_layer_create(GRect(0, 2, 71, 49));
  s_data_title[0] = text_layer_create(GRect(0, 49, 71, 15));

  s_data_layer[1] = text_layer_create(GRect(73, 2, 71, 49));
  s_data_title[1] = text_layer_create(GRect(73, 49, 71, 15));
  
  s_data_layer[2] = text_layer_create(GRect(0, 53, 71, 49));
  s_data_title[2] = text_layer_create(GRect(0, 102, 71, 14));
  
  s_data_layer[3] = text_layer_create(GRect(73, 53, 71, 49));
  s_data_title[3] = text_layer_create(GRect(73, 102, 71, 14));
  
  s_data_layer[4] = text_layer_create(GRect(0, 105, 71, 49));
  s_data_title[4] = text_layer_create(GRect(0, 154, 71, 15));
  
  s_data_layer[5] = text_layer_create(GRect(73, 105, 71, 49));
  s_data_title[5] = text_layer_create(GRect(73, 154, 71, 15));
  
  // Two data fields & their titles
  #define TWO_FIELD_INDEX 6
  #define TWO_FIELD_MAX 7
  s_data_layer[6] = text_layer_create(GRect(0, 2, 288, 60));
  layer_set_frame((Layer *) s_data_layer[6], GRect(0, 2, 144, 60));
  s_data_title[6] = text_layer_create(GRect(0, 64, 144, 28));
  
  s_data_layer[7] = text_layer_create(GRect(0, 79, 288, 60));
  layer_set_frame((Layer *) s_data_layer[7], GRect(0, 79, 144, 60));
  s_data_title[7] = text_layer_create(GRect(0, 140, 144, 28));

  
  // Four data fields & their titles
  #define FOUR_FIELD_INDEX 8
  #define FOUR_FIELD_MAX 11
  s_data_layer[8] = text_layer_create(GRect(0, 12, 142, 51));
  layer_set_frame((Layer *) s_data_layer[8], GRect(0, 12, 71, 51));
  s_data_title[8] = text_layer_create(GRect(0, 65, 71, 24));
  
  s_data_layer[9] = text_layer_create(GRect(73, 12, 71, 51));
  s_data_title[9] = text_layer_create(GRect(73, 65, 71, 24));
  
  s_data_layer[10] = text_layer_create(GRect(0, 91, 142, 51));
  layer_set_frame((Layer *) s_data_layer[10], GRect(0, 91, 71, 51));
  s_data_title[10] = text_layer_create(GRect(0, 144, 71, 24));
  
  s_data_layer[11] = text_layer_create(GRect(73, 91,  71, 51));
  s_data_title[11] = text_layer_create(GRect(73, 144, 71, 24));
  
  // Three fields - One big, two small
  //#define THREE_FIELD_INDEX 12
  #define THREE_FIELD_MAX 14
  s_data_layer[12] = text_layer_create(GRect(0, 10, 432, 65));
  layer_set_frame((Layer *) s_data_layer[12], GRect(0, 10, 144, 65));
  s_data_title[12] = text_layer_create(GRect(0, 75, 144, 28));

  s_data_layer[13] = text_layer_create(GRect(0, 91, 150, 51));
  layer_set_frame((Layer *) s_data_layer[13], GRect(0, 91, 71, 51));
  s_data_title[13] = text_layer_create(GRect(0, 144, 71, 24));
  
  
  //s_data_layer[14] = text_layer_create(GRect(73, 91, 142, 51));
  //layer_set_frame((Layer *) s_data_layer[14], GRect(73, 91, 71, 51));
  s_data_layer[14] = text_layer_create(GRect(73, 91,  71, 51));
  s_data_title[14] = text_layer_create(GRect(73, 144, 71, 24));
  
  
  // Top title
  s_data_layer[TITLE_INDEX] = text_layer_create(GRect(0, 0, 144, 16));
  
  

  // Set up top title area
    text_layer_set_background_color(s_data_layer[TITLE_INDEX], GColorBlack);
    text_layer_set_text_color(s_data_layer[TITLE_INDEX], GColorWhite);
    text_layer_set_text_alignment(s_data_layer[TITLE_INDEX], GTextAlignmentCenter);
    text_layer_set_text(s_data_layer[TITLE_INDEX], "StartLine");
    text_layer_set_font(s_data_layer[TITLE_INDEX], s_title_font);
    layer_add_child(window_get_root_layer(window), text_layer_get_layer(s_data_layer[TITLE_INDEX])); 
 
  window_set_background_color(window, GColorBlack);
  // Set up the messgage layer
  messageLayer = text_layer_create(GRect(10,30,124,120));
  text_layer_set_background_color(messageLayer, GColorClear);
  text_layer_set_text_color(messageLayer, GColorWhite);
  text_layer_set_text_alignment(messageLayer, GTextAlignmentCenter);
  text_layer_set_font(messageLayer, s_large_title_font);
  
  

  
  titleLayer = layer_create(GRect(0, 0, 144, 168));
  layer_insert_below_sibling(titleLayer, (Layer *)s_data_layer[TITLE_INDEX]);
  
  
  dataLayer = layer_create(GRect(0, 0, 144, 168));
  layer_insert_below_sibling(dataLayer, titleLayer); 
 
  
  int i;
  for (i =0; i < TITLE_INDEX; i++)
    {
    //Data

    text_layer_set_background_color(s_data_layer[i], GColorClear);
    text_layer_set_text_color(s_data_layer[i], GColorWhite);
    text_layer_set_text_alignment(s_data_layer[i], GTextAlignmentCenter);
    text_layer_set_overflow_mode(s_data_layer[i], GTextOverflowModeWordWrap);
    layer_add_child(dataLayer, text_layer_get_layer(s_data_layer[i]));
    
    //Title

    text_layer_set_background_color(s_data_title[i], GColorClear);
    text_layer_set_text_color(s_data_title[i], GColorWhite);
    text_layer_set_text_alignment(s_data_title[i], GTextAlignmentCenter);
    
    if (i >= SIX_FIELD_INDEX && i <= SIX_FIELD_MAX) // Small title fonts on the 6 field layout
      {
      text_layer_set_font(s_data_layer[i], s_6_font);    
      text_layer_set_font(s_data_title[i], s_title_font);
    }
    else if (i >= TWO_FIELD_INDEX && i <= TWO_FIELD_MAX) // This is 2 fields
      {
      text_layer_set_font(s_data_layer[i], s_2_font); 
      text_layer_set_font(s_data_title[i], s_large_title_font);
    }

    else if (i >= FOUR_FIELD_INDEX && i <= FOUR_FIELD_MAX) // 4 field layout
      {
      text_layer_set_font(s_data_layer[i], s_4_font); 
      text_layer_set_font(s_data_title[i], s_medium_title_font);
    }
    else if (i >= THREE_FIELD_INDEX && i <= THREE_FIELD_MAX)
      {
      if (i == THREE_FIELD_INDEX) // First field is big
        {
        text_layer_set_font(s_data_layer[i], s_3_font); 
        text_layer_set_font(s_data_title[i], s_large_title_font);
      } else
        {
        text_layer_set_font(s_data_layer[i], s_4_font);    
        text_layer_set_font(s_data_title[i], s_medium_title_font);        
      }
    }      
   
    layer_add_child(titleLayer, text_layer_get_layer(s_data_title[i]));
    
  }
  
 layer_add_child(window_get_root_layer(window), inverter_layer_get_layer(inverter));


  int ii;
  for (ii = 0; ii < 6; ii++) {
     layer_add_child(window_get_root_layer(window), inverter_layer_get_layer(dataInverter[ii]));
  }
  layer_add_child(window_get_root_layer(window), text_layer_get_layer(messageLayer)); 

   layer_add_child(window_get_root_layer(window), inverter_layer_get_layer(flash));

  
  // Go find a screen with some fields in use
  for (currentScreen = 0; screens[currentScreen].num_fields == 0; currentScreen++)
    ;

  // Add the padlock icon - steals the rest of my heap!!
  s_padlockLayer = bitmap_layer_create(GRect(133, 3, 8, 11));
  s_res_padlock = gbitmap_create_with_resource(RESOURCE_ID_PADLOCK);
  bitmap_layer_set_bitmap(s_padlockLayer, s_res_padlock);
  layer_add_child(window_get_root_layer(window), (Layer *)s_padlockLayer);
  layer_set_hidden((Layer *)s_padlockLayer, configLock == 1);
  
  // And make it the current screen
  updatescreen(currentScreen,"00");
}
示例#21
0
static void window_load(Window *window) {
    Layer *window_layer = window_get_root_layer(window);
    GRect bounds = layer_get_bounds(window_layer);
    //for GOTHIC_18_BOLD:
    //int textWidth = bounds.size.w / 3 - 4; //slightly less (for margin) than half screen width
    //for GOTHIC_24_BOLD:
    int textWidth = bounds.size.w / 2 - 4; //slightly less (for margin) than half screen width

    //1. Base layer contains coloured analogue watch face
    s_simple_bg_layer = layer_create(bounds);
    layer_set_update_proc(s_simple_bg_layer, bg_update_proc);
    layer_add_child(window_layer, s_simple_bg_layer);

    //2. 2nd layer contains date & hour text
    s_date_layer = layer_create(bounds);
    layer_set_update_proc(s_date_layer, date_update_proc);
    layer_add_child(window_layer, s_date_layer);

    //s_day_label = text_layer_create(GRect(46, 114, textWidth, 40));
    s_day_label = text_layer_create(GRect(46, 114, textWidth, 60));
    text_layer_set_text(s_day_label, s_day_buffer);
    text_layer_set_background_color(s_day_label, GColorClear);
    text_layer_set_text_color(s_day_label, GColorWhite);
    text_layer_set_font(s_day_label, fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD));
    text_layer_set_text_alignment(s_day_label, GTextAlignmentCenter);
    layer_add_child(s_date_layer, text_layer_get_layer(s_day_label));

    //1st 4 layers are for the text outline, last layer (topmost) is the text itself
    int i;
    for (i = 0; i < 5; ++i)
    {
        s_hour_label[i] = text_layer_create(GRect(OFFSET_OUTLINE[i][0], OFFSET_OUTLINE[i][1], 40, 32));
        text_layer_set_text(s_hour_label[i], s_hour_buffer);
        text_layer_set_background_color(s_hour_label[i], GColorClear);
        //text_layer_set_background_color(s_hour_label[i], GColorOrange); //DEBUG positioning of label
        text_layer_set_text_color(s_hour_label[i], GColorWhite);
        text_layer_set_font(s_hour_label[i], fonts_get_system_font(FONT_KEY_BITHAM_30_BLACK)); //FONT_KEY_GOTHIC_28_BOLD));
        text_layer_set_text_alignment(s_hour_label[i], GTextAlignmentCenter);
        layer_add_child(s_date_layer, text_layer_get_layer(s_hour_label[i]));
    }

    //3. 3rd layer contains the bluetooth & battery indicator
    s_spoke_layer = layer_create(bounds);
    layer_set_update_proc(s_spoke_layer, spoke_update_proc);
    layer_add_child(window_layer, s_spoke_layer);

    //4. Weather pic layer
    m_sLayerWeather = layer_create(bounds);
    layer_add_child(window_layer, m_sLayerWeather);
    m_spbmLayerW = bitmap_layer_create(GRect(0, -11, bounds.size.w, bounds.size.h)); //bounds);
    m_spbmPicWeather = gbitmap_create_with_resource(WEATHER_ICONS + m_nIconId);
    m_spbmPicWeatherDark = gbitmap_create_with_resource(WEATHER_ICONS_DARK + m_nIconId);
    bitmap_layer_set_background_color(m_spbmLayerW, GColorClear);
    bitmap_layer_set_compositing_mode(m_spbmLayerW, GCompOpSet);
    setWeatherIcon();
    layer_add_child(m_sLayerWeather, bitmap_layer_get_layer(m_spbmLayerW));
    layer_set_hidden(m_sLayerWeather, true);
    m_stxtWeather = text_layer_create(GRect(36, 85, textWidth, 60));
    text_layer_set_text(m_stxtWeather, m_szTemp);
    text_layer_set_background_color(m_stxtWeather, GColorClear);
    text_layer_set_text_color(m_stxtWeather, GColorWhite);
    text_layer_set_font(m_stxtWeather, fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD));
    text_layer_set_text_alignment(m_stxtWeather, GTextAlignmentCenter);
    layer_add_child(m_sLayerWeather, text_layer_get_layer(m_stxtWeather));
    layer_set_update_proc(m_sLayerWeather, weather_update_proc);

    //5. Surprise pic layer
    m_spbmLayer = bitmap_layer_create(bounds);
    for (i = 0; i < MAX_PICS; ++i)
    {
        m_spbmPics[i] = gbitmap_create_with_resource(PIC_ID[i]);
    }
    bitmap_layer_set_background_color(m_spbmLayer, GColorClear);
    bitmap_layer_set_compositing_mode(m_spbmLayer, GCompOpSet);
    bitmap_layer_set_bitmap(m_spbmLayer, m_spbmPics[0]);
    layer_add_child(window_layer, bitmap_layer_get_layer(m_spbmLayer));
}
示例#22
0
void SetTextLayerColor(TextLayer* TLLayer)
{
  text_layer_set_background_color(TLLayer, GColorBlack);
  text_layer_set_text_color(TLLayer, GColorClear);
}
示例#23
0
/* Initializes the watchface */
void handle_init(void) {
  window = window_create();
  window_set_background_color(window, GColorBlack);
  
  app_message_register_inbox_received((AppMessageInboxReceived) in_recv_handler);
  app_message_open(app_message_inbox_size_maximum(), app_message_outbox_size_maximum());
  /*
  bool user_zero = persist_read_bool(KEY_ZERO);
  bool user_battery = persist_read_bool(KEY_BATTERY);
  bool user_bluetooth = persist_read_bool(KEY_BLUETOOTH);
  */
  /* Sets the custom fonts as resources. */
  GFont abadi_62 = 
    fonts_load_custom_font(resource_get_handle(RESOURCE_ID_ARIAL_NARROW_BOLD_69));
  GFont abadi_24 =
    fonts_load_custom_font(resource_get_handle(RESOURCE_ID_ABADI_CONDENSED_20));
  
  /* Sets the transparent image as a resource. */
  bt_white_image = gbitmap_create_with_resource(RESOURCE_ID_WARNING_SIGN_WHITE);
//  bt_black_image = gbitmap_create_with_resource(RESOURCE_ID_WARNING_SIGN_BLACK);
  
  //HOUR LAYER
  hour_layer = text_layer_create(GRect(0,0, 82, 84));
  text_layer_set_font(hour_layer, abadi_62);
  text_layer_set_text_alignment(hour_layer, GTextAlignmentRight);
  text_layer_set_background_color(hour_layer, GColorBlack);
  text_layer_set_text_color(hour_layer, GColorWhite);
  
  layer_add_child(window_get_root_layer(window), text_layer_get_layer(hour_layer));
  
  //MINUTE LAYER
  min_layer = text_layer_create(GRect(64, 80, 80, 88));
  text_layer_set_font(min_layer, abadi_62);
  text_layer_set_text_alignment(min_layer, GTextAlignmentLeft);
  text_layer_set_background_color(min_layer, GColorBlack);
  text_layer_set_text_color(min_layer, GColorWhite);
  
  layer_add_child(window_get_root_layer(window), text_layer_get_layer(min_layer));
  
  //AM PM LAYER
  am_layer = text_layer_create(GRect(82, 32, 62, 36));
  text_layer_set_font(am_layer, abadi_24);
  text_layer_set_text_alignment(am_layer, GTextAlignmentCenter);
  text_layer_set_background_color(am_layer, GColorBlack);
  text_layer_set_text_color(am_layer, GColorWhite);
  
  layer_add_child(window_get_root_layer(window), text_layer_get_layer(am_layer));
  
  //DATE LAYER
  date_layer = text_layer_create(GRect(0, 102, 64, 84));  //Manually centered vertically
  text_layer_set_font(date_layer, abadi_24);
  text_layer_set_text_alignment(date_layer, GTextAlignmentCenter);
  text_layer_set_background_color(date_layer, GColorBlack);
  text_layer_set_text_color(date_layer, GColorWhite);
  
  layer_add_child(window_get_root_layer(window), text_layer_get_layer(date_layer));
  
  //BATTERY PERCENTAGE LAYER
  battery_layer = text_layer_create(GRect(0, 0, 0, 0)); //Creates the battery layer
  text_layer_set_background_color(battery_layer, GColorWhite);
  layer_add_child(window_get_root_layer(window), text_layer_get_layer(battery_layer));
  
  //IMAGE LAYERS
  /* Uses GCompOpOr to display white portions of image */
  bt_white_image_layer = bitmap_layer_create(GRect(82, 28, 62, 36)); //Matches am_layer, removes text buffer of 4 px
  bitmap_layer_set_bitmap(bt_white_image_layer, bt_white_image);
  bitmap_layer_set_alignment(bt_white_image_layer, GAlignCenter);
  bitmap_layer_set_background_color(bt_white_image_layer, GColorBlack);
  bitmap_layer_set_compositing_mode(bt_white_image_layer, GCompOpOr);
  
  layer_add_child(window_get_root_layer(window), bitmap_layer_get_layer(bt_white_image_layer));
  
  /* Uses GCompOpOr to display black portions of image */
  /*
  bt_black_image_layer = bitmap_layer_create(GRect(82, 32, 62, 36)); //Matches am_layer
  bitmap_layer_set_bitmap(bt_black_image_layer, bt_white_image);
  bitmap_layer_set_alignment(bt_black_image_layer, GAlignCenter);
  bitmap_layer_set_compositing_mode(bt_black_image_layer, GCompOpOr);
  layer_add_child(window_get_root_layer(window), bitmap_layer_get_layer(bt_black_image_layer));
  */
  
  if(settings.bluetoothWarning == 1){
  update_bluetooth_state(bluetooth_connection_service_peek());
  bluetooth_connection_service_subscribe(update_bluetooth_state);
  }
  
  if(settings.batteryBar == 1){
  update_battery_state(battery_state_service_peek()); 
  battery_state_service_subscribe(update_battery_state);
  }
  
  //TIME CHANGES
  /* Call the function to update time upon starting the watchface */
  time_t now = time(NULL);
  
  handle_timechanges(localtime(&now), MINUTE_UNIT | HOUR_UNIT);
  //handle_hourchanges(localtime(&now), HOUR_UNIT);
  
  /* Every minute, calls the handle_timechanges function */
  tick_timer_service_subscribe(MINUTE_UNIT, handle_timechanges);  
  
  window_stack_push(window, true);
}
示例#24
0
DateTimeLayer* date_time_layer_create(Watchface* watchface) {
    DateTimeLayer* date_time_layer = malloc(sizeof(DateTimeLayer));
    date_time_layer->watchface = watchface;
    
    GRect frame = layer_get_frame(watchface_get_layer(watchface));
    
    date_time_layer->layer = layer_create(frame);
    
    default_time_frame = GRect(0, 2, frame.size.w, frame.size.h-6);
    default_date_frame = GRect(1, 74, frame.size.w, frame.size.h-62);
    nudged_up_date_frame = GRect(
        default_date_frame.origin.x, default_date_frame.origin.y - 8,
        default_date_frame.size.w,   default_date_frame.size.h
    );
    if(HAS_LIGHT_WEATHER) {
        default_date_frame = nudged_up_date_frame;
    }
    
    date_time_layer->time_layer = text_layer_create(default_time_frame);
    date_time_layer->date_layer = text_layer_create(default_date_frame);
    
    text_layer_set_text_alignment(
        date_time_layer->time_layer, GTextAlignmentCenter
    );
    text_layer_set_background_color(
        date_time_layer->time_layer, GColorClear
    );
    text_layer_set_text_color(
        date_time_layer->time_layer, GColorWhite
    );
    text_layer_set_font(
        date_time_layer->time_layer, watchface_get_fonts(watchface)->futura_53
    );
    text_layer_set_text(date_time_layer->time_layer, "(null)");
    
    text_layer_set_text_alignment(
        date_time_layer->date_layer, GTextAlignmentCenter
    );
    text_layer_set_background_color(
        date_time_layer->date_layer, GColorClear
    );
    text_layer_set_text_color(
        date_time_layer->date_layer, GColorWhite
    );
    text_layer_set_font(
        date_time_layer->date_layer, watchface_get_fonts(watchface)->futura_18
    );
    
    layer_add_child(
        date_time_layer->layer,
        text_layer_get_layer(date_time_layer->time_layer)
    );
    layer_add_child(
        date_time_layer->layer,
        text_layer_get_layer(date_time_layer->date_layer)
    );
    
    date_time_layer_update_frame(date_time_layer);
    
    return date_time_layer;
}
示例#25
0
void BuildWindow(bool Text_Size){
	MainWindow = window_create();
	
	/*BT Icon*/
	BT = gbitmap_create_with_resource(RESOURCE_ID_BT_ICON);
	BT_Image = bitmap_layer_create(GRect(0, 2, 16, 16));
	bitmap_layer_set_bitmap(BT_Image, BT);
  	layer_add_child(window_get_root_layer(MainWindow), bitmap_layer_get_layer(BT_Image));
	
	/*Battery Icon*/
	BAT = gbitmap_create_with_resource(RESOURCE_ID_BAT_ICON_100);
	BAT_Image = bitmap_layer_create(GRect(127, 2, 16, 16));
	bitmap_layer_set_bitmap(BAT_Image, BAT);
  	layer_add_child(window_get_root_layer(MainWindow), bitmap_layer_get_layer(BAT_Image));
	
	/*Battery percent Text*/
	Bar_Font = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_IMAGINE_TIME_12));
  	Battery_Text = text_layer_create(GRect(16, 2, 112, 16));
	text_layer_set_text_alignment(Battery_Text, GTextAlignmentRight);
	text_layer_set_font(Battery_Text, Bar_Font);
	text_layer_set_background_color(Battery_Text, GColorClear);
	layer_add_child(window_get_root_layer(MainWindow), text_layer_get_layer(Battery_Text));
	
	/*Bluetooth connection percent Text*/
  	Connection_Text = text_layer_create(GRect(17, 2, 124, 16));
	text_layer_set_text_alignment(Connection_Text, GTextAlignmentLeft);
	text_layer_set_font(Connection_Text, Bar_Font);
	text_layer_set_background_color(Connection_Text, GColorClear);
	layer_add_child(window_get_root_layer(MainWindow), text_layer_get_layer(Connection_Text));
	
	/*Week Day Text*/
	Date_Font = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_IMAGINE_TIME_17));
	if (Text_Size)
		Week_Text = text_layer_create(GRect(0, 29, 145, 30)); //20 40
	else
    	Week_Text = text_layer_create(GRect(0, 34, 145, 30)); //20 40
	text_layer_set_text_alignment(Week_Text, GTextAlignmentCenter);
	text_layer_set_font(Week_Text, Date_Font);
	text_layer_set_background_color(Week_Text, GColorClear);
	layer_add_child(window_get_root_layer(MainWindow), text_layer_get_layer(Week_Text));
	
	/*Time Text*/
	
	if (Text_Size){	// large font 
		Time_Font = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_IMAGINE_BIG_43));
  		Time_Text = text_layer_create(GRect(2, 38, 145, 50)); //34
		text_layer_set_text_alignment(Time_Text, GTextAlignmentCenter);
		text_layer_set_font(Time_Text, Time_Font);
		text_layer_set_background_color(Time_Text, GColorClear);
		layer_add_child(window_get_root_layer(MainWindow), text_layer_get_layer(Time_Text));
	}
	
	else {
		Time_Font = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_IMAGINE_TIME_37));
  		Time_Text = text_layer_create(GRect(0, 46, 145, 50)); //34
		text_layer_set_text_alignment(Time_Text, GTextAlignmentCenter);
		text_layer_set_font(Time_Text, Time_Font);
		text_layer_set_background_color(Time_Text, GColorClear);
		layer_add_child(window_get_root_layer(MainWindow), text_layer_get_layer(Time_Text));
	}
	/*Date Text*/
	if (Text_Size)
		Date_Text = text_layer_create(GRect(0, 90, 145, 25)); //75  95
	else
		Date_Text = text_layer_create(GRect(0, 88, 145, 25)); //75  95
	text_layer_set_text_alignment(Date_Text, GTextAlignmentCenter);
	text_layer_set_font(Date_Text, Date_Font);
	text_layer_set_background_color(Date_Text, GColorClear);
	layer_add_child(window_get_root_layer(MainWindow), text_layer_get_layer(Date_Text));
	
	/*Current weather Text*/
	CWeather_Font = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_IMAGINE_TIME_14));
	CWeather_Text = text_layer_create(GRect(0, 147, 145, 25)); //105
	text_layer_set_text_alignment(CWeather_Text, GTextAlignmentCenter);
	text_layer_set_font(CWeather_Text, CWeather_Font);
	text_layer_set_background_color(CWeather_Text, GColorClear);
	layer_add_child(window_get_root_layer(MainWindow), text_layer_get_layer(CWeather_Text));

	/*Addiditonal String*/
	
	AddInfo_Text = text_layer_create(GRect(0, 129, 145, 18));
	text_layer_set_text_alignment(AddInfo_Text, GTextAlignmentCenter);
	text_layer_set_font(AddInfo_Text, CWeather_Font);
	layer_add_child(window_get_root_layer(MainWindow), text_layer_get_layer(AddInfo_Text));
	text_layer_set_background_color(AddInfo_Text, GColorClear);
}
示例#26
0
static void main_window_load(Window *window) {
	// Get information about the Window
	Layer *window_layer = window_get_root_layer(window);
	GRect bounds = layer_get_bounds(window_layer);

	// Create Layers
	s_time_textLayer = text_layer_create(
	    GRect(0, PBL_IF_ROUND_ELSE(58, 52), bounds.size.w, 50));
	s_weather_textLayer = text_layer_create(
		GRect(PBL_IF_ROUND_ELSE(65, 5), PBL_IF_ROUND_ELSE(0, 2), PBL_IF_ROUND_ELSE(70, bounds.size.w), 50));
	s_dayOfWeek_textLayer = text_layer_create(
		GRect(PBL_IF_ROUND_ELSE(30, -5), PBL_IF_ROUND_ELSE(25, 2), bounds.size.w, 50));
	s_date_textLayer = text_layer_create(
		GRect(0, PBL_IF_ROUND_ELSE(105, 115), PBL_IF_ROUND_ELSE(bounds.size.w-31, bounds.size.w-3), 50));
	// UI Layers
	s_ui_top = text_layer_create(
		GRect(0,0,bounds.size.w,PBL_IF_ROUND_ELSE(70,52)));
	s_ui_bottom = text_layer_create(
		GRect(0,PBL_IF_ROUND_ELSE(110,117),bounds.size.w,100));

	// Setup Background colors
	text_layer_set_background_color(s_time_textLayer, 		GColorClear);
	text_layer_set_background_color(s_weather_textLayer, 	GColorClear);
	text_layer_set_background_color(s_dayOfWeek_textLayer,	GColorClear);
	text_layer_set_background_color(s_date_textLayer,		GColorClear);

	// Setup Text Colors
	text_layer_set_text_color(s_time_textLayer, 			GColorBlack);
	text_layer_set_text_color(s_weather_textLayer,			GColorWhite);
	text_layer_set_text_color(s_dayOfWeek_textLayer,		GColorWhite);
	text_layer_set_text_color(s_date_textLayer,				GColorWhite);

	// Setup Font Styles
	time_font = fonts_get_system_font(FONT_KEY_ROBOTO_BOLD_SUBSET_49);
	nonTime_font = fonts_get_system_font(FONT_KEY_BITHAM_42_LIGHT);
	text_layer_set_font(s_time_textLayer, time_font);
	// text_layer_set_font(s_time_textLayer, s_time_gfont);
	text_layer_set_font(s_weather_textLayer, nonTime_font);
	text_layer_set_font(s_dayOfWeek_textLayer, nonTime_font);
	text_layer_set_font(s_date_textLayer, nonTime_font);

	// Format Text alignments
	text_layer_set_text_alignment(s_time_textLayer, 		GTextAlignmentCenter);
	text_layer_set_text_alignment(s_weather_textLayer,		GTextAlignmentRight);
	text_layer_set_text_alignment(s_dayOfWeek_textLayer,	GTextAlignmentLeft);
	text_layer_set_text_alignment(s_date_textLayer,			GTextAlignmentRight);

	// Optionally, Add Text to the layer as a placeholder
	text_layer_set_text(s_weather_textLayer, "...");
		
	// Perform Color Changes!
	#if defined(PBL_BW)
		text_layer_set_background_color(s_ui_top,				GColorBlack);
		text_layer_set_background_color(s_ui_bottom,			GColorBlack);
  	#elif defined(PBL_COLOR)
	    // Accent Color Setting
	    int red_accent = persist_read_int(KEY_COLOR_RED_ACCENT);
	    int green_accent = persist_read_int(KEY_COLOR_GREEN_ACCENT);
	    int blue_accent = persist_read_int(KEY_COLOR_BLUE_ACCENT);

	    // APP_LOG(APP_LOG_LEVEL_INFO, "color is %d". bg_color_accent);
		// APP_LOG(APP_LOG_LEVEL_INFO, "accent color is rgb %d %d %d", red_accent, green_accent,blue_accent);
	    if(red_accent >= 0 && green_accent >= 0 && blue_accent >= 0) {
	    	GColor bg_color_accent = GColorFromRGB(red_accent, green_accent, blue_accent);
	    	
	    	text_layer_set_background_color(s_ui_top, bg_color_accent);
	    	text_layer_set_background_color(s_ui_bottom, bg_color_accent);
	    	text_layer_set_text_color(s_dayOfWeek_textLayer, gcolor_is_dark(bg_color_accent) ? GColorWhite : GColorBlack);
	    	text_layer_set_text_color(s_date_textLayer, gcolor_is_dark(bg_color_accent) ? GColorWhite : GColorBlack);
	    	text_layer_set_text_color(s_weather_textLayer, gcolor_is_dark(bg_color_accent) ? GColorWhite : GColorBlack);
	    }
	    // Time Color Setting
	    int red_time = persist_read_int(KEY_COLOR_RED_TIME);
	    int green_time = persist_read_int(KEY_COLOR_GREEN_TIME);
	    int blue_time = persist_read_int(KEY_COLOR_BLUE_TIME);

	    if(red_time >= 0 && green_time >= 0 && blue_time >= 0) {
	    	GColor bg_color_time = GColorFromRGB(red_time, green_time, blue_time);
	    	
	    	window_set_background_color(s_main_window, bg_color_time);
	    	text_layer_set_text_color(s_time_textLayer, gcolor_is_dark(bg_color_time) ? GColorWhite : GColorBlack);
	    }
    #endif

	// UI
	layer_add_child(window_layer, text_layer_get_layer(s_ui_top));
	layer_add_child(window_layer, text_layer_get_layer(s_ui_bottom));
	// Add Layers as Children to window.
	layer_add_child(window_layer, text_layer_get_layer(s_time_textLayer));
	layer_add_child(window_layer, text_layer_get_layer(s_weather_textLayer));
	layer_add_child(window_layer, text_layer_get_layer(s_dayOfWeek_textLayer));
	layer_add_child(window_layer, text_layer_get_layer(s_date_textLayer));
	// Don't forget to destroy all layers below.
}
示例#27
0
static void init(void) {

  // Create window
  window = window_create();
  window_stack_push(window, true);

  // Set background as black
  window_set_background_color(window, GColorBlack);

  window_layer = window_get_root_layer(window);
 
  // Get the frame of the window and its bounds
  GRect frame = layer_get_frame(window_layer);
  GRect bounds = layer_get_bounds(window_layer);

  // Set the image as bluetooth.png from resources folder and defined in appinfo 
  bluetooth_image = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_BLUETOOTH);
  // Create the layer to host the image
  bluetooth_layer = bitmap_layer_create(GRect(0,0,40,31));
  // Set the image into the layer
  bitmap_layer_set_bitmap(bluetooth_layer, bluetooth_image);

  battery_text_layer = text_layer_create(GRect(70,3,30,25));
  text_layer_set_text_color(battery_text_layer, GColorWhite);
  text_layer_set_background_color(battery_text_layer, GColorClear);
  text_layer_set_text_alignment(battery_text_layer, GTextAlignmentCenter);
  text_layer_set_font(battery_text_layer, fonts_get_system_font(FONT_KEY_GOTHIC_18_BOLD));

  battery_image = gbitmap_create_with_resource(IMAGE_BATTERY_RESOURCE_IDS[0]);
  battery_layer = bitmap_layer_create(GRect(100,0,40,31));
  bitmap_layer_set_bitmap(battery_layer, battery_image);


  background_image = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_BACKGROUND);
  background_layer = bitmap_layer_create(GRect(0,30,frame.size.w,51));
  bitmap_layer_set_alignment(background_layer, GAlignCenter); 
  bitmap_layer_set_bitmap(background_layer, background_image);


  number_day = text_layer_create(GRect(00,80,frame.size.w,114));
  text_layer_set_text_color(number_day, GColorWhite);
  text_layer_set_background_color(number_day, GColorClear);
  text_layer_set_text_alignment(number_day,GTextAlignmentCenter);
  text_layer_set_font(number_day,
      fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_HALO_SUBSET_28)));


  month_layer = text_layer_create(GRect(00, 105, frame.size.w ,114));
  text_layer_set_text_color(month_layer, GColorWhite);
  text_layer_set_background_color(month_layer, GColorClear);
  text_layer_set_text_alignment(month_layer,GTextAlignmentCenter);
  // Font size = 22
  text_layer_set_font(month_layer,
      fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_HALO_SUBSET_22)));


  // Create layer in position (x,y)=(00,130) with size (width, height)= width of the window, 114px height
  time_layer = text_layer_create(GRect(00 /* posicion  x */,
                                       130 /* posicion y*/,
                                       frame.size.w /* ancho */,
                                       114 /* alto */));
  // Set the color of the text as white
  text_layer_set_text_color(time_layer, GColorWhite);
  // Set the background as transparent
  text_layer_set_background_color(time_layer, GColorClear);
  // Align the text in center
  text_layer_set_text_alignment(time_layer,GTextAlignmentCenter);

  // Set the font of the text as a custom one found in the resources folder and defined in appinfo.json
  // with size = 28
  text_layer_set_font(time_layer,
      fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_HALO_SUBSET_28)));


  // Layer that inverts the color of everything above
  inverter_layer = inverter_layer_create(bounds);

  // Get current time
  time_t now = time(NULL);  
  struct tm *current_time = localtime(&now);

  //Subscribe to services. Refresh time every minute
  handle_second_tick(current_time, MINUTE_UNIT);
  tick_timer_service_subscribe(MINUTE_UNIT, &handle_second_tick);
  battery_state_service_subscribe(&handle_battery);
  bluetooth_connection_service_subscribe(&handle_bluetooth);
  handle_bluetooth(bluetooth_connection_service_peek());
  handle_battery(battery_state_service_peek());

  layer_add_child(window_layer, bitmap_layer_get_layer(background_layer));
  layer_add_child(window_layer, text_layer_get_layer(time_layer));
  layer_add_child(window_layer, text_layer_get_layer(month_layer));
  layer_add_child(window_layer, text_layer_get_layer(number_day));
  layer_add_child(window_layer, bitmap_layer_get_layer(bluetooth_layer));
  layer_add_child(window_layer, text_layer_get_layer(battery_text_layer));
  layer_add_child(window_layer, bitmap_layer_get_layer(battery_layer));
  layer_add_child(window_layer, inverter_layer_get_layer(inverter_layer));
}
示例#28
0
static void inbox_received_callback(DictionaryIterator *iterator, void *context) {
	// Weather -------------------------------------------------------------------
	static char temperature_buffer[8];
	static char weather_layer_buffer[8];
	int temperature = 0;
	Tuple *temp_tuple = dict_find(iterator, KEY_TEMPERATURE);
	static int temp_in_c;
	if( temp_tuple ) {
		temp_in_c = (int)temp_tuple->value->int32;
		if( persist_read_bool(KEY_WEATHER_UNIT) == true ) {
			temperature = convert_to_fahrenheit(temp_in_c);
		} else {
			temperature = temp_in_c;
		}
	}
	Tuple *unit_tuple = dict_find(iterator, KEY_WEATHER_UNIT);
	if( unit_tuple && unit_tuple->value->int8 > 0 ) {
		// USE CELCIOUS UNITS
		persist_write_bool(KEY_WEATHER_UNIT, false);
		APP_LOG(APP_LOG_LEVEL_INFO, "Callback: Units are C\n");
		temperature = temp_in_c;
	} else if( unit_tuple && unit_tuple->value->int8 <= 0 ) {
		// USEFARIENHEIT
		persist_write_bool(KEY_WEATHER_UNIT, true);
		APP_LOG(APP_LOG_LEVEL_INFO, "Callback: Units are F\n");
		temperature = convert_to_fahrenheit(temp_in_c);
	}
	snprintf(temperature_buffer, sizeof(temperature_buffer), "%d", temperature);
	snprintf(weather_layer_buffer, sizeof(weather_layer_buffer), "%s°", temperature_buffer);
	text_layer_set_text(s_weather_textLayer, weather_layer_buffer);
	// End Weather ---------------------------------------------------------------

	// Configuration -------------------------------------------------------------
	// Color ===================
	#if defined(PBL_COLOR)
	  Tuple *color_red_accent = dict_find(iterator, KEY_COLOR_RED_ACCENT);
	  Tuple *color_green_accent = dict_find(iterator, KEY_COLOR_GREEN_ACCENT);
	  Tuple *color_blue_accent = dict_find(iterator, KEY_COLOR_BLUE_ACCENT);
	  Tuple *color_red_time = dict_find(iterator, KEY_COLOR_RED_TIME);
	  Tuple *color_green_time = dict_find(iterator, KEY_COLOR_GREEN_TIME);
	  Tuple *color_blue_time = dict_find(iterator, KEY_COLOR_BLUE_TIME);
	  if(color_red_accent && color_green_accent && color_blue_accent) {
	    // Apply the color if available
	  
	    int red_accent = color_red_accent->value->int32;
	    int green_accent = color_green_accent->value->int32;
	    int blue_accent = color_blue_accent->value->int32;

	    // Persist values
	    persist_write_int(KEY_COLOR_RED_ACCENT, red_accent);
	    persist_write_int(KEY_COLOR_GREEN_ACCENT, green_accent);
	    persist_write_int(KEY_COLOR_BLUE_ACCENT, blue_accent);

	    GColor bg_color_accent = GColorFromRGB(red_accent, green_accent, blue_accent);
	    text_layer_set_background_color(s_ui_top, bg_color_accent);
	    text_layer_set_background_color(s_ui_bottom, bg_color_accent);

	    text_layer_set_text_color(s_dayOfWeek_textLayer, gcolor_is_dark(bg_color_accent) ? GColorWhite : GColorBlack);
	    text_layer_set_text_color(s_date_textLayer, gcolor_is_dark(bg_color_accent) ? GColorWhite : GColorBlack);
	    text_layer_set_text_color(s_weather_textLayer, gcolor_is_dark(bg_color_accent) ? GColorWhite : GColorBlack);
	  }
	  
	  if(color_red_time && color_green_time && color_blue_time) {
	    // Apply the color if available
	    int red_time = color_red_time->value->int32;
	    int green_time = color_green_time->value->int32;
	    int blue_time = color_blue_time->value->int32;

	    // Persist values
	    persist_write_int(KEY_COLOR_RED_TIME, red_time);
	    persist_write_int(KEY_COLOR_GREEN_TIME, green_time);
	    persist_write_int(KEY_COLOR_BLUE_TIME, blue_time);

	    GColor bg_color_time = GColorFromRGB(red_time, green_time, blue_time);
	    window_set_background_color(s_main_window, bg_color_time);

	    text_layer_set_text_color(s_time_textLayer, gcolor_is_dark(bg_color_time) ? GColorWhite : GColorBlack);
	  }
	 #endif
	// End Color ===============

	// Date Format
	static char temporary_date_holder_callback[32];
	Tuple *date_format_tuple = dict_find(iterator, KEY_DATE_FORMAT);
	if( date_format_tuple ) {
		APP_LOG(APP_LOG_LEVEL_INFO, "Callback: Date Tuple Worked!\n");
		APP_LOG(APP_LOG_LEVEL_INFO, "Callback: Value Recieved from Date Tuple: %d\n", (int)date_format_tuple->value->int8);
	} else {
		APP_LOG(APP_LOG_LEVEL_INFO, "Callback: Date Tuple Failed\n");
	}
	if( date_format_tuple && date_format_tuple->value->int8 == 49 ) {
		snprintf(temporary_date_holder_callback, sizeof(temporary_date_holder_callback), "%s.%s", day_tickTime, month_tickTime);
		// snprintf(dateWithoutYear, sizeof(dateWithoutYear), "\0");
		snprintf(ddmm_dateWithoutYear, sizeof(ddmm_dateWithoutYear), "%s", temporary_date_holder_callback);
		persist_write_int(KEY_DATE_FORMAT, 1);
		text_layer_set_text(s_date_textLayer, temporary_date_holder_callback);
		APP_LOG(APP_LOG_LEVEL_INFO, "Callback: Date was updated as DD-MM 1\n");
	} else if( date_format_tuple && date_format_tuple->value->int8 == 48 ){
		snprintf(temporary_date_holder_callback, sizeof(temporary_date_holder_callback), "%s.%s", month_tickTime, day_tickTime);
		// snprintf(dateWithoutYear, sizeof(dateWithoutYear), "\0");
		snprintf(dateWithoutYear, sizeof(dateWithoutYear), "%s", temporary_date_holder_callback);
		persist_write_int(KEY_DATE_FORMAT, 0);
		text_layer_set_text(s_date_textLayer, temporary_date_holder_callback);
		APP_LOG(APP_LOG_LEVEL_INFO, "Callback: Date was updated as MM-DD 1\n");
	}

	// Add year or not
	static char temporary_dateWithoutYear_holder_update[32];
	Tuple *year_is_displayed_tuple = dict_find(iterator, KEY_DATE_ADD_YEAR);
	if( year_is_displayed_tuple && year_is_displayed_tuple->value->int8 > 0 ) {
		if( persist_read_int(KEY_DATE_FORMAT) == 1 ) {
			strcpy(temporary_dateWithoutYear_holder_update, ddmm_dateWithoutYear);
		}
		else if( persist_read_int(KEY_DATE_FORMAT) == 0 ) {
			strcpy(temporary_dateWithoutYear_holder_update, dateWithoutYear);
		}
		strcat(temporary_dateWithoutYear_holder_update, year_tickTime);
		persist_write_bool(KEY_DATE_ADD_YEAR, true);
		text_layer_set_text(s_date_textLayer, temporary_dateWithoutYear_holder_update);
	} else if( year_is_displayed_tuple && year_is_displayed_tuple->value->int8 <= 0 ) {
		persist_write_bool(KEY_DATE_ADD_YEAR, false);
		if( persist_read_int(KEY_DATE_FORMAT) == 1 )
			text_layer_set_text(s_date_textLayer, ddmm_dateWithoutYear);
		else
			text_layer_set_text(s_date_textLayer, dateWithoutYear);
	}

	// Language Handing On Callback			
	Tuple *lang_is_eng_tuple = dict_find(iterator, KEY_LANGUAGE);
	if( lang_is_eng_tuple ) {
		APP_LOG(APP_LOG_LEVEL_INFO, "Callback: lang Tuple Worked!\n");
		APP_LOG(APP_LOG_LEVEL_INFO, "Callback: Value Recieved from lang Tuple: %d\n", (int)lang_is_eng_tuple->value->int8);
	} else {
		APP_LOG(APP_LOG_LEVEL_INFO, "Callback: lang Tuple Failed\n");
	}
	if( lang_is_eng_tuple && lang_is_eng_tuple->value->int8 == 49 ) {
		// Time to convert this to spanish
		int dayOfWeekInt = atoi(dayOfWeekNumber_tickTime);
		static char temporary_day_of_week_holder_callback[8];
		switch(dayOfWeekInt) {
			case 0:
				snprintf(temporary_day_of_week_holder_callback, sizeof(temporary_day_of_week_holder_callback), "%s", "Dom");
			break;
			case 1:
				snprintf(temporary_day_of_week_holder_callback, sizeof(temporary_day_of_week_holder_callback), "%s", "Lun");
			break;
			case 2:
				snprintf(temporary_day_of_week_holder_callback, sizeof(temporary_day_of_week_holder_callback), "%s", "Mar");
			break;
			case 3:
				snprintf(temporary_day_of_week_holder_callback, sizeof(temporary_day_of_week_holder_callback), "%s", "Mie");
			break;
			case 4:
				snprintf(temporary_day_of_week_holder_callback, sizeof(temporary_day_of_week_holder_callback), "%s", "Jue");
			break;
			case 5:
				snprintf(temporary_day_of_week_holder_callback, sizeof(temporary_day_of_week_holder_callback), "%s", "Vie");
			break;
			case 6:
				snprintf(temporary_day_of_week_holder_callback, sizeof(temporary_day_of_week_holder_callback), "%s", "Sab");
			break;
			default:
				text_layer_set_text(s_dayOfWeek_textLayer, temporary_day_of_week_holder_callback);
			break;
		}
		persist_write_int(KEY_LANGUAGE, 1);
		text_layer_set_text(s_dayOfWeek_textLayer, temporary_day_of_week_holder_callback);
	} else if( lang_is_eng_tuple && lang_is_eng_tuple->value->int8 == 48 ) {
		persist_write_int(KEY_LANGUAGE, 0);
		// English
		text_layer_set_text(s_dayOfWeek_textLayer, engDayOfWeek_tickTime);
	}
	// End Configuration ---------------------------------------------------------
}
示例#29
0
void draw_display(Window **window, Layer **gui_layer, Layer **details_layer, TextLayer **text_layer_time, TextLayer **text_layer_speed,
	TextLayer **text_layer_mph, TextLayer **text_layer_battery, TextLayer **text_layer_temperature,
	BitmapLayer **battery_bitmap_layer, BitmapLayer **temperature_bitmap_layer,BitmapLayer **bt_bitmap_layer, Layer **arc_layer,
	TextLayer **text_layer_ride_time, TextLayer **text_layer_distance, TextLayer **text_layer_top_speed) {
	
	Layer *window_layer = window_get_root_layer(*window);
  GRect window_bounds = layer_get_bounds(window_layer);
	*gui_layer = layer_create(window_bounds);
	*details_layer = layer_create(window_bounds);

	font_square_l = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_SQUARE_50));
	font_square_m = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_SQUARE_20));
	font_square_s = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_SQUARE_15));
  
	*text_layer_time = text_layer_create(GRect(0, 0, window_bounds.size.w, 20));
	text_layer_set_font(*text_layer_time, font_square_s);
	
	*bt_bitmap_layer = bitmap_layer_create(GRect(window_bounds.size.w-24, 5, 24, 24));
	bitmap_layer_set_alignment(*bt_bitmap_layer, GAlignCenter);

	*arc_layer = layer_create(GRect(10, 22, window_bounds.size.w-20, window_bounds.size.w-20));
	
	*text_layer_speed = text_layer_create(GRect(0, 45, window_bounds.size.w, 50));
	text_layer_set_font(*text_layer_speed, font_square_l);

	*text_layer_mph = text_layer_create(GRect(0, 97, window_bounds.size.w, 23));
	text_layer_set_font(*text_layer_mph, font_square_m);
	
	*temperature_bitmap_layer = bitmap_layer_create(GRect(0, window_bounds.size.h-43, window_bounds.size.w/2, 20));
	bitmap_layer_set_alignment(*temperature_bitmap_layer, GAlignCenter);
	
	*battery_bitmap_layer = bitmap_layer_create(GRect(window_bounds.size.w/2, window_bounds.size.h-43, window_bounds.size.w/2, 20));
	bitmap_layer_set_alignment(*battery_bitmap_layer, GAlignCenter);

	*text_layer_temperature = text_layer_create(GRect(0, window_bounds.size.h-25, window_bounds.size.w/2, 25));
	text_layer_set_font(*text_layer_temperature, font_square_m);
	
	*text_layer_battery = text_layer_create(GRect(window_bounds.size.w/2, window_bounds.size.h-25, window_bounds.size.w/2, 25));
	text_layer_set_font(*text_layer_battery, font_square_m);
	
	text_layer_rt_title = text_layer_create(GRect(0, 9, window_bounds.size.w, 22));
	*text_layer_ride_time = text_layer_create(GRect(0, 31, window_bounds.size.w, 22));
	text_layer_set_background_color(text_layer_rt_title, GColorClear);
	text_layer_set_background_color(*text_layer_ride_time, GColorClear);
	text_layer_set_text_color(text_layer_rt_title, GColorWhite);
	text_layer_set_text_color(*text_layer_ride_time, GColorLightGray);
	text_layer_set_text_alignment(text_layer_rt_title, GTextAlignmentCenter);
	text_layer_set_text_alignment(*text_layer_ride_time, GTextAlignmentCenter);
	text_layer_set_text(text_layer_rt_title, "RIDE TIME");
	text_layer_set_font(text_layer_rt_title, font_square_m);
	text_layer_set_font(*text_layer_ride_time, font_square_m);
	
	text_layer_d_title = text_layer_create(GRect(0, 62, window_bounds.size.w, 22));
	*text_layer_distance = text_layer_create(GRect(0, 84, window_bounds.size.w, 22));
	text_layer_set_background_color(text_layer_d_title, GColorClear);
	text_layer_set_background_color(*text_layer_distance, GColorClear);
	text_layer_set_text_color(text_layer_d_title, GColorWhite);
	text_layer_set_text_color(*text_layer_distance, GColorLightGray);
	text_layer_set_text_alignment(text_layer_d_title, GTextAlignmentCenter);
	text_layer_set_text_alignment(*text_layer_distance, GTextAlignmentCenter);
	text_layer_set_text(text_layer_d_title, "DISTANCE");
	text_layer_set_font(text_layer_d_title, font_square_m);
	text_layer_set_font(*text_layer_distance, font_square_m);
	
	text_layer_ts_title = text_layer_create(GRect(0, 115, window_bounds.size.w, 22));
	*text_layer_top_speed = text_layer_create(GRect(0, 137, window_bounds.size.w, 23));
	text_layer_set_background_color(text_layer_ts_title, GColorClear);
	text_layer_set_background_color(*text_layer_top_speed, GColorClear);
	text_layer_set_text_color(text_layer_ts_title, GColorWhite);
	text_layer_set_text_color(*text_layer_top_speed, GColorLightGray);
	text_layer_set_text_alignment(text_layer_ts_title, GTextAlignmentCenter);
	text_layer_set_text_alignment(*text_layer_top_speed, GTextAlignmentCenter);
	text_layer_set_text(text_layer_ts_title, "TOP SPEED");
	text_layer_set_font(text_layer_ts_title, font_square_m);
	text_layer_set_font(*text_layer_top_speed, font_square_m);
	
	layer_add_child(*details_layer, text_layer_get_layer(text_layer_rt_title));
	layer_add_child(*details_layer, text_layer_get_layer(*text_layer_ride_time));
	layer_add_child(*details_layer, text_layer_get_layer(text_layer_d_title));
	layer_add_child(*details_layer, text_layer_get_layer(*text_layer_distance));
	layer_add_child(*details_layer, text_layer_get_layer(text_layer_ts_title));
	layer_add_child(*details_layer, text_layer_get_layer(*text_layer_top_speed));

}
示例#30
0
文件: main.c 项目: koudac/MyWatchFace
static void main_window_load(Window *window) {
  Layer *window_layer = window_get_root_layer(s_main_window);
  GRect bounds = layer_get_frame(window_layer);

	// Layer pour le Fond static
  s_image_layer = layer_create(bounds);
  layer_set_update_proc(s_image_layer, layer_update_callback);
  layer_add_child(window_layer, s_image_layer);
	s_image = gbitmap_create_with_resource(RESOURCE_ID_FOND_VIDE);
	
	// Layer pour le logo de la batterie
	s_image_batterie = layer_create(bounds);
	layer_set_update_proc(s_image_batterie, layer_update_callback);
  layer_add_child(window_layer, s_image_batterie);
	s_bitmap_batterie = gbitmap_create_with_resource(RESOURCE_ID_ICONE_BLUETOOTH_100);
	
	// Layer pour L'heure
  s_time_layer = text_layer_create(GRect(0, 60, bounds.size.w, 44));
  text_layer_set_text_color(s_time_layer, GColorOrange);
  text_layer_set_background_color(s_time_layer, GColorClear);
  text_layer_set_font(s_time_layer, fonts_get_system_font(FONT_KEY_LECO_42_NUMBERS));
  text_layer_set_text_alignment(s_time_layer, GTextAlignmentCenter);
	text_layer_set_text(s_time_layer, "---------------");

	// Layer pour la Date
	s_Date_layer = text_layer_create(GRect(2, 50, bounds.size.w, 34));
  text_layer_set_text_color(s_Date_layer, GColorWhite);
  text_layer_set_background_color(s_Date_layer, GColorClear);
  text_layer_set_font(s_Date_layer, fonts_get_system_font(FONT_KEY_GOTHIC_18));
  text_layer_set_text_alignment(s_Date_layer, GTextAlignmentCenter);

	// Layer pour le pourcentage de de la batterie
  s_battery_layer = text_layer_create(GRect(-72, 106, bounds.size.w, 34));
  text_layer_set_text_color(s_battery_layer, GColorWhite);
  text_layer_set_background_color(s_battery_layer, GColorClear);
  text_layer_set_font(s_battery_layer, fonts_get_system_font(FONT_KEY_GOTHIC_18));
  text_layer_set_text_alignment(s_battery_layer, GTextAlignmentRight);
  text_layer_set_text(s_battery_layer, "--- %");
	
  // Layer pour l'année
  s_year_layer = text_layer_create(GRect(-12, 106, bounds.size.w, 34));
  text_layer_set_text_color(s_year_layer, GColorWhite);
  text_layer_set_background_color(s_year_layer, GColorClear);
  text_layer_set_font(s_year_layer, fonts_get_system_font(FONT_KEY_GOTHIC_18));
  text_layer_set_text_alignment(s_year_layer, GTextAlignmentRight);
  text_layer_set_text(s_year_layer, "----");
	
  // Ensures time is displayed immediately (will break if NULL tick event accessed).
  // (This is why it's a good idea to have a separate routine to do the update itself.)
  time_t now = time(NULL);
  struct tm *current_time = localtime(&now);
  handle_seconde_tick(current_time, SECOND_UNIT);

  tick_timer_service_subscribe(SECOND_UNIT, handle_seconde_tick);
  battery_state_service_subscribe(handle_battery);
  bluetooth_connection_service_subscribe(handle_bluetooth);

  layer_add_child(window_layer, text_layer_get_layer(s_time_layer));
  layer_add_child(window_layer, text_layer_get_layer(s_battery_layer));
	layer_add_child(window_layer, text_layer_get_layer(s_Date_layer));
	layer_add_child(window_layer, text_layer_get_layer(s_year_layer));
}