void ttoggle_panel::signal_handler_pre_left_button_click(const event::tevent event) { DBG_GUI_E << get_control_type() << "[" << id() << "]: " << event << ".\n"; set_value(1); #if 0 /* * Disabled since it causes issues with gamestate inspector (bug #22095). * It was added in b84f2ebff0b53c7e4194da315c43f62a08494c52 for the lobby, * since that code is still experimental, prefer to fix a real issue caused * by it. * * The issue is that the gui2::tlistbox::add_row code was changed to * increase the content size. Before the list was shown the list was * cleared. The clear operation did not reduce the size (since the widgets * were not shown yet). The add operation afterwards again reserved the * space causing the size of the listbox to be twice the required space. * * 2014.06.09 -- Mordante */ if(callback_state_change_) { callback_state_change_(*this); } #endif }
tmatrix::tmatrix(const implementation::tbuilder_matrix& builder) : tbase(builder, get_control_type()) , content_() , pane_(NULL) { boost::intrusive_ptr<const tmatrix_definition::tresolution> cfg = boost::dynamic_pointer_cast< const tmatrix_definition::tresolution>(config()); tbuilder_widget::treplacements replacements; replacements.insert(std::make_pair("_main", builder.builder_main)); if(builder.builder_top) { replacements.insert(std::make_pair("_top", builder.builder_top)); } if(builder.builder_left) { replacements.insert(std::make_pair("_left", builder.builder_left)); } if(builder.builder_right) { replacements.insert(std::make_pair("_right", builder.builder_right)); } if(builder.builder_bottom) { replacements.insert(std::make_pair("_bottom", builder.builder_bottom)); } cfg->content->build(content_, replacements); content_.set_parent(this); pane_ = find_widget<tpane>(&content_, "pane", false, true); }
void tcontrol::layout_wrap(const unsigned maximum_width) { // Inherited. twidget::layout_wrap(maximum_width); assert(config_); if(label_.empty()) { // FIXME see what to do on an empty label later. return; } else { tpoint size = get_best_text_size( tpoint(0,0), tpoint(maximum_width - config_->text_extra_width, 0)); size.x += config_->text_extra_width; size.y += config_->text_extra_height; set_layout_size(size); DBG_G_L << "tcontrol(" + get_control_type() + ") " + __func__ + ":" << " maximum_width " << maximum_width << " result " << size << ".\n"; } }
static void print_control (CControl *control) { if(HAS_VERBOSE()) { char *flags = get_control_flags(control->flags); printf(" %s\n ID : 0x%08x,\n Type : %s,\n Flags : { %s },\n", control->name, control->id, get_control_type(control->type), flags); if(control->type == CC_TYPE_CHOICE) { char *choices = get_control_choices(control); printf(" Values : { %s },\n Default : %d\n", choices, control->def.value); free(choices); } else { printf(" Values : [ %d .. %d, step size: %d ],\n Default : %d\n", control->min.value, control->max.value, control->step.value, control->def.value); } free(flags); } else { printf(" %s\n", control->name); } }
void tcontrol::load_config() { if(!config()) { definition_load_configuration(get_control_type()); load_config_extra(); } }
void styled_widget::load_config() { if(!config()) { definition_load_configuration(get_control_type()); load_config_extra(); } }
tpoint tcontrol::get_config_minimum_size() const { assert(config_); tpoint result(config_->min_width, config_->min_height); DBG_G_L << "tcontrol(" + get_control_type() + ") " + __func__ + ":" << " result " << result << ".\n"; return result; }
void ttext_box::signal_handler_mouse_motion(const event::tevent event, bool& handled, const tpoint& coordinate) { DBG_GUI_E << get_control_type() << "[" << id() << "]: " << event << ".\n"; if(dragging_) { handle_mouse_selection(coordinate, false); } handled = true; }
void tcontrol::layout_shrink_width(const unsigned maximum_width) { DBG_G_L << "tcontrol(" + get_control_type() + ") " + __func__ + ":" << " maximum_width " << maximum_width << ".\n"; /** @todo handle the tooltip properly. */ shrunken_ = true; set_layout_size(tpoint(maximum_width, get_best_size().y)); assert(static_cast<unsigned>(get_best_size().x) == maximum_width); }
listbox::listbox(const implementation::builder_styled_widget& builder, const generator_base::placement placement, builder_grid_ptr list_builder, const bool has_minimum, const bool has_maximum, const bool select) : scrollbar_container(builder, get_control_type()) , generator_(generator_base::build(has_minimum, has_maximum, placement, select)) , is_horizontal_(placement == generator_base::horizontal_list) , list_builder_(list_builder) , need_layout_(false) , orders_() { }
void tcontrol::layout_fit_width(const unsigned maximum_width, const tfit_flags flags) { assert(get_visible() != twidget::INVISIBLE); log_scope2(gui_layout, "tcontrol(" + get_control_type() + ") " + __func__); DBG_G_L << "maximum_width " << maximum_width << " flags " << flags << ".\n"; // Already fits. if(get_best_size().x <= static_cast<int>(maximum_width)) { DBG_G_L << "Already fits.\n"; return; } // Wrap. if((flags & twidget::WRAP) && can_wrap()) { layout_wrap(maximum_width); if(get_best_size().x <= static_cast<int>(maximum_width)) { DBG_G_L << "Success: Wrapped.\n"; return; } } // Horizontal scrollbar. if((flags & twidget::SCROLLBAR) && has_horizontal_scrollbar()) { layout_use_horizontal_scrollbar(maximum_width); if(get_best_size().x <= static_cast<int>(maximum_width)) { DBG_G_L << "Success: Horizontal scrollbar.\n"; return; } } // Shrink. if((flags & twidget::SHRINK) && can_shrink_width()) { layout_shrink_width(maximum_width); DBG_G_L << "Success: Shrunken.\n"; } DBG_G_L << "Failed.\n"; }
tpoint tcontrol::calculate_best_size() const { assert(config_); tpoint result(config_->default_width, config_->default_height); if(! label_.empty()) { // If no label text set we use the predefined value. /** * @todo The value send should subtract the border size * and readd it after calculation to get the proper result. */ result = get_best_text_size(result); } DBG_G_L << "tcontrol(" + get_control_type() + ") " + __func__ + ":" << " empty label " << label_.empty() << " result " << result << ".\n"; return result; }
static BOOL is_control_displayonly(HWND control) { BOOL displayonly = 0; switch(get_control_type(control)) { case CT_STATIC: displayonly = TRUE; break; case CT_EDIT: displayonly = (GetWindowLong(control, GWL_STYLE) & ES_READONLY) ? TRUE : FALSE; break; default: displayonly = FALSE; break; } if (!IsWindowEnabled(control)) displayonly = TRUE; return displayonly; }
// --------------------------------------------------------------------------------------------------- void info_display_object_placement(int show_all) { static int old_Cur_object_index; static int old_type; static int old_movement_type; static int old_control_type; static int old_mode; char name[30]; if (init_info | show_all) { old_Cur_object_index = -2; old_type = -2; old_movement_type = -2; old_control_type = -2; old_mode = -2; } if ( ( Cur_object_index != old_Cur_object_index) || ( Objects[Cur_object_index].type != old_type) || ( Objects[Cur_object_index].movement_type != old_movement_type) || ( Objects[Cur_object_index].control_type != old_control_type) || ( Objects[Cur_object_index].ctype.ai_info.behavior != old_mode) ) { gr_uprintf( 0, 0, "Object id: %4d\n", Cur_object_index); gr_uprintf( 0, 16, "Type: %s\n", get_object_type(Objects[Cur_object_index].type , name)); gr_uprintf( 0, 32, "Movmnt: %s\n", get_movement_type(Objects[Cur_object_index].movement_type, name)); gr_uprintf( 0, 48, "Cntrl: %s\n", get_control_type(Objects[Cur_object_index].control_type, name)); gr_uprintf( 0, 64, "Mode: %s\n", get_ai_behavior(Objects[Cur_object_index].ctype.ai_info.behavior, name)); old_Cur_object_index = Cur_object_index; old_type = Objects[Cur_object_index].type; old_movement_type = Objects[Cur_object_index].movement_type; old_mode = Objects[Cur_object_index].control_type; old_mode = Objects[Cur_object_index].ctype.ai_info.behavior; } }
menu_button::menu_button(const implementation::builder_menu_button& builder) : styled_widget(builder, get_control_type()) , selectable_item() , state_(ENABLED) , retval_(0) , values_() , selected_() , keep_open_(false) { values_.emplace_back(::config {"label", this->get_label()}); connect_signal<event::MOUSE_ENTER>( std::bind(&menu_button::signal_handler_mouse_enter, this, _2, _3)); connect_signal<event::MOUSE_LEAVE>( std::bind(&menu_button::signal_handler_mouse_leave, this, _2, _3)); connect_signal<event::LEFT_BUTTON_DOWN>(std::bind( &menu_button::signal_handler_left_button_down, this, _2, _3)); connect_signal<event::LEFT_BUTTON_UP>( std::bind(&menu_button::signal_handler_left_button_up, this, _2, _3)); connect_signal<event::LEFT_BUTTON_CLICK>(std::bind( &menu_button::signal_handler_left_button_click, this, _2, _3)); }
multimenu_button::multimenu_button(const implementation::builder_multimenu_button& builder) : styled_widget(builder, get_control_type()) , state_(ENABLED) , retval_(0) , max_shown_(1) , values_() , toggle_states_() , droplist_(nullptr) { values_.emplace_back(::config {"label", this->get_label()}); connect_signal<event::MOUSE_ENTER>( std::bind(&multimenu_button::signal_handler_mouse_enter, this, _2, _3)); connect_signal<event::MOUSE_LEAVE>( std::bind(&multimenu_button::signal_handler_mouse_leave, this, _2, _3)); connect_signal<event::LEFT_BUTTON_DOWN>(std::bind( &multimenu_button::signal_handler_left_button_down, this, _2, _3)); connect_signal<event::LEFT_BUTTON_UP>( std::bind(&multimenu_button::signal_handler_left_button_up, this, _2, _3)); connect_signal<event::LEFT_BUTTON_CLICK>(std::bind( &multimenu_button::signal_handler_left_button_click, this, _2, _3)); }
void tcontrol::set_block_easy_close(const bool block) { twindow* window = get_window(); if(!window) { /* * This can happen in a listbox when the row data is manipulated before * the listbox is finalized. In that case that widget should do set the * state in its finalizer. */ DBG_GUI << "tcontrol(" + get_control_type() + ") " + __func__ + ": " "No window set, this might be a bug.\n"; return; } if(block) { if(id().empty()) { set_id(get_uid()); } window->add_easy_close_blocker(id()); } else if(!id().empty()) { // It might never have been enabled so the id might be empty. window->remove_easy_close_blocker(id()); } }
void list_rdr(SaHpiSessionIdT session_id, SaHpiResourceIdT resource_id) { SaErrorT err; SaHpiEntryIdT current_rdr; SaHpiEntryIdT next_rdr; SaHpiRdrT rdr; SaHpiSensorReadingT reading; SaHpiSensorTypeT sensor_type; SaHpiSensorNumT sensor_num; SaHpiEventCategoryT category; SaHpiSensorThresholdsT thres; SaHpiCtrlNumT ctrl_num; SaHpiCtrlStateT state; SaHpiCtrlTypeT ctrl_type; SaHpiEirIdT l_eirid; SaHpiInventoryDataT* l_inventdata; const SaHpiUint32T l_inventsize = 16384; SaHpiUint32T l_actualsize; printf("RDR Info:\n"); next_rdr = SAHPI_FIRST_ENTRY; do { char tmp_epath[128]; current_rdr = next_rdr; err = saHpiRdrGet(session_id, resource_id, current_rdr, &next_rdr, &rdr); if (SA_OK != err) { if (current_rdr == SAHPI_FIRST_ENTRY) printf("Empty RDR table\n"); else error("saHpiRdrGet", err); return; } printf("\tRecordId: %x\n", rdr.RecordId); printf("\tRdrType: %s\n", rdrtype2str(rdr.RdrType)); if (rdr.RdrType == SAHPI_SENSOR_RDR) { SaErrorT val; sensor_num = rdr.RdrTypeUnion.SensorRec.Num; val = saHpiSensorTypeGet(session_id, resource_id, sensor_num, &sensor_type, &category); printf("\tSensor num: %i\n\tType: %s\n", sensor_num, get_sensor_type(sensor_type)); printf("\tCategory: %s\n", get_sensor_category(category)); memset(&reading, 0, sizeof(SaHpiSensorReadingT)); err = saHpiSensorReadingGet(session_id, resource_id, sensor_num, &reading); if (err != SA_OK) { printf("Error=%d reading sensor data {sensor, %d}\n", err, sensor_num); continue; } if (reading.ValuesPresent & SAHPI_SRF_RAW) { printf("\tValues Present: RAW\n"); printf("\t\tRaw value: %d\n", reading.Raw); } if (reading.ValuesPresent & SAHPI_SRF_INTERPRETED) { printf("\tValues Present: Interpreted\n"); printf("\t\t"); interpreted2str(reading.Interpreted); } if (reading.ValuesPresent & SAHPI_SRF_EVENT_STATE) { printf("\tValues Present: Event State\n"); } if (rdr.RdrTypeUnion.SensorRec.ThresholdDefn.IsThreshold == SAHPI_TRUE) { memset(&thres, 0, sizeof(SaHpiSensorThresholdsT)); err = saHpiSensorThresholdsGet(session_id, resource_id, sensor_num, &thres); if (err != SA_OK) { printf("Error=%d reading sensor thresholds {sensor, %d}\n", err, sensor_num); continue; } if (thres.LowCritical.ValuesPresent) { printf("\t\tThreshold: Low Critical Values\n"); printreading(thres.LowCritical); } if (thres.LowMajor.ValuesPresent) { printf("\t\tThreshold: Low Major Values\n"); printreading(thres.LowMajor); } if (thres.LowMinor.ValuesPresent) { printf("\t\tThreshold: Low Minor Values\n"); printreading(thres.LowMinor); } if (thres.UpCritical.ValuesPresent) { printf("\t\tThreshold: Up Critical Values\n"); printreading(thres.UpCritical); } if (thres.UpMajor.ValuesPresent) { printf("\t\tThreshold: Up Major Values\n"); printreading(thres.UpMajor); } if (thres.UpMinor.ValuesPresent) { printf("\t\tThreshold: Up Minor Values\n"); printreading(thres.UpMinor); } if (thres.PosThdHysteresis.ValuesPresent) { printf("\t\tThreshold: Pos Threshold Hysteresis Values\n"); printreading(thres.PosThdHysteresis); } if (thres.NegThdHysteresis.ValuesPresent) { printf("\t\tThreshold: Neg Threshold Hysteresis Values\n"); printreading(thres.NegThdHysteresis); } } } if (rdr.RdrType == SAHPI_CTRL_RDR) { ctrl_num = rdr.RdrTypeUnion.CtrlRec.Num; err = saHpiControlTypeGet(session_id, resource_id, ctrl_num, &ctrl_type); if (err != SA_OK) { printf("Error=%d reading control type {control, %d}\n", err, ctrl_num); continue; } printf("\tControl num: %i\n\tType: %s\n", ctrl_num, get_control_type(ctrl_type)); err = saHpiControlStateGet(session_id, resource_id, ctrl_num, &state); if (err != SA_OK) { printf("Error=%d reading control state {control, %d}\n", err, ctrl_num); continue; } if (ctrl_type != state.Type) { printf("Control Type mismatch between saHpiControlTypeGet=%d and saHpiControlStateGet = %d\n", ctrl_type, state.Type); } switch (state.Type) { case SAHPI_CTRL_TYPE_DIGITAL: printf("\t\tControl Digital State: %s\n", ctrldigital2str(state.StateUnion.Digital)); break; case SAHPI_CTRL_TYPE_DISCRETE: printf("\t\tControl Discrete State: %x\n", state.StateUnion.Discrete); break; case SAHPI_CTRL_TYPE_ANALOG: printf("\t\tControl Analog State: %x\n", state.StateUnion.Analog); break; case SAHPI_CTRL_TYPE_STREAM: printf("\t\tControl Stream Repeat: %d\n", state.StateUnion.Stream.Repeat); printf("\t\tControl Stream Data: "); display_oembuffer(state.StateUnion.Stream.StreamLength, state.StateUnion.Stream.Stream); break; case SAHPI_CTRL_TYPE_TEXT: printf("\t\tControl Text Line Num: %c\n", state.StateUnion.Text.Line); display_textbuffer(state.StateUnion.Text.Text); break; case SAHPI_CTRL_TYPE_OEM: printf("\t\tControl OEM Manufacturer: %d\n", state.StateUnion.Oem.MId); printf("\t\tControl OEM Data: "); display_oembuffer((SaHpiUint32T)state.StateUnion.Oem.BodyLength, state.StateUnion.Oem.Body); break; default: printf("\t\tInvalid control type (%d) from saHpiControlStateGet\n", state.Type); } } if (rdr.RdrType == SAHPI_INVENTORY_RDR) { l_eirid = rdr.RdrTypeUnion.InventoryRec.EirId; l_inventdata = (SaHpiInventoryDataT *)g_malloc(l_inventsize); err = saHpiEntityInventoryDataRead(session_id, resource_id, l_eirid, l_inventsize, l_inventdata, &l_actualsize); if (err != SA_OK) { printf("Error=%d reading inventory type {EirId, %d}\n", err, l_eirid); continue; } else if (l_inventdata->Validity == SAHPI_INVENT_DATA_VALID) { printf("\tFound Inventory RDR with EirId: %x\n", l_eirid); printf("\tRDR l_inventsize = %d, actualsize = %d\n", l_inventsize, l_actualsize); switch (l_inventdata->DataRecords[0]->RecordType) { case SAHPI_INVENT_RECTYPE_INTERNAL_USE: printf( "Internal Use\n"); break; case SAHPI_INVENT_RECTYPE_PRODUCT_INFO: printf( "Product Info\n"); break; case SAHPI_INVENT_RECTYPE_CHASSIS_INFO: printf( "Chassis Info\n"); break; case SAHPI_INVENT_RECTYPE_BOARD_INFO: printf( "Board Info\n"); break; case SAHPI_INVENT_RECTYPE_OEM: printf( "OEM Record\n"); break; default: printf(" Invalid Invent Rec Type =%x\n", l_inventdata->DataRecords[0]->RecordType); break; } } g_free(l_inventdata); } printf("\tEntity: \n"); entitypath2string(&rdr.Entity, tmp_epath, sizeof(tmp_epath)); printf("\t\t%s\n", tmp_epath); printf("\tIdString: "); display_textbuffer(rdr.IdString); printf("\n"); /* Produce blank line between rdrs. */ }while(next_rdr != SAHPI_LAST_ENTRY); }
scrollbar_panel::scrollbar_panel(const implementation::builder_scrollbar_panel& builder) : scrollbar_container(builder, get_control_type()) { }
static void populate_control(datamap *map, HWND control, windows_options *opts, datamap_entry *entry, const char *option_name) { int i = 0; BOOL bool_value = 0; int int_value = 0; float float_value = 0; const char *string_value; const char *item_string; int selected_index = 0; char buffer[128]; int trackbar_range = 0; int trackbar_pos = 0; double trackbar_range_d = 0; // use default populate control value switch(get_control_type(control)) { case CT_BUTTON: assert(entry->type == DM_BOOL); bool_value = opts->bool_value(option_name); Button_SetCheck(control, bool_value); break; case CT_EDIT: case CT_STATIC: switch(entry->type) { case DM_STRING: string_value = opts->value(option_name); break; case DM_INT: int_value = opts->int_value(option_name); if (entry->int_format != NULL) snprintf(buffer, ARRAY_LENGTH(buffer), entry->int_format, int_value); else snprintf(buffer, ARRAY_LENGTH(buffer), "%d", int_value); string_value = buffer; break; case DM_FLOAT: float_value = opts->float_value(option_name); if (entry->float_format != NULL) snprintf(buffer, ARRAY_LENGTH(buffer), entry->float_format, float_value); else snprintf(buffer, ARRAY_LENGTH(buffer), "%f", float_value); string_value = buffer; break; default: string_value = ""; break; } if (string_value == NULL) string_value = ""; win_set_window_text_utf8(control, string_value); break; case CT_COMBOBOX: selected_index = 0; switch(entry->type) { case DM_INT: int_value = opts->int_value(option_name); for (i = 0; i < ComboBox_GetCount(control); i++) { if (int_value == (int) ComboBox_GetItemData(control, i)) { selected_index = i; break; } } break; case DM_STRING: string_value = opts->value(option_name); for (i = 0; i < ComboBox_GetCount(control); i++) { item_string = (const char *) ComboBox_GetItemData(control, i); if (!core_stricmp(string_value, item_string ? item_string : "")) { selected_index = i; break; } } break; default: break; } (void)ComboBox_SetCurSel(control, selected_index); break; case CT_TRACKBAR: // do we need to set the trackbar options? /* if (!entry->use_trackbar_options) { switch(options_get_range_type(opts, option_name)) { case OPTION_RANGE_NONE: // do nothing break; case OPTION_RANGE_INT: options_get_range_int(opts, option_name, &minval_int, &maxval_int); entry->use_trackbar_options = TRUE; entry->trackbar_min = minval_int; entry->trackbar_max = maxval_int; entry->trackbar_increments = 1; break; case OPTION_RANGE_FLOAT: options_get_range_float(opts, option_name, &minval_float, &maxval_float); entry->use_trackbar_options = TRUE; entry->trackbar_min = minval_float; entry->trackbar_max = maxval_float; entry->trackbar_increments = (float)0.05; break; } } */ // do we specify default options for this control? if so, we need to specify // the range if (entry->use_trackbar_options) { trackbar_range_d = floor(((entry->trackbar_max - entry->trackbar_min) / entry->trackbar_increments) + 0.5); trackbar_range = (int) trackbar_range_d; SendMessage(control, TBM_SETRANGEMIN, (WPARAM) FALSE, (LPARAM) 0); SendMessage(control, TBM_SETRANGEMAX, (WPARAM) FALSE, (LPARAM) trackbar_range); } switch(entry->type) { case DM_INT: int_value = opts->int_value(option_name); trackbar_pos = trackbar_position_from_value(entry, int_value); break; case DM_FLOAT: float_value = opts->float_value(option_name); trackbar_pos = trackbar_position_from_value(entry, float_value); break; default: trackbar_pos = 0; break; } SendMessage(control, TBM_SETPOS, (WPARAM) TRUE, (LPARAM) trackbar_pos); break; case CT_LISTVIEW: case CT_UNKNOWN: // non applicable break; } }
static void read_control(datamap *map, HWND control, windows_options *opts, datamap_entry *entry, const char *option_name) { BOOL bool_value = 0; int int_value = 0; float float_value = 0; const char *string_value; int selected_index = 0; int trackbar_pos = 0; std::string error; // use default read value behavior switch(get_control_type(control)) { case CT_BUTTON: assert(entry->type == DM_BOOL); bool_value = Button_GetCheck(control); opts->set_value(option_name, bool_value, OPTION_PRIORITY_CMDLINE,error); break; case CT_COMBOBOX: selected_index = ComboBox_GetCurSel(control); if (selected_index >= 0) { switch(entry->type) { case DM_INT: int_value = (int) ComboBox_GetItemData(control, selected_index); opts->set_value(option_name, int_value, OPTION_PRIORITY_CMDLINE,error); break; case DM_STRING: string_value = (const char *) ComboBox_GetItemData(control, selected_index); opts->set_value(option_name, string_value ? string_value : "", OPTION_PRIORITY_CMDLINE,error); break; default: break; } } break; case CT_TRACKBAR: trackbar_pos = SendMessage(control, TBM_GETPOS, 0, 0); float_value = trackbar_value_from_position(entry, trackbar_pos); switch(entry->type) { case DM_INT: int_value = (int) float_value; if (int_value != opts->int_value(option_name)) { opts->set_value(option_name, int_value, OPTION_PRIORITY_CMDLINE,error); } break; case DM_FLOAT: // Use tztrim(float_value) or we get trailing zero's that break options_equal(). if (float_value != opts->float_value(option_name)) { opts->set_value(option_name, tztrim(float_value), OPTION_PRIORITY_CMDLINE,error); } break; default: break; } break; case CT_EDIT: // NYI break; case CT_STATIC: case CT_LISTVIEW: case CT_UNKNOWN: // non applicable break; } }