void clAuiGlossyTabArt::DoDrawInactiveTabSeparator(wxGCDC& gdc, const wxRect& tabRect)
{
    wxRect rr = tabRect;
    rr.SetWidth(1);
    rr.SetHeight(tabRect.GetHeight()+2);
    rr.x = tabRect.GetTopRight().x - 1;
    rr.y = tabRect.GetTopRight().y - 2;
    
    wxColour sideColour;
    if ( DrawingUtils::IsThemeDark() ) {
        sideColour = m_bgColour.ChangeLightness(110);
    } else {
        sideColour = *wxWHITE;
    }
    // Draw 2 lines on the sides of the "main" line
    wxRect rectLeft, rectRight, rectCenter;
    wxPoint topPt = rr.GetTopLeft();
    topPt.x -= 1;
    rectLeft = wxRect(topPt, wxSize(1, rr.GetHeight()) );
    gdc.GradientFillLinear(rectLeft, sideColour, m_bgColour, wxNORTH);
    
    topPt.x += 1;
    rectCenter = wxRect(topPt, wxSize(1, rr.GetHeight()) );
    gdc.GradientFillLinear(rectCenter, m_penColour.ChangeLightness(80), m_bgColour, wxNORTH);
    
    topPt.x += 1;
    rectRight = wxRect(topPt, wxSize(1, rr.GetHeight()) );
    gdc.GradientFillLinear(rectRight, sideColour, m_bgColour, wxNORTH);
}

 void BenchmarkDCAndGC(const char* dckind, wxDC& dc, wxGCDC& gcdc)
 {
     if ( opts.useDC )
     {
         BenchmarkAll(wxString::Format("%6s DC", dckind), dc);
     }
     else if ( opts.useGC && gcdc.IsOk() )
     {
         wxString rendName = gcdc.GetGraphicsContext()->GetRenderer()->GetName();
         BenchmarkAll(wxString::Format("%6s GC (%s)", dckind, rendName.c_str()), gcdc);
     }
 }

void MorphanView::DrawGrid(wxGCDC& gcdc)
{
    int w, h;
    gcdc.GetSize(&w, &h);

    float gridw = grid_width;// * zoom;
    float gridh = grid_height;// * zoom;

    for (float i = gridh; i < h; i += gridh)
        gcdc.DrawLine(0, i, w, i);

    for (float j = gridw; j < w; j += gridw)
        gcdc.DrawLine(j, 0, j, h);
}

bool DrawingUtils::GetGCDC(wxDC& dc, wxGCDC& gdc)
{
    wxGraphicsRenderer* const renderer = wxGraphicsRenderer::GetDefaultRenderer();
    wxGraphicsContext* context;
    
    if ( wxPaintDC *paintdc = wxDynamicCast(&dc, wxPaintDC) ) {
        context = renderer->CreateContext(*paintdc);

    } else if ( wxMemoryDC *memdc = wxDynamicCast(&dc, wxMemoryDC) ) {
        context = renderer->CreateContext(*memdc);

    } else {
        wxFAIL_MSG( "Unknown wxDC kind" );
        return false;
    }
    
    gdc.SetGraphicsContext(context);
    return true;
}

void wxFlatButton::GetGCDC(wxAutoBufferedPaintDC& dc, wxGCDC& gdc)
{
    wxGraphicsRenderer* const renderer = wxGraphicsRenderer::GetDefaultRenderer();
    wxGraphicsContext* context = renderer->CreateContext(dc);
    gdc.SetGraphicsContext(context);
}

