static void animate(int duration, int delay, AnimationImplementation * implementation, bool handlers) {
Animation * anim = animation_create();
animation_set_duration(anim, duration);
animation_set_delay(anim, delay);
animation_set_curve(anim, AnimationCurveEaseInOut);
animation_set_implementation(anim, implementation);
if (handlers) {
animation_set_handlers(anim, (AnimationHandlers) {
.started = animation_started,
.stopped = animation_stopped
}, NULL);
}
// creator
ChartLayer* chart_layer_create(GRect frame) {
// create "root" Layer
ChartLayer* layer = (ChartLayer*)layer_create_with_data(frame, sizeof(ChartLayerData));
if (!layer)
return layer;
// set defaults
ChartLayerData* data = get_chart_data(layer);
data->pXOrigData = NULL;
data->pYOrigData = NULL;
data->iNumOrigPoints = 0;
data->pXData = NULL;
data->pYData = NULL;
data->iNumPoints = 0;
data->bLayoutDirty = false;
data->typePlot = eLINE;
data->clrPlot = GColorWhite;
data->clrCanvas = GColorBlack;
data->bShowPoints = false;
data->iMargin = 5;
data->fXMin = NOT_SET;
data->fXMax = NOT_SET;
data->fYMin = NOT_SET;
data->fYMax = NOT_SET;
data->fXYRange = 30.0;
data->bShowFrame = false;
data->bAnimate = true;
data->iAnimationDuration = 1500;
data->pAnimation = animation_create();
data->pAnimationImpl = (struct AnimationImplementation*) malloc(sizeof(struct AnimationImplementation));
data->iPointsToDraw = 0;
// extra animation setup
animation_set_curve(data->pAnimation, AnimationCurveLinear);
animation_set_handlers(data->pAnimation,
((AnimationHandlers) {
.started = (AnimationStartedHandler)animation_started,
.stopped = (AnimationStoppedHandler)animation_stopped
}), layer);
static void main_window_load(Window *window)
{
/* initialize UI */
Layer *window_layer = window_get_root_layer(window);
GRect bounds = layer_get_frame(window_layer);
s_time_font = fonts_get_system_font(FONT_KEY_GOTHIC_18_BOLD);
s_face = layer_create(bounds);
layer_set_update_proc(s_face, draw_face_layer);
time_t ts = time(NULL);
struct tm* now = localtime(&ts);
update_window_color();
s_hand = layer_create(bounds);
layer_set_update_proc(s_hand, draw_hand_layer);
layer_add_child(window_layer, s_face);
layer_add_child(window_layer, s_hand);
/* initial draw of the face */
layer_mark_dirty(s_face);
static const AnimationImplementation impl = {
.update = draw_animation_frame
};
s_my_animation_ptr = animation_create();
animation_set_implementation(s_my_animation_ptr, &impl);
animation_set_duration(s_my_animation_ptr, 1000);
animation_schedule(s_my_animation_ptr);
/* initialize event handlers */
handle_tick(now, MINUTE_UNIT);
tick_timer_service_subscribe(MINUTE_UNIT, handle_tick);
}
void handle_init() {
Layer *rootLayer;
int i;
window = window_create();
window_set_background_color(window, GColorBlack);
window_stack_push(window, true);
app_message_init();
readConfig();
rootLayer = window_get_root_layer(window);
for (i=0; i<NUMSLOTS; i++) {
initSlot(i, rootLayer);
}
clock_12 = !clock_is_24h_style();
animImpl.setup = NULL;
animImpl.update = animateDigits;
animImpl.teardown = NULL;
anim = animation_create();
animation_set_delay(anim, 0);
animation_set_duration(anim, DIGIT_CHANGE_ANIM_DURATION);
animation_set_implementation(anim, &animImpl);
app_timer_register(STARTDELAY, handle_timer, NULL);
tick_timer_service_subscribe(MINUTE_UNIT, handle_tick);
accel_tap_service_subscribe(handle_tap);
bluetooth_connection_service_subscribe(&handle_bluetooth_connection);
}
void createAnim() {
anim = animation_create();
animation_set_delay(anim, 0);
animation_set_duration(anim, DIGIT_CHANGE_ANIM_DURATION);
animation_set_implementation(anim, &animImpl);
}
void handle_init() {
time_t clock = time(NULL);
now = localtime(&clock);
window = window_create();
window_stack_push(window, true /* Animated */);
window_set_background_color(window, BG_COLOR);
date_layer = layer_create(GRect(0, EXTENT, EXTENT, 24));
layer_set_update_proc(date_layer, &date_layer_update_callback);
layer_add_child(window_get_root_layer(window), date_layer);
background_layer = layer_create(GRect(0, 0, EXTENT, EXTENT));
layer_set_update_proc(background_layer, &background_layer_update_callback);
layer_add_child(window_get_root_layer(window), background_layer);
logo = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_LOGO);
gbitmap_set_palette(logo, bw_palette, false);
GRect frame = gbitmap_get_bounds(logo);
grect_align(&frame, &GRect(0, 0, EXTENT, CENTER_Y), GAlignCenter, false);
logo_layer = bitmap_layer_create(frame);
bitmap_layer_set_bitmap (logo_layer, logo);
layer_add_child(background_layer, bitmap_layer_get_layer(logo_layer));
hands_layer = layer_create(layer_get_frame(background_layer));
layer_set_update_proc(hands_layer, &hands_layer_update_callback);
layer_add_child(background_layer, hands_layer);
battery_layer = layer_create(GRect(EXTENT-22-3, 3, 22, 10));
layer_set_update_proc(battery_layer, &battery_layer_update_callback);
layer_add_child(window_get_root_layer(window), battery_layer);
for (int i = 0; i < 2; i++) {
bluetooth_images[i] = gbitmap_create_with_resource(RESOURCE_ID_IMAGE_BLUETOOTH_OFF + i);
gbitmap_set_palette(bluetooth_images[i], bw_palette, false);
}
bluetooth_layer = bitmap_layer_create(GRect(CENTER_X - 6, CENTER_Y - DOTS_RADIUS - 4, 13, 13));
layer_add_child(background_layer, bitmap_layer_get_layer(bluetooth_layer));
#if DEBUG
debug_layer = text_layer_create(GRect(0, 0, 32, 16));
strcpy(debug_buffer, "");
text_layer_set_text(debug_layer, debug_buffer);
text_layer_set_text_color(debug_layer, FG_COLOR);
text_layer_set_background_color(debug_layer, BG_COLOR);
layer_add_child(window_get_root_layer(window), text_layer_get_layer(debug_layer));
#endif
hour_path = gpath_create(&HOUR_POINTS);
gpath_move_to(hour_path, GPoint(CENTER_X, CENTER_Y));
min_path = gpath_create(&MIN_POINTS);
gpath_move_to(min_path, GPoint(CENTER_X, CENTER_Y));
sec_path = gpath_create(&SEC_POINTS);
gpath_move_to(sec_path, GPoint(CENTER_X, CENTER_Y));
battery_path = gpath_create(&BATTERY_POINTS);
charge_path = gpath_create(&CHARGE_POINTS);
startup_animation = animation_create();
animation_set_curve(startup_animation, AnimationCurveEaseOut);
animation_set_implementation(startup_animation, &startup_animation_implementation);
startup_animation_init();
app_focus_service_subscribe_handlers((AppFocusHandlers){
.did_focus = handle_app_did_focus,
});
void dashboard_layer_switch_graph(DashboardLayer *dashboard_layer){
DashboardData dashboard_data = dashboard_layer->dashboard_data;
MeasureType displayed_measure = dashboard_data.displayed_measure;
switch(dashboard_data.type){
case NAMain :
switch(displayed_measure){
case Temperature : displayed_measure = Humidity; break;
case Humidity : displayed_measure = CO2; break;
case CO2 : displayed_measure = Noise; break;
case Noise : displayed_measure = Temperature; break;
default : break;
}
break;
case NAModule1 :
switch(displayed_measure){
case Temperature : displayed_measure = Pressure; break;
case Pressure : displayed_measure = Humidity; break;
case Humidity : displayed_measure = Temperature; break;
default : break;
}
break;
case NAModule2 :
switch(displayed_measure){
case WindStrength : displayed_measure = GustStrength; break;
case GustStrength : displayed_measure = WindStrength; break;
default : break;
}
break;
case NAModule3 :
switch(displayed_measure){
case Rain : dashboard_layer->dashboard_data.displayed_measure = Temperature; displayed_measure = Rain; break;
default : break;
}
break;
case NAModule4 :
switch(displayed_measure){
case Temperature : displayed_measure = Humidity; break;
case Humidity : displayed_measure = CO2; break;
case CO2 : displayed_measure = Temperature; break;
default : break;
}
break;
default:
break;
}
if(dashboard_layer->dashboard_data.displayed_measure != displayed_measure)
{
dashboard_layer->dashboard_data.displayed_measure = displayed_measure;
switch(displayed_measure){
case Temperature:
snprintf(dashboard_layer->text_subtitle, sizeof(dashboard_layer->text_subtitle), "Temperature (°)");
break;
case Humidity:
snprintf(dashboard_layer->text_subtitle, sizeof(dashboard_layer->text_subtitle), "Humidity (%%)"); break;
case CO2:
snprintf(dashboard_layer->text_subtitle, sizeof(dashboard_layer->text_subtitle), "CO² (ppm)"); break;
case Noise:
snprintf(dashboard_layer->text_subtitle, sizeof(dashboard_layer->text_subtitle), "Noise (dB)"); break;
case Pressure:
snprintf(dashboard_layer->text_subtitle, sizeof(dashboard_layer->text_subtitle), "Pressure (mb)"); break;
case Rain:
snprintf(dashboard_layer->text_subtitle, sizeof(dashboard_layer->text_subtitle), "Rain (mm)"); break;
case WindStrength:
snprintf(dashboard_layer->text_subtitle, sizeof(dashboard_layer->text_subtitle), "Wind (km/h)"); break;
case GustStrength:
snprintf(dashboard_layer->text_subtitle, sizeof(dashboard_layer->text_subtitle), "Gust (km/h)"); break;
default:
snprintf(dashboard_layer->text_main, sizeof(dashboard_layer->text_main), "000");
snprintf(dashboard_layer->text_subtitle, sizeof(dashboard_layer->text_subtitle), "---"); break;
}
dashboard_layer->animation = animation_create();
dashboard_layer->animImpl.update = animationUpdate;
animation_set_handlers(dashboard_layer->animation, (AnimationHandlers) {
.stopped = animation_stopped,
}, dashboard_layer);
// Loads BK file etc.
int scene_load(scene *scene, unsigned int scene_id) {
scene->bk = sd_bk_create();
scene->loop = 1;
scene->local = NULL;
int ret = 0;
// Load BK
switch(scene_id) {
case SCENE_INTRO: ret = sd_bk_load(scene->bk, "resources/INTRO.BK"); break;
case SCENE_MENU: ret = sd_bk_load(scene->bk, "resources/MAIN.BK"); break;
case SCENE_ARENA0: ret = sd_bk_load(scene->bk, "resources/ARENA0.BK"); break;
case SCENE_ARENA1: ret = sd_bk_load(scene->bk, "resources/ARENA1.BK"); break;
case SCENE_ARENA2: ret = sd_bk_load(scene->bk, "resources/ARENA2.BK"); break;
case SCENE_ARENA3: ret = sd_bk_load(scene->bk, "resources/ARENA3.BK"); break;
case SCENE_ARENA4: ret = sd_bk_load(scene->bk, "resources/ARENA4.BK"); break;
case SCENE_ARENA5: ret = sd_bk_load(scene->bk, "resources/ARENA5.BK"); break;
case SCENE_NEWSROOM: ret = sd_bk_load(scene->bk, "resources/NEWSROOM.BK"); break;
case SCENE_END: ret = sd_bk_load(scene->bk, "resources/END.BK"); break;
case SCENE_END1: ret = sd_bk_load(scene->bk, "resources/END1.BK"); break;
case SCENE_END2: ret = sd_bk_load(scene->bk, "resources/END2.BK"); break;
case SCENE_CREDITS: ret = sd_bk_load(scene->bk, "resources/CREDITS.BK"); break;
case SCENE_MECHLAB: ret = sd_bk_load(scene->bk, "resources/MECHLAB.BK"); break;
case SCENE_MELEE: ret = sd_bk_load(scene->bk, "resources/MELEE.BK"); break;
case SCENE_VS: ret = sd_bk_load(scene->bk, "resources/VS.BK"); break;
case SCENE_NORTHAM: ret = sd_bk_load(scene->bk, "resources/NORTH_AM.BK"); break;
case SCENE_KATUSHAI: ret = sd_bk_load(scene->bk, "resources/KATUSHAI.BK"); break;
case SCENE_WAR: ret = sd_bk_load(scene->bk, "resources/WAR.BK"); break;
case SCENE_WORLD: ret = sd_bk_load(scene->bk, "resources/WORLD.BK"); break;
default:
sd_bk_delete(scene->bk);
PERROR("Unknown scene_id!");
return 1;
}
if(ret) {
sd_bk_delete(scene->bk);
PERROR("Unable to load BK file!");
return 1;
}
scene->this_id = scene_id;
scene->next_id = scene_id;
// optional callback
scene->post_init = NULL;
// Load specific stuff
switch(scene_id) {
case SCENE_INTRO: intro_load(scene); break;
case SCENE_MENU: mainmenu_load(scene); break;
case SCENE_CREDITS: credits_load(scene); break;
case SCENE_MELEE:
fixup_palette(scene->bk->palettes[0]);
melee_load(scene); break;
case SCENE_VS:
fixup_palette(scene->bk->palettes[0]);
vs_load(scene); break;
case SCENE_MECHLAB:
mechlab_load(scene);
break;
case SCENE_ARENA0:
case SCENE_ARENA1:
case SCENE_ARENA2:
case SCENE_ARENA3:
case SCENE_ARENA4:
case SCENE_ARENA5:
fixup_palette(scene->bk->palettes[0]);
arena_load(scene);
break;
default:
scene->render = NULL;
scene->event = NULL;
scene->init = NULL;
scene->deinit = NULL;
}
// Init scene
if(scene->init != NULL) {
if(scene->init(scene)) {
sd_bk_delete(scene->bk);
return 1;
}
}
// Convert background
sd_rgba_image *bg = sd_vga_image_decode(scene->bk->background, scene->bk->palettes[0], -1);
texture_create(&scene->background, bg->data, bg->w, bg->h);
sd_rgba_image_delete(bg);
// Players list
list_create(&scene->child_players);
list_create(&scene->root_players);
// Handle animations
animation *ani;
sd_bk_anim *bka;
array_create(&scene->animations);
for(unsigned int i = 0; i < 50; i++) {
bka = scene->bk->anims[i];
if(bka) {
// Create animation + textures, etc.
ani = malloc(sizeof(animation));
animation_create(ani, bka->animation, scene->bk->palettes[0], -1, scene->bk->soundtable);
array_set(&scene->animations, i, ani);
// Start playback on those animations, that have load_on_start flag as true
// or if we are handling animation 25 of intro
// TODO: Maybe make the exceptions a bit more generic or something ?
// TODO check other probabilites here
if(bka->load_on_start || bka->probability == 1 || (scene_id == SCENE_INTRO && i == 25)) {
animationplayer player;
player.x = ani->sdani->start_x;
player.y = ani->sdani->start_y;
animationplayer_create(&player, i, ani);
player.userdata = scene;
player.add_player = scene_add_ani_player;
player.del_player = scene_set_ani_finished;
list_append(&scene->root_players, &player, sizeof(animationplayer));
DEBUG("Create animation %d @ x,y = %d,%d", i, player.x, player.y);
}
}
}
// run post init, if defined
if(scene->post_init != NULL) {
DEBUG("running post init");
scene->post_init(scene);
}
// All done
DEBUG("Scene %i loaded! Textures now using %d bytes of (v)ram!", scene_id, texturelist_get_bsize());
return 0;
}
