Ejemplo n.º 1
0
static void buildIconsDisplay(Window *window){
  //create bluetooth icon gbitmap
  s_bt_icon_bitmap = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_BT_ICON);

  // create the bitmaplayer to display the bitmap
  s_bt_icon_layer = bitmap_layer_create(GRect(0, 0, 24, 24));
  bitmap_layer_set_bitmap(s_bt_icon_layer, s_bt_icon_bitmap);
  bitmap_layer_set_compositing_mode(s_bt_icon_layer, GCompOpSet);
  layer_add_child(s_root_layer, bitmap_layer_get_layer(s_bt_icon_layer));

  //create bluetooth icon gbitmap
  s_weather_icon_bitmap = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_50DN);

  // create the bitmaplayer to display the bitmap
  s_weather_icon_layer = bitmap_layer_create(GRect(20, s_bounds.size.h - 50, 50, 50));
  bitmap_layer_set_bitmap(s_weather_icon_layer, s_weather_icon_bitmap);
  bitmap_layer_set_compositing_mode(s_weather_icon_layer, GCompOpSet);
  layer_add_child(s_root_layer, bitmap_layer_get_layer(s_weather_icon_layer));

  //create charge icon gbitmap
  s_charge_icon_bitmap = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_CHARGE);
  GRect image_frame = GRect(s_bounds.size.w-24, 1, 24, 24);

  // create the bitmaplayer to display the bitmap
  s_charge_icon_layer = bitmap_layer_create(image_frame);
  bitmap_layer_set_bitmap(s_charge_icon_layer, s_charge_icon_bitmap);
  bitmap_layer_set_compositing_mode(s_charge_icon_layer, GCompOpSet);
  layer_add_child(s_root_layer, bitmap_layer_get_layer(s_charge_icon_layer));
}
Ejemplo n.º 2
0
// Initialise UI
static void init(void)
{
	srand(time(NULL));
	inverter_timer 	= app_timer_register(INVERTER_TIMEOUT, inverter_timer_callback, 0);
	time_timer 			= app_timer_register(TIME_TIMEOUT, update_time, 0);
	
  window 					= window_create();
	
	window_set_fullscreen(window, true);
  window_stack_push(window, false);
	
	// Assign resources
  s_res_tv_image 				= gbitmap_create_with_resource(RESOURCE_ID_TV_IMAGE);
  s_res_static_1_image 	= gbitmap_create_with_resource(RESOURCE_ID_STATIC_2_IMAGE);
	s_res_bitham_42_bold 	= fonts_get_system_font(FONT_KEY_BITHAM_42_BOLD);
	s_res_gothic_14 			= fonts_get_system_font(FONT_KEY_GOTHIC_14);
		
	// tv_bitmap
	tv_bitmap = bitmap_layer_create(GRect(0,0,144,168));
	bitmap_layer_set_bitmap(tv_bitmap, s_res_tv_image);
	bitmap_layer_set_background_color(tv_bitmap, GColorClear);
	bitmap_layer_set_compositing_mode(tv_bitmap, GCompOpAssign);
	layer_add_child(window_get_root_layer(window), (Layer *) tv_bitmap);
	
  // static_1_bitmap
  static_1_bitmap = bitmap_layer_create(GRect(14, 42, 115, 87));
  bitmap_layer_set_bitmap(static_1_bitmap, s_res_static_1_image);
	bitmap_layer_set_compositing_mode(static_1_bitmap, GCompOpOr);
  layer_add_child(window_get_root_layer(window), (Layer *)static_1_bitmap);
  
  // inverter_layer
  static_inverter_layer = inverter_layer_create(GRect(14, 42, 115, 0));
  layer_add_child(window_get_root_layer(window), (Layer *)static_inverter_layer);
	layer_set_hidden(inverter_layer_get_layer(static_inverter_layer), false);
	
	// Screen On layer
  screen_on_layer = text_layer_create(GRect(14, 42, 115, 87));
  text_layer_set_background_color(screen_on_layer, GColorWhite);
  layer_set_hidden(text_layer_get_layer(screen_on_layer), true);
	layer_add_child(window_get_root_layer(window), text_layer_get_layer(screen_on_layer));
	
	// ch_layer
	ch_layer = text_layer_create(GRect(102, 46, 24, 14));
	text_layer_set_background_color(ch_layer, GColorClear);
	text_layer_set_text(ch_layer, "Ch 3");
	text_layer_set_font(ch_layer, s_res_gothic_14);
	layer_add_child(window_get_root_layer(window), text_layer_get_layer(ch_layer));
	
  // time_layer
	clock_copy_time_string(buffer, 12);
  time_layer = text_layer_create(GRect(0, 56, 144, 42));
  text_layer_set_background_color(time_layer, GColorClear);
  text_layer_set_text(time_layer, buffer);
  text_layer_set_text_alignment(time_layer, GTextAlignmentCenter);
  text_layer_set_font(time_layer, s_res_bitham_42_bold);
	layer_set_hidden(text_layer_get_layer(time_layer), true);
  layer_add_child(window_get_root_layer(window), (Layer *)time_layer);
	
	accel_tap_service_subscribe(tap_handler); // Subcribe to the tap event service
}
Ejemplo n.º 3
0
static void main_window_load(Window *window) {

    // Create bitmap
    s_example_bitmap = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_NUM_1);
    s_bitmap_layer = bitmap_layer_create(GRect(0, 0, 144, 168));
    bitmap_layer_set_bitmap(s_bitmap_layer, s_example_bitmap);
#ifdef PBL_PLATFORM_APLITE
    bitmap_layer_set_compositing_mode(s_bitmap_layer, GCompOpAssign);
