void menuitem_rebuild_screen_ip(MenuItem *item, Screen *s) { Widget *w; debug(RPT_DEBUG, "%s(item=[%s], screen=[%s])", __FUNCTION__, ((item != NULL) ? item->id : "(null)"), ((s != NULL) ? s->id : "(null)")); if ((item == NULL) || (s == NULL)) return; if (display_props->height >= 2) { /* Only add a title if enough space... */ w = widget_create("text", WID_STRING, s); screen_add_widget(s, w); w->text = strdup(item->text); w->x = 1; w->y = 1; } w = widget_create("value", WID_STRING, s); screen_add_widget(s, w); w->text = malloc(item->data.ip.maxlength+1); w->x = 2; w->y = display_props->height / 2 + 1; /* Only display error string if enough space... */ if (display_props->height > 2) { w = widget_create("error", WID_STRING, s); screen_add_widget(s, w); w->text = strdup(""); w->x = 1; w->y = display_props->height; } }
g_error widget_derive(struct widget **w, handle *h, int type,struct widget *parent, handle hparent,int rship,int owner) { g_error e; DBG("type %d, rship %d, parent %p, owner %d\n",type,rship,parent,owner); /* Allow using this to detach widgets too. Makes sense, since this is called * by the attachwidget request handler. */ if (!parent) return widget_attach(*w, NULL, NULL, 0); switch (rship) { case PG_DERIVE_INSIDE: if (*w == NULL ) { e = widget_create(w,h, type, parent->dt, hparent, owner); errorcheck; } e = widget_attach(*w, parent->dt,parent->sub,hparent); break; case PG_DERIVE_AFTER: if ( *w == NULL ) { e = widget_create(w,h, type, parent->dt, parent->container, owner); errorcheck; } e = widget_attach(*w,parent->dt,parent->out,parent->container); break; case PG_DERIVE_BEFORE: case PG_DERIVE_BEFORE_OLD: if ( *w == NULL ) { e = widget_create(w,h, type, parent->dt, parent->container, owner); errorcheck; } e = widget_attach(*w,parent->dt,parent->where,parent->container); break; default: return mkerror(PG_ERRT_BADPARAM,22); } /* Error checking code common to all cases */ if (iserror(e)) { widget_remove(*w); errorcheck; } if ((*w)->def->post_attach) { e = (*w)->def->post_attach(*w,parent,rship); errorcheck; } return success; }
void menuitem_rebuild_screen_slider(MenuItem *item, Screen *s) { Widget *w; debug(RPT_DEBUG, "%s(item=[%s], screen=[%s])", __FUNCTION__, ((item != NULL) ? item->id : "(null)"), ((s != NULL) ? s->id : "(null)")); if ((item == NULL) || (s == NULL)) return; if (display_props->height >= 2) { /* Only add a title if enough space... */ w = widget_create("text", WID_STRING, s); screen_add_widget(s, w); w->text = strdup(item->text); w->x = 1; w->y = 1; } w = widget_create("bar", WID_HBAR, s); screen_add_widget(s, w); w->width = display_props->width; if (display_props->height > 2) { /* This is option 1: we have enought space, so the bar and * min/max texts can be on separate lines. */ w->x = 2; w->y = display_props->height / 2 + 1; w->width = display_props->width - 2; } w = widget_create("min", WID_STRING, s); screen_add_widget(s, w); w->text = NULL; w->x = 1; if (display_props->height > 2) { w->y = display_props->height / 2 + 2; } else { w->y = display_props->height / 2 + 1; } w = widget_create("max", WID_STRING, s); screen_add_widget(s, w); w->text = NULL; w->x = 1; if (display_props->height > 2) { w->y = display_props->height / 2 + 2; } else { w->y = display_props->height / 2 + 1; } }
void gameend_init () { widget_t framepoint, pmframes[6]; widget_t point_cell[4]; integer_t i; framepoint = create_basic_info_frame ("frame", gameend, pmframes, 400, 0, 1); widget_configure (pmframes[4], resource_frame_start, 270); gameendokbutton = pmframes[5]; gameend_header = widget_create ("pmcontainer", framepoint); widget_set_geometry (gameend_header, xwidth - (LEFTMARGIN * 2), YAKUHEAD_H); gameend_pos = widget_create ("pmcontainer", framepoint); widget_set_geometry (gameend_pos, xwidth - (LEFTMARGIN * 2), 73); for (i = 0; i < 4; i++) { widget_t w; point_cell[i] = widget_create ("frame", framepoint); widget_configure (point_cell[i], resource_packed, resource_horizontal); widget_set_geometry (point_cell[i], xwidth, RESULTHOME_H); gameend_name[i] = widget_create ("text", point_cell[i]); widget_set_geometry (gameend_name[i], 160, RESULTHOME_H); widget_configure (gameend_name[i], resource_textfont, MEDIUMJP); widget_configure (gameend_name[i], resource_textcolor, white); w = widget_create ("frame", point_cell[i]); widget_configure (w, resource_packed, resource_virtical); gameend_tpoint1[i] = widget_create ("pmcontainer", w); gameend_tpoint2[i] = widget_create ("pmcontainer", w); widget_set_geometry (gameend_tpoint1[i], 110, 14); widget_set_geometry (gameend_tpoint2[i], 110, 14); gameend_rpoint[i] = widget_create ("text", point_cell[i]); widget_set_geometry (gameend_rpoint[i], 110, RESULTHOME_H); widget_configure (gameend_rpoint[i], resource_textfont, TIMESIB); widget_configure (gameend_rpoint[i], resource_textcolor, white); gameend_xpoint[i] = widget_create ("text", point_cell[i]); widget_set_geometry (gameend_xpoint[i], 110, RESULTHOME_H); widget_configure (gameend_xpoint[i], resource_textfont, TIMESIB); widget_configure (gameend_xpoint[i], resource_textcolor, white); } pmcontainer_print (gameend_header, pm_gameend_header); widget_pack (gameend); widget_fix (gameend); widget_set_geometry (gameend, xwidth, xheight); }
component* textinput_create(const text_settings *tconf, const char *text, const char *initialvalue) { component *c = widget_create(); textinput *tb = malloc(sizeof(textinput)); memset(tb, 0, sizeof(textinput)); tb->text = strdup(text); memcpy(&tb->tconf, tconf, sizeof(text_settings)); tb->pos = &tb->pos_; // Background for field int tsize = text_char_width(&tb->tconf); image img; image_create(&img, 15*tsize+2, tsize+3); image_clear(&img, COLOR_MENU_BG); image_rect(&img, 0, 0, 15*tsize+1, tsize+2, COLOR_MENU_BORDER); surface_create_from_image(&tb->sur, &img); image_free(&img); // Copy over the initial value memcpy(tb->buf, initialvalue, strlen(initialvalue)+1); // Widget stuff widget_set_obj(c, tb); widget_set_render_cb(c, textinput_render); widget_set_event_cb(c, textinput_event); widget_set_tick_cb(c, textinput_tick); widget_set_free_cb(c, textinput_free); return c; }
widget_t* controller_settings_screen_create(temp_controller_id_t controller) { controller_settings_screen_t* s = calloc(1, sizeof(controller_settings_screen_t)); s->screen = widget_create(NULL, &controller_settings_widget_class, s, display_rect); widget_set_background(s->screen, BLACK, FALSE); char* title; temp_controller_id_t other_controller; if (controller == CONTROLLER_1) { title = "Controller 1 Setup"; other_controller = CONTROLLER_2; } else { title = "Controller 2 Setup"; other_controller = CONTROLLER_1; } s->button_list = button_list_screen_create(s->screen, title, back_button_clicked, s); s->controller = controller; s->settings = *app_cfg_get_controller_settings(controller); /* Convert enabled flags to selection enum */ if (s->settings.output_settings[OUTPUT_1].enabled && s->settings.output_settings[OUTPUT_2].enabled) s->output_selection = SELECT_1_2; else if (s->settings.output_settings[OUTPUT_1].enabled) s->output_selection = SELECT_1; else if (s->settings.output_settings[OUTPUT_2].enabled) s->output_selection = SELECT_2; else s->output_selection = SELECT_NONE; /* Figure out which output selections are allowed by checking which outputs are currently * being controlled by the other controller. */ const controller_settings_t* other_controller_settings = app_cfg_get_controller_settings(other_controller); s->output_selection_valid[SELECT_NONE] = true; if (!other_controller_settings->output_settings[OUTPUT_1].enabled) s->output_selection_valid[SELECT_1] = true; if (!other_controller_settings->output_settings[OUTPUT_2].enabled) s->output_selection_valid[SELECT_2] = true; if (!other_controller_settings->output_settings[OUTPUT_1].enabled && !other_controller_settings->output_settings[OUTPUT_2].enabled) s->output_selection_valid[SELECT_1_2] = true; /* If the current output selection is not valid, set it to none */ if (!s->output_selection_valid[s->output_selection]) s->output_selection = SELECT_NONE; set_controller_settings(s); return s->screen; }
void screen_saver_create() { screen_saver_t* s = calloc(1, sizeof(screen_saver_t)); s->screen = widget_create(NULL, &screen_saver_widget_class, s, display_rect); chThdCreateFromHeap(NULL, 1024, NORMALPRIO, screen_saver_thread, s); gui_msg_subscribe(MSG_TOUCH_INPUT, s->screen); }
widget_t* icon_create(widget_t* parent, rect_t rect, const Image_t* image, uint16_t icon_color, uint16_t bg_color) { icon_t* i = calloc(1, sizeof(icon_t)); i->image = image; i->icon_color = icon_color; widget_t* w = widget_create(parent, &icon_widget_class, i, rect); widget_set_background(w, bg_color, FALSE); return w; }
widget_t* calib_screen_create() { calib_screen_t* s = calloc(1, sizeof(calib_screen_t)); s->widget = widget_create(NULL, &calib_widget_class, s, display_rect); widget_set_background(s->widget, BLACK); rect_t rect = { .x = 15, .y = 15, .width = 56, .height = 56, }; s->complete_button = button_create(s->widget, rect, img_left, WHITE, BLACK, complete_calib); widget_hide(s->complete_button); button_set_up_bg_color(s->complete_button, BLACK); button_set_up_icon_color(s->complete_button, WHITE); button_set_down_bg_color(s->complete_button, BLACK); button_set_down_icon_color(s->complete_button, LIGHT_GRAY); button_set_disabled_bg_color(s->complete_button, BLACK); button_set_disabled_icon_color(s->complete_button, DARK_GRAY); rect.x = 320 - 56 - 15; rect.y = 240 - 56 - 15; s->recal_button = button_create(s->widget, rect, img_update, WHITE, BLACK, restart_calib); widget_hide(s->recal_button); button_set_up_bg_color(s->recal_button, BLACK); button_set_up_icon_color(s->recal_button, WHITE); button_set_down_bg_color(s->recal_button, BLACK); button_set_down_icon_color(s->recal_button, LIGHT_GRAY); button_set_disabled_bg_color(s->recal_button, BLACK); button_set_disabled_icon_color(s->recal_button, DARK_GRAY); rect.x = 50; rect.y = 100; rect.width = 175; s->lbl_instructions = label_create(s->widget, rect, "Touch and hold the marker until it turns green", font_opensans_regular_18, WHITE, 3); gui_msg_subscribe(MSG_TOUCH_INPUT, s->widget); return s->widget; } static void calib_widget_destroy(widget_t* w) { calib_screen_t* s = widget_get_instance_data(w); gui_msg_unsubscribe(MSG_TOUCH_INPUT, s->widget); free(s); }
LOCAL ICACHE_FLASH_ATTR int handleCommandAdd(clientInfo_t *cl) { int x, y; char *end; if (cl->argc<5) { client_senderror(cl,"INVALIDARGS"); } screen_t *s = screen_find(cl->argv[0]); if (!s) { client_senderror(cl,"NOTFOUND"); return -1; } const widgetdef_t *c = widgetdef_find(cl->argv[1]); if (!c) { client_senderror(cl,"INVALID"); return -1; } widget_t *w = widget_find(cl->argv[2]); if (w) { client_senderror(cl,"ALREADY"); return -1; } x = (int)strtol(cl->argv[3],&end,10); if (*end !='\0') { client_senderror(cl,"INVALID"); return -1; } y = (int)strtol(cl->argv[4],&end,10); if (*end !='\0') { client_senderror(cl,"INVALID"); return -1; } /* Ok, create it. */ w = widget_create(cl->argv[1], cl->argv[2]); if (!w) { client_senderror(cl,"INVALID"); return -1; } screen_add_widget(s, w, x, y); client_sendOK(cl,"ADD"); return 0; }
widget_t* offset_screen_create() { offset_screen_t* s = calloc(1, sizeof(offset_screen_t)); s->screen = widget_create(NULL, &offset_widget_class, s, display_rect); widget_set_background(s->screen, BLACK); char* title = "Set Probe Offset"; s->button_list = button_list_screen_create(s->screen, title, back_button_clicked, s); gui_msg_subscribe(MSG_SENSOR_SAMPLE, s->screen); gui_msg_subscribe(MSG_SENSOR_TIMEOUT, s->screen); rebuild_offset_screen(s); return s->screen; }
component* textbutton_create(const text_settings *tconf, const char *text, int disabled, textbutton_click_cb cb, void *userdata) { component *c = widget_create(); component_disable(c, disabled); textbutton *tb = malloc(sizeof(textbutton)); memset(tb, 0, sizeof(textbutton)); tb->text = strdup(text); memcpy(&tb->tconf, tconf, sizeof(text_settings)); tb->click_cb = cb; tb->userdata = userdata; widget_set_obj(c, tb); widget_set_render_cb(c, textbutton_render); widget_set_action_cb(c, textbutton_action); widget_set_tick_cb(c, textbutton_tick); widget_set_free_cb(c, textbutton_free); return c; }
component* spritebutton_create(const text_settings *tconf, const char *text, surface *img, int disabled, spritebutton_click_cb cb, void *userdata) { component *c = widget_create(); component_disable(c, disabled); spritebutton *sb = malloc(sizeof(spritebutton)); memset(sb, 0, sizeof(spritebutton)); if(text != NULL) sb->text = strdup(text); memcpy(&sb->tconf, tconf, sizeof(text_settings)); sb->click_cb = cb; sb->img = img; sb->userdata = userdata; widget_set_obj(c, sb); widget_set_render_cb(c, spritebutton_render); widget_set_action_cb(c, spritebutton_action); widget_set_tick_cb(c, spritebutton_tick); widget_set_free_cb(c, spritebutton_free); return c; }
g_error tabpage_install(struct widget *self) { g_error e; struct widget *tab; WIDGET_INSTALL_PARENT(PG_WIDGET_BOX); WIDGET_ALLOC_DATA(tabpagedata); /* Set custom defaults */ e = widget_base_set(self, PG_WP_THOBJ, PGTH_O_TAB_PAGE); errorcheck; e = widget_base_set(self, PG_WP_SIZE, 0); errorcheck; /* Go ahead and create the tab. We will attach the tab * later when we're attached ourselves, but create it early so the * properties can be set. */ e = widget_create(&tab, &DATA->htab, PG_WIDGET_BUTTON, self->dt, self->container, self->owner); errorcheck; e = widget_set(tab, PG_WP_EXTDEVENTS, PG_EXEV_TOGGLE | PG_EXEV_EXCLUSIVE); errorcheck; e = widget_set(tab, PG_WP_THOBJ_BUTTON, PGTH_O_TAB); errorcheck; e = widget_set(tab, PG_WP_THOBJ_BUTTON_HILIGHT, PGTH_O_TAB_HILIGHT); errorcheck; e = widget_set(tab, PG_WP_THOBJ_BUTTON_ON, PGTH_O_TAB_ON); errorcheck; e = widget_set(tab, PG_WP_THOBJ_BUTTON_ON_NOHILIGHT, PGTH_O_TAB_ON_NOHILIGHT); errorcheck; tab->callback = &tabpage_tab_callback; tab->callback_owner = self; return success; }
widget_t* listbox_create(widget_t* parent, rect_t rect, int item_height) { listbox_t* l = calloc(1, sizeof(listbox_t)); widget_t* lb = widget_create(parent, NULL, l, rect); l->pos = 0; l->item_height = item_height; rect_t container_rect = { .x = 0, .y = 0, .width = rect.width - 52, .height = rect.height }; l->item_container = widget_create(lb, &listbox_widget_class, l, container_rect); int button_pad = (rect.height - (2 * 52)) / 3; rect_t button_rect = { .x = rect.width - 52, .y = button_pad, .width = 52, .height = 52 }; l->up_button = button_create(lb, button_rect, img_up, WHITE, BLACK, up_button_event); button_set_up_bg_color(l->up_button, BLACK); button_set_up_icon_color(l->up_button, WHITE); button_set_down_bg_color(l->up_button, BLACK); button_set_down_icon_color(l->up_button, LIGHT_GRAY); button_set_disabled_bg_color(l->up_button, BLACK); button_set_disabled_icon_color(l->up_button, DARK_GRAY); button_rect.y += 52 + button_pad; l->dn_button = button_create(lb, button_rect, img_down, WHITE, BLACK, down_button_event); button_set_up_bg_color(l->dn_button, BLACK); button_set_up_icon_color(l->dn_button, WHITE); button_set_down_bg_color(l->dn_button, BLACK); button_set_down_icon_color(l->dn_button, LIGHT_GRAY); button_set_disabled_bg_color(l->dn_button, BLACK); button_set_disabled_icon_color(l->dn_button, DARK_GRAY); return lb; } void listbox_clear(widget_t* lb) { listbox_t* l = widget_get_instance_data(lb); while (1) { widget_t* w = widget_get_child(l->item_container, 0); if (w == NULL) break; widget_unparent(w); widget_destroy(w); } widget_invalidate(lb); } static void listbox_destroy(widget_t* w) { listbox_t* l = widget_get_instance_data(w); free(l); }
widget_t bdcolor_init () { widget_t frame; widget_t aframe, bframe, cframe; widget_t xframe, yframe, zframe, w; widget_t texts[N_COMBO]; frame = widget_create ("frame", root_widget); aframe = widget_create ("text", frame); widget_set_geometry (aframe, xwidth, 54); widget_configure (aframe, resource_textcolor, tomato); widget_configure (aframe, resource_textfont, XLARGETIMESIB); widget_configure (aframe, resource_textshadow, 1); widget_configure (aframe, resource_text, " Board Color Selection"); bframe = widget_create ("frame", frame); widget_configure (bframe, resource_packed, resource_horizontal); widget_set_geometry (bframe, xwidth, 20 * N_COMBO); xframe = widget_create ("frame", bframe); widget_set_geometry (xframe, 100, 20 * N_COMBO); widget_configure (xframe, resource_wrap, 0); yframe = widget_create ("frame", bframe); widget_set_geometry (yframe, xwidth - 200, 20 * N_COMBO); zframe = widget_create ("frame", bframe); widget_set_geometry (zframe, 100, 20 * N_COMBO); widget_configure (zframe, resource_wrap, 0); { int i; for (i = 0; i < N_COMBO; i++) { char buffer[64]; texts[i] = widget_create ("text", yframe); sprintf (buffer, "Click me!! %s", colorcombo[i].name); widget_model_change (texts[i], colorcombo[i].color, black, black, black); widget_set_geometry (texts[i], xwidth - 200, 20); widget_configure (texts[i], resource_relief, relief_raised); widget_configure (texts[i], resource_border_width, 2); widget_configure (texts[i], resource_text, buffer); widget_configure (texts[i], resource_cannot_change_model, 1); if (colorcombo[i].color != white) widget_configure (texts[i], resource_textcolor, white); else widget_configure (texts[i], resource_textcolor, black); widget_configure (texts[i], resource_textfont, HELVB); widget_add_callback (texts[i], resource_buttonpress_callback, select_bdcolor, i); } } widget_pack (yframe); widget_pack (bframe); widget_pack (frame); widget_fix (frame); widget_set_geometry (frame, xwidth, xheight); return frame; }
void textentry_screen_show(textentry_format_t format, text_handler_t text_handler, void* user_data) { int i; textentry_screen_t* screen = calloc(1, sizeof(textentry_screen_t)); screen->text_handler = text_handler; screen->user_data = user_data; switch (format) { case TXT_FMT_IP: screen->btn_layout = btn_layout_numeric; screen->num_rows = NUM_ROWS_NUMERIC; break; default: case TXT_FMT_ANY: screen->btn_layout = btn_layout_all; screen->num_rows = NUM_ROWS_ALL; break; } screen->widget = widget_create(NULL, &textentry_screen_widget_class, screen, display_rect); rect_t rect = { .x = 7, .y = 5, .width = 48, .height = 48, }; widget_t* back_btn = button_create(screen->widget, rect, img_cancel, WHITE, BLACK, back_button_clicked); button_set_up_bg_color(back_btn, BLACK); button_set_up_icon_color(back_btn, WHITE); button_set_down_bg_color(back_btn, BLACK); button_set_down_icon_color(back_btn, LIGHT_GRAY); button_set_disabled_bg_color(back_btn, BLACK); button_set_disabled_icon_color(back_btn, DARK_GRAY); rect.x = 7; rect.y = 65; for (i = 0; i < NUM_VISIBLE_ROWS; ++i) { int j; for (j = 0; j < NUM_BUTTONS_PER_ROW; ++j) { widget_t* b = button_create(screen->widget, rect, img_circle, WHITE, BLACK, char_button_clicked); button_set_font(b, font_opensans_regular_22); button_set_up_bg_color(b, BLACK); button_set_up_icon_color(b, WHITE); button_set_down_bg_color(b, BLACK); button_set_down_icon_color(b, LIGHT_GRAY); button_set_disabled_bg_color(b, BLACK); button_set_disabled_icon_color(b, DARK_GRAY); screen->buttons[i][j] = b; rect.x += 52; } rect.y += 58; rect.x = 7; } rect.x = 268; rect.y = 5; widget_t* b = button_create(screen->widget, rect, img_check, WHITE, BLACK, ok_button_clicked); button_set_up_bg_color(b, BLACK); button_set_up_icon_color(b, WHITE); button_set_down_bg_color(b, BLACK); button_set_down_icon_color(b, LIGHT_GRAY); button_set_disabled_bg_color(b, BLACK); button_set_disabled_icon_color(b, DARK_GRAY); rect.y = 65; b = button_create(screen->widget, rect, img_backspace, WHITE, BLACK, backspace_button_clicked); button_set_up_bg_color(b, BLACK); button_set_up_icon_color(b, WHITE); button_set_down_bg_color(b, BLACK); button_set_down_icon_color(b, LIGHT_GRAY); button_set_disabled_bg_color(b, BLACK); button_set_disabled_icon_color(b, DARK_GRAY); rect.y += 58; b = button_create(screen->widget, rect, img_up, WHITE, BLACK, up_button_clicked); button_set_up_bg_color(b, BLACK); button_set_up_icon_color(b, WHITE); button_set_down_bg_color(b, BLACK); button_set_down_icon_color(b, LIGHT_GRAY); button_set_disabled_bg_color(b, BLACK); button_set_disabled_icon_color(b, DARK_GRAY); rect.y += 58; b = button_create(screen->widget, rect, img_down, WHITE, BLACK, down_button_clicked); button_set_up_bg_color(b, BLACK); button_set_up_icon_color(b, WHITE); button_set_down_bg_color(b, BLACK); button_set_down_icon_color(b, LIGHT_GRAY); button_set_disabled_bg_color(b, BLACK); button_set_disabled_icon_color(b, DARK_GRAY); update_input_buttons(screen); rect.x = 60; rect.y = 8; rect.width = 200; screen->text_label = label_create(screen->widget, rect, "", font_opensans_regular_22, WHITE, 2); widget_set_background(screen->text_label, LIGHT_GRAY); gui_push_screen(screen->widget); } static void update_input_buttons(textentry_screen_t* screen) { int i; for (i = 0; i < NUM_VISIBLE_ROWS; ++i) { btn_row_t* row = &screen->btn_layout[screen->row_idx + i]; int j; for (j = 0; j < NUM_BUTTONS_PER_ROW; ++j) { widget_t* btn = screen->buttons[i][j]; const char* btn_text = (*row)[j]; if (btn_text == NULL) widget_hide(btn); else { if (*btn_text == ' ') button_set_icon(btn, img_space); else button_set_icon(btn, img_circle); button_set_text(btn, btn_text); widget_show(btn); } } } }
widget_t* home_screen_create() { home_screen_t* s = calloc(1, sizeof(home_screen_t)); s->sample_timestamp = chTimeNow(); s->screen = widget_create(NULL, &home_widget_class, s, display_rect); widget_set_background(s->screen, BLACK); rect_t rect = { .x = TILE_X(0), .y = TILE_Y(0), .width = TILE_SPAN(3), .height = TILE_SPAN(2), }; s->stage_widget = widget_create(s->screen, NULL, NULL, rect); widget_set_background(s->stage_widget, GREEN); rect.x = TILE_X(3); rect.width = TILE_SPAN(1); rect.height = TILE_SPAN(1); s->sensors[SENSOR_1].button = button_create(s->screen, rect, img_temp_med, WHITE, STEEL, click_sensor_button); rect.y = TILE_Y(1); s->sensors[SENSOR_2].button = button_create(s->screen, rect, img_temp_med, WHITE, STEEL, click_sensor_button); rect.x = TILE_X(0); rect.y = TILE_Y(2); s->outputs[OUTPUT_1].button = button_create(s->screen, rect, img_plug, WHITE, STEEL, click_output_button); rect.x = TILE_X(1); s->outputs[OUTPUT_2].button = button_create(s->screen, rect, img_plug, WHITE, STEEL, click_output_button); rect.x = TILE_X(2); s->conn_button = button_create(s->screen, rect, img_signal, RED, STEEL, click_conn_button); rect.x = TILE_X(3); s->settings_button = button_create(s->screen, rect, img_settings, WHITE, COBALT, click_settings_button); rect.x = 0; rect.width = TILE_SPAN(3); s->sensors[SENSOR_1].quantity_widget = quantity_widget_create(s->stage_widget, rect, app_cfg_get_temp_unit()); widget_disable(s->sensors[SENSOR_1].quantity_widget); s->sensors[SENSOR_2].quantity_widget = quantity_widget_create(s->stage_widget, rect, app_cfg_get_temp_unit()); widget_disable(s->sensors[SENSOR_2].quantity_widget); place_quantity_widgets(s); set_output_settings(s, OUTPUT_1, temp_control_get_output_function(OUTPUT_1)); set_output_settings(s, OUTPUT_2, temp_control_get_output_function(OUTPUT_2)); gui_msg_subscribe(MSG_SENSOR_SAMPLE, s->screen); gui_msg_subscribe(MSG_SENSOR_TIMEOUT, s->screen); gui_msg_subscribe(MSG_OUTPUT_STATUS, s->screen); gui_msg_subscribe(MSG_TEMP_UNIT, s->screen); gui_msg_subscribe(MSG_NET_STATUS, s->screen); gui_msg_subscribe(MSG_API_STATUS, s->screen); gui_msg_subscribe(MSG_CONTROLLER_SETTINGS, s->screen); gui_msg_subscribe(MSG_API_CONTROLLER_SETTINGS, s->screen); return s->screen; } void home_screen_destroy(widget_t* w) { home_screen_t* s = widget_get_instance_data(w); gui_msg_unsubscribe(MSG_SENSOR_SAMPLE, s->screen); gui_msg_unsubscribe(MSG_SENSOR_TIMEOUT, s->screen); gui_msg_unsubscribe(MSG_OUTPUT_STATUS, s->screen); gui_msg_unsubscribe(MSG_TEMP_UNIT, s->screen); gui_msg_unsubscribe(MSG_NET_STATUS, s->screen); gui_msg_unsubscribe(MSG_API_STATUS, s->screen); gui_msg_unsubscribe(MSG_CONTROLLER_SETTINGS, s->screen); gui_msg_unsubscribe(MSG_API_CONTROLLER_SETTINGS, s->screen); free(s); }
g_error panel_install(struct widget *self) { struct widget *bar, *title; g_error e; WIDGET_ALLOC_DATA(paneldata); /* This split determines the size of the main panel area */ e = newdiv(&self->in,self); errorcheck; self->in->flags &= ~(DIVNODE_SIZE_AUTOSPLIT | DIVNODE_SIZE_RECURSIVE); self->in->flags |= PG_S_TOP; /* An optional border inside that main panel area */ e = newdiv(&self->in->div,self); errorcheck; self->in->div->flags &= ~(DIVNODE_SIZE_AUTOSPLIT | DIVNODE_SIZE_RECURSIVE); self->in->div->flags |= DIVNODE_SPLIT_BORDER; self->in->div->build = &build_panel_border; /* Create the panelbar widget */ e = widget_create(&bar,&DATA->hbar,PG_WIDGET_PANELBAR, self->dt,self->container,self->owner); errorcheck; e = widget_attach(bar,self->dt,&self->in->div->div,0); errorcheck; e = widget_set(bar,PG_WP_BIND,self->h); errorcheck; /* This draws the panel background */ e = newdiv(bar->out,self); errorcheck; DATA->bg = *bar->out; DATA->bg->flags |= DIVNODE_SPLIT_BORDER; DATA->bg->flags &= ~DIVNODE_SIZE_AUTOSPLIT; DATA->bg->build = &build_bgfill_only; DATA->bg->state = PGTH_O_PANEL; /* Set up us the container! */ self->out = &self->in->next; self->sub = &DATA->bg->div; /* Firstly, create a label widget in the panelbar to present the title */ title = NULL; e = widget_derive(&title,&DATA->hlabel,PG_WIDGET_LABEL,bar,DATA->hbar, PG_DERIVE_INSIDE,self->owner); errorcheck; widget_set(title,PG_WP_SIDE,PG_S_ALL); widget_set(title,PG_WP_THOBJ,PGTH_O_PANELBAR); /* Nextly, create the standard buttons for a panel app */ e = panel_std_button(&DATA->hzoom, self, PGTH_O_ZOOMBTN, PGTH_O_ZOOMBTN_ON, PGTH_O_ZOOMBTN_HILIGHT, PG_EXEV_TOGGLE, &panel_zoom_callback); errorcheck; e = panel_std_button(&DATA->hrotate, self, PGTH_O_ROTATEBTN, PGTH_O_ROTATEBTN_ON, PGTH_O_ROTATEBTN_HILIGHT, 0, &panel_rotate_callback); errorcheck; e = panel_std_button(&DATA->hclose, self, PGTH_O_CLOSEBTN, PGTH_O_CLOSEBTN_ON, PGTH_O_CLOSEBTN_HILIGHT, 0, &panel_close_callback); errorcheck; /* Make sure we default to our minimum rolled-up size */ widget_set(self, PG_WP_SIZE, 0); return success; }
void point_init () { widget_t framepoint, frames[6], button; widget_t point_cell[30]; integer_t i, x, y; integer_t n_point_idx_count; /* calculation maximam cell */ extern integer_t yellow; memset (point_cell, 0, sizeof (point_cell)); read_result_name (); framepoint = create_basic_info_frame ("frame", point, frames, PAI_W * 18, 0, 1); widget_configure (frames[4], resource_frame_start, 270); pointokbutton = frames[5]; quicklogbutton = button = widget_create ("button", frames[4]); widget_set_geometry (button, BUTTON_W, BUTTON_H); widget_configure (button, resource_text, "quicklog"); widget_configure (button, resource_textcolor, yellow); widget_configure (button, resource_textfont, TIMESI); widget_add_callback (button, resource_buttonpress_callback, (void *) quick_log_button_callback, ""); if (!PAICARD) { point_header = widget_create ("pmcontainer", framepoint); widget_set_geometry (point_header, 100, YAKUHEAD_H); pmcontainer_print (point_header, pm_point_header); } widget_get_geometry (frames[1], &x, &y); n_point_idx_count = ((y - ((HEAD_H + 4) * 2) - (PAI_H + 4) * 3) / CELL_H); for (i = 0; i < 24; i++) { point_cell[i] = widget_create ("frame", framepoint); widget_configure (point_cell[i], resource_packed, resource_horizontal); if (i == 0) { widget_configure (point_cell[i], resource_packed, resource_virtical); point_results = widget_create ("pmcontainer", point_cell[i]); widget_set_geometry (point_results, xwidth, HEAD_H + 4); hora_init (point_cell[i], xwidth - 100); } else if (1 <= i && i <= 4) { widget_set_geometry (point_cell[i], xwidth, CELLHOME_H); point_home[i - 1] = widget_create ("pmcontainer", point_cell[i]); point_home_user[i - 1] = widget_create ("text", point_cell[i]); point_home_point[i - 1] = widget_create ("text", point_cell[i]); widget_set_geometry (point_home[i - 1], 100, CELLHOME_H); widget_set_geometry (point_home_user[i - 1], 100, CELLHOME_H); widget_set_geometry (point_home_point[i - 1], 150, CELLHOME_H); widget_configure (point_home_user[i - 1], resource_textfont, MEDIUMJP); widget_configure (point_home_point[i - 1], resource_textfont, TIMESIB); } else if (i == 5) { /* spaceing */ widget_t graph; widget_set_geometry (point_cell[i], xwidth, CELL_H); graph = widget_create ("pmcontainer", point_cell[i]); widget_set_geometry (graph, xwidth, CELL_H); } else if (i == 6) { point_fubase = point_cell[i]; point_fu = widget_create ("text", point_cell[i]); point_fustr = widget_create ("pmcontainer", point_cell[i]); point_fan = widget_create ("text", point_cell[i]); point_fanstr = widget_create ("pmcontainer", point_cell[i]); widget_set_geometry (point_fu, 48, HEAD_H); widget_set_geometry (point_fustr, 48, HEAD_H); widget_set_geometry (point_fan, 48, HEAD_H); widget_set_geometry (point_fanstr, 48, HEAD_H); widget_configure (point_fu, resource_textfont, LUCIDA); widget_configure (point_fan, resource_textfont, LUCIDA); } #define YB 7 #define YL 5 else if (0 <= (i - YB) && (i - YB) < YL) { widget_t *wk; point_yaku[i - YB] = widget_create ("text", point_cell[i]); point_yaku_point[i - YB] = widget_create ("text", point_cell[i]); point_yaku[i - YB + YL] = widget_create ("text", point_cell[i]); point_yaku_point[i - YB + YL] = widget_create ("text", point_cell[i]); widget_configure (point_yaku[i - YB], resource_textfont, MEDIUMJP); widget_configure (point_yaku[i - YB + YL], resource_textfont, MEDIUMJP); widget_configure (point_yaku_point[i - YB], resource_textfont, TIMESIB); widget_configure (point_yaku_point[i - YB + YL], resource_textfont, TIMESIB); widget_set_geometry (point_yaku[i - YB], 200, CELL_H); widget_set_geometry (point_yaku[i - YB + YL], 200, CELL_H); widget_set_geometry (point_yaku_point[i - YB], 100, CELL_H); widget_set_geometry (point_yaku_point[i - YB + YL], 100, CELL_H); } } /* for */ pmcontainer_print (point_fustr, pm_point_fu_sfx); pmcontainer_print (point_fanstr, pm_point_fan_sfx); widget_pack (point); widget_fix (point); widget_set_geometry (point, xwidth, xheight); }
widget_t create_basic_info_frame (char *type, widget_t parent, widget_t pmframes[6], integer_t centerwidth, integer_t frame3_p, integer_t button_p) { widget_t frame1, frame2, frame3, frame2left, frame2center, frame2right, frame4; widget_t okbutton, quitbutton; integer_t x; integer_t frame1h, frame2h, frame3h, frame4h; frame1 = widget_create ("frame", parent); frame2 = widget_create ("frame", parent); frame3 = widget_create ("pmcontainer", parent); frame4 = widget_create ("frame", parent); widget_configure (frame1, resource_packed, resource_horizontal); widget_set_geometry (frame1, xwidth, TOPMARGIN); widget_configure (frame1, resource_wrap, 0); widget_configure (frame2, resource_packed, resource_horizontal); widget_configure (frame4, resource_packed, resource_horizontal); frame2left = widget_create ("pmcontainer", frame2); frame2center = widget_create (type, frame2); frame2right = widget_create ("pmcontainer", frame2); frame1h = TOPMARGIN; if (frame3_p) { frame3h = BOTTOMMARGIN; } else { frame3h = 5; } if (frame1h < 0) { frame1h = 5, frame3h = 5; } frame4h = BUTTON_H; frame2h = xheight - (frame1h + frame3h + frame4h + BUTTON_H); widget_set_geometry (frame1, xwidth, frame1h); widget_configure (frame1, resource_wrap, 0); widget_set_geometry (frame3, xwidth, frame3h); widget_set_geometry (frame2, xwidth, frame2h); { integer_t leftmargin = (xwidth - centerwidth) / 2; widget_set_geometry (frame2left, leftmargin, frame2h); widget_set_geometry (frame2center, xwidth - leftmargin * 2, frame2h); widget_set_geometry (frame2right, leftmargin, frame2h); } if (button_p) { okbutton = widget_create ("button", frame4); /* quitbutton = widget_create ("button", frame4); */ widget_set_geometry (okbutton, BUTTON_W, BUTTON_H); /* widget_set_geometry (quitbutton, BUTTON_W, BUTTON_H); */ widget_configure (okbutton, resource_text, "ok"); widget_configure (okbutton, resource_textcolor, yellow); widget_configure (okbutton, resource_textfont, TIMESI); widget_add_callback (okbutton, resource_buttonpress_callback, (void *) keywait_callback, ""); /* widget_configure (quitbutton, resource_text, "quit"); widget_configure (quitbutton, resource_textcolor, yellow); widget_configure (quitbutton, resource_textfont, TIMESI); widget_add_callback (quitbutton, resource_buttonpress_callback, (void *) quit_callback, ""); */ } pmframes[0] = frame1; pmframes[1] = frame2left; pmframes[2] = frame2right; pmframes[3] = frame3; pmframes[4] = frame4; pmframes[5] = okbutton; return frame2center; }