//=================================================================================
void SliderControlBase::CalcContinuumGeometry( ContinuumGeometry& continuumGeometry, const wxSize& size )
{
    continuumGeometry.radius = size.GetHeight() / 2;
    continuumGeometry.leftMostPos.x = continuumGeometry.radius;
    continuumGeometry.leftMostPos.y = size.GetHeight() / 2;
    continuumGeometry.rightMostPos.x = size.GetWidth() - continuumGeometry.radius;
    continuumGeometry.rightMostPos.y = size.GetHeight() / 2;
}

// This function converts to the right size with the given background colour
wxBitmap PrepareIcon(wxIcon icon, wxSize size)
{
	if (icon.GetWidth() == size.GetWidth() && icon.GetHeight() == size.GetHeight())
		return icon;
	wxBitmap bmp;
	bmp.CopyFromIcon(icon);
	return bmp.ConvertToImage().Rescale(size.GetWidth(), size.GetHeight());
}

wxString Variant::MakeString (const wxSize & size)
{
    wxString tmp;
    tmp << "{" << size.GetWidth()
        << ", " << size.GetHeight() << "}"
        ;
    return tmp;
}

bool wxVideoXANIM::SetSize(wxSize size)
{
    if (!m_video_output)
        return false;

    m_video_output->SetSize(size.GetWidth(), size.GetHeight());
    return false;
}

void
TstLayer_t::setSize(const wxSize &sz)
{
    if (sz == mDC->GetSize()) return;
    mSurface->SetWidth(sz.GetWidth());
    mSurface->SetHeight(sz.GetHeight());
    _updateDC();
}

void wxPolarAreaChart::SliceArc::Resize(const wxSize &size)
{
    wxDouble x = (size.GetX() / 2);
    wxDouble y = (size.GetY() / 2);
    wxDouble radius = ((x < y) ? x : y);

    SetCenter(x, y);
}

void wxJigsawInputParameter::Draw(wxDC & dc, const wxPoint & pos, const wxSize & offset, double scale, wxColour color)
{
	wxPoint realPosition(
		pos.x + offset.GetWidth(), 
		pos.y /*+ offset.GetHeight()*/);
	/*wxLogTrace(wxTraceMask(), _("ParameterPos = %i,%i; Offset=%i, %i"),
		realPosition.x, realPosition.y, offset.x, offset.y);*/
	wxSize labelSize;
	wxSize size = GetSize(dc, scale);
	dc.GetTextExtent(m_Label, &labelSize.x, &labelSize.y, 0, 0, (wxFont *)&dc.GetFont());

	//Draw the text with bevel
	wxRect rectText(realPosition, size);
	rectText.x++;
	rectText.y++;
	dc.SetTextForeground(*wxBLACK);
	dc.DrawLabel(m_Label, rectText, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL);

	rectText.x--;
	rectText.y--;
	dc.SetTextForeground(*wxWHITE);
	dc.DrawLabel(m_Label, rectText, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL);

	
	wxPoint shapePos;
	wxSize shapeSize;
	if(m_Shape)
	{
		shapeSize = m_Shape->GetSize(dc, scale);
		shapePos = wxPoint(
			pos.x + labelSize.x + wxJigsawInputParameter::ParameterSpacing*scale, 
			pos.y + (size.GetHeight()-shapeSize.GetHeight())/2);
		m_Shape->SetPosition(shapePos.x, 
			shapePos.y + (size.GetHeight()-shapeSize.GetHeight())*scale/2 - offset.GetHeight());
		m_Shape->Draw(dc, offset, scale);
	}
	else
	{
		dc.SetPen(*wxBLACK_PEN);

		wxBrush paramBrush(wxColour(color.Red()*.9,color.Green()*.9,color.Blue()*.9)); 
		dc.SetBrush(paramBrush);
		//dc.SetBrush(*wxWHITE_BRUSH);

		shapeSize = wxJigsawInputParameter::GetDefaultParameterSize();
		shapeSize.x *= scale;
		shapeSize.y *= scale;
		shapePos = wxPoint(
			realPosition.x + labelSize.x + wxJigsawInputParameter::ParameterSpacing*scale, 
			realPosition.y + (size.GetHeight()-shapeSize.GetHeight())/2);
		wxJigsawShape::DrawShapeHeader(dc, shapePos, 
			shapeSize, GetStyle());
	}
	//dc.SetBrush(*wxTRANSPARENT_BRUSH);
	//dc.SetPen(*wxBLACK_PEN);
	//dc.DrawRectangle(realPosition, size);
}