#elif PBL_PLATFORM_BASALT
    bitmap_layer_set_compositing_mode(s_bitmap_layer, GCompOpSet);
    #endif

    layer_add_child(window_get_root_layer(window), bitmap_layer_get_layer(s_bitmap_layer));

    // Create time TextLayer
    s_time_layer = text_layer_create(GRect(0, 10, 144, 50));
    text_layer_set_background_color(s_time_layer, GColorBlack);
    text_layer_set_text_color(s_time_layer, GColorWhite);

    // Create GFont
    s_time_font = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_SAN_FRANCISCO_42));

    // Apply to time TextLayer
    text_layer_set_font(s_time_layer, s_time_font);
    text_layer_set_text_alignment(s_time_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));

    update_time();
}
Ejemplo n.º 4
0
static void main_window_load(Window *window) {
  int left = 0;

  left += LAYER_STATUS_LEFT_GAP;
  s_status_bt_layer = bitmap_layer_create(GRect(left, 0, LAYER_STATUS_BMP_WIDTH, LAYER_STATUS_HEIGHT));
  bitmap_layer_set_alignment(s_status_bt_layer, GAlignRight);
  bitmap_layer_set_compositing_mode(s_status_bt_layer, GCompOpAssignInverted);
  layer_add_child(window_get_root_layer(window), (Layer *) s_status_bt_layer);
  
  left += LAYER_STATUS_BMP_WIDTH + LAYER_STATUS_GAP;
  s_status_battery_layer = bitmap_layer_create(GRect(left, 0,
                                                     LAYER_STATUS_BMP_WIDTH, LAYER_STATUS_HEIGHT));\
  bitmap_layer_set_alignment(s_status_battery_layer, GAlignLeft);
  bitmap_layer_set_compositing_mode(s_status_battery_layer, GCompOpAssignInverted);
  layer_add_child(window_get_root_layer(window), (Layer *) s_status_battery_layer);

  left += LAYER_STATUS_BMP_WIDTH;
  s_status_charge_layer = bitmap_layer_create(GRect(left, 0,
                                                    LAYER_STATUS_BMP_WIDTH, LAYER_STATUS_HEIGHT));\
  bitmap_layer_set_alignment(s_status_charge_layer, GAlignLeft);
  bitmap_layer_set_compositing_mode(s_status_charge_layer, GCompOpAssignInverted);
  layer_add_child(window_get_root_layer(window), (Layer *) s_status_charge_layer);

  left += LAYER_STATUS_BMP_WIDTH;
  s_status_text_layer = create_text_layer(window, GRect(left, 0, LAYER_STATUS_TEXT_WIDTH, LAYER_STATUS_HEIGHT));
  text_layer_set_text_alignment(s_status_text_layer, GAlignRight);
  set_status_text("");

}
static void window_load(Window *window) {
    Layer *window_layer = window_get_root_layer(window);
    GRect bounds = layer_get_bounds(window_layer);

    // We do this to account for the offset due to the status bar
    // at the top of the app window.
    GRect layer_frame_description = layer_get_frame(window_layer);
    layer_frame_description.origin.x = 0;
    layer_frame_description.origin.y = 0;

    // Add some background content to help demonstrate transparency.
    text_layer = text_layer_create(layer_frame_description);
    text_layer_set_text(text_layer,
                        "pandamonium pandamon\n"
                        "ium pandamonium panda\n"
                        "monium     pandamonium\n"
                        "pandamonium pandamon\n"
                        "ium pandamonium panda\n"
                        "monium     pandamonium\n"
                        "pandamonium pandamon\n"
                        "ium pandamonium panda\n"
                        "monium pandamonium p\n"
                        "andamonium pandamoni\n");
    layer_add_child(window_layer, text_layer_get_layer(text_layer));

    white_image = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_PANDA_WHITE);
    black_image = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_PANDA_BLACK);

    const GPoint center = grect_center_point(&bounds);
    GRect image_frame = (GRect) {
        .origin = center, .size = white_image->bounds.size
    };
    image_frame.origin.x -= white_image->bounds.size.w/2;
    image_frame.origin.y -= white_image->bounds.size.h/2;

    // Use GCompOpOr to display the white portions of the image
    white_image_layer = bitmap_layer_create(image_frame);
    bitmap_layer_set_bitmap(white_image_layer, white_image);
    bitmap_layer_set_compositing_mode(white_image_layer, GCompOpOr);
    layer_add_child(window_layer, bitmap_layer_get_layer(white_image_layer));

    // Use GCompOpClear to display the black portions of the image
    black_image_layer = bitmap_layer_create(image_frame);
    bitmap_layer_set_bitmap(black_image_layer, black_image);
    bitmap_layer_set_compositing_mode(black_image_layer, GCompOpClear);
    layer_add_child(window_layer, bitmap_layer_get_layer(black_image_layer));
}

