void image_t::measure(extents_t& result) { if (callback_m) result.horizontal().length_m = fixed_width; // REVISIT (fbrereto) : Fixed value else result.horizontal().length_m = (long)image_m.width(); }
void measure_vertical(label_t& value, extents_t& result, const place_data_t& placed_horizontal) { // Note (fbrereto) : This is explicit (instead of using implementation::measure) because // we need to set the inbound rect to be the potential dimensions of the // text so the reflow will shrink the bounds if it needs to. assert(value.control_m.get()); ::Rect old_bounds = { 0 }; ::GetControlBounds(value.control_m.get(), &old_bounds); ::Rect static_bounds = { 0, 0, 2048, static_cast<short>(placed_horizontal.horizontal().length_m) }; ::Rect bounds = { 0 }; ::SInt16 best_baseline(0); implementation::set_bounds(value.control_m, static_bounds); ::GetBestControlRect(value.control_m.get(), &bounds, &best_baseline); result.height() = bounds.bottom - bounds.top; result.width() = bounds.right - bounds.left; if (best_baseline) result.vertical().guide_set_m.push_back(result.height() + best_baseline); result = implementation::apply_fudges(value, result); implementation::set_bounds(value.control_m, old_bounds); }
void button_t::measure(extents_t& result) { result = metrics::measure(control_m); button_state_set_t::iterator state(button_modifier_state(state_set_m, modifier_mask_m, modifiers_m)); boost::shared_ptr<GG::Font> font = implementation::DefaultFont(); if (state == state_set_m.end()) state = button_default_state(state_set_m); extents_t cur_text_extents(metrics::measure_text(state->name_m, font)); result.width() -= cur_text_extents.width(); result.height() = Value(control_m->Height()); long width_additional(0); for (button_state_set_t::iterator iter(state_set_m.begin()), last(state_set_m.end()); iter != last; ++iter) { extents_t tmp(metrics::measure_text(iter->name_m, font)); width_additional = (std::max)(width_additional, tmp.width()); } result.width() += width_additional; result.width() += Value(2 * implementation::CharWidth()); result.width() = (std::max)(result.width(), 70L); }
void reveal_t::measure(extents_t& result) { using adobe::measure; // REVISIT (fbrereto) : hardwired defaults result.width() = 16; result.height() = 17; if (!using_label_m) return; extents_t label_extents; measure(name_m, label_extents); place_data_t label_place; width(label_place) = label_extents.width(); height(label_place) = label_extents.height(); measure_vertical(name_m, label_extents, label_place); result.width() += 4 /* gap */ + label_extents.width(); result.height() = (std::max)(result.height(), label_extents.height()); }
void link_t::measure(extents_t& result) { result.width() = 15; result.height() = 5; for (long i(0); i < count_m; ++i) result.vertical().guide_set_m.push_back(2); }
void measure(label_t& value, extents_t& result) { assert(value.window_m); GG::X w = static_cast<int>(value.characters_m) * implementation::CharWidth(); GG::Pt extent = implementation::DefaultFont()->TextExtent(value.name_m, value.format_m, w); result.horizontal().length_m = Value(extent.x); assert(result.horizontal().length_m); }
void measure_vertical(label_t& value, extents_t& calculated_horizontal, const place_data_t& placed_horizontal) { assert(value.window_m); GG::Pt extent = implementation::DefaultFont()->TextExtent(value.name_m, value.format_m, GG::X(width(placed_horizontal))); calculated_horizontal.vertical().length_m = Value(extent.y); calculated_horizontal.vertical().guide_set_m.push_back( Value(implementation::DefaultFont()->Ascent())); }
void separator_t::measure(extents_t& result) { #ifdef BOOST_MSVC result.horizontal().length_m = 2; result.vertical().length_m = 2; #elif ADOBE_PLATFORM_MAC result.horizontal().length_m = is_vertical_m ? 5 : 6; result.vertical().length_m = is_vertical_m ? 6 : 5; #endif }
void presets_t::measure(extents_t& result) { assert(control_m); popup_m.measure(result); result.width() += 4 + 26; // gap + icon result.height() = (std::max)(result.height(), 21L); extents_t cat_result; category_popup_m.measure(cat_result); result.width() = (std::max)(result.width(), cat_result.width()); // REVISIT (fbrereto) : This presumes the popups are of the same height. popup_height_m = cat_result.height(); result.height() += popup_height_m + 4; if (!result.horizontal().guide_set_m.empty() && !cat_result.horizontal().guide_set_m.empty()) { result.horizontal().guide_set_m[0] = (std::max)(result.horizontal().guide_set_m[0], cat_result.horizontal().guide_set_m[0]); } }
void toggle_t::measure(extents_t& result) { assert(control_m); result = extents_t(); const adobe::toggle_t::image_type& image(current_image(*this)); result.height() = static_cast<long>(image.height()); result.width() = static_cast<long>(image.width()); }
void button_t::measure(extents_t& result) { assert(control_m); std::vector<std::string> name_set; adobe::for_each(state_set_m, boost::bind(&add_to_name_set, boost::ref(name_set), _1)); result = implementation::widget_best_bounds(*this, &name_set[0], &name_set[0] + name_set.size()); result.horizontal().length_m = std::max<long>(70 /* REVISIT (fbrereto) : fixed value */, result.horizontal().length_m ); }
void edit_text_t::measure(extents_t& result) { assert(control_m); extents_t attrs; std::string base_text(cols_m, std::string::value_type('0')); if (rows_m > 1) { attrs = implementation::measure_theme_text(base_text, theme_m); result = attrs; // REVISIT (fbrereto) : There is an issue here where the attributes of an edit_text // widget don't propagate properly to a static_text widget, so // measurement is inherently inaccurate. A better solution should // be found than simply doubling the row count. result.height() *= rows_m; } else { std::string placeholder(implementation::get_field_text(*this)); implementation::set_field_text(*this, base_text); // measure the control directly because we don't apply the // fudges yet; we want to do that with the edit text values result = implementation::measure(this->control_m); implementation::set_field_text(*this, placeholder); } result = implementation::apply_fudges(*this, result); edit_height_m = result.height(); edit_baseline_m = result.vertical().guide_set_m[0]; if (!using_label_m) return; extents_t label_bounds(implementation::measure_theme_text(implementation::get_name(get_label()), theme_m)); if (result.vertical().guide_set_m.size() && label_bounds.vertical().guide_set_m.size()) align_slices(result.vertical(), label_bounds.vertical()); result.horizontal() = implementation::merge_slices_with(result, metrics_m, label_bounds, get_label().metrics_m, extents_slices_t::horizontal); result.width() += implementation::global_metrics()(implementation::k_metric_gap); result.horizontal().guide_set_m.push_back(label_bounds.width()); static_width_m = label_bounds.width(); static_height_m = label_bounds.height(); static_baseline_m = label_bounds.vertical().guide_set_m.empty() ? 0 : label_bounds.vertical().guide_set_m[0]; }
void image_t::measure_vertical(extents_t& result, const place_data_t& placed_horizontal) { if (callback_m) result.vertical().length_m = fixed_height; // REVISIT (fbrereto) : Fixed value else { // NOTE (fbrereto) : We calculate and use the aspect ratio here to // maintain a proper initial height and width in // the case when the image grew based on how it // is being laid out. float aspect_ratio(image_m.height() / static_cast<float>(image_m.width())); result.vertical().length_m = static_cast<long>(placed_horizontal.horizontal().length_m * aspect_ratio); } }
void display_text_t::measure_vertical(extents_t& calculated_horizontal, const place_data_t& placed_horizontal) { assert(window_m); extents_t::slice_t& vert = calculated_horizontal.vertical(); vert.length_m = Value(implementation::DefaultFont()->Lineskip()); vert.guide_set_m.push_back(Value(implementation::DefaultFont()->Ascent())); }
void display_number_t::measure_vertical(extents_t& calculated_horizontal, const place_data_t& placed_horizontal) { assert(window_m); place_data_t save_bounds; implementation::get_control_bounds(window_m, save_bounds); place_data_t static_bounds; top(static_bounds) = top(placed_horizontal); left(static_bounds) = left(placed_horizontal); width(static_bounds) = width(placed_horizontal); height(static_bounds) = 10000; // bottomless implementation::set_control_bounds(window_m, static_bounds); HDC hdc(::GetWindowDC(window_m)); std::string title(implementation::get_window_title(window_m)); std::wstring wtitle; to_utf16(title.begin(), title.end(), std::back_inserter(wtitle)); place_data_liukahr_t out_extent; // metrics::set_theme_name(L"Edit"); // // If we don't have the type of this widget, then we should return a // zero sized rectangle. This is usually correct, and a good assumption // anyway. // int uxtheme_type = EP_EDITTEXT; // // Get the text metrics (and calculate the baseline of this widget) // TEXTMETRIC widget_tm; bool have_tm = metrics::get_font_metrics(uxtheme_type, widget_tm); assert(have_tm); const place_data_liukahr_t in_extents = static_bounds; bool have_extents = metrics::get_text_extents(uxtheme_type, wtitle.c_str(), out_extent, &in_extents); assert(have_extents); extents_t::slice_t& vert = calculated_horizontal.vertical(); vert.length_m = height(out_extent); // set the baseline for the text metrics::set_window(window_m); if (have_tm) // distance from top to baseline vert.guide_set_m.push_back(widget_tm.tmHeight - widget_tm.tmDescent); implementation::set_control_bounds(window_m, save_bounds); }
void window_t::measure(extents_t& result) { assert(window_m); if (name_m.empty()) { result.height() = 15; result.width() = 15; return; } // REVISIT (fbrereto) : A lot of static metrics values added here boost::shared_ptr<GG::StyleFactory> style = GG::GUI::GetGUI()->GetStyleFactory(); result = metrics::measure_text(name_m, style->DefaultFont()); result.width() = static_cast<long>(result.width() * 1.5); }
void tab_group_t::measure(extents_t& result) { assert(control_m); // REVISIT (fbrereto) : A lot of static metrics values added here boost::shared_ptr<GG::StyleFactory> style = GG::GUI::GetGUI()->GetStyleFactory(); for (tab_set_t::iterator first(items_m.begin()), last(items_m.end()); first != last; ++first) { GG::X text_width = style->DefaultFont()->TextExtent(first->name_m).x; result.width() += Value(text_width) + 18; } result.height() = Value(control_m->MinUsableSize().y); result.vertical().frame_m.first = result.height() + 7; result.height() = 5; }
void display_text_t::measure(extents_t& result) { assert(window_m); boost::shared_ptr<GG::Font> font = implementation::DefaultFont(); extents_t space_extents(metrics::measure_text(std::string(" "), font)); extents_t label_extents(metrics::measure_text(name_m, font)); extents_t characters_extents(metrics::measure_text(std::string(characters_m, '0'), font)); // set up default settings (baseline, etc.) result = space_extents; // set the width to the label width (if any) result.width() = label_extents.width(); // add a guide for the label result.horizontal().guide_set_m.push_back(label_extents.width()); // if there's a label, add space for a space if (label_extents.width() != 0) result.width() += space_extents.width(); // append the character extents (if any) result.width() += characters_extents.width(); // if there are character extents, add space for a space if (characters_extents.width() != 0) result.width() += space_extents.width(); assert(result.horizontal().length_m); }
void measure_label_text(const std::string& text, theme_t theme, extents_t& result) { label_t label(text, std::string(), 0, theme); initialize(label, NULL); measure(label, result); place_data_t p; p.horizontal().length_m = result.width(); measure_vertical(label, result, p); }
void edit_number_t::measure(extents_t& result) { // REVISIT (fbrereto) : This whole measure/place suite needs better // handling of the baseline alignment issue; we // skirt it currently and we should not. using adobe::measure; measure(edit_text_m, result); if (!using_popup()) return; edit_text_width_m = result.width(); extents_t popup_extents; measure(popup_m, popup_extents); // REVISIT (fbrereto) : constant value result.width() += 4 /*gap*/ + popup_extents.width(); result.height() = (std::max)(result.height(), popup_extents.height()); }
void display_number_t::measure(extents_t& result) { assert(window_m); extents_t space_extents(metrics::measure_text(std::string(" "), window_m, EP_EDITTEXT)); extents_t unit_max_extents; extents_t label_extents(metrics::measure_text(name_m, window_m, EP_EDITTEXT)); extents_t characters_extents = metrics::measure_text(std::string(characters_m, '0'), window_m, EP_EDITTEXT); for (display_number_t::unit_set_t::iterator iter(unit_set_m.begin()), end(unit_set_m.end()); iter != end; ++iter) { extents_t tmp(metrics::measure_text(iter->name_m, window_m, EP_EDITTEXT)); if (tmp.width() > unit_max_extents.width()) unit_max_extents = tmp; } // set up default settings (baseline, etc.) result = space_extents; // set the width to the label width (if any) result.width() = label_extents.width(); // add a guide for the label result.horizontal().guide_set_m.push_back(label_extents.width()); // if there's a label, add space for a space if (label_extents.width() != 0) result.width() += space_extents.width(); // append the character extents (if any) result.width() += characters_extents.width(); // if there are character extents, add space for a space if (characters_extents.width() != 0) result.width() += space_extents.width(); // append the max unit extents (if any) result.width() += unit_max_extents.width(); assert(result.horizontal().length_m); }
void checkbox_t::measure(extents_t& result) { result = metrics::measure(control_m, BP_CHECKBOX); // // Get the text margins, and factor those into the bounds. // RECT margins = {0, 0, 0, 0}; metrics::set_window(control_m); if (metrics::get_button_text_margins(BP_CHECKBOX, margins)) { // // Add the width margins in. The height margins aren't important because // the widget is already large enough to contain big text (as calculated // by calculate_best_bounds). // result.width() += margins.left + margins.right; } }
void measure(label_t& value, extents_t& result) { assert(value.control_m.get()); ::Point io_bounds = { 0 }; ::SInt16 out_baseline(0); std::string base_text(value.characters_m != 0 ? std::string(value.characters_m * 2, std::string::value_type('0')) : implementation::get_name(value)); auto_cfstring_t auto_cfstring(explicit_cast<auto_cfstring_t>(base_text)); ::ADOBE_REQUIRE_STATUS(::GetThemeTextDimensions( auto_cfstring.get(), implementation::theme_to_ThemeFontID(value.theme_m), kThemeStateActive, false, &io_bounds, &out_baseline)); result.width() = io_bounds.h; result = implementation::apply_fudges(value, result); }
void tab_group_t::measure(extents_t& result) { assert(control_m); // REVISIT (fbrereto) : A lot of static metrics values added here for (tab_set_t::iterator first(items_m.begin()), last(items_m.end()); first != last; ++first) { extents_t attrs; measure_label_text(label_t(first->name_m, std::string(), 0, theme_m), attrs, ::GetParent(control_m)); result.width() += attrs.width() + 18; result.height() = (std::max)(result.height(), attrs.height()); } result.vertical().frame_m.first = result.height() + 7; result.height() = 5; }
void edit_text_t::measure(extents_t& result) { assert(control_m); // // The calculate_edit_bounds function can figure out the size this edit box // should be, based on the number of rows and columns. // result = calculate_edit_bounds(control_m, cols_m, rows_m); // // Store the height and baseline so that we can correctly align the edit widget // in set_bounds. // edit_height_m = result.height(); if (!result.vertical().guide_set_m.empty()) edit_baseline_m = result.vertical().guide_set_m[0]; // // If we have a label then we need to make extra space // for it. // if (!using_label_m) return; extents_t label_bounds; measure_label_text(get_label(), label_bounds, ::GetParent(control_m)); // // Make sure that the height can accomodate both the label // and the edit widget. // align_slices(result.vertical(), label_bounds.vertical()); // // We put the label on the left side of the edit box, and // place a point of interest at the end of the label, so // that colon alignment can be performed. // result.width() += gap + label_bounds.width(); result.horizontal().guide_set_m.push_back(label_bounds.width()); // // We use the height and baseline of the label to size and // align it in set_bounds. // static_height_m = label_bounds.height(); static_baseline_m = label_bounds.vertical().guide_set_m[0]; }
void group_t::measure(extents_t& result) { assert(control_m); if (name_m.empty()) { result.height() = 15; result.width() = 15; return; } // REVISIT (fbrereto) : A lot of static metrics values added here result = measure_text(name_m, theme_m, ::GetParent(control_m)); result.width() += 15; result.vertical().frame_m.first = result.height() + 7; result.height() = 5; }
void color_button_t::measure(extents_t& result) { assert(control_m); result.width() = Value(original_size_m.x); result.height() = Value(original_size_m.y); boost::shared_ptr<GG::Font> font = implementation::DefaultFont(); GG::Y baseline_offset = (control_m->Height() - font->Height()) / 2; result.vertical().guide_set_m.push_back(Value(baseline_offset)); if (!using_label_m) return; extents_t label_bounds(measure_text(name_m.name_m, font)); label_bounds.vertical().guide_set_m.push_back(0); align_slices(result.vertical(), label_bounds.vertical()); result.width() += gap + label_bounds.width(); result.horizontal().guide_set_m.push_back(label_bounds.width()); }
void popup_t::measure(extents_t& result) { assert(control_m); // // Make sure that metrics_t is initialized. // metrics::set_window(control_m); // // The popup_t has multiple text items. We need to find the one with // the widest extents (when drawn). Then we can make sure that we get // enough space to draw our largest text item. // menu_item_set_t::iterator first(menu_items_m.begin()); menu_item_set_t::iterator last(menu_items_m.end()); RECT largest_extents = { 0, 0, 0, 0 }; bool have_extents = false; // // Now iterate through all of our text. // while (first != last) { // // Discover the extents of this text! // RECT extents; if (metrics::get_text_extents(CP_DROPDOWNBUTTON, hackery::convert_utf(first->first), extents)) { // // Alright, we were able to obtain the required extents. // Now we just need to see if they are larger than the // ones we already have. // if ((extents.right - extents.left) > (largest_extents.right - largest_extents.left)) largest_extents = extents; have_extents = true; } ++first; } // // We don't really use much of UxTheme to discover the bounds of // the combobox. We can use the GetComboboxInfo function to get // most of the information we require (such as where the text will // lie). // TEXTMETRIC font_metrics; int border; bool have_metrics = metrics::get_font_metrics(CP_DROPDOWNBUTTON, font_metrics); bool have_border = metrics::get_integer(CP_DROPDOWNBUTTON, TMT_BORDERSIZE, border); COMBOBOXINFO cbi; cbi.cbSize = sizeof(cbi); if (GetComboBoxInfo(control_m, &cbi)) { RECT text = { 0, 0, 0, 0 }; // currently unused // RECT size = { 0, 0, 0, 0 }; WINDOWINFO wi = { 0 }; wi.cbSize = sizeof(wi); if (!GetWindowInfo(control_m, &wi)) ADOBE_THROW_LAST_ERROR; // // Figure out the borders around the text entry area. // text.left = wi.rcClient.left - wi.rcWindow.left + cbi.rcItem.left; text.right = wi.rcWindow.right - wi.rcClient.right + cbi.rcItem.right; text.top = wi.rcClient.top - wi.rcWindow.top + cbi.rcItem.top; text.bottom = wi.rcWindow.bottom - wi.rcWindow.bottom + cbi.rcItem.bottom; // // Figure out the dimensions for the entire control. // result.width() = text.left + largest_extents.right - largest_extents.left + cbi.rcButton.right - cbi.rcButton.left; result.height() = wi.rcWindow.bottom - wi.rcWindow.top; // // Deduce the baseline from the text rectangle. // int baseline = 0; if (have_metrics) { baseline = text.top + font_metrics.tmAscent; if (have_border) baseline += border; } result.vertical().guide_set_m.push_back(baseline); } else ADOBE_THROW_LAST_ERROR; // // If we have a label (always on our left side?) then we // need to add the size of the label to our result. We try // to align the label with the popup by baseline. Which is // kind of what Eve does, so it's bad that we do this // ourselves, really... // if (!using_label_m) return; // // We store the height of the label, from this we can // figure out how much to offset it when positioning // the widgets in set_bounds. // extents_t label_bounds; measure_label_text(name_m, label_bounds, ::GetParent(control_m)); static_height_m = label_bounds.height(); static_baseline_m = label_bounds.vertical().guide_set_m[0]; // // Now we can align the label within the vertical // slice of the result. This doesn't do anything if // the label is shorter than the popup. // align_slices(result.vertical(), label_bounds.vertical()); // // Add the width of the label (plus a gap) to the // resulting width. // result.width() += gap + label_bounds.width(); // // Don't let the width of the popup go too crazy now... // result.width() = std::min<long>(static_cast<long>(result.width()), 300); // REVISIT (fbrereto) : fixed width // // Add a point-of-interest where the label ends. // We put the label to the left of the popup. // result.horizontal().guide_set_m.push_back(label_bounds.width()); return; }
const int& height() const { return extents_m.height(); }
const int& width() const { return extents_m.width(); }