void MaterialWindow::drawNode(wxGCDC& gdc, Node* node)
{
    // Background
    gdc.SetBrush(wxBrush(Theme::lightBackgroundColor, wxBRUSHSTYLE_SOLID));
    gdc.DrawRoundedRectangle(mWindowX + node->x, mWindowY + node->y, node->width, node->height, 10);

    // Title Bar Background
    if ( node->mouseOver || mSelectedNode == node )
        gdc.SetBrush(wxBrush(wxColour(50, 50, 50), wxBRUSHSTYLE_SOLID));
    else
        gdc.SetBrush(wxBrush(Theme::darkBackgroundColor, wxBRUSHSTYLE_SOLID));
    gdc.DrawRoundedRectangle(mWindowX + node->x + 5, mWindowY + node->y + 5, node->width - 10, 30, 10);

    // Title Bar Text
    wxFont font(10, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_BOLD, false);
    gdc.SetFont(font);
    gdc.SetTextForeground(wxColour(200, 200, 190));
    wxSize textSize = gdc.GetTextExtent(node->name);
    gdc.DrawText(node->name, mWindowX + node->x + (node->width / 2) - (textSize.GetWidth() / 2), mWindowY + node->y + 18 - (textSize.GetHeight() / 2));

    // Input Points
    for(S32 n = 0; n < node->inputs.size(); ++n )
    {
        InputPoint* input = &node->inputs[n];
        input->lastPosition = wxPoint(mWindowX + node->x + 12.0f, mWindowY + node->y + 49.0f + (n * 20.0f));

        U8 alpha_val = input->mouseOver ? 255 : 175;

        gdc.SetBrush(wxBrush(wxColour(255, 255, 255, alpha_val), wxBRUSHSTYLE_SOLID));
        gdc.DrawCircle(mWindowX + node->x + 12.0f, mWindowY + node->y + 49.0f + (n * 20.0f), 5);

        wxSize inputTextSize = gdc.GetTextExtent(input->name);
        wxFont inputfont(10, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL, false);
        gdc.SetFont(inputfont);
        gdc.SetTextForeground(wxColour(255, 255, 255, alpha_val));
        gdc.DrawText(input->name, mWindowX + node->x + 22, mWindowY + node->y + 41 + (n * 20));
    }

    // Output Points
    for(S32 n = 0; n < node->outputs.size(); ++n )
    {
        OutputPoint* output = &node->outputs[n];
        output->lastPosition = wxPoint(mWindowX + node->x + node->width - 12.0f, mWindowY + node->y + 49.0f + (n * 20.0f));

        U8 alpha_val = output->mouseOver ? 255 : 175;

        gdc.SetBrush(wxBrush(wxColour(output->color.red, output->color.green, output->color.blue, alpha_val), wxBRUSHSTYLE_SOLID));
        gdc.DrawCircle(mWindowX + node->x + node->width - 12.0f, mWindowY + node->y + 49.0f + (n * 20.0f), 5);
    }

    // Float can be shown in a single line of text.
    if (node->type == "Float")
    {
        wxString floatValue = wxString::Format("%f", node->color.red);
        wxFont inputfont(10, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL, false);
        gdc.SetFont(inputfont);
        gdc.SetTextForeground(wxColour(255, 255, 255, 255));
        gdc.DrawText(floatValue, mWindowX + node->x + 12.0f, mWindowY + node->y + 41);
    }

    // Vec3 and Vec4 draw a color preview.
    if (node->type == "Vec3" || node->type == "Vec4")
    {
        gdc.SetBrush(wxBrush(wxColour(node->color.red * 255, node->color.green * 255, node->color.blue * 255, node->color.alpha * 255), wxBRUSHSTYLE_SOLID));
        gdc.DrawRectangle(mWindowX + node->x + 12.0f, mWindowY + node->y + 16.0f + (node->height / 2.0f) - 32.0f, 64.0f, 64.0f);
    }
}

void GCDCBoundingBoxTestCase::DrawRectsOnTransformedDC()
{
    m_gcdc->DrawRectangle(10, 15, 50, 30);
    m_gcdc->SetDeviceOrigin(15, 20);
    m_gcdc->DrawRectangle(15, 20, 45, 35);
    m_gcdc->SetDeviceOrigin(5, 10);
    AssertBox(5, 5, 65, 60);
}

void GCDCBoundingBoxTestCase::CrossHair()
{
    int w, h;
    m_gcdc->GetSize(&w, &h);

    m_gcdc->CrossHair(33, 33);
    AssertBox(0, 0, w, h);
}

void GCDCBoundingBoxTestCase::DrawText()
{
    wxString text("H");
    wxCoord w, h;
    m_gcdc->GetTextExtent(text, &w, &h);

    m_gcdc->DrawText(text, 3, 3);
    AssertBox(3, 3, w, h, 3);
}