static void window_unload(Window *window) {
    bitmap_layer_destroy(white_image_layer);
    bitmap_layer_destroy(black_image_layer);
    text_layer_destroy(text_layer);

    gbitmap_destroy(white_image);
    gbitmap_destroy(black_image);

}
static void set_button_graphic( Layer *window_layer, BitmapLayer *layer_white, BitmapLayer *layer_black,
							                         GBitmap     *bmp_white,   GBitmap 	   *bmp_black   ) {
	bitmap_layer_set_bitmap          ( layer_white,  bmp_white );
	bitmap_layer_set_compositing_mode( layer_white,  GCompOpOr );
	bitmap_layer_set_bitmap          ( layer_black,  bmp_black    );
	bitmap_layer_set_compositing_mode( layer_black,  GCompOpClear );
	
	layer_add_child                  ( window_layer, bitmap_layer_get_layer(layer_white) );
	layer_add_child                  ( window_layer, bitmap_layer_get_layer(layer_black) );
}
Ejemplo n.º 7
0
void show_tripwindow(void) {
  initialise_ui();
  
  layer_set_update_proc(s_score_layer,score_layer_update);
  bitmap_layer_set_compositing_mode(s_hardbrakes_bitmaplayer,GCompOpSet);
  bitmap_layer_set_compositing_mode(s_hardaccs_bitmaplayer,GCompOpSet);
  bitmap_layer_set_compositing_mode(s_trend_bitmaplayer,GCompOpSet);
//  window_set_background_color(s_window,GColorChromeYellow);
  
  window_set_window_handlers(s_window, (WindowHandlers) {
    .unload = handle_window_unload,
  });
Ejemplo n.º 8
0
TransBitmapLayer * trans_bitmap_layer_create(GBitmap *black_image, GBitmap *white_image, GRect frame)
{
    TransBitmapLayer *layer;
    layer = malloc(sizeof(TransBitmapLayer));
    layer->black_layer = bitmap_layer_create(frame);
    layer->white_layer = bitmap_layer_create(frame);
    bitmap_layer_set_bitmap(layer->black_layer, black_image);
    bitmap_layer_set_bitmap(layer->white_layer, white_image);
    bitmap_layer_set_compositing_mode(layer->black_layer, GCompOpAnd);
    bitmap_layer_set_compositing_mode(layer->white_layer, GCompOpSet);
    return layer;
}
Ejemplo n.º 9
0
static void window_load(Window *window)
{
    window_set_background_color(window, GColorBlack);

    //Power bitmap
    power_bitmap = gbitmap_create_with_resource(RESOURCE_ID_POWER);

    //Phase
    phase_layer = layer_create(GRECT_PHASE_SHOWING);
    layer_set_update_proc(phase_layer, (LayerUpdateProc)phase_update_proc);
    layer_add_child(window_get_root_layer(window), phase_layer);

    //Time display under background
    time_bg_layer = layer_create(GRECT_TIME_BG_HIDDEN);
    time_layer = cl_init_text_layer(GRECT_TIME_BG_HIDDEN, GColorBlack, GColorClear, false, 0, FONT_KEY_GOTHIC_24_BOLD, GTextAlignmentCenter);
    layer_set_update_proc(time_bg_layer, (LayerUpdateProc)bg_update_proc);
    layer_add_child(window_get_root_layer(window), time_bg_layer);
    layer_add_child(window_get_root_layer(window), text_layer_get_layer(time_layer));

    //Bluetooth
    bt_on_bitmap = gbitmap_create_with_resource(RESOURCE_ID_BT_ON);
    bt_off_bitmap = gbitmap_create_with_resource(RESOURCE_ID_BT_OFF);
    bt_layer = bitmap_layer_create(GRECT_BT_HIDDEN);
    layer_add_child(window_get_root_layer(window), bitmap_layer_get_layer(bt_layer));

    //Battery
    battery_layer = layer_create(GRECT_BATTERY_HIDDEN);
    layer_set_update_proc(battery_layer, (LayerUpdateProc)battery_update_proc);
    layer_add_child(window_get_root_layer(window), battery_layer);

    //Background
    background_white_bitmap = gbitmap_create_with_resource(RESOURCE_ID_BACKGROUND_WHITE);
    background_white_layer = bitmap_layer_create(GRect(0, 0, 144, 168));
    bitmap_layer_set_compositing_mode(background_white_layer, GCompOpOr);
    bitmap_layer_set_bitmap(background_white_layer, background_white_bitmap);
    layer_add_child(window_get_root_layer(window), bitmap_layer_get_layer(background_white_layer));

    background_black_bitmap = gbitmap_create_with_resource(RESOURCE_ID_BACKGROUND_BLACK);
    background_black_layer = bitmap_layer_create(GRect(0, 0, 144, 168));
    bitmap_layer_set_compositing_mode(background_black_layer, GCompOpAnd);
    bitmap_layer_set_bitmap(background_black_layer, background_black_bitmap);
    layer_add_child(window_get_root_layer(window), bitmap_layer_get_layer(background_black_layer));

    //Date
    date_bg_layer = layer_create(GRECT_DATE_BG_HIDDEN);
    date_layer = cl_init_text_layer(GRECT_DATE_BG_HIDDEN, GColorBlack, GColorClear, false, 0, FONT_KEY_GOTHIC_24_BOLD, GTextAlignmentCenter);
    layer_set_update_proc(date_bg_layer, (LayerUpdateProc)bg_update_proc);
    layer_add_child(window_get_root_layer(window), date_bg_layer);
    layer_add_child(window_get_root_layer(window), text_layer_get_layer(date_layer));

    //Animate in
    cl_animate_layer(phase_layer, GRECT_PHASE_HIDDEN, GRECT_PHASE_SHOWING, 1000, 200);
}
Ejemplo n.º 10
0
void handle_main_window_load(Window *window) {
  // Create GBitmap, then set to created BitmapLayer
  s_background_bitmap = gbitmap_create_with_resource(IMAGE_RESOURCE_IDS_BACKGROUNDS[4]);
  s_point_bitmap = gbitmap_create_with_resource(IMAGE_RESOURCE_IDS_HANDS[1]);
  
  s_background_layer = bitmap_layer_create(GRect(0, 12, 144, 144));
  bitmap_layer_set_bitmap(s_background_layer, s_background_bitmap);

#if defined(USER_ROT_BITMAP)
  s_hour_point_layer = rot_bitmap_layer_create(s_point_bitmap);
  rot_bitmap_set_compositing_mode(s_hour_point_layer, GCompOpAnd);
  
  s_min_point_layer = rot_bitmap_layer_create(s_point_bitmap);
  rot_bitmap_set_compositing_mode(s_min_point_layer, GCompOpAnd);
#else
  GRect rec= {{0, 0}, {16, 16}};
  s_hour_point_layer = bitmap_layer_create(rec);
  bitmap_layer_set_bitmap(s_hour_point_layer, s_point_bitmap);
  bitmap_layer_set_compositing_mode(s_hour_point_layer, GCompOpAnd);
  
  s_min_point_layer = bitmap_layer_create(rec);
  bitmap_layer_set_bitmap(s_min_point_layer, s_point_bitmap);
  bitmap_layer_set_compositing_mode(s_min_point_layer, GCompOpAnd);
#endif

  // Update the time now
  handle_update();
  
  Layer * root_layer = window_get_root_layer(window);
  
  // Add it as a child layer to the Window's root layer
  layer_add_child(root_layer, bitmap_layer_get_layer(s_background_layer));
  
#if defined(USER_ROT_BITMAP)
  layer_add_child(root_layer, (Layer*)(s_hour_point_layer));
  layer_add_child(root_layer, (Layer*)(s_min_point_layer));
#else
  layer_add_child(root_layer, bitmap_layer_get_layer(s_hour_point_layer));
  layer_add_child(root_layer, bitmap_layer_get_layer(s_min_point_layer));
#endif
  
  add_invert(root_layer);
  
  // Register with TickTimerService
#if defined(USE_TEST_SECONDS)
  tick_timer_service_subscribe(SECOND_UNIT, handle_tick);
#else
  tick_timer_service_subscribe(MINUTE_UNIT, handle_tick);
#endif
}
Ejemplo n.º 11
0
/**
 * Function intiailzes the main Window object
 * @param window Pointer to window to be intiailized
 */
static void main_window_load(Window *window) {

    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);
#ifdef PBL_BW
    bitmap_layer_set_compositing_mode(s_background_layer, GCompOpAssign);
#elif PBL_COLOR
    bitmap_layer_set_compositing_mode(s_background_layer, GCompOpSet);
#endif
    layer_add_child(window_get_root_layer(window), bitmap_layer_get_layer(s_background_layer));

    welcome_window_build(window);
}
Ejemplo n.º 12
0
Archivo: main.c Proyecto: timj92/Cuboid
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);
  
  // Set background
  if(watch_info_get_model() != WATCH_INFO_MODEL_PEBBLE_ORIGINAL && watch_info_get_model() != WATCH_INFO_MODEL_PEBBLE_STEEL) {
    bg_grass = gbitmap_create_with_resource(RESOURCE_ID_BG_GRASS);
    background_image = bitmap_layer_create(bounds);
    bitmap_layer_set_bitmap(background_image, bg_grass);
    layer_add_child(window_layer, bitmap_layer_get_layer(background_image));
  }
  
  // Create GBitmaps
  num0 = gbitmap_create_with_resource(RESOURCE_ID_NUM_0);
  num1left = gbitmap_create_with_resource(RESOURCE_ID_NUM_1_LEFT);
  num1right = gbitmap_create_with_resource(RESOURCE_ID_NUM_1_RIGHT);
  num2 = gbitmap_create_with_resource(RESOURCE_ID_NUM_2);
  num3 = gbitmap_create_with_resource(RESOURCE_ID_NUM_3);
  num4 = gbitmap_create_with_resource(RESOURCE_ID_NUM_4);
  num5 = gbitmap_create_with_resource(RESOURCE_ID_NUM_5);
  num6 = gbitmap_create_with_resource(RESOURCE_ID_NUM_6);
  num7 = gbitmap_create_with_resource(RESOURCE_ID_NUM_7);
  num8 = gbitmap_create_with_resource(RESOURCE_ID_NUM_8);
  num9 = gbitmap_create_with_resource(RESOURCE_ID_NUM_9);
  
  // Create BitmapLayers
  topleft_image = bitmap_layer_create(GRect(7, 5, 64, 76));
  topright_image = bitmap_layer_create(GRect(71, 5, 64, 76));
  bottomleft_image = bitmap_layer_create(GRect(7, 86, 64, 76));
  bottomright_image = bitmap_layer_create(GRect(71, 86, 64, 76));

  // Set transparency
  bitmap_layer_set_background_color(topleft_image, GColorClear);
  bitmap_layer_set_background_color(topright_image, GColorClear);
  bitmap_layer_set_background_color(bottomleft_image, GColorClear);
  bitmap_layer_set_background_color(bottomright_image, GColorClear);
  
  bitmap_layer_set_compositing_mode(topleft_image, GCompOpSet);
  bitmap_layer_set_compositing_mode(topright_image, GCompOpSet);
  bitmap_layer_set_compositing_mode(bottomleft_image, GCompOpSet);
  bitmap_layer_set_compositing_mode(bottomright_image, GCompOpSet);

  // Add BitmapLayers as child layers to the Window's root layer
  layer_add_child(window_layer, bitmap_layer_get_layer(topleft_image));
  layer_add_child(window_layer, bitmap_layer_get_layer(topright_image));
  layer_add_child(window_layer, bitmap_layer_get_layer(bottomleft_image));
  layer_add_child(window_layer, bitmap_layer_get_layer(bottomright_image));
}
Ejemplo n.º 13
0
static void main_window_load(Window *window) {
  Layer *window_layer = window_get_root_layer(window);
  GRect bounds = layer_get_bounds(window_layer);

  s_bitmap = gbitmap_create_with_resource(RESOURCE_ID_BG_IMAGE);

  s_bitmap_layer = bitmap_layer_create(bounds);
  bitmap_layer_set_bitmap(s_bitmap_layer, s_bitmap);
#ifdef PBL_PLATFORM_APLITE
  bitmap_layer_set_compositing_mode(s_bitmap_layer, GCompOpAssign);
#elif PBL_PLATFORM_BASALT
  bitmap_layer_set_compositing_mode(s_bitmap_layer, GCompOpSet);
#endif
  layer_add_child(window_layer, bitmap_layer_get_layer(s_bitmap_layer));
}
Ejemplo n.º 14
0
static void main_window_load(Window *window) {
  Layer *window_layer = window_get_root_layer(window);
  GRect bounds = layer_get_bounds(window_layer);

  s_bitmap = gbitmap_create_with_resource(RESOURCE_ID_US_FLAG_IMAGE);

  s_bitmap_layer = bitmap_layer_create(bounds);
  bitmap_layer_set_bitmap(s_bitmap_layer, s_bitmap);
#if defined(PBL_BW)
  bitmap_layer_set_compositing_mode(s_bitmap_layer, GCompOpAssign);
#elif defined(PBL_COLOR)
  bitmap_layer_set_compositing_mode(s_bitmap_layer, GCompOpSet);
#endif
  layer_add_child(window_layer, bitmap_layer_get_layer(s_bitmap_layer));
}
Ejemplo n.º 15
0
/*!
 * Initializes graphic elements and subscribes to accelerometer
 * 
 * \param window the app's main window
 */
