예제 #1
0
static bool update_sliding_row(SlidingTextData *data, SlidingRow *row) {
  (void) data;

  GRect frame = layer_get_frame(text_layer_get_layer(row->label));
  bool something_changed = true;
  switch (row->state) {
    case PREPARE_TO_MOVE:
      frame.origin.x = row->still_pos;
      row->delay_count++;
      if (row->delay_count > row->movement_delay) {
        row->state = MOVING_OUT;
        row->delay_count = 0;
      }
    break;

    case MOVING_IN: {
      int speed = abs(frame.origin.x - row->still_pos) / 3 + 1;
      frame.origin.x -= speed;
      if (frame.origin.x <= row->still_pos) {
        frame.origin.x = row->still_pos;
        row->state = IN_FRAME;
      }
    }
    break;

    case MOVING_OUT: {
      int speed = abs(frame.origin.x - row->still_pos) / 3 + 1;
      frame.origin.x -= speed;

      if (frame.origin.x <= row->left_pos) {
        frame.origin.x = row->right_pos;
        row->state = MOVING_IN;
        text_layer_set_text(row->label, row->next_string);
        row->next_string = NULL;
      }
    }
    break;

    case IN_FRAME:
    default:
      something_changed = false;
      break;
  }
  if (something_changed) {
    layer_set_frame(text_layer_get_layer(row->label), frame);
  }
  return something_changed;
}
static void set_container_image(GBitmap **bmp_image, BitmapLayer *bmp_layer, const int resource_id, GPoint origin) {
  GBitmap *old_image = *bmp_image;

  *bmp_image = gbitmap_create_with_resource(resource_id);
#ifdef PBL_PLATFORM_BASALT
  GRect bitmap_bounds = gbitmap_get_bounds((*bmp_image));
#else
  GRect bitmap_bounds = (*bmp_image)->bounds;
#endif
  GRect frame = GRect(origin.x, origin.y, bitmap_bounds.size.w, bitmap_bounds.size.h);
  bitmap_layer_set_bitmap(bmp_layer, *bmp_image);
  layer_set_frame(bitmap_layer_get_layer(bmp_layer), frame);

  if (old_image != NULL) {
  	gbitmap_destroy(old_image);
  }
}
// Handle the start-up of the app
void handle_init(AppContextRef app_ctx) {

    // Create our app's base window
    window_init(&window, "Peanut Butter Jelly Time");
    window_stack_push(&window, true);
    window_set_background_color(&window, GColorBlack);

    GFont font_date;

    resource_init_current_app(&APP_RESOURCES);

    font_date = fonts_get_system_font(FONT_KEY_GOTHIC_14);

    // 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);


    // Set up a layer for the hour hand
    rotbmp_pair_init_container(RESOURCE_ID_IMAGE_HOUR_HAND_WHITE, RESOURCE_ID_IMAGE_HOUR_HAND_BLACK, &hour_hand_image_container);
    rotbmp_pair_layer_set_src_ic(&hour_hand_image_container.layer, GPoint(33, 40));
    layer_add_child(&window.layer, &hour_hand_image_container.layer.layer);


    // Set up a layer for the minute hand
    rotbmp_pair_init_container(RESOURCE_ID_IMAGE_MINUTE_HAND_WHITE, RESOURCE_ID_IMAGE_MINUTE_HAND_BLACK, &minute_hand_image_container);
    rotbmp_pair_layer_set_src_ic(&minute_hand_image_container.layer, GPoint(16, 60));
    layer_add_child(&window.layer, &minute_hand_image_container.layer.layer);

    // Set up a layer for the 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(8, 152, 144-8, 168-92));
    text_layer_set_font(&text_date_layer, font_date);
    text_layer_set_text_alignment(&text_date_layer,GTextAlignmentCenter);
    layer_add_child(&window.layer, &text_date_layer.layer);


    PblTm t;
    get_time(&t);
    update_watch(&t);

    last_wday = -1;

}
예제 #4
0
void set_container_image(RotBmpPairContainer  *bmp_container, const int resource_id_white, const int resource_id_black, GPoint origin, int digit, int position) {
 
  layer_remove_from_parent(&bmp_container->layer.layer);
  rotbmp_pair_deinit_container(bmp_container);

  rotbmp_pair_init_container(resource_id_white, resource_id_black, bmp_container);

  GRect frame = layer_get_frame(&bmp_container->layer.layer);
  frame.origin.x = origin.x - 13;
  frame.origin.y = origin.y;
  if (position == 2 && digit == 1) {
	frame.origin.x -= 16;
  }
  layer_set_frame(&bmp_container->layer.layer, frame);

  layer_add_child(&window.layer, &bmp_container->layer.layer);
}
예제 #5
0
static void initialise_ui(void) {
  s_window = window_create();
  window_set_background_color(s_window, GColorBlack);
  IF_A(window_set_fullscreen(s_window, true));
  
  s_res_img_standby = gbitmap_create_with_resource(RESOURCE_ID_IMG_STANDBY);
  s_res_img_settings = gbitmap_create_with_resource(RESOURCE_ID_IMG_SETTINGS);
  s_res_roboto_bold_subset_49 = fonts_get_system_font(FONT_KEY_ROBOTO_BOLD_SUBSET_49);
  s_res_gothic_18_bold = fonts_get_system_font(FONT_KEY_GOTHIC_18_BOLD);
  // action_layer
  action_layer = action_bar_layer_create();
  action_bar_layer_add_to_window(action_layer, s_window);
  action_bar_layer_set_background_color(action_layer, GColorWhite);
  action_bar_layer_set_icon(action_layer, BUTTON_ID_UP, s_res_img_standby);
  action_bar_layer_set_icon(action_layer, BUTTON_ID_DOWN, s_res_img_settings);
  layer_set_frame(action_bar_layer_get_layer(action_layer), GRect(124, 0, 20, 168));
  IF_B(layer_set_bounds(action_bar_layer_get_layer(action_layer), GRect(-5, 0, 30, 168)));
  layer_add_child(window_get_root_layer(s_window), (Layer *)action_layer);
  
  // clockbg_layer
  clockbg_layer = text_layer_create(GRect(0, 60, 144, 50));
  text_layer_set_background_color(clockbg_layer, GColorBlack);
  text_layer_set_text_color(clockbg_layer, GColorClear);
  text_layer_set_text(clockbg_layer, "    ");
  layer_add_child(window_get_root_layer(s_window), (Layer *)clockbg_layer);
  
  // clock_layer
  clock_layer = text_layer_create(GRect(0, 52, 144, 65));
  text_layer_set_background_color(clock_layer, GColorClear);
  text_layer_set_text_color(clock_layer, GColorWhite);
  text_layer_set_text(clock_layer, "23:55");
  text_layer_set_text_alignment(clock_layer, GTextAlignmentCenter);
  text_layer_set_font(clock_layer, s_res_roboto_bold_subset_49);
  layer_add_child(window_get_root_layer(s_window), (Layer *)clock_layer);
  
  // onoff_layer
  onoff_layer = text_layer_create(GRect(2, 2, 119, 56));
  layer_set_update_proc(text_layer_get_layer(onoff_layer), draw_onoff); 
  layer_add_child(window_get_root_layer(s_window), (Layer *)onoff_layer);
  
  // info_layer
  info_layer = text_layer_create(GRect(2, 110, 119, 56));
  layer_set_update_proc(text_layer_get_layer(info_layer), draw_info); 
  layer_add_child(window_get_root_layer(s_window), (Layer *)info_layer);
}
예제 #6
0
// init app and setup
void handle_init(AppContextRef ctx) {
  (void)ctx;

  // init main window and app wide resources
  window_init(&main_window, "Lively");
  window_stack_push(&main_window, true);
  window_set_background_color(&main_window, GColorClear);
  resource_init_current_app(&APP_RESOURCES);

  // custom fonts
  avenir_font = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_AVENIR_NEXT_COND_42));
  silkscreen_font = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_SILKSCREEN_8));

  // background image
  layer_init(&background_layer, GRect(0, 0, SCREEN_WIDWTH, SCREEN_HEIGHT));
  bmp_init_container(RESOURCE_ID_EDWARD_AND_KATE, &background_image);
  layer_add_child(&main_window.layer, &background_image.layer.layer);
  layer_set_frame(&background_image.layer.layer, GRect(0, 0, SCREEN_WIDWTH, SCREEN_HEIGHT));

  // date text
  text_layer_init(&date_text_layer, GRect(99, 100, 45, 8));
  text_layer_set_font(&date_text_layer, silkscreen_font);
  text_layer_set_text_alignment(&date_text_layer, GTextAlignmentRight);
  text_layer_set_text_color(&date_text_layer, GColorWhite);
  text_layer_set_background_color(&date_text_layer, /*GColorClear*/ GColorBlack);
  layer_add_child(&main_window.layer, &date_text_layer.layer); 

  // init time text
  text_layer_init(&time_text_layer, GRect(22, 108, 120, 42));
  text_layer_set_font(&time_text_layer, avenir_font);
  text_layer_set_text_alignment(&time_text_layer, GTextAlignmentRight);
  text_layer_set_text_color(&time_text_layer, GColorWhite);
  text_layer_set_background_color(&time_text_layer, GColorBlack);
  layer_add_child(&main_window.layer, &time_text_layer.layer);

  // update initial time
  PblTm current_time;
  get_time(&current_time);
  update_time(ctx, &current_time);

  // button bindings
  window_set_click_config_provider(&main_window, (ClickConfigProvider) config_provider);
}
예제 #7
0
파일: main.c 프로젝트: SahaSG552/PebbleDicT
static void inbox_received_callback(DictionaryIterator *iterator, void *context) {
  Tuple *tuple = dict_find(iterator, 0);
  if (!tuple) {
    APP_LOG(APP_LOG_LEVEL_ERROR, "The tuple was missing!");
    return;
  }
  s_speaking_enabled = true;
  APP_LOG(APP_LOG_LEVEL_INFO, "Got message: %s", tuple->value->cstring);
  snprintf(s_defn_buffer, sizeof(s_defn_buffer), "%s", tuple->value->cstring);
  //where the word and def show up
  
  GSize size = graphics_text_layout_get_content_size(s_defn_buffer, fonts_get_system_font(FONT_KEY_GOTHIC_18_BOLD),
                                        GRect(0, 0, 134, 1000), GTextOverflowModeWordWrap, GTextAlignmentCenter);
  layer_set_frame((Layer *)s_def_layer, GRect(5, 40, 134, size.h));
  scroll_layer_set_content_size(s_scroll_layer, GSize(144, 50 + size.h));
  text_layer_set_text(s_word_layer, s_last_text_buffer); 
  text_layer_set_text(s_def_layer, s_defn_buffer);
  window_stack_push(s_def_window, true);
}
예제 #8
0
파일: Aviator.c 프로젝트: Dr-Mike/aviator
static void toggleSeconds(bool hidden) {
    layer_set_hidden(bitmap_layer_get_layer(time_digits_layers[5]), hidden);
    layer_set_hidden(bitmap_layer_get_layer(time_digits_layers[6]), hidden);
    layer_set_hidden(bitmap_layer_get_layer(time_digits_layers[7]), hidden);

    layer_set_hidden(bitmap_layer_get_layer(zulu_time_digits_layers[5]), hidden);
    layer_set_hidden(bitmap_layer_get_layer(zulu_time_digits_layers[6]), hidden);
    layer_set_hidden(bitmap_layer_get_layer(zulu_time_digits_layers[7]), hidden);

    if (hidden) {
		// seconds aren't visible
		if (mTimeLayerShifted) {
			// 12hr clock, single digit
			layer_set_frame(time_layer, GRect(9, 0, 144, 168));
		} else {
			layer_set_frame(time_layer, GRect(16, 0, 144, 168));
		}
		if (mZuluLayerShifted) {
			// 12hr clock, single digit
			layer_set_frame(zulu_time_layer, GRect(9, 0, 144, 168));
		} else {
			layer_set_frame(zulu_time_layer, GRect(16, 0, 144, 168));
		}

    } else {
        // seconds are visible
		if (mTimeLayerShifted) {
			// 12hr clock, single digit
			layer_set_frame(time_layer, GRect(-7, 0, 144, 168));
		} else {
			layer_set_frame(time_layer, GRect(0, 0, 144, 168));
		}
		if (mZuluLayerShifted) {
			// 12hr clock, single digit
			layer_set_frame(zulu_time_layer, GRect(-7, 0, 144, 168));
		} else {
			layer_set_frame(zulu_time_layer, GRect(0, 0, 144, 168));
		}
    }
}
예제 #9
0
파일: mainwin.c 프로젝트: SeaPea/GentleWake
static void initialise_ui(void) {
  
  Layer *root_layer = NULL;
  GRect bounds; 
  s_window = window_create_fullscreen(&root_layer, &bounds);
  
  s_res_img_standby = gbitmap_create_with_resource(RESOURCE_ID_IMG_STANDBY);
  s_res_img_settings = gbitmap_create_with_resource(RESOURCE_ID_IMG_SETTINGS);
  s_res_roboto_bold_subset_49 = fonts_get_system_font(FONT_KEY_ROBOTO_BOLD_SUBSET_49);
  s_res_gothic_18_bold = fonts_get_system_font(FONT_KEY_GOTHIC_18_BOLD);
  // action_layer
  action_layer = action_bar_layer_create();
  action_bar_layer_add_to_window(action_layer, s_window);
  action_bar_layer_set_background_color(action_layer, GColorWhite);
  action_bar_layer_set_icon(action_layer, BUTTON_ID_UP, s_res_img_standby);
  action_bar_layer_set_icon(action_layer, BUTTON_ID_DOWN, s_res_img_settings);
#ifdef PBL_RECT
  layer_set_frame(action_bar_layer_get_layer(action_layer), GRect(bounds.size.w-20, 0, 20, bounds.size.h));
  IF_3(layer_set_bounds(action_bar_layer_get_layer(action_layer), GRect(-6, 0, 31, bounds.size.h)));
  // Put Action Bar underneath other layers on rectangular Pebbles
  layer_add_child(root_layer, action_bar_layer_get_layer(action_layer));
#endif
  
  // clock_layer
  clock_layer = layer_create_with_proc(root_layer, draw_clock,
                                       GRect(0 - PBL_IF_RECT_ELSE(0, ACTION_BAR_WIDTH/2), (bounds.size.h/2)-32-PBL_IF_ROUND_ELSE(2, 0), bounds.size.w, 65));
  
  // onoff_layer
  onoff_layer = layer_create_with_proc(root_layer, draw_onoff,
                                      PBL_IF_RECT_ELSE(GRect(2, (bounds.size.h/2)-82, 119, 56),
                                                   GRect(-10, (bounds.size.h/2)-82, bounds.size.w+11, 56)));
  
  // info_layer
  info_layer = layer_create_with_proc(root_layer, draw_info,
                                     PBL_IF_RECT_ELSE(GRect(2, (bounds.size.h/2)+26, 119, 56),
                                                 GRect(-10, (bounds.size.h/2)+24, bounds.size.w+11, 56)));
  
#ifdef PBL_ROUND
  // Put Action Bar on top for Pebble Round
  layer_add_child(root_layer, (Layer *)action_layer);
#endif
}
예제 #10
0
// --------------------------------------------------------
//			page_start_tick()
//		(called from TempusFugit tick handler)
// --------------------------------------------------------
void page_start_tick(int tick_count) {

	if(tick_count < (NUMBER_OF_IMAGES - 1)) {		// Increment tick_count & Animate Logo
		layer_remove_from_parent(&page_start_logo_data.image_container[tick_count].layer.layer);
		page_start_logo_data.current_logo = page_start_logo_data.current_logo+1;
		layer_set_frame(&page_start_logo_data.image_container[page_start_logo_data.current_logo].layer.layer, GRect(24,2,100,115));
		layer_add_child(&tf_start_window.layer, &page_start_logo_data.image_container[page_start_logo_data.current_logo].layer.layer);
	}

	else if (tick_count == NUMBER_OF_IMAGES){		// Show "Tempus" field
		layer_add_child(&tf_start_window.layer, &tempus_layer.layer);	
	}
	else if (tick_count == (NUMBER_OF_IMAGES+1)){	// Show "Fugit" field
		layer_add_child(&tf_start_window.layer, &fugit_layer.layer);	
	}	
	else if (tick_count == (NUMBER_OF_IMAGES+2)){	// Show version field
		layer_add_child(&tf_start_window.layer, &version_layer.layer);	
	}


}  // page_start_tick(int tick_count)
예제 #11
0
void handle_init(AppContextRef ctx) {
    (void)ctx;
    
    window_init(&window, "FSU Spear");
    window_stack_push(&window, true /* Animated */);
    window_set_background_color(&window, GColorBlack);
    
    resource_init_current_app(&RESOURCES);
    
    
    bmp_init_container(RESOURCE_ID_IMAGE_FSU_SPEAR, &image_container);
    layer_add_child(&window.layer, &image_container.layer.layer);
    
    text_layer_init(&text_time_layer, window.layer.frame);
    text_layer_set_text_color(&text_time_layer, GColorWhite);
    text_layer_set_text_alignment(&text_time_layer, GTextAlignmentCenter);
    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_AVENIR_44)) /*fonts_get_system_font(FONT_KEY_GOTHAM_30_BLACK)*/);
    layer_set_frame(&text_time_layer.layer, GRect(0,116,144,68));
    layer_add_child(&window.layer, &text_time_layer.layer);
}
static void prv_draw_cell_backgrounds(Layer *layer, GContext *ctx) {
  SelectionLayerData *data = layer_get_data(layer);
  // Loop over each cell and draw the background rectangles
  for (int i = 0, current_x_offset = 0; i < data->num_cells; i++) {
    if (data->cell_widths[i] == 0) {
      continue;
    }

    int y_offset = 0;
    if (data->selected_cell_idx == i && data->bump_is_upwards) {
      y_offset = -prv_get_pixels_for_bump_settle(data->bump_settle_anim_progress);
    }

    int height = layer_get_bounds(layer).size.h;
    if (data->selected_cell_idx == i) {
      height += prv_get_pixels_for_bump_settle(data->bump_settle_anim_progress);
    }

    const GRect rect = GRect(current_x_offset, y_offset, data->cell_widths[i], height);

#ifdef PBL_SDK_3
    GColor bg_color = data->inactive_background_color;

    if (data->selected_cell_idx == i && !data->slide_amin_progress) {
      bg_color = data->active_background_color;
    }
    graphics_context_set_fill_color(ctx, bg_color);
    graphics_fill_rect(ctx, rect, 1, GCornerNone);
#elif PBL_SDK_2
    graphics_context_set_stroke_color(ctx, GColorBlack);
    graphics_draw_rect(ctx, rect);

    if (data->selected_cell_idx == i && !data->slide_amin_progress){
      layer_set_frame(inverter_layer_get_layer(data->inverter), rect);
    }
#endif

    current_x_offset += data->cell_widths[i] + data->cell_padding;
  }
}
static void prv_draw_slider_slide(Layer *layer, GContext *ctx) {
  SelectionLayerData *data = layer_get_data(layer);
  
  int starting_x_offset = 0;
  for (int i = 0; i < data->num_cells; i++) {
    if (data->selected_cell_idx == i) {
      break;
    }
    starting_x_offset += data->cell_widths[i] + data->cell_padding;
  }

  int next_cell_width = data->cell_widths[data->selected_cell_idx + 1];
  if (!data->slide_is_forward) {
    next_cell_width = data->cell_widths[data->selected_cell_idx - 1];
  }
  
  int slide_distance = next_cell_width + data->cell_padding;
  int current_slide_distance = (slide_distance * data->slide_amin_progress) / 100;
  if (!data->slide_is_forward) {
    current_slide_distance = -current_slide_distance;
  }

  int current_x_offset = starting_x_offset + current_slide_distance;
  int cur_cell_width = data->cell_widths[data->selected_cell_idx];
  int total_cell_width_change = next_cell_width - cur_cell_width + data->cell_padding;
  int current_cell_width_change = (total_cell_width_change * (int) data->slide_amin_progress) / 100;
  int current_cell_width = cur_cell_width + current_cell_width_change;
  if (!data->slide_is_forward) {
    current_x_offset -= current_cell_width_change;
  }

  GRect rect = GRect(current_x_offset, 0, current_cell_width, layer_get_bounds(layer).size.h);

#ifdef PBL_COLOR
  graphics_context_set_fill_color(ctx, data->active_background_color);
  graphics_fill_rect(ctx, rect, 1, GCornerNone);
#else
  layer_set_frame(inverter_layer_get_layer(data->inverter), rect);
#endif
}
static Layer* selection_layer_init(SelectionLayerData *selection_layer_, GRect frame, int num_cells) {
  Layer *layer = layer_create_with_data(frame, sizeof(SelectionLayerData));
  SelectionLayerData *selection_layer_data = layer_get_data(layer);

  if (num_cells > MAX_SELECTION_LAYER_CELLS) {
    num_cells = MAX_SELECTION_LAYER_CELLS;
  }
  
  // Set layer defaults
  *selection_layer_data = (SelectionLayerData) {
#ifdef PBL_COLOR
    .active_background_color = DEFAULT_ACTIVE_COLOR,
    .inactive_background_color = DEFAULT_INACTIVE_COLOR,
#else
    .inverter = inverter_layer_create(GRect(0, 0, 0, frame.size.h)),
#endif
    .num_cells = num_cells,
    .cell_padding = DEFAULT_CELL_PADDING,
    .selected_cell_idx = DEFAULT_SELECTED_INDEX,
    .font = fonts_get_system_font(DEFAULT_FONT),
    .is_active = true,
  };
  for (int i = 0; i < num_cells; i++) {
    selection_layer_data->cell_widths[i] = 0;
  }
  layer_set_frame(layer, frame);
  layer_set_clips(layer, false);
  layer_set_update_proc(layer, (LayerUpdateProc)prv_draw_selection_layer);

#ifndef PBL_COLOR
  layer_add_child(layer, inverter_layer_get_layer(selection_layer_data->inverter));
#endif

  return layer;
}

