void FleetButton::RenderRollover() {
glDisable(GL_TEXTURE_2D);
glColor(GG::CLR_WHITE);
CircleArc(UpperLeft(), LowerRight(), 0.0, TWO_PI, true);
glEnable(GL_TEXTURE_2D);
RenderUnpressed();
}
void CUIWnd::SizeMove(const GG::Pt& ul, const GG::Pt& lr) {
Wnd::SizeMove(ul, lr);
GG::Pt button_ul = GG::Pt(Width() - BUTTON_RIGHT_OFFSET, BUTTON_TOP_OFFSET) + UpperLeft() - ClientUpperLeft();
if (m_close_button)
m_close_button->MoveTo(GG::Pt(button_ul.x, button_ul.y));
if (m_minimize_button)
m_minimize_button->MoveTo(GG::Pt(button_ul.x - (m_close_button ? BUTTON_RIGHT_OFFSET : GG::X0), button_ul.y));
}
void CUIWnd::LDrag(const GG::Pt& pt, const GG::Pt& move, GG::Flags<GG::ModKey> mod_keys) {
if (m_drag_offset != GG::Pt(-GG::X1, -GG::Y1)) { // resize-dragging
GG::Pt new_lr = pt - m_drag_offset;
// constrain to within parent
if (GG::Wnd* parent = Parent()) {
GG::Pt max_lr = parent->ClientLowerRight();
new_lr.x = std::min(new_lr.x, max_lr.x);
new_lr.y = std::min(new_lr.y, max_lr.y);
}
Resize(new_lr - UpperLeft());
} else { // normal-dragging
if (GG::Wnd* parent = Parent()) {
GG::Pt ul = UpperLeft();
GG::Pt new_ul = ul + move;
//GG::Pt new_lr = lr + move;
GG::Pt min_ul = parent->ClientUpperLeft() + GG::Pt(GG::X1, GG::Y1);
GG::Pt max_lr = parent->ClientLowerRight();
GG::Pt max_ul = max_lr - Size();
new_ul.x = std::max(min_ul.x, std::min(max_ul.x, new_ul.x));
new_ul.y = std::max(min_ul.y, std::min(max_ul.y, new_ul.y));
GG::Pt final_move = new_ul - ul;
GG::Wnd::LDrag(pt, final_move, mod_keys);
} else {
GG::Pt ul = UpperLeft();
GG::Pt requested_ul = ul + move;
GG::Pt min_ul = GG::Pt(GG::X1, GG::Y1);
GG::Pt max_ul = GG::Pt(GG::GUI::GetGUI()->AppWidth() - this->Width(),
GG::GUI::GetGUI()->AppHeight() - this->Height());
GG::X new_x = std::min(max_ul.x, std::max(min_ul.x, requested_ul.x));
GG::Y new_y = std::min(max_ul.y, std::max(min_ul.y, requested_ul.y));
GG::Pt new_ul(new_x, new_y);
GG::Pt final_move = new_ul - ul;
GG::Wnd::LDrag(pt, final_move, mod_keys);
}
}
}
void FleetButton::RenderPressed() {
const double TWO_PI = 2.0*3.14159;
glDisable(GL_TEXTURE_2D);
glColor(Color());
CircleArc(UpperLeft(), LowerRight(), 0.0, TWO_PI, true);
glEnable(GL_TEXTURE_2D);
RenderUnpressed();
}
void SystemResourceSummaryBrowseWnd::Render() {
GG::Pt ul = UpperLeft();
GG::Pt lr = LowerRight();
GG::FlatRectangle(ul, lr, OpaqueColor(ClientUI::WndColor()), ClientUI::WndOuterBorderColor(), 1); // main background
GG::FlatRectangle(GG::Pt(ul.x, ul.y + production_label_top), GG::Pt(lr.x, ul.y + production_label_top + row_height),
ClientUI::WndOuterBorderColor(), ClientUI::WndOuterBorderColor(), 0); // production label background
GG::FlatRectangle(GG::Pt(ul.x, ul.y + allocation_label_top), GG::Pt(lr.x, ul.y + allocation_label_top + row_height),
ClientUI::WndOuterBorderColor(), ClientUI::WndOuterBorderColor(), 0); // allocation label background
GG::FlatRectangle(GG::Pt(ul.x, ul.y + import_export_label_top), GG::Pt(lr.x, ul.y + import_export_label_top + row_height),
ClientUI::WndOuterBorderColor(), ClientUI::WndOuterBorderColor(), 0); // import or export label background
}
void ImageBlock::Render()
{
if (m_graphic == 0) {
// Error: no image. Draw red x.
Pt ul = UpperLeft();
Pt lr = LowerRight();
Pt size = lr - ul;
ul.x += size.x / 2 - X(Value(size.y)) / 2;
lr.x -= size.x / 2 - X(Value(size.y)) / 2;
FlatX(ul, lr, CLR_RED);
}
}
void CUIWnd::Render() {
GG::Pt ul = UpperLeft();
GG::Pt lr = LowerRight();
GG::Pt cl_ul = ClientUpperLeft();
GG::Pt cl_lr = ClientLowerRight();
if (!m_minimized) {
AngledCornerRectangle(ul, lr, ClientUI::WndColor(), ClientUI::WndOuterBorderColor(),
OUTER_EDGE_ANGLE_OFFSET, 1, false, !m_resizable); // show notched bottom-right corner if not resizable, pointed corner if resizable
// use GL to draw the lines
glDisable(GL_TEXTURE_2D);
// draw inner border, including extra resize-tab lines
glBegin(GL_LINE_STRIP);
glColor(ClientUI::WndInnerBorderColor());
glVertex(cl_ul.x, cl_ul.y);
glVertex(cl_lr.x, cl_ul.y);
if (m_resizable) {
glVertex(cl_lr.x, cl_lr.y - INNER_BORDER_ANGLE_OFFSET);
glVertex(cl_lr.x - INNER_BORDER_ANGLE_OFFSET, cl_lr.y);
} else {
glVertex(cl_lr.x, cl_lr.y);
}
glVertex(cl_ul.x, cl_lr.y);
glVertex(cl_ul.x, cl_ul.y);
glEnd();
if (m_resizable) {
glBegin(GL_LINES);
// draw the extra lines of the resize tab
GG::Clr tab_lines_colour = m_mouse_in_resize_tab ? ClientUI::WndInnerBorderColor() : ClientUI::WndOuterBorderColor();
glColor(tab_lines_colour);
glVertex(cl_lr.x, cl_lr.y - RESIZE_HASHMARK1_OFFSET);
glVertex(cl_lr.x - RESIZE_HASHMARK1_OFFSET, cl_lr.y);
glVertex(cl_lr.x, cl_lr.y - RESIZE_HASHMARK2_OFFSET);
glVertex(cl_lr.x - RESIZE_HASHMARK2_OFFSET, cl_lr.y);
glEnd();
}
glEnable(GL_TEXTURE_2D);
} else {
GG::FlatRectangle(ul, lr, ClientUI::WndColor(), ClientUI::WndOuterBorderColor(), 1);
}
GG::BeginScissorClipping(ul, lr);
glColor(ClientUI::TextColor());
boost::shared_ptr<GG::Font> font = ClientUI::GetTitleFont();
font->RenderText(GG::Pt(ul.x + BORDER_LEFT, ul.y + TITLE_OFFSET), Name());
GG::EndScissorClipping();
}
bool FleetButton::InWindow(const GG::Pt& pt) const {
// find if cursor is within required distance of centre of icon
GG::Pt ul = UpperLeft(), lr = LowerRight();
const float midX = Value(ul.x + lr.x)/2.0f;
const float midY = Value(ul.y + lr.y)/2.0f;
const float RADIUS2 = Value(Width())*Value(Width())/4.0f;
const float ptX = Value(pt.x);
const float ptY = Value(pt.y);
const float distx = ptX - midX, disty = ptY - midY;
return distx*distx + disty*disty <= RADIUS2;
}
bool FleetButton::InWindow(const GG::Pt& pt) const {
// find if cursor is within required distance of centre of icon
const int RADIUS = Value(Width()) / 2;
const int RADIUS2 = RADIUS*RADIUS;
GG::Pt ul = UpperLeft(), lr = LowerRight();
GG::Pt size = lr - ul;
GG::Pt half_size = GG::Pt(size.x / 2, size.y / 2);
GG::Pt middle = ul + half_size;
GG::Pt delta = pt - middle;
const int distx = Value(delta.x);
const int disty = Value(delta.y);
return distx*distx + disty*disty <= RADIUS2;
}
void CUIWnd::InitButtons() {
// create the close button
GG::Pt button_ul = GG::Pt(Width() - BUTTON_RIGHT_OFFSET, BUTTON_TOP_OFFSET) + UpperLeft() - ClientUpperLeft();
if (m_closable) {
m_close_button = new CUI_CloseButton(button_ul.x, button_ul.y);
GG::Connect(m_close_button->LeftClickedSignal, &CUIWnd::CloseClicked, this);
AttachChild(m_close_button);
m_close_button->NonClientChild(true);
}
// create the minimize button
if (m_minimizable) {
m_minimize_button = new CUI_MinRestoreButton(button_ul.x - (m_close_button ? BUTTON_RIGHT_OFFSET : GG::X0), button_ul.y);
GG::Connect(m_minimize_button->LeftClickedSignal, &CUIWnd::MinimizeClicked, this);
AttachChild(m_minimize_button);
m_minimize_button->NonClientChild(true);
}
}
bool FieldIcon::InWindow(const GG::Pt& pt) const {
// find if cursor is within required distance of centre of icon
const int RADIUS = Value(Width())/2;
const int RADIUS2 = RADIUS*RADIUS;
GG::Pt ul = UpperLeft(), lr = LowerRight();
GG::Pt size = lr - ul;
GG::Pt half_size = GG::Pt(size.x / 2, size.y / 2);
GG::Pt middle = ul + half_size;
GG::Pt delta = pt - middle;
const int distx = Value(delta.x);
const int disty = Value(delta.y);
//std::cout << "Radius: " << RADIUS << " dist: " << std::sqrt<double>(distx*distx + disty*disty) << std::endl;
return distx*distx + disty*disty <= RADIUS2;
}
void CreditsWnd::Render() {
if (!m_bRender)
return;
GG::Pt ul = UpperLeft(), lr = LowerRight();
if (m_displayListID == 0) {
// compile credits
m_displayListID = glGenLists(1);
glNewList(m_displayListID, GL_COMPILE);
DrawCredits(ul.x+m_cx, ul.y+m_cy, ul.x+m_cx+m_cw, ul.y+m_cy+m_ch, 255);
glEndList();
}
//time passed
int passedTicks = GG::GUI::GetGUI()->Ticks() - m_start_time;
//draw background
GG::FlatRectangle(ul, lr, GG::FloatClr(0.0, 0.0, 0.0, 0.5), GG::CLR_ZERO,0);
glPushAttrib(GL_ALL_ATTRIB_BITS );
glPushMatrix();
// define clip area
glEnable(GL_SCISSOR_TEST);
glScissor(Value(ul.x+m_cx), Value(GG::GUI::GetGUI()->AppHeight()- lr.y), m_cw, m_ch);
// move credits
glTranslatef(0, m_co + passedTicks / -40.0f, 0);
if (m_displayListID != 0) {
// draw credits using prepared display list
// !!! in order for the display list to be valid, the font object (m_font) may not be destroyed !!!
glCallList(m_displayListID);
} else {
// draw credits directly
DrawCredits(ul.x+m_cx, ul.y+m_cy, ul.x+m_cx+m_cw, ul.y+m_cy+m_ch, 255);
}
glPopMatrix();
glPopAttrib();
//check if we are done
if (m_creditsHeight + m_ch < m_co + passedTicks / 40.0)
StopRendering();
}
void CharacterWindow::Draw() const
{
COORD ulTitleBox = UpperLeft(),
brTitleBox = {LowerRight().X,UpperLeft().Y+3},
ulClientBox = {UpperLeft().X,UpperLeft().Y+2},
brClientBox = LowerRight();
COORD titlePosition = {UpperLeft().X+1,UpperLeft().Y+1};
CharacterBox titleBox(ulTitleBox,brTitleBox,BorderColor(),ClientColor(),Fill())
,clientBox(ulClientBox,brClientBox,BorderColor(),ClientColor(),Fill());
titleBox.Draw();
clientBox.Draw();
if(m_title.size())
ConsoleCore::GetInstance()->Prints(m_title,FALSE,&ClientColor(),titlePosition.X,titlePosition.Y);
}
void CUI_MinRestoreButton::Render() {
GG::Pt ul = UpperLeft();
GG::Pt lr = LowerRight();
GG::Clr color_to_use = ClientUI::WndInnerBorderColor();
if (State() != BN_ROLLOVER)
AdjustBrightness(color_to_use, BUTTON_DIMMING_SCALE_FACTOR);
if (m_mode == MIN_BUTTON) {
// draw a dash to signify the minimize command
GG::Y middle_y = (lr.y + ul.y) / 2;
glDisable(GL_TEXTURE_2D);
glColor(color_to_use);
glBegin(GL_LINES);
glVertex(ul.x, middle_y);
glVertex(lr.x, middle_y);
glEnd();
glEnable(GL_TEXTURE_2D);
} else {
// draw a square to signify the restore command
GG::FlatRectangle(ul, lr, GG::CLR_ZERO, ClientUI::WndInnerBorderColor(), 1);
}
}
void ResourceBrowseWnd::Render() {
GG::Pt ul = UpperLeft();
glPushMatrix();
glLoadIdentity();
glTranslatef(static_cast<GLfloat>(Value(m_offset.x + ul.x)), static_cast<GLfloat>(Value(m_offset.y + ul.y)), 0.0f);
glDisable(GL_TEXTURE_2D);
glLineWidth(1.0);
glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS);
glEnableClientState(GL_VERTEX_ARRAY);
m_buffer.activate();
glColor(ClientUI::WndColor());
glDrawArrays(GL_TRIANGLE_FAN, 2, 4);
glColor(ClientUI::WndOuterBorderColor());
glDrawArrays(GL_LINE_LOOP, 2, 4);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glEnable(GL_TEXTURE_2D);
glPopMatrix();
glPopClientAttrib();
}
void BuildingIndicator::Render() {
// copied from CUIWnd
GG::Pt ul = UpperLeft();
GG::Pt lr = LowerRight();
// Draw outline and background...
GG::FlatRectangle(ul, lr, ClientUI::WndColor(), ClientUI::WndOuterBorderColor(), 1);
// Scanlines for not currently-visible objects?
int empire_id = HumanClientApp::GetApp()->EmpireID();
if (!s_scanline_shader || empire_id == ALL_EMPIRES || !GetOptionsDB().Get<bool>("UI.system-fog-of-war"))
return;
if (m_building_id == INVALID_OBJECT_ID)
return;
if (GetUniverse().GetObjectVisibilityByEmpire(m_building_id, empire_id) >= VIS_BASIC_VISIBILITY)
return;
float fog_scanline_spacing = static_cast<float>(GetOptionsDB().Get<double>("UI.system-fog-of-war-spacing"));
s_scanline_shader->Use();
s_scanline_shader->Bind("scanline_spacing", fog_scanline_spacing);
GLfloat verts[8];
verts[0] = Value(ul.x); verts[1] = Value(ul.y);
verts[2] = Value(lr.x); verts[3] = Value(ul.y);
verts[4] = Value(lr.x); verts[5] = Value(lr.y);
verts[6] = Value(ul.x); verts[7] = Value(lr.y);
glDisable(GL_TEXTURE_2D);
glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(2, GL_FLOAT, 0, verts);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glPopClientAttrib();
glEnable(GL_TEXTURE_2D);
s_scanline_shader->stopUse();
}
void AccordionPanel::Render() {
if (Height() < 1 || Width() < 1)
return;
GG::Pt ul = UpperLeft();
glPushMatrix();
glLoadIdentity();
glTranslatef(static_cast<GLfloat>(Value(ul.x)), static_cast<GLfloat>(Value(ul.y)), 0.0f);
glDisable(GL_TEXTURE_2D);
glLineWidth(1.0f);
glEnableClientState(GL_VERTEX_ARRAY);
m_border_buffer.activate();
glColor(m_interior_color);
glDrawArrays(GL_TRIANGLE_FAN, 0, m_border_buffer.size() - 1);
glColor(ClientUI::WndOuterBorderColor());
glDrawArrays(GL_LINE_STRIP, 0, m_border_buffer.size());
glEnable(GL_TEXTURE_2D);
glPopMatrix();
glDisableClientState(GL_VERTEX_ARRAY);
}
void GraphicalSummaryWnd::Render() {
GG::FlatRectangle(UpperLeft() + GG::Pt(GG::X1, GG::Y0), LowerRight(), ClientUI::CtrlColor(),
ClientUI::CtrlBorderColor(), 1);
}
GG::Pt CUIWnd::ClientUpperLeft() const
{ return m_minimized ? UpperLeft() : UpperLeft() + GG::Pt(BORDER_LEFT, BORDER_TOP); }
GG::Pt AccordionPanel::ClientUpperLeft() const
{ return UpperLeft() + GG::Pt((m_is_left ? GG::X(EXPAND_BUTTON_SIZE + m_border_margin) : GG::X0), GG::Y0); }
void Dialog::Render() {
GG::Wnd::Render();
GG::FlatRectangle ( UpperLeft(), LowerRight(),
GG::CLR_GRAY, GG::CLR_SHADOW, 1u );
}
void GraphicalSummaryWnd::Render()
{
GG::Pt one(GG::X(2), GG::Y1);
AngledCornerRectangle(UpperLeft(), LowerRight() - one, ClientUI::CtrlColor(), GG::CLR_ZERO,
8, 1, false, true);
}
void MultiMeterStatusBar::Render() {
GG::Clr DARY_GREY = GG::Clr(44, 44, 44, 255);
GG::Clr HALF_GREY = GG::Clr(128, 128, 128, 128);
GG::Pt ul = UpperLeft();
GG::Pt lr = LowerRight();
// outline of whole control
GG::FlatRectangle(ul, lr, ClientUI::WndColor(), ClientUI::WndOuterBorderColor(), 1);
const GG::X BAR_LEFT = ClientUpperLeft().x + EDGE_PAD - 1;
const GG::X BAR_RIGHT = ClientLowerRight().x - EDGE_PAD + 1;
const GG::X BAR_MAX_LENGTH = BAR_RIGHT - BAR_LEFT;
const GG::Y TOP = ClientUpperLeft().y + EDGE_PAD - 1;
GG::Y y = TOP;
for (unsigned int i = 0; i < m_initial_values.size(); ++i) {
// bar grey backgrounds
GG::FlatRectangle(GG::Pt(BAR_LEFT, y), GG::Pt(BAR_RIGHT, y + BAR_HEIGHT), DARY_GREY, DARY_GREY, 0);
y += BAR_HEIGHT + BAR_PAD;
}
// Find the largest value to be displayed to determine the scale factor
double largest_value = 0;
for (unsigned int i = 0; i < m_initial_values.size(); ++i) {
if ((m_initial_values[i] != Meter::INVALID_VALUE) && (m_initial_values[i] > largest_value))
largest_value = m_initial_values[i];
if ((m_projected_values[i] != Meter::INVALID_VALUE) && (m_projected_values[i] > largest_value))
largest_value = m_projected_values[i];
if ((m_target_max_values[i] != Meter::INVALID_VALUE) && (m_target_max_values[i] > largest_value))
largest_value = m_target_max_values[i];
}
double num_full_increments =
std::ceil(largest_value / MULTI_METER_STATUS_BAR_DISPLAYED_METER_RANGE_INCREMENT);
double MULTI_METER_STATUS_BAR_DISPLAYED_METER_RANGE =
num_full_increments * MULTI_METER_STATUS_BAR_DISPLAYED_METER_RANGE_INCREMENT;
// lines for 20, 40, 60, 80 etc.
int num_segments = num_full_increments * 5;
GG::GL2DVertexBuffer bar_verts;
bar_verts.reserve(num_segments - 1);
for (int ii_div_line = 1; ii_div_line <= (num_segments -1); ++ii_div_line) {
bar_verts.store(BAR_LEFT + ii_div_line*BAR_MAX_LENGTH/num_segments, TOP);
bar_verts.store(BAR_LEFT + ii_div_line*BAR_MAX_LENGTH/num_segments, y - BAR_PAD);
}
bar_verts.activate();
glColor(HALF_GREY);
glDisable(GL_TEXTURE_2D);
glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS);
glEnableClientState(GL_VERTEX_ARRAY);
glDrawArrays(GL_LINES, 0, bar_verts.size());
glPopClientAttrib();
glEnable(GL_TEXTURE_2D);
// current, initial, and target/max horizontal bars for each pair of MeterType
y = TOP;
for (unsigned int i = 0; i < m_initial_values.size(); ++i) {
GG::Clr clr;
const GG::Y BAR_TOP = y;
const GG::Y BAR_BOTTOM = BAR_TOP + BAR_HEIGHT;
const bool SHOW_INITIAL = (m_initial_values[i] != Meter::INVALID_VALUE);
const bool SHOW_PROJECTED = (m_projected_values[i] != Meter::INVALID_VALUE);
const bool SHOW_TARGET_MAX = (m_target_max_values[i] != Meter::INVALID_VALUE);
const GG::X INITIAL_RIGHT(BAR_LEFT + BAR_MAX_LENGTH * m_initial_values[i] / MULTI_METER_STATUS_BAR_DISPLAYED_METER_RANGE);
const GG::Y INITIAL_TOP(BAR_TOP);
if (SHOW_INITIAL) {
// initial value
const GG::X INITIAL_RIGHT(BAR_LEFT + BAR_MAX_LENGTH * m_initial_values[i] / MULTI_METER_STATUS_BAR_DISPLAYED_METER_RANGE);
const GG::Y INITIAL_TOP(BAR_TOP);
glColor(m_bar_colours[i]);
m_bar_shading_texture->OrthoBlit(GG::Pt(BAR_LEFT, INITIAL_TOP), GG::Pt(INITIAL_RIGHT, BAR_BOTTOM));
// black border
GG::FlatRectangle(GG::Pt(BAR_LEFT, INITIAL_TOP), GG::Pt(INITIAL_RIGHT, BAR_BOTTOM), GG::CLR_ZERO, GG::CLR_BLACK, 1);
}
const GG::X PROJECTED_RIGHT(BAR_LEFT + BAR_MAX_LENGTH * m_projected_values[i] / MULTI_METER_STATUS_BAR_DISPLAYED_METER_RANGE);
const GG::Y PROJECTED_TOP(INITIAL_TOP);
if (SHOW_PROJECTED) {
// projected colour bar with black border
if (PROJECTED_RIGHT > INITIAL_RIGHT) {
GG::FlatRectangle(GG::Pt(INITIAL_RIGHT - 1, PROJECTED_TOP), GG::Pt(PROJECTED_RIGHT, BAR_BOTTOM), ClientUI::StatIncrColor(), GG::CLR_BLACK, 1);
} else if (PROJECTED_RIGHT < INITIAL_RIGHT) {
GG::FlatRectangle(GG::Pt(PROJECTED_RIGHT - 1, PROJECTED_TOP), GG::Pt(INITIAL_RIGHT, BAR_BOTTOM), ClientUI::StatDecrColor(), GG::CLR_BLACK, 1);
}
}
const GG::X TARGET_MAX_RIGHT(BAR_LEFT + BAR_MAX_LENGTH * m_target_max_values[i] / MULTI_METER_STATUS_BAR_DISPLAYED_METER_RANGE);
if (SHOW_TARGET_MAX && TARGET_MAX_RIGHT > BAR_LEFT) {
// max / target value
//glColor(DarkColor(m_bar_colours[i]));
//m_bar_shading_texture->OrthoBlit(GG::Pt(BAR_LEFT, BAR_TOP), GG::Pt(TARGET_MAX_RIGHT, BAR_BOTTOM));
// black border
GG::FlatRectangle(GG::Pt(BAR_LEFT, BAR_TOP), GG::Pt(TARGET_MAX_RIGHT, BAR_BOTTOM), GG::CLR_ZERO, m_bar_colours[i], 1);
}
// move down position of next bar, if any
y += BAR_HEIGHT + BAR_PAD;
}
}
void CUIWnd::MinimizeClicked() {
if (!m_minimized) {
m_minimized = true;
m_original_size = Size();
SetMinSize(GG::Pt(MinimizedWidth(), BORDER_TOP));
Resize(GG::Pt(MINIMIZED_WND_WIDTH, BORDER_TOP));
GG::Pt button_ul = GG::Pt(Width() - BUTTON_RIGHT_OFFSET, BUTTON_TOP_OFFSET);
if (m_close_button)
m_close_button->MoveTo(GG::Pt(button_ul.x, button_ul.y));
if (m_minimize_button)
m_minimize_button->MoveTo(GG::Pt(button_ul.x - (m_close_button ? BUTTON_RIGHT_OFFSET : GG::X0), button_ul.y));
Hide();
Show(false);
if (m_close_button)
m_close_button->Show();
if (m_minimize_button)
m_minimize_button->Show();
} else {
m_minimized = false;
SetMinSize(GG::Pt(MinimizedWidth(), BORDER_TOP + INNER_BORDER_ANGLE_OFFSET + BORDER_BOTTOM + 10));
Resize(GG::Pt(m_original_size));
GG::Pt button_ul = GG::Pt(Width() - BUTTON_RIGHT_OFFSET, BUTTON_TOP_OFFSET) + UpperLeft() - ClientUpperLeft();
if (m_close_button)
m_close_button->MoveTo(GG::Pt(button_ul.x, button_ul.y));
if (m_minimize_button)
m_minimize_button->MoveTo(GG::Pt(button_ul.x - (m_close_button ? BUTTON_RIGHT_OFFSET : GG::X0), button_ul.y));
Show();
}
}
/** Excludes border from the client area. */
virtual GG::Pt ClientUpperLeft() const {
return UpperLeft() + GG::Pt ( GG::X ( SAVE_FILE_CELL_MARGIN ), GG::Y ( SAVE_FILE_CELL_MARGIN ) );
}
GG::Pt CombatLogWnd::ClientUpperLeft() const
{ return UpperLeft() + GG::Pt(GG::X(MARGIN), GG::Y(MARGIN)); }