void GCDCBoundingBoxTestCase::DrawRotatedText()
{
    wxString text("vertical");
    wxCoord w, h;
    m_gcdc->GetTextExtent(text, &w, &h);

    m_gcdc->DrawRotatedText(text, 43, 22, -90);
    AssertBox(43 - h, 22, h, w, 3);
}

    void AssertBox(int minX, int minY, int width, int height, int margin = 0)
    {
        int maxX = minX + width;
        int maxY = minY + height;

        // Allow for a margin of error due to different implementation
        // specificities regarding drawing paths.
        if ( margin )
        {
            #define WX_ASSERT_CLOSE(expected, actual, delta) \
                WX_ASSERT_MESSAGE(("%d != %d", actual, expected), \
                                  abs(actual - expected) <= delta)

            WX_ASSERT_CLOSE(minX, m_gcdc->MinX(), margin);
            WX_ASSERT_CLOSE(minY, m_gcdc->MinY(), margin);
            WX_ASSERT_CLOSE(maxX, m_gcdc->MaxX(), margin);
            WX_ASSERT_CLOSE(maxY, m_gcdc->MaxY(), margin);

            #undef WX_ASSERT_CLOSE
        }
        else
        {
            CPPUNIT_ASSERT_EQUAL(minX, m_gcdc->MinX());
            CPPUNIT_ASSERT_EQUAL(minY, m_gcdc->MinY());
            CPPUNIT_ASSERT_EQUAL(maxX, m_gcdc->MaxX());
            CPPUNIT_ASSERT_EQUAL(maxY, m_gcdc->MaxY());
        }
    }

void GCDCBoundingBoxTestCase::DrawBitmap()
{
    wxBitmap bitmap;
    bitmap.Create(12, 12);

    m_gcdc->DrawBitmap(bitmap, 5, 5);
    AssertBox(5, 5, 12, 12);
}

void GCDCBoundingBoxTestCase::DrawPolygon()
{
    wxPoint points[3];
    points[0] = wxPoint(10, 30);
    points[1] = wxPoint(20, 10);
    points[2] = wxPoint(30, 30);

    m_gcdc->DrawPolygon(3, points, -5, -7);
    AssertBox(5, 3, 20, 20);
}

void GCDCBoundingBoxTestCase::DrawSpline()
{
    wxPoint points[3];
    points[0] = wxPoint(10, 30);
    points[1] = wxPoint(20, 20);
    points[2] = wxPoint(40, 50);

    m_gcdc->DrawSpline(3, points);
    AssertBox(10, 20, 30, 30, 5);
}

void GCDCBoundingBoxTestCase::DrawIcon()
{
    wxBitmap bitmap;
    bitmap.Create(16, 16);
    wxIcon icon;
    icon.CopyFromBitmap(bitmap);

    m_gcdc->DrawIcon(icon, 42, 42);
    AssertBox(42, 42, 16, 16);
}

void GCDCBoundingBoxTestCase::DrawLines()
{
    wxPoint points[4];
    points[0] = wxPoint(10, 20);
    points[1] = wxPoint(20, 10);
    points[2] = wxPoint(30, 20);
    points[3] = wxPoint(20, 30);

    m_gcdc->DrawLines(4, points, 7, 8);
    AssertBox(17, 18, 20, 20);
}

void GCDCBoundingBoxTestCase::Blit()
{
    wxBitmap bitmap;
    bitmap.Create(20, 20);
    wxMemoryDC dc(bitmap);

    m_gcdc->Blit(20, 10, 12, 7, &dc, 0, 0);
    AssertBox(20, 10, 12, 7);

    dc.SelectObject(wxNullBitmap);
}

void GCDCBoundingBoxTestCase::StretchBlit()
{
    wxBitmap bitmap;
    bitmap.Create(20, 20);
    wxMemoryDC dc(bitmap);

    m_gcdc->StretchBlit(30, 50, 5, 5, &dc, 0, 0, 12, 4);
    AssertBox(30, 50, 5, 5);

    dc.SelectObject(wxNullBitmap);
}

void GCDCBoundingBoxTestCase::DrawPolyPolygon()
{
    int lenghts[2];
    lenghts[0] = 3;
    lenghts[1] = 3;
    wxPoint points[6];
    points[0] = wxPoint(10, 30);
    points[1] = wxPoint(20, 10);
    points[2] = wxPoint(30, 30);
    points[3] = wxPoint(20, 60);
    points[4] = wxPoint(30, 40);
    points[5] = wxPoint(40, 60);

    m_gcdc->DrawPolyPolygon(2, lenghts, points, 12, 5);
    AssertBox(22, 15, 30, 50, 4);
}

void GCDCBoundingBoxTestCase::DrawLine()
{
    m_gcdc->DrawLine(10, 10, 20, 15);
    AssertBox(10, 10, 10, 5);
}