Layer* selection_layer_create(GRect frame, int num_cells) {
  SelectionLayerData *selection_layer_data = NULL;
  return selection_layer_init(selection_layer_data, frame, num_cells);
}
예제 #15
0
static void
load(Window *window)
{
  Layer *rl = window_get_root_layer(window);
  user_data *ud;
  Layer *l;
  GRect f;
  GSize s;
 
  ud = (user_data*) malloc(sizeof(*ud));
  if (!ud)
    return;
  *ud = (user_data) { .moving = {-1, -1} };
  window_set_user_data(window, ud);
  
  ud->icon = gbitmap_create_with_resource(RESOURCE_ID_MOVE);

  ud->tl = text_layer_create(layer_get_bounds(rl));
  text_layer_set_text(ud->tl, "Use FreeOTP on your mobile device to add tokens.");
  text_layer_set_text_alignment(ud->tl, GTextAlignmentCenter);
  text_layer_set_overflow_mode(ud->tl, GTextOverflowModeWordWrap);
  s = text_layer_get_content_size(ud->tl);
  l = text_layer_get_layer(ud->tl);
  f = layer_get_frame(l);
  f.origin.y = (f.size.h - s.h) / 2;
  f.size.h = s.h;
  layer_set_frame(l, f);
  layer_set_hidden(l, true);
  
  ud->ml = menu_layer_create(layer_get_bounds(rl));
  layer_set_hidden(menu_layer_get_layer(ud->ml), false);
  menu_layer_set_click_config_onto_window(ud->ml, window);
  menu_layer_set_callbacks(ud->ml, ud, (MenuLayerCallbacks) {
    .draw_row = menu_draw_row,
    .get_num_rows = menu_get_num_rows,
    .select_click = menu_select_click,
    .select_long_click = menu_select_long_click,
    .selection_changed = menu_selection_changed
  });
예제 #16
0
파일: main.c 프로젝트: ShaBP/91DubPro
/*
static void sync_tuple_changed_callback(const uint32_t key, const Tuple* new_tuple, const Tuple* old_tuple, void* context) {
  switch (key) {
    case BLINK_KEY:
      settings.Blink = new_tuple->value->uint8;
      tick_timer_service_unsubscribe();
      if(settings.Blink) {
        tick_timer_service_subscribe(SECOND_UNIT, handle_tick);
      }
      else {
        tick_timer_service_subscribe(MINUTE_UNIT, handle_tick);
      }
      break;
    case INVERT_KEY:
      settings.Invert = new_tuple->value->uint8;
      change_background();
      break;
    case BLUETOOTHVIBE_KEY:
      settings.BluetoothVibe = new_tuple->value->uint8;
      break;      
    case HOURLYVIBE_KEY:
      settings.HourlyVibe = new_tuple->value->uint8;
      break;
    case BRANDING_MASK_KEY:
      settings.BrandingMask = new_tuple->value->uint8;
      layer_set_hidden(bitmap_layer_get_layer(branding_mask_layer), !settings.BrandingMask);
      break;
  }
}
*/
static void set_container_image(GBitmap **bmp_image, BitmapLayer *bmp_layer, const int resource_id, GPoint origin) {
  GBitmap *old_image = *bmp_image;
  *bmp_image = gbitmap_create_with_resource(resource_id);
  GRect frame = (GRect) {
    .origin = origin,
    .size = (*bmp_image)->bounds.size
  };
  bitmap_layer_set_bitmap(bmp_layer, *bmp_image);
  layer_set_frame(bitmap_layer_get_layer(bmp_layer), frame);
  if (old_image != NULL) {
	gbitmap_destroy(old_image);
	old_image = NULL;
  }
}

static void update_battery(BatteryChargeState charge_state) {

  batteryPercent = charge_state.charge_percent;

  if(batteryPercent==100) {
	change_battery_icon(false);
	layer_set_hidden(bitmap_layer_get_layer(battery_layer), false);
    for (int i = 0; i < TOTAL_BATTERY_PERCENT_DIGITS; ++i) {
      layer_set_hidden(bitmap_layer_get_layer(battery_percent_layers[i]), true);
    }  
    return;
  }

  layer_set_hidden(bitmap_layer_get_layer(battery_layer), charge_state.is_charging);
  change_battery_icon(charge_state.is_charging);
    
  for (int i = 0; i < TOTAL_BATTERY_PERCENT_DIGITS; ++i) {
    layer_set_hidden(bitmap_layer_get_layer(battery_percent_layers[i]), false);
  }  
  set_container_image(&battery_percent_image[0], battery_percent_layers[0], TINY_IMAGE_RESOURCE_IDS[charge_state.charge_percent/10], GPoint(89, 43));
  set_container_image(&battery_percent_image[1], battery_percent_layers[1], TINY_IMAGE_RESOURCE_IDS[charge_state.charge_percent%10], GPoint(95, 43));
  set_container_image(&battery_percent_image[2], battery_percent_layers[2], TINY_IMAGE_RESOURCE_IDS[10], GPoint(101, 43));
 
}
예제 #17
0
void LoadMainBmpImage(Window *window, int id)
{
	int resourceId = id;
	
	if(!window)
		return;
		
	if(mainImageLoaded)
	{
		if(mainImageResourceLoaded == resourceId)
		{
			layer_add_child(&window->layer, &mainImage.layer.layer);
			return; // already loaded the correct one.
		}
		UnloadMainBmpImage();
	}
	bmp_init_container(resourceId, &mainImage);
	layer_set_frame(&mainImage.layer.layer, mainFrame);
	layer_add_child(&window->layer, &mainImage.layer.layer);
	mainImageLoaded = true;
	mainImageResourceLoaded = resourceId;
}
예제 #18
0
static void set_container_image(GBitmap **bmp_image, BitmapLayer *bmp_layer, const int resource_id, GPoint origin) {
  GBitmap *old_image = *bmp_image;
  *bmp_image = gbitmap_create_with_resource(resource_id);
  GRect frame = (GRect) {
    .origin = origin,
    .size = (*bmp_image)->bounds.size
  };
  bitmap_layer_set_bitmap(bmp_layer, *bmp_image);
  layer_set_frame(bitmap_layer_get_layer(bmp_layer), frame);
  gbitmap_destroy(old_image);
}

static void toggle_bluetooth_icon(bool connected) {
  if(appStarted && !connected && bluetoothvibe) {
    //vibe!
    vibes_long_pulse();
  }
}

void bluetooth_connection_callback(bool connected) {
  toggle_bluetooth_icon(connected);
}
예제 #19
0
void set_container_image(RotBmpContainer *bmp_container, const int resource_id, GPoint origin) {

  layer_remove_from_parent(&bmp_container->layer.layer);
  rotbmp_deinit_container(bmp_container);

  rotbmp_init_container(resource_id, bmp_container);

	//TODO: This doesn't seem to work when black on white
  time_digits_images[0].layer.compositing_mode = GCompOpOr;
  time_digits_images[1].layer.compositing_mode = GCompOpOr;
  time_colon_image.layer.compositing_mode = GCompOpOr;
  time_digits_images[2].layer.compositing_mode = GCompOpOr;
  time_digits_images[3].layer.compositing_mode = GCompOpOr;
	

  GRect frame = layer_get_frame(&bmp_container->layer.layer);
  frame.origin.x = origin.x;
  frame.origin.y = origin.y;
  layer_set_frame(&bmp_container->layer.layer, frame);

  layer_add_child(&window.layer, &bmp_container->layer.layer);
}
예제 #20
0
MarqueeTextLayer* marquee_text_layer_create(GRect frame) {
    
	MarqueeTextLayer *marquee = layer_create_with_data(frame, sizeof(MarqueeData));
	MarqueeData *marqueedata = (MarqueeData *)layer_get_data(marquee);
	//APP_LOG(APP_LOG_LEVEL_DEBUG, "marquee_text_layer_create: malloc MarqueeTextLayer");
	//APP_LOG(APP_LOG_LEVEL_DEBUG, "marquee_text_layer_create: got a marquee pointer, allocated %d bytes at %p", sizeof(MarqueeTextLayer), marquee);
	
	marqueedata->text = malloc(128); // allocate some bytes for the string
	if (marqueedata->text)
		APP_LOG(APP_LOG_LEVEL_DEBUG, "allocated 128 bytes for marquee->text at %p", marqueedata->text);
	
	
	// And now we lie about our frame. See above.
    //frame.origin.x -= BOUND_OFFSET;
    //frame.size.w += BOUND_OFFSET;
	
	layer_set_frame(marquee,GRect(frame.origin.x - BOUND_OFFSET,frame.origin.y,frame.size.w + BOUND_OFFSET, frame.size.h));
	APP_LOG(APP_LOG_LEVEL_DEBUG, "frame.origin.x = %d, frame.origin.y = %d, frame.size.w = %d, frame.size.h = %d", layer_get_frame(marquee).origin.x, layer_get_frame(marquee).origin.y, layer_get_frame(marquee).size.w, layer_get_frame(marquee).size.h);
	
    //GRect bounds = layer_get_bounds(marquee);
    //APP_LOG(APP_LOG_LEVEL_DEBUG, "pre bounds.origin.x = %d, bounds.origin.y = %d, bounds.size.w = %d, bounds.size.h = %d", bounds.origin.x, bounds.origin.y, bounds.size.w, bounds.size.h);
	//bounds.origin.x += BOUND_OFFSET + 25;
    //APP_LOG(APP_LOG_LEVEL_DEBUG, "post adjust bounds.origin.x = %d, bounds.origin.y = %d, bounds.size.w = %d, bounds.size.h = %d", bounds.origin.x, bounds.origin.y, bounds.size.w, bounds.size.h);
	//layer_set_bounds(marquee, bounds);
	layer_set_bounds(marquee,GRect(layer_get_bounds(marquee).origin.x + BOUND_OFFSET,0,frame.size.w + BOUND_OFFSET, frame.size.h));
	APP_LOG(APP_LOG_LEVEL_DEBUG, "post set bounds.origin.x = %d, bounds.origin.y = %d, bounds.size.w = %d, bounds.size.h = %d", layer_get_bounds(marquee).origin.x, layer_get_bounds(marquee).origin.y, layer_get_bounds(marquee).size.w, layer_get_bounds(marquee).size.h);
    marqueedata->background_colour = GColorWhite;
    marqueedata->text_colour = GColorBlack;
    marqueedata->offset = 0;
	marqueedata->text_width = -1;
    marqueedata->countdown = 100;
    marqueedata->font = fonts_get_system_font(FONT_KEY_FONT_FALLBACK);

	layer_set_clips(marquee, false);
	layer_set_update_proc(marquee, do_draw);
	marquee_text_layer_mark_dirty(marquee);
		
	return marquee;
}
예제 #21
0
void update_date_display(struct tm* tick_time) {
//    strftime(g_date_str, sizeof(g_date_str), "%A\n%x", tick_time);
    strftime(g_date_str, sizeof(g_date_str), "%a %b %d", tick_time);
    for (char* c = g_date_str; *c; ++c) {
        if (*c >= 'a' && *c <= 'z') *c += 'A' - 'a';
    }
    
    GRect layerSize = GRect(0, 0, c_viewportWidth, c_viewportHeight);

    GSize dateSize = graphics_text_layout_get_content_size(
        g_date_str,
        g_font_info,
        layerSize,
        0,
        GTextAlignmentLeft);
    
    layerSize.origin.x = c_viewportWidth - dateSize.w - DT_EDGE_PAD;
    layerSize.origin.y = c_viewportHeight - dateSize.h;
    layerSize.size = dateSize;
    
    text_layer_set_text(dateLayer, g_date_str);
    layer_set_frame((Layer*) dateLayer, layerSize);
}
예제 #22
0
void rot_bitmap_set_src_ic(RotBitmapLayer *image, GPoint ic) {
  image->src_ic = ic;

  // adjust the frame so the whole image will still be visible
  const int32_t horiz = MAX(ic.x, abs(image->bitmap->bounds.size.w - ic.x));
  const int32_t vert = MAX(ic.y, abs(image->bitmap->bounds.size.h - ic.y));

  GRect r = layer_get_frame(&image->layer);
  //// const int32_t new_dist = integer_sqrt(horiz*horiz + vert*vert) * 2;
  const int32_t new_dist = (integer_sqrt(horiz*horiz + vert*vert) * 2) + 1; //// Fudge to deal with non-even dimensions--to ensure right-most and bottom-most edges aren't cut off.

  r.size.w = new_dist;
  r.size.h = new_dist;
  layer_set_frame(&image->layer, r);

  r.origin = GPoint(0, 0);
  ////layer_set_bounds(&image->layer, r);
  image->layer.bounds = r;

  image->dest_ic = GPoint(new_dist / 2, new_dist / 2);

  layer_mark_dirty(&(image->layer));
}
예제 #23
0
파일: main.c 프로젝트: alcor/Chronology
static void tick_handler(struct tm *tick_time, TimeUnits units_changed) {
  update_time();
  layer_mark_dirty(s_hand_layer);
  
  int bhour = tick_time->tm_hour;
  int bmin = tick_time->tm_min;
  float angle = 30 * ((float)(bhour % 12) + ((float)bmin / 60));
  if (debug) angle = 12 * tick_time->tm_sec;
  
  GRect frame = layer_get_frame(s_face_layer);
  GRect frame2 = layer_get_frame(s_hand_layer);
  
  float size = (frame.size.w + frame2.size.w) / 2;
  
  GPoint origin = gpoint_from_polar(grect_inset(frame2, GEdgeInsets(-150)), GOvalScaleModeFitCircle , DEG_TO_TRIGANGLE(angle + 180));
  frame.origin = origin;
  frame.origin.x -= frame.size.w / 2;
  frame.origin.y -= frame.size.w / 2;

  layer_set_frame(s_face_layer, frame);
  
  
}
예제 #24
0
파일: main.c 프로젝트: KeriWarr/MemoryTrain
static void window_load(Window *window) {
    current_question = QA[4];
    
    window_layer = window_get_root_layer(window);
    GRect bounds = layer_get_frame(window_layer);    
    GRect inner = GRect(0,0,112,168);
    
    s_background_bitmap = gbitmap_create_with_resource(RESOURCE_ID_background);
    s_background_layer = bitmap_layer_create(bounds);
    bitmap_layer_set_bitmap(s_background_layer, s_background_bitmap);
    layer_add_child(window_get_root_layer(window), bitmap_layer_get_layer(s_background_layer));
    
    prompt_layer = text_layer_create(inner);
    text_layer_set_text_color(prompt_layer, GColorBlack);
    text_layer_set_background_color(prompt_layer, GColorClear);
    text_layer_set_font(prompt_layer, fonts_get_system_font(FONT_KEY_GOTHIC_18_BOLD));
    text_layer_set_text_alignment(prompt_layer, GTextAlignmentCenter);
    layer_set_frame(
        text_layer_get_layer(prompt_layer),
        GRect(0, ((168 - (text_layer_get_content_size(prompt_layer).h)) / 2) - 4, 112, text_layer_get_content_size(prompt_layer).h)
    );
    layer_add_child(window_layer, text_layer_get_layer(prompt_layer));
}
예제 #25
0
void screen_map_layer_init(Window* window) {

    for (int i = 0; i < NUM_POINTS; i++) {
        pts[i] = GPoint(0, 0);
    }

    s_data.page_map = layer_create(GRect(0,TOPBAR_HEIGHT,SCREEN_W,SCREEN_H-TOPBAR_HEIGHT));
    layer_add_child(window_get_root_layer(window), s_data.page_map);

    for(int i = 0; i < NUM_LIVE_FRIENDS; i++) {
        s_live.friends[i].name_frame = GRect(0, 15, 100, 15);
        s_live.friends[i].name_layer = text_layer_create(s_live.friends[i].name_frame);
        set_layer_attr_full(s_live.friends[i].name_layer, s_live.friends[i].name, font_12, GTextAlignmentLeft, GColorBlack, GColorWhite, s_data.page_map);
    }

    pathFrame = GRect(0, 0, MAP_VSIZE_X, MAP_VSIZE_Y);
    path_layer = layer_create(pathFrame);
    pathFrame.origin.x = -XINI + SCREEN_W/2;
    pathFrame.origin.y = -YINI + SCREEN_H/2;
    layer_set_frame(path_layer, pathFrame);
    layer_set_update_proc(path_layer, path_layer_update_callback);
    layer_add_child(s_data.page_map, path_layer);

    bearing_layer = layer_create(GRect(0, 0, SCREEN_W, SCREEN_H));
    layer_set_update_proc(bearing_layer, bearing_layer_update_callback);
    layer_add_child(s_data.page_map, bearing_layer);

    bearing_gpath = gpath_create(&BEARING_PATH_POINTS);
    gpath_move_to(bearing_gpath, GPoint(SCREEN_W/2, SCREEN_H/2));

    layer_set_hidden(s_data.page_map, true);


    s_gpsdata.xpos=0;
    s_gpsdata.ypos=0;
    s_gpsdata.nb_received=0;
}
예제 #26
0
void refresh_settings(){
	phrases_set_settings(main_settings);

	//Little hack to update the words beforehand
	phrases_get_main_swear(true, true);
	phrases_get_main_swear(false, true);

	text_layer_set_text(second_word_t, phrases_get_main_swear(altWordBuffer, false));
	layer_set_frame(text_layer_get_layer(second_word_t), get_new_frame(second_word_t, phrases_get_main_swear(altWordBuffer, false)));
	adapt_font_size_to_frame(second_word_t);

	layer_set_hidden(inverter_layer_get_layer(theme), !main_settings.invert);
	layer_set_hidden(battery_bar_layer, !main_settings.batteryBar);
	layer_set_hidden(text_layer_get_layer(slot_t), false);
	layer_set_hidden(text_layer_get_layer(seconds_t), !main_settings.seconds);
	switch(main_settings.slotUse){
		case SLOT_USE_NOTHING:
			layer_set_hidden(text_layer_get_layer(slot_t), true);
			break;
		case SLOT_USE_CUSTOM_TEXT:
			text_layer_set_text(slot_t, main_settings.customslottext[0]);
			break;
		case SLOT_USE_BLUETOOTH_STATUS:;
			bool connected = bluetooth_connection_service_peek();
			text_layer_set_text(slot_t, phrases_get_bluetooth(connected));
			break;
	}
	if(main_settings.shakeAction == SHAKE_USE_DISABLED){
		accel_tap_service_unsubscribe();
	}
	else{
		accel_tap_service_unsubscribe();
		accel_tap_service_subscribe(shake_handler);
	}
	notify_bar_set_enabled(main_settings.alerts);
	set_animation_use(main_settings.animation);
}
예제 #27
0
void changeTextFont(myTextLayer *mtl, int font_size) {
  int font_height;
  int font_id;
  int delta_y = 0;
  
  if(font_size==-1) {
    font_height = 10;
    font_id = RESOURCE_ID_FONT_XXS_10;
  }
  if(font_size==0) {
    font_height = 15;
    font_id = RESOURCE_ID_FONT_SMALL_14;
  }
  if(font_size==1) {
    font_height = 20;
    font_id = RESOURCE_ID_FONT_SMALL_18;
  }
  if(font_size==2) {
    font_height = 30;
    font_id = RESOURCE_ID_FONT_MEDIUM_22;
  }
  if(font_size==3) {
    font_height = 35;
    font_id = RESOURCE_ID_FONT_BIG_28;
  }
  if(font_size!=mtl->current_font_size) {
    delta_y = 2*(font_size - mtl->current_font_size);
  }
  
  mtl->current_font_size = font_size;
  Layer *l = text_layer_get_layer(mtl->tl_obj);
  GRect bounds = layer_get_frame(l);
  bounds.size.h = font_height;
  bounds.origin.y -= delta_y;
  layer_set_frame(l,bounds);
  text_layer_set_font(mtl->tl_obj, fonts_load_custom_font(resource_get_handle(font_id)));
}
예제 #28
0
파일: main.c 프로젝트: manelto/pizarra
static void sustituye_imagen(GBitmap **imagen, BitmapLayer *bmp_layer, const int resource_id, GPoint origen) {
    GBitmap *vieja_imagen = *imagen;
    *imagen = gbitmap_create_with_resource(resource_id);
    GRect frame = (GRect) {
        .origin = origen,
        .size = (*imagen)->bounds.size
    };
    bitmap_layer_set_bitmap(bmp_layer, *imagen);
    layer_set_frame(bitmap_layer_get_layer(bmp_layer), frame);
    gbitmap_destroy(vieja_imagen);
}


static void destroy_ui(void) {
  window_destroy(pwindow);
  bitmap_layer_destroy(BLFondo);
  text_layer_destroy(TLHora);
  text_layer_destroy(TLMinuto);
  text_layer_destroy(TLDiaSem);
  text_layer_destroy(TLDia);
  text_layer_destroy(TLMes);
  inverter_layer_destroy(ILFondo);
  text_layer_destroy(TLBateria);
}
예제 #29
0
파일: main.c 프로젝트: exant/BarWatch
void handle_tick(AppContextRef ctx, PebbleTickEvent *event) {
	string_format_time(s_days_in_year_str_buffer, DAYS_IN_YEAR_STR_BUFFER_BYTES, "%j", event->tick_time);
	string_format_time(s_days_in_month_str_buffer, DAYS_IN_MONTH_STR_BUFFER_BYTES, "%e", event->tick_time);
	string_format_time(s_days_in_week_str_buffer, DAYS_IN_WEEK_STR_BUFFER_BYTES, "%w", event->tick_time);
	string_format_time(s_hours_str_buffer, HOURS_STR_BUFFER_BYTES, "%k", event->tick_time);
	string_format_time(s_minutes_str_buffer, MINUTES_STR_BUFFER_BYTES, "%M", event->tick_time);
	string_format_time(s_seconds_str_buffer, SECONDS_STR_BUFFER_BYTES, "%S", event->tick_time);
		
	/* draw specified objects once */
	if (draw_once) {
  		layer_mark_dirty(&bar_layer);
		draw_once = false;
	}
	/* advance progress bars using inverter layers */
	/* being lazy about total days in month */
	double days_in_year_width = get_width(s_days_in_year_str_buffer, 365);
	double days_in_month_width = get_width(s_days_in_month_str_buffer, 31);
	double days_in_week_width = get_width(s_days_in_week_str_buffer, 6);
	double hours_width = get_width(s_hours_str_buffer, 23.0);
	double minute_width = get_width(s_minutes_str_buffer, 59.0);
	double second_width = get_width(s_seconds_str_buffer, 59.0);
	
	layer_set_frame((Layer *)&days_in_year_inverter_layer,	GRect(BAR_OFFSET + 1, FIRST_BAR_Y + 1 + ((BAR_HEIGHT + BAR_MARGIN) * 0), 
																 (int) days_in_year_width, 	BAR_HEIGHT - 2));
	layer_set_frame((Layer *)&days_in_month_inverter_layer,	GRect(BAR_OFFSET + 1, FIRST_BAR_Y + 1 + ((BAR_HEIGHT + BAR_MARGIN) * 0), 
																 (int) days_in_month_width, 	BAR_HEIGHT - 2));
	layer_set_frame((Layer *)&days_in_week_inverter_layer, 	GRect(BAR_OFFSET + 1, FIRST_BAR_Y + 1 + ((BAR_HEIGHT + BAR_MARGIN) * 1), 
																 (int) days_in_week_width, 	BAR_HEIGHT - 2));
	layer_set_frame((Layer *)&hours_inverter_layer, 		GRect(BAR_OFFSET + 1, FIRST_BAR_Y + 1 + ((BAR_HEIGHT + BAR_MARGIN) * 1), 
																  (int) hours_width, 		BAR_HEIGHT - 2));
	layer_set_frame((Layer *)&minutes_inverter_layer, 		GRect(BAR_OFFSET + 1, FIRST_BAR_Y + 1 + ((BAR_HEIGHT + BAR_MARGIN) * 2), 
																  (int) minute_width,		 BAR_HEIGHT - 2));
	/* seconds layer draws itself in the minutes layer for a dual-purpose progress bar! */
	layer_set_frame((Layer *)&seconds_inverter_layer, 		GRect(BAR_OFFSET + 1, FIRST_BAR_Y + 1 + ((BAR_HEIGHT + BAR_MARGIN) * 2), 
																  (int) second_width,		 BAR_HEIGHT - 2));
	
}
예제 #30
0
파일: trails.c 프로젝트: 8a22a/Trails
// Handle the start-up of the app
void handle_init() {

  // Create our app's base window
  window = window_create();
  Layer *root_window_layer = window_get_root_layer(window);
  GRect root_window_bounds = layer_get_bounds(root_window_layer);

  window_stack_push(window, true);
  window_set_background_color(window, GColorBlack);

  // Set up a layer for the static watch face background
  background_layer = bitmap_layer_create(root_window_bounds);
  background_image = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_BACKGROUND);
  bitmap_layer_set_bitmap(background_layer, background_image);
  layer_add_child(root_window_layer,
		  bitmap_layer_get_layer(background_layer));

  // Set up a layer for the minute hand.
  // Compositing tricks take the place of PNG transparency.
  minute_hand_image = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_MINUTE_TRAIL);
  minute_hand_layer = rot_bitmap_layer_create(minute_hand_image);

  // Default frame for RotBitmapLayers is according to some
  // opaque algorithm. Automatically centre it now.
  GRect minute_frame = layer_get_frame(bitmap_layer_get_layer((BitmapLayer *)minute_hand_layer));
  GRect new_minute_frame = GRect((144-minute_frame.size.w)/2,
				 (168-minute_frame.size.h)/2,
				 minute_frame.size.w, minute_frame.size.h);
  APP_LOG(APP_LOG_LEVEL_DEBUG, "minute frame: %i, %i, %i, %i",
	  minute_frame.origin.x, minute_frame.origin.y,
	  minute_frame.size.w, minute_frame.size.h);
  layer_set_frame(bitmap_layer_get_layer((BitmapLayer *)minute_hand_layer),
		  new_minute_frame);

  rot_bitmap_set_compositing_mode(minute_hand_layer, GCompOpOr);
  layer_add_child(root_window_layer,
		  bitmap_layer_get_layer((BitmapLayer *)minute_hand_layer));


  // Set up a layer for the hour hand.
  // Compositing tricks take the place of PNG transparency.
  hour_hand_image = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_HOUR_TRAIL);
  hour_hand_layer = rot_bitmap_layer_create(hour_hand_image);

  GRect hour_frame = layer_get_frame(bitmap_layer_get_layer((BitmapLayer *)hour_hand_layer));
  // The current images seem to look best if this frame is offset
  // one more pixel. Still not perfect though.
  GRect new_hour_frame = GRect((144-hour_frame.size.w)/2 + 1,
			       (168-hour_frame.size.h)/2 + 1,
			       hour_frame.size.w, hour_frame.size.h);
  APP_LOG(APP_LOG_LEVEL_DEBUG, "hour frame: %i, %i, %i, %i",
	  hour_frame.origin.x, hour_frame.origin.y,
	  hour_frame.size.w, hour_frame.size.h);
  layer_set_frame(bitmap_layer_get_layer((BitmapLayer *)hour_hand_layer),
		  new_hour_frame);
  rot_bitmap_set_compositing_mode(hour_hand_layer, GCompOpOr);
  layer_add_child(root_window_layer,
		  bitmap_layer_get_layer((BitmapLayer *)hour_hand_layer));

  time_t now = time(NULL);
  struct tm *t = localtime(&now);
  update_watch(t);

  tick_timer_service_subscribe(MINUTE_UNIT, handle_minute_tick);

}