wxSize wxRibbonGallery::DoGetNextLargerSize(wxOrientation direction,
                                       wxSize relative_to) const
{
    if(m_art == NULL)
        return relative_to;

    wxMemoryDC dc;

    wxSize client = m_art->GetGalleryClientSize(dc, this, relative_to, NULL,
        NULL, NULL, NULL);

    // No need to grow if the given size can already display every item
    int nitems = (client.GetWidth() / m_bitmap_padded_size.x) *
        (client.GetHeight() / m_bitmap_padded_size.y);
    if(nitems >= (int)m_items.GetCount())
        return relative_to;

    switch(direction)
    {
    case wxHORIZONTAL:
        client.IncBy(m_bitmap_padded_size.x, 0);
        break;
    case wxVERTICAL:
        client.IncBy(0, m_bitmap_padded_size.y);
        break;
    case wxBOTH:
        client.IncBy(m_bitmap_padded_size);
        break;
    }

    client.x = (client.x / m_bitmap_padded_size.x) * m_bitmap_padded_size.x;
    client.y = (client.y / m_bitmap_padded_size.y) * m_bitmap_padded_size.y;

    wxSize size = m_art->GetGallerySize(dc, this, client);
    wxSize minimum = GetMinSize();

    if(size.GetWidth() < minimum.GetWidth() ||
        size.GetHeight() < minimum.GetHeight())
    {
        return relative_to;
    }

    switch(direction)
    {
    case wxHORIZONTAL:
        size.SetHeight(relative_to.GetHeight());
        break;
    case wxVERTICAL:
        size.SetWidth(relative_to.GetWidth());
        break;
    default:
        break;
    }

    return size;
}

bool wxRibbonPanel::IsMinimised(wxSize at_size) const
{
    if(!m_minimised_size.IsFullySpecified())
        return false;

    return (at_size.GetX() <= m_minimised_size.GetX() &&
        at_size.GetY() <= m_minimised_size.GetY()) || 
        at_size.GetX() < m_smallest_unminimised_size.GetX() ||
        at_size.GetY() < m_smallest_unminimised_size.GetY();
}

bool check_negative_size(VALUE val, wxSize &size)
{
	size = unwrap<wxSize>(val);
	if(size.GetHeight() <= 0 || size.GetWidth() <= 0)
	{
		rb_raise(rb_eArgError,"%" PRIsVALUE " does have invalid size.", RB_OBJ_STRING(rb_inspect(val)));
		return false;
	}
	return true;
}

 void RenderCanvas::OnPaint( wxPaintEvent& event )
 {
     // This is required even though dc is not used otherwise.
     // PrepareDC(dc);
     wxPaintDC dc(this);
     const wxSize size = GetClientSize();
     if ( m_RenderManager ) m_RenderManager->ResizeViewport( size.GetWidth(), size.GetHeight() );
     RenderFrame();
     event.Skip();
 }

bool wxcWrite(const wxString& path, const wxSize& val) {
    wxConfigBase* conf = wxConfigBase::Get(false);
    if (!conf)
        return false;
    if (!conf->Write(path + wxT("_w"), val.GetWidth()))
        return false;
    if (!conf->Write(path + wxT("_h"), val.GetHeight()))
        return false;
    return true;
}

wxMoColourPanel::wxMoColourPanel( wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style, const wxString& name  ) :
wxPanel( parent, id,  pos, size, style | wxNO_BORDER | wxFULL_REPAINT_ON_RESIZE, name ), wxMoColour( (wxColour::ChannelType) 0, (wxColour::ChannelType)0, (wxColour::ChannelType)0, (wxColour::ChannelType)255 ) {

  SetBackgroundStyle(wxBG_STYLE_CUSTOM );

  if (!m_Pattern.Create( size.GetWidth(), size.GetHeight(), 24 )) {
        wxMessageBox(wxString("wxMoColourPanel error creating pattern bitmap."));
  }

}

    void SetPixelSize(const wxSize& pixelSize)
    {
        wxCHECK_RET( pixelSize.GetWidth() >= 0, "negative font width" );
        wxCHECK_RET( pixelSize.GetHeight() != 0, "zero font height" );

        Free();

        m_nativeFontInfo.SetPixelSize(pixelSize);
        m_sizeUsingPixels = true;
    }