void window_load(Window *window)
{
    Layer *window_layer = window_get_root_layer(window);

    bitmap = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_MAIN);

    GRect bounds = layer_get_frame(window_layer);
    image_layer = bitmap_layer_create(bounds);
    bitmap_layer_set_alignment(image_layer, GAlignCenter);

    note_layer = bitmap_layer_create(bounds);
    bitmap_layer_set_compositing_mode(note_layer, GCompOpAnd);
    bitmap_layer_set_alignment(note_layer, GAlignCenter);
    bitmap_layer_set_bitmap(note_layer, bitmap);

    bitmap_layer_set_bitmap(image_layer, bitmap);

    notes[NOTE_C] = gbitmap_create_with_resource(RESOURCE_ID_NOTE_C);
    notes[NOTE_D] = gbitmap_create_with_resource(RESOURCE_ID_NOTE_D);
    notes[NOTE_E] = gbitmap_create_with_resource(RESOURCE_ID_NOTE_E);
    notes[NOTE_F] = gbitmap_create_with_resource(RESOURCE_ID_NOTE_F);
    notes[NOTE_G] = gbitmap_create_with_resource(RESOURCE_ID_NOTE_G);
    notes[NOTE_A] = gbitmap_create_with_resource(RESOURCE_ID_NOTE_A);
    notes[NOTE_B] = gbitmap_create_with_resource(RESOURCE_ID_NOTE_B);
    notes[NOTE_HI_C] = gbitmap_create_with_resource(RESOURCE_ID_NOTE_HI_C);

    layer_add_child(window_layer, bitmap_layer_get_layer(image_layer));
    /* layer_add_child(window_layer, bitmap_layer_get_layer(note_layer)); */
    layer_insert_above_sibling(bitmap_layer_get_layer(note_layer), bitmap_layer_get_layer(image_layer));

    accel_data_service_subscribe(0, accel_handler);
    accel_service_set_sampling_rate(ACCEL_SAMPLING_50HZ);
}
ConnectionStatusComponent* connection_status_component_create(Layer *parent, int x, int y) {
  BitmapLayer *icon_layer = bitmap_layer_create(GRect(x, y, REASON_ICON_WIDTH, REASON_ICON_WIDTH));
  // draw the icon background over the graph
  bitmap_layer_set_compositing_mode(icon_layer, get_element_data(parent)->black ? GCompOpAssignInverted : GCompOpAssign);
  layer_set_hidden(bitmap_layer_get_layer(icon_layer), true);
  layer_add_child(parent, bitmap_layer_get_layer(icon_layer));

  FontChoice font = get_font(FONT_18_BOLD);
  TextLayer *staleness_text = text_layer_create(GRect(
    x + REASON_ICON_WIDTH + 1,
    y + (REASON_ICON_WIDTH - font.height) / 2 - font.padding_top,
    INITIAL_TEXT_SIZE,
    font.height + font.padding_top + font.padding_bottom
  ));
  text_layer_set_font(staleness_text, fonts_get_system_font(font.key));
  text_layer_set_background_color(staleness_text, element_bg(parent));
  text_layer_set_text_color(staleness_text, element_fg(parent));
  text_layer_set_text_alignment(staleness_text, GTextAlignmentLeft);
  layer_set_hidden(text_layer_get_layer(staleness_text), true);
  layer_add_child(parent, text_layer_get_layer(staleness_text));

  ConnectionStatusComponent *c = malloc(sizeof(ConnectionStatusComponent));
  c->icon_layer = icon_layer;
  c->icon_bitmap = NULL;
  c->staleness_text = staleness_text;
  return c;
}
Ejemplo n.º 17
0
static void main_window_load(Window *window) {
  Layer *window_layer = window_get_root_layer(window);
  GRect window_bounds = layer_get_bounds(window_layer);
  window_set_background_color(s_main_window, GColorMalachite);
  
  s_bitmap = gbitmap_create_with_resource(RESOURCE_ID_FACE);
  s_bitmap_layer = bitmap_layer_create(window_bounds);
  bitmap_layer_set_bitmap(s_bitmap_layer, s_bitmap);
  bitmap_layer_set_compositing_mode(s_bitmap_layer, GCompOpSet);
  layer_add_child(window_layer, bitmap_layer_get_layer(s_bitmap_layer));

  action_bar = action_bar_layer_create();
  action_bar_layer_add_to_window(action_bar, s_main_window);
  action_bar_layer_set_click_config_provider(action_bar, click_config_provider);
  
  action_bar_layer_set_icon_animated(action_bar, BUTTON_ID_UP, menu_daily_up, true);
  action_bar_layer_set_icon_animated(action_bar, BUTTON_ID_SELECT, menu_stats_select, true);
  action_bar_layer_set_icon_animated(action_bar, BUTTON_ID_DOWN, menu_settings_down, true);
    
  s_output_layer = text_layer_create(GRect(5, 0, window_bounds.size.w - 5, window_bounds.size.h));
  text_layer_set_font(s_output_layer, fonts_get_system_font(FONT_KEY_GOTHIC_24));
  text_layer_set_background_color(s_output_layer, GColorClear);
  text_layer_set_text(s_output_layer, "Press a Button");
  text_layer_set_text_alignment(s_output_layer, PBL_IF_ROUND_ELSE(GTextAlignmentCenter, GTextAlignmentLeft));
  
  layer_add_child(window_layer, text_layer_get_layer(s_output_layer));
}
Ejemplo n.º 18
0
static void onWindowLoad(Window *window) {
    // 配置按键
    window_set_click_config_provider(window, clickConfigProvider);

    // 窗口信息
    Layer *layer = window_get_root_layer(window);
    bounds = layer_get_bounds(layer);

    // bitmap图层
    GRect fromRect = GRect(0, 0, bounds.size.w, bounds.size.h);
    GRect toRect = GRect(0, bounds.size.h, bounds.size.w, bounds.size.h);
    bitmapLayer = bitmap_layer_create(fromRect);

    // bitmap对象
    bitmap = gbitmap_create_with_resource(RESOURCE_ID_MY_LOGO);
    bitmap_layer_set_compositing_mode(bitmapLayer, GCompOpSet);
    bitmap_layer_set_bitmap(bitmapLayer, bitmap);

    // logo动画
    PropertyAnimation *propAnim = property_animation_create_layer_frame((Layer *)bitmapLayer, &fromRect, &toRect);
    Animation *anim = property_animation_get_animation(propAnim);
    const int delay_ms = 1000;
    const int duration_ms = 3000;
    animation_set_curve(anim, AnimationCurveEaseOut);
    animation_set_delay(anim, delay_ms);
    animation_set_duration(anim, duration_ms);
    animation_schedule(anim);

    // 添加图层
    layer_add_child(window_get_root_layer(window), bitmap_layer_get_layer(bitmapLayer));
}
Ejemplo n.º 19
0
BatteryComponent* battery_component_create(Layer *parent, int16_t x, int16_t y, bool align_right) {
    battery_state_service_subscribe(battery_handler);

    BatteryComponent *c = malloc(sizeof(BatteryComponent));
    c->icon_layer = NULL;
    c->icon_bitmap = NULL;
    c->text_layer = NULL;

    if (get_prefs()->battery_as_number) {

        FontChoice font = get_font(BATTERY_FONT);
        c->text_layer = add_text_layer(
                            parent,
                            GRect(x, y - font.padding_top + font.padding_bottom, BATTERY_TEXT_WIDTH, font.height + font.padding_top + font.padding_bottom),
                            fonts_get_system_font(font.key),
                            element_fg(parent),
                            align_right ? GTextAlignmentRight : GTextAlignmentLeft
                        );

    } else {

        c->icon_layer = bitmap_layer_create(GRect(x, y + BATTERY_ICON_TOP_FUDGE, BATTERY_ICON_WIDTH, BATTERY_ICON_HEIGHT));
        bitmap_layer_set_compositing_mode(c->icon_layer, element_comp_op(parent));
        layer_add_child(parent, bitmap_layer_get_layer(c->icon_layer));

    }

    // XXX
    s_component = c;
    battery_handler(battery_state_service_peek());

    return c;
}
Ejemplo n.º 20
0
static void main_window_load(Window *window) {
  window_set_background_color(window, GColorBlack);

  offscreen_layer = layer_create(GRect(0, 0, 180, 180));
  layer_set_update_proc(offscreen_layer, offscreen_layer_update);

  sun_layer = layer_create(GRect(0, 0, 180, 180));
  layer_set_update_proc(sun_layer, sun_layer_update);

  stars = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_STARS);
  night_layer = bitmap_layer_create(GRect(0, 0, 180, 180));
  bitmap_layer_set_bitmap(night_layer, stars);
  bitmap_layer_set_compositing_mode(night_layer, GCompOpSet);

  sun = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_SUN);
  moon = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_MOON);
  ring_layer = layer_create(GRect(0, 0, 180, 180));
  layer_set_update_proc(ring_layer, ring_layer_update);
  
  time_layer = text_layer_create(GRect(62, 130, 56, 25));
  text_layer_set_background_color(time_layer, GColorOxfordBlue);
  text_layer_set_text_color(time_layer, GColorWhite);
  text_layer_set_text(time_layer, "00:00");
  text_layer_set_font(time_layer, fonts_get_system_font(FONT_KEY_ROBOTO_CONDENSED_21));
  text_layer_set_text_alignment(time_layer, GTextAlignmentCenter);

  layer_add_child(window_get_root_layer(window), offscreen_layer);
  layer_add_child(window_get_root_layer(window), sun_layer);
  layer_add_child(window_get_root_layer(window), bitmap_layer_get_layer(night_layer));
  layer_add_child(window_get_root_layer(window), text_layer_get_layer(time_layer));
  layer_add_child(window_get_root_layer(window), ring_layer);
}
Ejemplo n.º 21
0
void load_weather(Window *window) {
	s_weather_layer = text_layer_create(GRect(0,0,144,50));
	//text_layer_set_text_color(s_weather_layer, GColorWhite);
	text_layer_set_text_color(s_weather_layer, default_color);
  text_layer_set_text_alignment(s_weather_layer, GTextAlignmentCenter);
	text_layer_set_background_color(s_weather_layer, GColorClear);
	text_layer_set_font(s_weather_layer, fonts_get_system_font(FONT_KEY_GOTHIC_14));
	
	s_weather_temp_min = text_layer_create(GRect(126,34,144,50));
	text_layer_set_text_color(s_weather_temp_min, default_color);
	text_layer_set_background_color(s_weather_temp_min, GColorClear);
	text_layer_set_font(s_weather_temp_min, fonts_get_system_font(FONT_KEY_GOTHIC_14));
	
	s_weather_temp_max = text_layer_create(GRect(126,23,144,50));
	text_layer_set_text_color(s_weather_temp_max, default_color);
	text_layer_set_background_color(s_weather_temp_max, GColorClear);
	text_layer_set_font(s_weather_temp_max, fonts_get_system_font(FONT_KEY_GOTHIC_14));
	
  s_weather_icon_layer = bitmap_layer_create(GRect(100, -8, 50, 50));
	//bitmap_layer_set_background_color(s_weather_icon_layer, GColorWhite);
	bitmap_layer_set_compositing_mode(s_weather_icon_layer, GCompOpSet);
  	
	s_weather_icon_draw_layer = layer_create(GRect(118, 1, 25, 25));
	layer_set_update_proc(s_weather_icon_draw_layer, update_weather_cmd_img_proc);
	
	weather_display_refresh();

  layer_add_child(window_get_root_layer(window), text_layer_get_layer(s_weather_layer));
	layer_add_child(window_get_root_layer(window), text_layer_get_layer(s_weather_temp_max));
	layer_add_child(window_get_root_layer(window), text_layer_get_layer(s_weather_temp_min));
	layer_add_child(window_get_root_layer(window), bitmap_layer_get_layer(s_weather_icon_layer));
	layer_add_child(window_get_root_layer(window), s_weather_icon_draw_layer);
}
Ejemplo n.º 22
0
static void window_load(Window *window) {
  Layer *window_layer = window_get_root_layer(window);
  GRect bounds = layer_get_bounds(window_layer);

  s_icon_bitmap = gbitmap_create_with_resource(RESOURCE_ID_CONFIG_REQUIRED);
  GRect bitmap_bounds = gbitmap_get_bounds(s_icon_bitmap);

  s_icon_layer = bitmap_layer_create(GRect(
    (bounds.size.w - bitmap_bounds.size.w) / 2, 
    ((bounds.size.h - bitmap_bounds.size.h) / 2) - 10, 
    bitmap_bounds.size.w, bitmap_bounds.size.h)
  );
  bitmap_layer_set_bitmap(s_icon_layer, s_icon_bitmap);
  bitmap_layer_set_compositing_mode(s_icon_layer, GCompOpSet);
  layer_add_child(window_layer, bitmap_layer_get_layer(s_icon_layer));

  s_title_layer = text_layer_create(GRect(0, 5, bounds.size.w, 60));
  text_layer_set_text(s_title_layer, DIALOG_CONFIG_WINDOW_APP_NAME);
  text_layer_set_text_color(s_title_layer, GColorWhite);
  text_layer_set_background_color(s_title_layer, GColorClear);
  text_layer_set_text_alignment(s_title_layer, GTextAlignmentCenter);
  text_layer_set_font(s_title_layer, fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD));
  layer_add_child(window_layer, text_layer_get_layer(s_title_layer));

  s_body_layer = text_layer_create(GRect(5, 120, bounds.size.w - 10, 60));
  text_layer_set_text(s_body_layer, DIALOG_CONFIG_WINDOW_MESSAGE);
  text_layer_set_text_color(s_body_layer, GColorWhite);
  text_layer_set_background_color(s_body_layer, GColorClear);
  text_layer_set_font(s_body_layer, fonts_get_system_font(FONT_KEY_GOTHIC_18_BOLD));
  text_layer_set_text_alignment(s_body_layer, GTextAlignmentCenter);
  layer_add_child(window_layer, text_layer_get_layer(s_body_layer));
}
Ejemplo n.º 23
0
static void sync_tuple_changed_callback(const uint32_t key, const Tuple* new_tuple, const Tuple* old_tuple, void* context) {
  switch (key) {
    case WEATHER_ICON_KEY:
      if (s_icon_bitmap) {
        gbitmap_destroy(s_icon_bitmap);
      }

      s_icon_bitmap = gbitmap_create_with_resource(WEATHER_ICONS[new_tuple->value->uint8]);

#ifdef PBL_SDK_3
      bitmap_layer_set_compositing_mode(s_icon_layer, GCompOpSet);
#endif

      bitmap_layer_set_bitmap(s_icon_layer, s_icon_bitmap);
      break;

    case WEATHER_TEMPERATURE_KEY:
      // App Sync keeps new_tuple in s_sync_buffer, so we may use it directly
      text_layer_set_text(s_temperature_layer, new_tuple->value->cstring);
      break;

    case WEATHER_CITY_KEY:
      text_layer_set_text(s_city_layer, new_tuple->value->cstring);
      break;
  }
}
Ejemplo n.º 24
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 the TextLayer with specific bounds
  s_time_layer = text_layer_create(
      GRect(PBL_IF_ROUND_ELSE(32, 28), PBL_IF_ROUND_ELSE(65, 60), bounds.size.w, 60));
  
  // Improve the layout to be more like a watchface
  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_font(s_time_layer, fonts_get_system_font(PBL_IF_ROUND_ELSE(FONT_KEY_LECO_32_BOLD_NUMBERS, FONT_KEY_LECO_26_BOLD_NUMBERS_AM_PM)));
  text_layer_set_text_alignment(s_time_layer, GTextAlignmentCenter);
  

  
  // Add to Window 
  s_bitmap = gbitmap_create_with_resource(PBL_IF_ROUND_ELSE(RESOURCE_ID_TORI, RESOURCE_ID_TORIS));
  s_bitmap_layer = bitmap_layer_create(bounds);
  bitmap_layer_set_background_color(s_bitmap_layer, GColorTiffanyBlue);
  bitmap_layer_set_bitmap(s_bitmap_layer, s_bitmap);
  bitmap_layer_set_compositing_mode(s_bitmap_layer, GCompOpSet);
  layer_add_child(window_layer, bitmap_layer_get_layer(s_bitmap_layer));
  
  
  // Add it as a child layer to the Window's root layer
  layer_add_child(window_layer, text_layer_get_layer(s_time_layer));

}
Ejemplo n.º 25
0
static void window_load(Window *window) {
  Layer *window_layer = window_get_root_layer(window);
  GRect bounds = layer_get_bounds(window_layer);

  s_icon_bitmap = gbitmap_create_with_resource(RESOURCE_ID_CONFIRM);
  GRect bitmap_bounds = gbitmap_get_bounds(s_icon_bitmap);

  s_header_layer = text_layer_create(GRect(10, 5, 124,
    bounds.size.h - (10 + bitmap_bounds.size.h + 15)));
  text_layer_set_text(s_header_layer, RESULTS_WINDOW_HEADER);
  text_layer_set_background_color(s_header_layer, GColorClear);
  text_layer_set_text_alignment(s_header_layer, GTextAlignmentCenter);
  text_layer_set_font(s_header_layer, fonts_get_system_font(FONT_KEY_BITHAM_30_BLACK));
  layer_add_child(window_layer, text_layer_get_layer(s_header_layer));

  s_icon_layer = bitmap_layer_create(GRect((bounds.size.w / 2) -
    (bitmap_bounds.size.w / 2), 45, bitmap_bounds.size.w, bitmap_bounds.size.h));
  bitmap_layer_set_bitmap(s_icon_layer, s_icon_bitmap);
  bitmap_layer_set_compositing_mode(s_icon_layer, GCompOpSet);
  layer_add_child(window_layer, bitmap_layer_get_layer(s_icon_layer));

  s_label_layer = text_layer_create(GRect(10, 30 + bitmap_bounds.size.h + 5, 124,
    bounds.size.h - (10 + bitmap_bounds.size.h + 15)));
  set_results_speed(0);
  text_layer_set_background_color(s_label_layer, GColorClear);
  text_layer_set_text_alignment(s_label_layer, GTextAlignmentCenter);
  text_layer_set_font(s_label_layer, fonts_get_system_font(FONT_KEY_GOTHIC_24_BOLD));
  layer_add_child(window_layer, text_layer_get_layer(s_label_layer));
}
Ejemplo n.º 26
0
void setup_bolt()
{
	bolt = bitmap_layer_create(FRAME01);
	bitmap_layer_set_bitmap(bolt, bolt_image);
	bitmap_layer_set_compositing_mode(bolt, GCompOpAnd);
	layer_add_child(window_get_root_layer(window),  bitmap_layer_get_layer(bolt));
	layer_set_hidden(bitmap_layer_get_layer(bolt), true);	
}
Ejemplo n.º 27
0
static void window_load(Window *window) {
  Layer *root_layer = window_get_root_layer(window);
  GRect bounds = layer_get_bounds(root_layer);

  s_bitmap_layer = bitmap_layer_create(bounds);
  bitmap_layer_set_compositing_mode(s_bitmap_layer, GCompOpSet);
  layer_add_child(root_layer, bitmap_layer_get_layer(s_bitmap_layer));
}
Ejemplo n.º 28
0
void setup_explosion()
{
	explosion = bitmap_layer_create(LASTFRAME);
	bitmap_layer_set_bitmap(explosion, explosion_image);
	bitmap_layer_set_compositing_mode(explosion, GCompOpAnd);
	layer_add_child(window_get_root_layer(window),  bitmap_layer_get_layer(explosion));
	layer_set_hidden(bitmap_layer_get_layer(explosion), true);	
}
Ejemplo n.º 29
0
void custom_main_window_load(Window *window) {
    Layer *window_layer=window_get_root_layer(window);
#ifdef BG_IMAGE_GRECT
    GRect bounds=BG_IMAGE_GRECT;  /* Hand crafted */
#else /* BG_IMAGE_GRECT */
    GRect bounds=layer_get_bounds(window_layer);  /* screen size, center image */
#endif /* BG_IMAGE_GRECT */


    // Create GBitmap, then set to created BitmapLayer
    s_background_bitmap_main = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_MAIN);
    s_background_bitmap_alt = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_ALT);
    
    s_background_layer = bitmap_layer_create(bounds);

