void styled_widget::request_reduce_width(const unsigned maximum_width)
{
assert(config_);
if(!label_.empty() && can_wrap()) {
point size = get_best_text_size(
point(), point(maximum_width - config_->text_extra_width, 0));
size.x += config_->text_extra_width;
size.y += config_->text_extra_height;
set_layout_size(size);
DBG_GUI_L << LOG_HEADER << " label '" << debug_truncate(label_)
<< "' maximum_width " << maximum_width << " result " << size
<< ".\n";
} else if(label_.empty()) {
point size = get_best_size();
point min_size = get_config_minimum_size();
size.x = std::min(size.x, std::max<int>(maximum_width, min_size.x));
set_layout_size(size);
DBG_GUI_L << LOG_HEADER << " styled_widget " << id()
<< " maximum_width " << maximum_width << " result " << size
<< ".\n";
} else {
DBG_GUI_L << LOG_HEADER << " label '" << debug_truncate(label_)
<< "' failed; either no label or wrapping not allowed.\n";
}
}
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";
}
}
void tcontrol::request_reduce_width(const unsigned maximum_width)
{
assert(config_);
if(!label_.empty() && can_wrap()) {
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_GUI_L << LOG_HEADER
<< " label '" << debug_truncate(label_)
<< "' maximum_width " << maximum_width
<< " result " << size
<< ".\n";
} else {
DBG_GUI_L << LOG_HEADER
<< " label '" << debug_truncate(label_)
<< "' failed; either no label or wrapping not allowed.\n";
}
}
void grid::request_reduce_height(const unsigned maximum_height)
{
point size = get_best_size();
if(size.y <= static_cast<int>(maximum_height)) {
/** @todo this point shouldn't be reached, find out why it does. */
return;
}
const unsigned too_high = size.y - maximum_height;
unsigned reduced = 0;
for(size_t row = 0; row < rows_; ++row) {
unsigned wanted_height = row_height_[row] - (too_high - reduced);
/**
* @todo Improve this code.
*
* Now we try every item to be reduced, maybe items need a flag whether
* or not to try to reduce and also evaluate whether the force
* reduction is still needed.
*/
if(too_high - reduced >= row_height_[row]) {
DBG_GUI_L << LOG_HEADER << " row " << row << " height "
<< row_height_[row] << " want to reduce " << too_high
<< " is too small to be reduced fully try 1 pixel.\n";
wanted_height = 1;
}
/* Reducing the height of a widget causes the widget to save its new size
in widget::layout_size_. After that, get_best_size() will return that
size and not the originally calculated optimal size.
Thus, it's perfectly correct that grid::calculate_best_size() that we
call later calls get_best_size() for child widgets as if size reduction
had never happened. */
const unsigned height = grid_implementation::row_request_reduce_height(
*this, row, wanted_height);
if(height < row_height_[row]) {
unsigned reduction = row_height_[row] - height;
DBG_GUI_L << LOG_HEADER << " row " << row << " height "
<< row_height_[row] << " want to reduce " << too_high
<< " reduced " << reduction << " pixels.\n";
size.y -= reduction;
reduced += reduction;
}
if(size.y <= static_cast<int>(maximum_height)) {
break;
}
}
size = calculate_best_size();
DBG_GUI_L << LOG_HEADER << " Requested maximum " << maximum_height
<< " resulting height " << size.y << ".\n";
set_layout_size(size);
}
void styled_widget::set_label(const t_string& label)
{
if(label == label_) {
return;
}
label_ = label;
set_layout_size(point());
update_canvas();
set_is_dirty(true);
}
void tcontrol::set_label(const t_string& label)
{
if(label == label_) {
return;
}
label_ = label;
set_layout_size(tpoint(0, 0));
update_canvas();
set_is_dirty(true);
}
void tgrid::request_reduce_height(const unsigned maximum_height)
{
tpoint size = get_best_size();
if(size.y <= static_cast<int>(maximum_height)) {
/** @todo this point shouldn't be reached, find out why it does. */
return;
}
const unsigned too_high = size.y - maximum_height;
unsigned reduced = 0;
for(size_t row = 0; row < rows_; ++row) {
unsigned wanted_height = row_height_[row] - (too_high - reduced);
/**
* @todo Improve this code.
*
* Now we try every item to be reduced, maybe items need a flag whether
* or not to try to reduce and also evaluate whether the force
* reduction is still needed.
*/
if(too_high - reduced >= row_height_[row]) {
DBG_GUI_L << LOG_HEADER << " row " << row << " height "
<< row_height_[row] << " want to reduce " << too_high
<< " is too small to be reduced fully try 1 pixel.\n";
wanted_height = 1;
}
const unsigned height = tgrid_implementation::row_request_reduce_height(
*this, row, wanted_height);
if(height < row_height_[row]) {
DBG_GUI_L << LOG_HEADER << " row " << row << " height "
<< row_height_[row] << " want to reduce " << too_high
<< " reduced " << row_height_[row] - height
<< " pixels.\n";
size.y -= row_height_[row] - height;
row_height_[row] = height;
}
if(size.y <= static_cast<int>(maximum_height)) {
break;
}
}
size = calculate_best_size();
DBG_GUI_L << LOG_HEADER << " Requested maximum " << maximum_height
<< " resulting height " << size.y << ".\n";
set_layout_size(size);
}
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);
}
void styled_widget::request_reduce_height(const unsigned maximum_height)
{
if(!label_.empty()) {
// Do nothing
} else {
point size = get_best_size();
point min_size = get_config_minimum_size();
size.y = std::min(size.y, std::max<int>(maximum_height, min_size.y));
set_layout_size(size);
DBG_GUI_L << LOG_HEADER << " styled_widget " << id()
<< " maximum_height " << maximum_height << " result " << size
<< ".\n";
}
}
void grid::request_reduce_width(const unsigned maximum_width)
{
point size = get_best_size();
if(size.x <= static_cast<int>(maximum_width)) {
/** @todo this point shouldn't be reached, find out why it does. */
return;
}
const unsigned too_wide = size.x - maximum_width;
unsigned reduced = 0;
for(size_t col = 0; col < cols_; ++col) {
if(too_wide - reduced >= col_width_[col]) {
DBG_GUI_L << LOG_HEADER << " column " << col
<< " is too small to be reduced.\n";
continue;
}
const unsigned wanted_width = col_width_[col] - (too_wide - reduced);
const unsigned width
= grid_implementation::column_request_reduce_width(
*this, col, wanted_width);
if(width < col_width_[col]) {
unsigned reduction = col_width_[col] - width;
DBG_GUI_L << LOG_HEADER << " reduced " << reduction
<< " pixels for column " << col << ".\n";
size.x -= reduction;
reduced += reduction;
}
if(size.x <= static_cast<int>(maximum_width)) {
break;
}
}
set_layout_size(calculate_best_size());
}
void tscrollbar_container::request_reduce_width(
const unsigned maximum_width)
{
DBG_GUI_L << LOG_HEADER
<< " requested width " << maximum_width
<< ".\n";
// First ask our content, it might be able to wrap which looks better as
// a scrollbar.
assert(content_grid_);
const unsigned offset
= vertical_scrollbar_grid_
&& vertical_scrollbar_grid_->get_visible()
!= twidget::tvisible::invisible
? vertical_scrollbar_grid_->get_best_size().x
: 0;
content_grid_->request_reduce_width(maximum_width - offset);
// Did we manage to achieve the wanted size?
tpoint size = get_best_size();
if(static_cast<unsigned>(size.x) <= maximum_width) {
DBG_GUI_L << LOG_HEADER
<< " child honored request, width " << size.x
<< ".\n";
return;
}
if(horizontal_scrollbar_mode_ == always_invisible) {
DBG_GUI_L << LOG_HEADER << " request failed due to scrollbar mode.\n";
return;
}
// Always set the bar visible, is a nop when it's already visible.
assert(horizontal_scrollbar_grid_);
horizontal_scrollbar_grid_->set_visible(twidget::tvisible::visible);
size = get_best_size();
const tpoint scrollbar_size = horizontal_scrollbar_grid_->get_best_size();
// If showing the scrollbar increased the width, hide and abort.
if(horizontal_scrollbar_mode_ == auto_visible_first_run
&& scrollbar_size.x > size.x) {
horizontal_scrollbar_grid_->set_visible(twidget::tvisible::invisible);
DBG_GUI_L << LOG_HEADER
<< " request failed, showing the scrollbar"
<< " increased the width to " << scrollbar_size.x
<< ".\n";
return;
}
if(maximum_width > static_cast<unsigned>(scrollbar_size.x)) {
size.x = maximum_width;
} else {
size.x = scrollbar_size.x;
}
// FIXME adjust for the step size of the scrollbar
set_layout_size(size);
DBG_GUI_L << LOG_HEADER
<< " resize resulted in " << size.x
<< ".\n";
}
void tscrollbar_container::request_reduce_height(
const unsigned maximum_height)
{
DBG_GUI_L << LOG_HEADER
<< " requested height " << maximum_height
<< ".\n";
/*
* First ask the content to reduce it's height. This seems to work for now,
* but maybe some sizing hints will be required later.
*/
/** @todo Evaluate whether sizing hints are required. */
assert(content_grid_);
const unsigned offset
= horizontal_scrollbar_grid_
&& horizontal_scrollbar_grid_->get_visible()
!= twidget::tvisible::invisible
? horizontal_scrollbar_grid_->get_best_size().y
: 0;
content_grid_->request_reduce_height(maximum_height - offset);
// Did we manage to achieve the wanted size?
tpoint size = get_best_size();
if(static_cast<unsigned>(size.y) <= maximum_height) {
DBG_GUI_L << LOG_HEADER
<< " child honored request, height " << size.y
<< ".\n";
return;
}
if(vertical_scrollbar_mode_ == always_invisible) {
DBG_GUI_L << LOG_HEADER << " request failed due to scrollbar mode.\n";
return;
}
assert(vertical_scrollbar_grid_);
const bool resized =
vertical_scrollbar_grid_->get_visible() == twidget::tvisible::invisible;
// Always set the bar visible, is a nop is already visible.
vertical_scrollbar_grid_->set_visible(twidget::tvisible::visible);
const tpoint scrollbar_size = vertical_scrollbar_grid_->get_best_size();
// If showing the scrollbar increased the height, hide and abort.
if(resized && scrollbar_size.y > size.y) {
vertical_scrollbar_grid_->set_visible(twidget::tvisible::invisible);
DBG_GUI_L << LOG_HEADER
<< " request failed, showing the scrollbar"
<< " increased the height to " << scrollbar_size.y
<< ".\n";
return;
}
if(maximum_height > static_cast<unsigned>(scrollbar_size.y)) {
size.y = maximum_height;
} else {
size.y = scrollbar_size.y;
}
// FIXME adjust for the step size of the scrollbar
set_layout_size(size);
DBG_GUI_L << LOG_HEADER
<< " resize resulted in " << size.y
<< ".\n";
if(resized) {
DBG_GUI_L << LOG_HEADER
<< " resize modified the width, throw notification.\n";
throw tlayout_exception_width_modified();
}
}
tpoint tgrid::recalculate_best_size()
{
tpoint best_size = calculate_best_size();
set_layout_size(best_size);
return best_size;
}