bool TryParse( wxSize& dest, wxStringTokenizer& parts )
{
	long result[2];

	if( !parts.HasMoreTokens() || !parts.GetNextToken().ToLong( &result[0] ) ) return false;
	if( !parts.HasMoreTokens() || !parts.GetNextToken().ToLong( &result[1] ) ) return false;
	dest.SetWidth( result[0] );
	dest.SetHeight( result[1] );

	return true;
}

void ClientSizeTestCase::ClientSizeNotNegative()
{
    wxWindow* w = new wxWindow(wxTheApp->GetTopWindow(), -1,
                               wxDefaultPosition, wxDefaultSize,
                               wxBORDER_THEME);
    w->SetSize(wxSize(1,1));
    const wxSize szw = w->GetClientSize();
    CPPUNIT_ASSERT(szw.GetWidth() >= 0);
    CPPUNIT_ASSERT(szw.GetHeight() >= 0);
    w->Destroy();
}

void wxDoughnutAndPieChartBase::SliceArc::Resize(const wxSize &size,
                                                 const wxDoughnutAndPieChartOptionsBase& options)
{
    wxDouble x = (size.GetX() / 2) - 2;
    wxDouble y = (size.GetY() / 2) - 2;
    wxDouble outerRadius = ((x < y) ? x : y) - (GetOptions().GetOutlineWidth() / 2);
    wxDouble innerRadius = outerRadius * ((wxDouble)options.GetPercentageInnerCutout()) / 100;

    SetCenter(x, y);
    SetRadiuses(outerRadius, innerRadius);
}

static void AdjustFontSize(wxFont& font, wxDC& dc, const wxSize& pixelSize)
{
    int currentSize = 0;
    int largestGood = 0;
    int smallestBad = 0;

    bool initialGoodFound = false;
    bool initialBadFound = false;

    // NB: this assignment was separated from the variable definition
    // in order to fix a gcc v3.3.3 compiler crash
    currentSize = font.GetPointSize();
    while (currentSize > 0)
    {
        dc.SetFont(font);

        // if currentSize (in points) results in a font that is smaller
        // than required by pixelSize it is considered a good size
        if (dc.GetCharHeight() <= pixelSize.GetHeight() &&
                (!pixelSize.GetWidth() ||
                 dc.GetCharWidth() <= pixelSize.GetWidth()))
        {
            largestGood = currentSize;
            initialGoodFound = true;
        }
        else
        {
            smallestBad = currentSize;
            initialBadFound = true;
        }
        if (!initialGoodFound)
        {
            currentSize /= 2;
        }
        else if (!initialBadFound)
        {
            currentSize *= 2;
        }
        else
        {
            int distance = smallestBad - largestGood;
            if (distance == 1)
                break;

            currentSize = largestGood + distance / 2;
        }

        font.SetPointSize(currentSize);
    }

    if (currentSize != largestGood)
        font.SetPointSize(largestGood);
}

wxSize wxcRead(const wxString& path, const wxSize& def) {
    wxConfigBase* conf = wxConfigBase::Get(false);
    if (!conf)
        return def;
    wxSize val = def;
    int i;
    if (conf->Read(path + wxT("_w"), &i, def.GetWidth()))
        val.SetWidth(i);
    if (conf->Read(path + wxT("_h"), &i, def.GetHeight()))
        val.SetHeight(i);
    return val;
}

void wxPolarAreaChart::Add(const wxChartSliceData &slice, 
                           size_t index,
                           const wxSize &size)
{
    wxDouble x = (size.GetX() / 2);
    wxDouble y = (size.GetY() / 2);
    wxDouble radius = ((x < y) ? x : y);

    SliceArc::ptr newSlice = SliceArc::ptr(new SliceArc(slice,
        x, y, 0, 0, radius));
    m_slices.insert(m_slices.begin() + index, newSlice);
}