void handle_init(AppContextRef ctx) {
	resource_init_current_app(&HOUSECONTROL);
	
	window_init(&homeWindow, "Group Selection");
	WindowHandlers handlers = {
		.appear = &handle_home_window_appear
	};
	window_set_window_handlers(&homeWindow, handlers);
	window_stack_push(&homeWindow, true /* Animated */);
	
	window_init(&groupWindow, "Device Selection");
	WindowHandlers handlers2 = {
		.appear = &handle_group_window_appear
	};
	window_set_window_handlers(&groupWindow, handlers2);
	
	window_init(&deviceWindow, "Device");
	WindowHandlers handlers3 = {
		.appear = &handle_device_window_appear
	};
	window_set_window_handlers(&deviceWindow, handlers3);
	
	//HOME LAYER
	GRect bounds = homeWindow.layer.bounds;
	menu_layer_init(&homeLayer, bounds);
	
	menu_layer_set_callbacks(&homeLayer, NULL, (MenuLayerCallbacks){
		.get_num_rows		= menu_home_get_num_rows,
		.draw_row 			= menu_home_draw_row,
		.select_click 		= menu_home_select_click
	});
/*
 * Initialize our app and both windows
 */
static void init() {
  current_font = 0;
  current_message = 0;

  main_window = window_create();
  window_set_window_handlers(main_window, main_window_handlers);

  font_window = window_create();
  window_set_window_handlers(font_window, font_window_handlers);

  window_stack_push(main_window, true /* Animated */);
}
Example #3
0
void push_chrono_digital_handler(ClickRecognizerRef recognizer, void *context) {
  //  app_log(APP_LOG_LEVEL_INFO, __FILE__, __LINE__, "push chrono digital");
  if (!chrono_digital_window_showing) {

    // Release some caches and repack our memory allocations before we
    // push the window.
    recreate_all_objects();
    
    // If we don't already have a chrono_digital_window object
    // created, create it now.
    if (chrono_digital_window == NULL) {
      chrono_digital_window = window_create();
      if (chrono_digital_window == NULL) {
	trigger_memory_panic(__LINE__);
	return;
      }

      struct WindowHandlers chrono_digital_window_handlers;
      memset(&chrono_digital_window_handlers, 0, sizeof(chrono_digital_window_handlers));
      chrono_digital_window_handlers.load = chrono_digital_window_load_handler;
      chrono_digital_window_handlers.appear = chrono_digital_window_appear_handler;
      chrono_digital_window_handlers.disappear = chrono_digital_window_disappear_handler;
      chrono_digital_window_handlers.unload = chrono_digital_window_unload_handler;
      window_set_window_handlers(chrono_digital_window, chrono_digital_window_handlers);
    }

    // We'll push without animation, mainly so the pop also comes
    // without animation, which is important because the main window
    // needs to be able to grab the framebuffer once it draws, and
    // there's no way to ask the Pebble SDK when the window has
    // finished animating into its proper place (to know when it's
    // safe to grab the framebuffer).
    window_stack_push(chrono_digital_window, false);
  }
}
Example #4
0
/* Initialize the main app elements */
void carga_paradas(int n1, int fav, int buscar)
{
  i_buscar = 0;
  numero1= n1/100;
  numero2= (n1 % 100) /10;
  numero3=n1 % 10;
	window = window_create();
	WindowHandlers handlers = {
		.load = window_load,
		.unload = window_unload
	};
  #ifdef PBL_SDK_2
    window_set_fullscreen(window, true);
  #endif
	//app_message_register_inbox_received(in_received_handler);					 
	window_set_window_handlers(window, (WindowHandlers) handlers);
  if (fav==1)
    posicion=2;
  if (buscar==1)
    i_buscar = 1;
  valores_parada[0].tiempo1 = 0;
	window_stack_push(window, true);


}
Example #5
0
void handle_init()
{
	window = window_create();
	
	Layer *window_layer = window_get_root_layer(window);
	GRect windowFrame = layer_get_frame(window_layer);
	
	int16_t aThird = windowFrame.size.h / 3;	
	
	GRect textFrame;
	textFrame.origin.x = 0;
	textFrame.origin.y = 0;
	textFrame.size.w = windowFrame.size.w;
	textFrame.size.h = aThird;
	
	textFrame.origin.y = aThird;
	statusTextLayer = text_layer_create( textFrame );
	
	text_layer_set_text(statusTextLayer, STATUS_READY);
	text_layer_set_text_alignment(statusTextLayer, GTextAlignmentLeft);
	text_layer_set_font(statusTextLayer, fonts_get_system_font(FONT_KEY_GOTHIC_28_BOLD));
	layer_add_child( window_layer, text_layer_get_layer( statusTextLayer ) );
	
	init_app_message();
	
	WindowHandlers handlers = {
		.load = window_load,
		.unload = window_unload
	};
	
	window_set_window_handlers(window, handlers);
	
	window_stack_push(window, true /* Animated */);
}
Example #6
0
void push_chrono_digital_handler(ClickRecognizerRef recognizer, void *context) {
  //  app_log(APP_LOG_LEVEL_INFO, __FILE__, __LINE__, "push chrono digital");
  if (!chrono_digital_window_showing) {
    
    // If we don't already have a chrono_digital_window object
    // created, create it now.
    if (chrono_digital_window == NULL) {
      chrono_digital_window = window_create();
      if (chrono_digital_window == NULL) {
	trigger_memory_panic(__LINE__);
	return;
      }

      struct WindowHandlers chrono_digital_window_handlers;
      memset(&chrono_digital_window_handlers, 0, sizeof(chrono_digital_window_handlers));
      chrono_digital_window_handlers.load = chrono_digital_window_load_handler;
      chrono_digital_window_handlers.appear = chrono_digital_window_appear_handler;
      chrono_digital_window_handlers.disappear = chrono_digital_window_disappear_handler;
      chrono_digital_window_handlers.unload = chrono_digital_window_unload_handler;
      window_set_window_handlers(chrono_digital_window, chrono_digital_window_handlers);
    }

    window_stack_push(chrono_digital_window, true);
  }
}
Example #7
0
void init() {
	window = window_create();
  window_set_background_color(window, GColorBlack);
	WindowHandlers handlers = {
		.load = window_load,
		.unload = window_unload
	};
	window_set_window_handlers(window, handlers);
  window_set_fullscreen(window, true);

	//Register AppMessage events
	app_message_register_inbox_received(in_received_handler);
	app_message_open(512, 512);		//Large input and output buffer sizes

	window_stack_push(window, true);

  // Init the text layer used to show the time
    time_layer = text_layer_create(GRect(0, 0, 144 /* width */, 50 /* height */));
    text_layer_set_text_color(time_layer, GColorBlack);
    text_layer_set_background_color(time_layer, GColorWhite);
    text_layer_set_font(time_layer, fonts_get_system_font(FONT_KEY_BITHAM_42_BOLD));
    text_layer_set_text_alignment(time_layer, GTextAlignmentCenter);

    // 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_battery(battery_state_service_peek());
    handle_second_tick(current_time, SECOND_UNIT);
    tick_timer_service_subscribe(SECOND_UNIT, &handle_second_tick);
    battery_state_service_subscribe(&handle_battery);

    layer_add_child(window_get_root_layer(window), text_layer_get_layer(time_layer));
}
Example #8
0
void ui_init(void) {
  ui_main_window = window_create();

  WindowHandlers handlers = { .load = onload, .unload = onunload };
  window_set_window_handlers(ui_main_window, handlers);

  window_stack_push(ui_main_window, true);
}
Example #9
0
Window * InitializeMenuWindow(const char *name, WindowHandler init, WindowHandler deinit, WindowHandler appear, WindowHandler disappear)
{
	Window *window = InitializeWindow(name);
	WindowHandlers handlers = {.load = init, .unload = deinit, .appear = appear, .disappear = disappear};
	window_set_window_handlers(window,handlers);
	
	SetMenuClickConfigProvider(window);
	return window;
}
Example #10
0
/*----------------------------------------------------------------------------*/
int main(void)
{
  APP_LOG(APP_LOG_LEVEL_INFO, "main: entry:  %s %s", __TIME__, __DATE__);

  /*
   *   Commission App
   */
  window = window_create();

  WindowHandlers handlers = {.load = window_load, .unload = window_unload };
  window_set_window_handlers(window, handlers);

  const bool animated = true;
  window_stack_push(window, animated);

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

  /* Display the simple splash screen to indicate PebblePointer is running. */
  image = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_PEBBLEPOINTER);
  image_layer = bitmap_layer_create(bounds);
  bitmap_layer_set_bitmap(image_layer, image);
  bitmap_layer_set_alignment(image_layer, GAlignCenter);
  layer_add_child(window_layer, bitmap_layer_get_layer(image_layer));

  /* Basic accelerometer initialization.  Enable Tap-Tap functionality. */
  accel_service_set_sampling_rate( SAMPLING_RATE );
  accel_tap_service_subscribe( (AccelTapHandler) accel_tap_callback );
  app_message_open(SYNC_BUFFER_SIZE, SYNC_BUFFER_SIZE);

  /* Request notfication on Bluetooth connectivity changes.  */
  bluetooth_connection_service_subscribe( bluetooth_connection_callback );
  isConnected = bluetooth_connection_service_peek();
  APP_LOG(APP_LOG_LEVEL_INFO, "initially %sonnected", (isConnected) ? "c" : "disc");

  /*
   *   Event Processing
   */
  app_event_loop();

  /*
   *   Decommission App
   */
  if (tapSwitchState == true) {
    accel_data_service_unsubscribe();
  }

  /* Remove the Tap-Tap callback */
  accel_tap_service_unsubscribe();

  /* Release splash-screen resources */
  gbitmap_destroy(image);
  bitmap_layer_destroy(image_layer);
  window_destroy(window);

  APP_LOG(APP_LOG_LEVEL_INFO, "main: exit");
}
Example #11
0
static void main_window_create() {
    s_main_window = window_create();
    WindowHandlers wh = {
	.load   = main_window_load,
        .unload = main_window_unload
    };
    window_set_background_color(s_main_window, GColorBlack);
    window_set_window_handlers(s_main_window, wh);
    window_stack_push(s_main_window, true);
}
Example #12
0
void devices_window_push() {
    devices_window = window_create();
    WindowHandlers handlers = {
        .load = window_load,
        .unload = window_unload,
        .appear = window_appear
    };
    window_set_window_handlers(devices_window, (WindowHandlers) handlers);
    window_stack_push(devices_window, true);
}
Example #13
0
void cpay_init()
{
  cpay_window = window_create();
  WindowHandlers handlers = {
     .load = window_load,
     .unload = window_unload,
  };
  window_set_window_handlers(cpay_window, (WindowHandlers) handlers);
  window_push++;
  window_stack_push(cpay_window, true);
}
Example #14
0
Window * InitializeMenuWindow(void *menuWindow, const char *name, bool animated, WindowHandler init, WindowHandler deinit, WindowHandler appear, WindowHandler disappear)
{
	Window *window = InitializeWindow(name, animated);
	WindowHandlers handlers = {.load = init, .unload = deinit, .appear = appear, .disappear = disappear};
	window_set_window_handlers(window,handlers);
	
	SetMenuClickConfigProvider(window);
	window_set_user_data(window,menuWindow);
	window_stack_push(window, animated);
	return window;
}
Example #15
0
void emergency_conf_init()
{
    window = window_create();
    WindowHandlers handlers = {
        .load = emergency_conf_window_load,
        .unload = emergency_conf_window_unload
    };
    window_set_window_handlers(window, (WindowHandlers) handlers);
    window_set_click_config_provider(window, (ClickConfigProvider) emergency_conf_click_config_provider);
    window_stack_push(window, true);
}
static void init(void) {
	window = window_create();
	WindowHandlers handlers = {
		.load = window_load,
		.unload = window_unload
	};
	window_set_window_handlers(window, handlers);

	tick_timer_service_subscribe(MINUTE_UNIT, tick_handler);

	window_stack_push(window, true);
}
Example #17
0
void error_window_init(void) {
	error_bitmap = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_ERROR);

	window = window_create();
    window_set_background_color(window, GColorBlack);
	window_set_click_config_provider(window, window_click_config_provider);
    window_set_fullscreen(window, true);

    static const WindowHandlers window_handlers = {
        .load = window_load,
    };
    window_set_window_handlers(window, window_handlers);
}
Example #18
0
// initialize main window
void init()
{
  window = window_create();
  splash_window = window_create();
  // create some text
  WindowHandlers handlers = {
    .load = window_load,
    .unload = window_unload
  };
  window_set_window_handlers(window, handlers);
  
  window_set_window_handlers(splash_window, (WindowHandlers) {
     .load = splash_window_load,
     .unload = splash_window_unload,
  });
static void init(void) 
{
  window = window_create();
  WindowHandlers handlers = {
    .load = window_load,
    .unload = window_unload
  };
  window_set_window_handlers(window, handlers);
  window_set_background_color(window, GColorBlack);

  //Get tick events
  tick_timer_service_subscribe(MINUTE_UNIT, tick_handler);

  //Finally
  window_stack_push(window, true);
}
Example #20
0
void InboxCreate()
{
	window_init	(&s_window, "email window");
	window_set_fullscreen(&s_window, true);
	menu_layer_init	(&s_menu_layer, s_window.layer.frame);
	layer_add_child(&s_window.layer, &s_menu_layer.scroll_layer.layer);
	s_waitingForData = false;
	menu_layer_set_callbacks(&s_menu_layer,  0, s_callbacks);

	menu_layer_set_click_config_onto_window	(&s_menu_layer, &s_window);

	WindowHandlers wh =  {.appear = s_appear, .disappear = s_disapear};

	window_set_window_handlers(&s_window, wh);

}
static void init() {
  s_main_window = window_create();
  WindowHandlers handlers = {
    .load = main_window_load,
    .unload = main_window_unload
  };
  window_set_window_handlers(s_main_window, handlers);

  fg_color = COLOR_FALLBACK(GColorRed, GColorBlack);
  bg_color = GColorWhite;
#ifdef PBL_SDK_3
  inverter_layer_compat_set_colors(bg_color, fg_color);
#endif

  tick_timer_service_subscribe(SECOND_UNIT, tick_handler);

  window_stack_push(s_main_window, true);
}
Example #22
0
static void init(void) {
    upgrade();

    app_message_init();
    error_window_init();
    stats_layer_global_init();
    refresh_layer_global_init();

    window = window_create();
    window_set_background_color(window, GColorBlack);
    window_set_click_config_provider(window, window_click_config_provider);
    window_set_fullscreen(window, true);

    static const WindowHandlers window_handlers = {
        .load = window_load,
        .unload = window_unload,
    };
    window_set_window_handlers(window, window_handlers);
    window_stack_push(window, true);
}
Example #23
0
/* Initialize the main app elements */
void init()
{
	window = window_create();
	WindowHandlers handlers = 
     {
		.load     = window_load,
		.unload   = window_unload
	};
	window_set_window_handlers(window, (WindowHandlers) handlers);
	window_set_click_config_provider(window, click_config_provider);
	window_stack_push(window, true);
 
	// Register AppMessage handlers
	app_message_register_inbox_received(in_received_handler); 
	app_message_register_inbox_dropped(in_dropped_handler); 
	app_message_register_outbox_failed(out_failed_handler);
		
	app_message_open(app_message_inbox_size_maximum(), app_message_outbox_size_maximum());
	
	send_message(STRT);
}
void init() {
    time_buffer[TEXT_BUFFER_SIZE] =
        date_buffer[TEXT_BUFFER_SIZE] =
            weekday_buffer[TEXT_BUFFER_SIZE] =
                status_buffer[TEXT_BUFFER_SIZE] = '\0';

    window = window_create();
    WindowHandlers handlers = {
        .load = window_load,
        .unload = window_unload
    };
    window_set_window_handlers(window, handlers);
    window_stack_push(window, true);
    app_message_init();
    ping_app_message();

    battery_state_service_subscribe(handle_battery);
    BatteryChargeState charge_state = battery_state_service_peek();
    handle_battery(charge_state);

    app_log(APP_LOG_LEVEL_DEBUG, "pebblemonface.c", __LINE__, "Done Initializing");
}
Example #25
0
void init()
{
	window = window_create();
	//window_set_fullscreen(window, true);
	WindowHandlers handlers = {
		.load = window_load,
		.unload = window_unload
	};
	window_set_window_handlers(window, handlers);

	//Register AppMessage events
	app_message_register_inbox_received(in_received_handler);					 
	app_message_open(512, 512);		//Large input and output buffer sizes
	
	//Register to receive minutely updates
	tick_timer_service_subscribe(MINUTE_UNIT, tick_callback);

	window_stack_push(window, true);
	


}
Example #26
0
static void init()
{
  //Show AppMessage errors
  cl_set_debug(true);

  //Show initial Window
  splash_window = window_create();
  WindowHandlers handlers = {
    .load = splash_window_load,
    .unload = splash_window_unload
  };
  window_set_window_handlers(splash_window, (WindowHandlers) handlers);

  //Open AppMessage at high speed
  app_comm_set_sniff_interval(SNIFF_INTERVAL_REDUCED);
  cl_app_message_open(
    app_message_inbox_size_maximum(),
    app_message_outbox_size_maximum(),
    (AppMessageInboxReceived)in_recv_handler
  );

  //Show Window
  window_stack_push(splash_window, true);
}
Example #27
0
// Creates all of the objects needed for the watch.  Normally called
// only by handle_init(), but might be invoked midstream in a
// memory-panic situation.
void create_objects() {
  app_log(APP_LOG_LEVEL_INFO, __FILE__, __LINE__, "create_objects");
  window = window_create();
  assert(window != NULL);

  struct WindowHandlers window_handlers;
  memset(&window_handlers, 0, sizeof(window_handlers));
  window_handlers.load = window_load_handler;
  window_handlers.appear = window_appear_handler;
  window_handlers.disappear = window_disappear_handler;
  window_handlers.unload = window_unload_handler;
  window_set_window_handlers(window, window_handlers);

  window_set_fullscreen(window, true);
  window_stack_push(window, false);

  hand_cache_init(&hour_cache);
  hand_cache_init(&minute_cache);
  hand_cache_init(&second_cache);

  Layer *window_layer = window_get_root_layer(window);
  GRect window_frame = layer_get_frame(window_layer);

  clock_face_layer = layer_create(window_frame);
  assert(clock_face_layer != NULL);
  layer_set_update_proc(clock_face_layer, &clock_face_layer_update_callback);
  layer_add_child(window_layer, clock_face_layer);

  {
    const struct IndicatorTable *window = &battery_table[config.face_index];
    init_battery_gauge(window_layer, window->x, window->y, window->invert, window->opaque);
  }
  {
    const struct IndicatorTable *window = &bluetooth_table[config.face_index];
    init_bluetooth_indicator(window_layer, window->x, window->y, window->invert, window->opaque);
  }

  for (int i = 0; i < NUM_DATE_WINDOWS; ++i) {
    const struct IndicatorTable *window = &date_windows[i][config.face_index];
    Layer *layer = layer_create_with_data(GRect(window->x - 19, window->y - 8, 39, 19), sizeof(DateWindowData));
    assert(layer != NULL);
    date_window_layers[i] = layer;
    DateWindowData *data = (DateWindowData *)layer_get_data(layer);
    data->date_window_index = i;

    layer_set_update_proc(layer, &date_window_layer_update_callback);
    layer_add_child(window_layer, layer);
  }

#ifdef MAKE_CHRONOGRAPH
  create_chrono_objects();
#endif  // MAKE_CHRONOGRAPH

  // Init all of the hands, taking care to arrange them in the correct
  // stacking order.
  int i;
  for (i = 0; stacking_order[i] != STACKING_ORDER_DONE; ++i) {
    switch (stacking_order[i]) {
    case STACKING_ORDER_HOUR:
      hour_layer = layer_create(window_frame);
      assert(hour_layer != NULL);
      layer_set_update_proc(hour_layer, &hour_layer_update_callback);
      layer_add_child(window_layer, hour_layer);
      break;

    case STACKING_ORDER_MINUTE:
      minute_layer = layer_create(window_frame);
      assert(minute_layer != NULL);
      layer_set_update_proc(minute_layer, &minute_layer_update_callback);
      layer_add_child(window_layer, minute_layer);
      break;

    case STACKING_ORDER_SECOND:
      second_layer = layer_create(window_frame);
      assert(second_layer != NULL);
      layer_set_update_proc(second_layer, &second_layer_update_callback);
      layer_add_child(window_layer, second_layer);
      break;

    case STACKING_ORDER_CHRONO_MINUTE:
#if defined(ENABLE_CHRONO_MINUTE_HAND) && defined(MAKE_CHRONOGRAPH)
      chrono_minute_layer = layer_create(window_frame);
      assert(chrono_minute_layer != NULL);
      layer_set_update_proc(chrono_minute_layer, &chrono_minute_layer_update_callback);
      layer_add_child(window_layer, chrono_minute_layer);
#endif  // ENABLE_CHRONO_MINUTE_HAND
      break;

    case STACKING_ORDER_CHRONO_SECOND:
#if defined(ENABLE_CHRONO_SECOND_HAND) && defined(MAKE_CHRONOGRAPH)
      chrono_second_layer = layer_create(window_frame);
      assert(chrono_second_layer != NULL);
      layer_set_update_proc(chrono_second_layer, &chrono_second_layer_update_callback);
      layer_add_child(window_layer, chrono_second_layer);
#endif  // ENABLE_CHRONO_SECOND_HAND
      break;

    case STACKING_ORDER_CHRONO_TENTH:
#if defined(ENABLE_CHRONO_TENTH_HAND) && defined(MAKE_CHRONOGRAPH)
      chrono_tenth_layer = layer_create(window_frame);
      assert(chrono_tenth_layer != NULL);
      layer_set_update_proc(chrono_tenth_layer, &chrono_tenth_layer_update_callback);
      layer_add_child(window_layer, chrono_tenth_layer);
#endif  // ENABLE_CHRONO_TENTH_HAND
      break;
    }
  }
}