#ifdef FAST_SWITCH
    /* show s_bg_image and then within 1 second show the next image */
    if (s_bg_image == RESOURCE_ID_IMAGE_MAIN)
#else /* not FAST_SWITCH */
    /*
    ** set reverse image,  TICK_HANDLER()/custom_tick_handler() is called
    ** almost immediately which will toggle the image
    */
    if (s_bg_image != RESOURCE_ID_IMAGE_MAIN)
#endif /* FAST_SWITCH/KEEP_IMAGE */
    {
        bitmap_layer_set_bitmap(s_background_layer, s_background_bitmap_main);
    }
    else
    {
        bitmap_layer_set_bitmap(s_background_layer, s_background_bitmap_alt);
    }

#ifdef PBL_COLOR
     bitmap_layer_set_compositing_mode(s_background_layer, GCompOpSet);
#else /* PBL_BW MONO */
     bitmap_layer_set_compositing_mode(s_background_layer, GCompOpAssign);
#endif

    window_set_background_color(main_window, background_color);

    layer_add_child(window_layer, bitmap_layer_get_layer(s_background_layer));

    /* End of custom code, call generic code */
    main_window_load(window);
}
Ejemplo n.º 30
0
void LoadMainBmpImage(Window *window, int id, int floorId)
{
	int resourceId = id;
	
	Layer *window_layer = window_get_root_layer(window);
	
#if DISABLE_MENU_BMPS
	return;
#endif
	
	if(!window)
	{
		DEBUG_LOG("Skipping image load due to window not yet available.");
		return;
	}
		
	if(mainImageLoaded)
	{
		if(mainImageResourceLoaded == resourceId)
		{
			DEBUG_LOG("Resource %d already loaded.", resourceId);
			if(floorImageLoaded)
				layer_add_child(window_layer, bitmap_layer_get_layer(floorImage));
			layer_add_child(window_layer, bitmap_layer_get_layer(mainImage));
			return; // already loaded the correct one.
		}
		DEBUG_LOG("Unloading resourceId %d.", mainImageResourceLoaded);
		UnloadMainBmpImage();
	}
	
	DEBUG_LOG("Loading resourceId %d.", resourceId);

#if defined(PBL_COLOR)
	if(floorId >= 0)
	{
		floorImageBitmap = gbitmap_create_with_resource(floorId);
		floorImage = bitmap_layer_create(mainFrame);
		bitmap_layer_set_bitmap(floorImage, floorImageBitmap);
		bitmap_layer_set_alignment(floorImage, GAlignCenter);
		layer_add_child(window_layer, bitmap_layer_get_layer(floorImage));
		floorImageLoaded = true;
	}
#endif

	ProfileLogStart("LoadMainBmpImage");
	mainImageBitmap = gbitmap_create_with_resource(resourceId);
	mainImage = bitmap_layer_create(mainFrame);
	bitmap_layer_set_bitmap(mainImage, mainImageBitmap);
	bitmap_layer_set_alignment(mainImage, GAlignCenter);
#if defined(PBL_COLOR)
	bitmap_layer_set_compositing_mode(mainImage, GCompOpSet);
#endif
	layer_add_child(window_layer, bitmap_layer_get_layer(mainImage));
	mainImageLoaded = true;
	mainImageResourceLoaded = resourceId;
	ProfileLogStop("LoadMainBmpImage");
}