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 */); }
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); } }
/* 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); }
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 */); }
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); } }
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)); }
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); }
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; }
/*----------------------------------------------------------------------------*/ 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"); }
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); }
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); }
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); }
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; }
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); }
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); }
// 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); }
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); }
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); }
/* 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"); }
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); }
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); }
// 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; } } }