]> git.saurik.com Git - wxWidgets.git/commitdiff
Applied FloodFill patch
authorJulian Smart <julian@anthemion.co.uk>
Mon, 1 Apr 2002 21:40:42 +0000 (21:40 +0000)
committerJulian Smart <julian@anthemion.co.uk>
Mon, 1 Apr 2002 21:40:42 +0000 (21:40 +0000)
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@14894 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

distrib/msw/msw.rsp
docs/latex/wx/dc.tex
include/wx/image.h
src/common/image.cpp
src/gtk/dcclient.cpp
src/gtk1/dcclient.cpp
src/mac/carbon/dc.cpp
src/mac/dc.cpp
src/mgl/dc.cpp
src/motif/dcclient.cpp
src/x11/dcclient.cpp

index 40b85a13af3d94fb66c316a24e907d62de24d93a..b705079f2a04aaa85110a4946ef4a3ce47035480 100644 (file)
@@ -51,8 +51,6 @@ src/*.bat
 
 src/common/dosyacc.c
 src/common/doslex.c
 
 src/common/dosyacc.c
 src/common/doslex.c
-src/common/y_tab.c
-src/common/lex_yy.c
 src/common/*.rc
 
 src/msw/*.cpp
 src/common/*.rc
 
 src/msw/*.cpp
index b2d9573af90283badbd4b23d7903b754b5ba8ebb..dc731b363de887e4fed7a5a7f79138472b9c61d6 100644 (file)
@@ -497,7 +497,8 @@ the {\it current brush colour}, and using a style:
 \item wxFLOOD\_BORDER: the area to be flooded is bounded by the given colour.
 \end{itemize}
 
 \item wxFLOOD\_BORDER: the area to be flooded is bounded by the given colour.
 \end{itemize}
 
-{\it Note:} this function is available in MS Windows only.
+{\it Note:} The present implementation for non-Windows platforms may fail to find
+colour borders if the pixels do not match the colour exactly.
 
 \membersection{wxDC::GetBackground}\label{wxdcgetbackground}
 
 
 \membersection{wxDC::GetBackground}\label{wxdcgetbackground}
 
index 7522d068541b532cfc0cc8f944aa1658261c4c53..786b76f3a214de059308144c04bfbe3826e6dbf1 100644 (file)
@@ -175,6 +175,12 @@ public:
     bool SetMaskFromImage(const wxImage & mask,
                           unsigned char mr, unsigned char mg, unsigned char mb);
 
     bool SetMaskFromImage(const wxImage & mask,
                           unsigned char mr, unsigned char mg, unsigned char mb);
 
+    void DoFloodFill (wxCoord x, wxCoord y,
+        const wxBrush & fillBrush,
+        const wxColour& testColour,
+        int style = wxFLOOD_SURFACE,
+        int LogicalFunction = wxCOPY /* currently unused */ ) ;
+
     static bool CanRead( const wxString& name );
     static int GetImageCount( const wxString& name, long type = wxBITMAP_TYPE_ANY );
     virtual bool LoadFile( const wxString& name, long type = wxBITMAP_TYPE_ANY, int index = -1 );
     static bool CanRead( const wxString& name );
     static int GetImageCount( const wxString& name, long type = wxBITMAP_TYPE_ANY );
     virtual bool LoadFile( const wxString& name, long type = wxBITMAP_TYPE_ANY, int index = -1 );
@@ -264,6 +270,10 @@ protected:
     static wxList   sm_handlers;
 
 private:
     static wxList   sm_handlers;
 
 private:
+    //these two are called by FloodFill
+    bool MatchPixel(int x, int y, int w, int h, const wxColour & c) ;
+    bool MatchBoundaryPixel(int x, int y, int w, int h, const wxColour & fill, const wxColour & bound) ;
+
     friend class WXDLLEXPORT wxImageHandler;
 
     DECLARE_DYNAMIC_CLASS(wxImage)
     friend class WXDLLEXPORT wxImageHandler;
 
     DECLARE_DYNAMIC_CLASS(wxImage)
index d4f9ddac8cfe2a6020b03bf03dd412a70d28c4e8..f98926b073568fbd5822d91e08d1f84c25337436 100644 (file)
@@ -820,6 +820,248 @@ bool wxImage::SetMaskFromImage(const wxImage& mask,
     return TRUE;
 }
 
     return TRUE;
 }
 
+
+// DoFloodFill
+// Fills with the colour extracted from fillBrush, starting at x,y until either
+// a color different from the start pixel is reached (wxFLOOD_SURFACE)
+// or fill color is reached (wxFLOOD_BORDER)
+
+bool wxImage::MatchPixel(int x, int y, int w, int h, const wxColour & c)
+{
+    if ((x<0)||(x>=w)||(y<0)||(y>=h)) return false;
+
+    unsigned char r = GetRed(x,y);
+    unsigned char g = GetGreen(x,y);
+    unsigned char b = GetBlue(x,y);
+    return c.Red() == r && c.Green() == g && c.Blue() == b ;
+}
+
+bool wxImage::MatchBoundaryPixel(int x, int y, int w, int h, const wxColour & fill, const wxColour & bound)
+{
+    if ((x<0)||(x>=w)||(y<0)||(y>=h)) return TRUE;
+
+    unsigned char r = GetRed(x,y);
+    unsigned char g = GetGreen(x,y);
+    unsigned char b = GetBlue(x,y);
+    if ( fill.Red() == r && fill.Green() == g && fill.Blue() == b ) return TRUE;
+    if ( bound.Red() == r && bound.Green() == g && bound.Blue() == b ) return TRUE;
+    return FALSE ;
+}
+
+
+void wxImage::DoFloodFill (wxCoord x, wxCoord y, const wxBrush & fillBrush,
+        const wxColour& testColour, int style /*=wxFLOOD_SURFACE */,
+        int LogicalFunction /*= wxCOPY, currently unused */)
+{
+    /* A diamond flood-fill using a circular queue system.
+    Each pixel surrounding the current pixel is added to
+    the queue if it meets the criteria, then is retrieved in
+    its turn.  Code originally based on http://www.drawit.co.nz/Developers.htm */
+
+    int width = GetWidth();
+    int height = GetHeight();
+
+    //Draw using a pen made from the current brush colour
+    //Potentially allows us to use patterned flood fills in future code
+    wxColour fillColour = fillBrush.GetColour();
+    unsigned char r = fillColour.Red();
+    unsigned char g = fillColour.Green();
+    unsigned char b = fillColour.Blue();
+
+    //initial test :
+    if (style == wxFLOOD_SURFACE)
+    {
+       //if wxFLOOD_SURFACE, if fill colour is same as required, we don't do anything
+       if (     GetRed(x,y)   != r
+             || GetGreen(x,y) != g
+             || GetBlue (x,y) != b   )
+        {
+        //prepare memory for queue
+        //queue save, start, read
+        size_t *qs, *qst, *qr;
+
+        //queue size (physical)
+        long qSz= height * width * 2;
+        qst = new size_t [qSz];
+
+        //temporary x and y locations
+        int xt, yt;
+
+        for (int i=0; i < qSz; i++)
+            qst[i] = 0;
+
+        // start queue
+        qs=qr=qst;
+        *qs=xt=x;
+        qs++;
+        *qs=yt=y;
+        qs++;
+
+        SetRGB(xt,yt,r,g,b);
+
+        //Main queue loop
+        while(qr!=qs)
+        {
+            //Add new members to queue
+            //Above current pixel
+            if(MatchPixel(xt,yt-1,width,height,testColour))
+            {
+                *qs=xt;
+                qs++;
+                *qs=yt-1;
+                qs++;
+                SetRGB(xt,yt-1,r,g,b);
+
+                //Loop back to beginning of queue
+                if(qs>=(qst+qSz)) qs=qst;
+            }
+
+            //Below current pixel
+            if(MatchPixel(xt,yt+1,width,height,testColour))
+            {
+                *qs=xt;
+                qs++;
+                *qs=yt+1;
+                qs++;
+                SetRGB(xt,yt+1,r,g,b);
+                if(qs>=(qst+qSz)) qs=qst;
+            }
+
+            //Left of current pixel
+            if(MatchPixel(xt-1,yt,width,height,testColour))
+            {
+                *qs=xt-1;
+                qs++;
+                *qs=yt;
+                qs++;
+                SetRGB(xt-1,yt,r,g,b);
+                if(qs>=(qst+qSz)) qs=qst;
+            }
+
+            //Right of current pixel
+            if(MatchPixel(xt+1,yt,width,height,testColour))
+            {
+                *qs=xt+1;
+                qs++;
+                *qs=yt;
+                qs++;
+                SetRGB(xt+1,yt,r,g,b);
+                if(qs>=(qst+qSz)) qs=qst;
+            }
+
+            //Retrieve current queue member
+            qr+=2;
+
+            //Loop back to the beginning
+            if(qr>=(qst+qSz)) qr=qst;
+            xt=*qr;
+            yt=*(qr+1);
+
+        //Go Back to beginning of loop
+        }
+
+        delete [] qst ;
+        }
+    }
+    else
+    {
+    //style is wxFLOOD_BORDER
+    // fill up to testColor border - if already testColour don't do anything
+    if (  GetRed(x,y)   != testColour.Red()
+       || GetGreen(x,y) != testColour.Green()
+       || GetBlue(x,y)  != testColour.Blue()   )
+        {
+        //prepare memory for queue
+        //queue save, start, read
+        size_t *qs, *qst, *qr;
+
+        //queue size (physical)
+        long qSz= height * width * 2;
+        qst = new size_t [qSz];
+
+        //temporary x and y locations
+        int xt, yt;
+
+        for (int i=0; i < qSz; i++)
+            qst[i] = 0;
+
+        // start queue
+        qs=qr=qst;
+        *qs=xt=x;
+        qs++;
+        *qs=yt=y;
+        qs++;
+
+        SetRGB(xt,yt,r,g,b);
+
+        //Main queue loop
+        while(qr!=qs)
+        {
+            //Add new members to queue
+            //Above current pixel
+            if(!MatchBoundaryPixel(xt,yt-1,width,height,fillColour,testColour))
+            {
+                *qs=xt;
+                qs++;
+                *qs=yt-1;
+                qs++;
+                SetRGB(xt,yt-1,r,g,b);
+
+                //Loop back to beginning of queue
+                if(qs>=(qst+qSz)) qs=qst;
+            }
+
+            //Below current pixel
+            if(!MatchBoundaryPixel(xt,yt+1,width,height,fillColour,testColour))
+            {
+                *qs=xt;
+                qs++;
+                *qs=yt+1;
+                qs++;
+                SetRGB(xt,yt+1,r,g,b);
+                if(qs>=(qst+qSz)) qs=qst;
+            }
+
+            //Left of current pixel
+            if(!MatchBoundaryPixel(xt-1,yt,width,height,fillColour,testColour))
+            {
+                *qs=xt-1;
+                qs++;
+                *qs=yt;
+                qs++;
+                SetRGB(xt-1,yt,r,g,b);
+                if(qs>=(qst+qSz)) qs=qst;
+            }
+
+            //Right of current pixel
+            if(!MatchBoundaryPixel(xt+1,yt,width,height,fillColour,testColour))
+            {
+                *qs=xt+1;
+                qs++;
+                *qs=yt;
+                qs++;
+                SetRGB(xt+1,yt,r,g,b);
+                if(qs>=(qst+qSz)) qs=qst;
+            }
+
+            //Retrieve current queue member
+            qr+=2;
+
+            //Loop back to the beginning
+            if(qr>=(qst+qSz)) qr=qst;
+            xt=*qr;
+            yt=*(qr+1);
+
+        //Go Back to beginning of loop
+        }
+
+        delete [] qst ;
+        }
+    }
+    //all done,
+}
+
+
 #if wxUSE_PALETTE
 
 // Palette functions
 #if wxUSE_PALETTE
 
 // Palette functions
index 2d4299ad5a99f2ba24397cd25d6d5753071169e8..d903e9311c4c86e839075a27149f841ca0e7237b 100644 (file)
@@ -19,6 +19,7 @@
 #include "wx/dcmemory.h"
 #include "wx/image.h"
 #include "wx/module.h"
 #include "wx/dcmemory.h"
 #include "wx/image.h"
 #include "wx/module.h"
+#include "wx/log.h"
 
 #include "wx/gtk/win_gtk.h"
 
 
 #include "wx/gtk/win_gtk.h"
 
@@ -400,10 +401,37 @@ void wxWindowDC::DoGetSize( int* width, int* height ) const
     m_owner->GetSize(width, height);
 }
 
     m_owner->GetSize(width, height);
 }
 
-void wxWindowDC::DoFloodFill( wxCoord WXUNUSED(x), wxCoord WXUNUSED(y),
-                           const wxColour &WXUNUSED(col), int WXUNUSED(style) )
+void wxWindowDC::DoFloodFill( wxCoord x, wxCoord y,
+                           const wxColour & col, int style )
 {
 {
-    wxFAIL_MSG( wxT("wxWindowDC::DoFloodFill not implemented") );
+    if (GetBrush().GetStyle() == wxTRANSPARENT)
+    {
+        wxLogDebug(wxT("In FloodFill, current Brush is transparent, no filling done"));
+        return ;
+    }
+    int height = 0;
+    int width  = 0;
+    this->GetSize(&width, &height);
+    //it would be nice to fail if we don't get a sensible size...
+    if (width < 1 || height < 1)
+    {
+        wxLogError(wxT("In FloodFill, dc.GetSize routine failed, method not supported by this DC"));
+        return ;
+    }
+
+    //this is much faster than doing the individual pixels
+    wxMemoryDC memdc;
+    wxBitmap bitmap(width, height);
+    memdc.SelectObject(bitmap);
+    memdc.Blit(0, 0, width, height, (wxDC*) this, 0, 0);
+    memdc.SelectObject(wxNullBitmap);
+
+    wxImage image(bitmap);
+    image.DoFloodFill (x,y, GetBrush(), col, style, GetLogicalFunction());
+    bitmap = wxBitmap(image);
+    memdc.SelectObject(bitmap);
+    this->Blit(0, 0, width, height, &memdc, 0, 0);
+    memdc.SelectObject(wxNullBitmap);
 }
 
 bool wxWindowDC::DoGetPixel( wxCoord x1, wxCoord y1, wxColour *col ) const
 }
 
 bool wxWindowDC::DoGetPixel( wxCoord x1, wxCoord y1, wxColour *col ) const
index 2d4299ad5a99f2ba24397cd25d6d5753071169e8..d903e9311c4c86e839075a27149f841ca0e7237b 100644 (file)
@@ -19,6 +19,7 @@
 #include "wx/dcmemory.h"
 #include "wx/image.h"
 #include "wx/module.h"
 #include "wx/dcmemory.h"
 #include "wx/image.h"
 #include "wx/module.h"
+#include "wx/log.h"
 
 #include "wx/gtk/win_gtk.h"
 
 
 #include "wx/gtk/win_gtk.h"
 
@@ -400,10 +401,37 @@ void wxWindowDC::DoGetSize( int* width, int* height ) const
     m_owner->GetSize(width, height);
 }
 
     m_owner->GetSize(width, height);
 }
 
-void wxWindowDC::DoFloodFill( wxCoord WXUNUSED(x), wxCoord WXUNUSED(y),
-                           const wxColour &WXUNUSED(col), int WXUNUSED(style) )
+void wxWindowDC::DoFloodFill( wxCoord x, wxCoord y,
+                           const wxColour & col, int style )
 {
 {
-    wxFAIL_MSG( wxT("wxWindowDC::DoFloodFill not implemented") );
+    if (GetBrush().GetStyle() == wxTRANSPARENT)
+    {
+        wxLogDebug(wxT("In FloodFill, current Brush is transparent, no filling done"));
+        return ;
+    }
+    int height = 0;
+    int width  = 0;
+    this->GetSize(&width, &height);
+    //it would be nice to fail if we don't get a sensible size...
+    if (width < 1 || height < 1)
+    {
+        wxLogError(wxT("In FloodFill, dc.GetSize routine failed, method not supported by this DC"));
+        return ;
+    }
+
+    //this is much faster than doing the individual pixels
+    wxMemoryDC memdc;
+    wxBitmap bitmap(width, height);
+    memdc.SelectObject(bitmap);
+    memdc.Blit(0, 0, width, height, (wxDC*) this, 0, 0);
+    memdc.SelectObject(wxNullBitmap);
+
+    wxImage image(bitmap);
+    image.DoFloodFill (x,y, GetBrush(), col, style, GetLogicalFunction());
+    bitmap = wxBitmap(image);
+    memdc.SelectObject(bitmap);
+    this->Blit(0, 0, width, height, &memdc, 0, 0);
+    memdc.SelectObject(wxNullBitmap);
 }
 
 bool wxWindowDC::DoGetPixel( wxCoord x1, wxCoord y1, wxColour *col ) const
 }
 
 bool wxWindowDC::DoGetPixel( wxCoord x1, wxCoord y1, wxColour *col ) const
index f44f47270f3340ead770515b6b186d31cc9cc7bb..2828b715c6f727d6f61d49424785862c2e5a9d60 100644 (file)
@@ -19,6 +19,7 @@
 #include "wx/dcmemory.h"
 #include "wx/region.h"
 #include "wx/image.h"
 #include "wx/dcmemory.h"
 #include "wx/region.h"
 #include "wx/image.h"
+#include "wx/log.h"
 
 
 #if __MSL__ >= 0x6000
 
 
 #if __MSL__ >= 0x6000
@@ -653,6 +654,34 @@ void  wxDC::DoFloodFill( wxCoord x, wxCoord y, const wxColour& col,
 {
 }
 
 {
 }
 
+    if (GetBrush().GetStyle() == wxTRANSPARENT)
+    {
+        wxLogDebug(wxT("In FloodFill, Current Brush is transparent, no filling done"));
+        return ;
+    }
+    int height = 0;
+    int width  = 0;
+    this->GetSize(&width, &height);
+    //it would be nice to fail if we don't get a sensible size...
+    if (width < 1 || height < 1)
+    {
+        wxLogError(wxT("In FloodFill, dc.GetSize routine failed, method not supported by this DC"));
+        return ;
+    }
+
+    //this is much faster than doing the individual pixels
+    wxMemoryDC memdc;
+    wxBitmap bitmap(width, height);
+    memdc.SelectObject(bitmap);
+    memdc.Blit(0, 0, width, height, (wxDC*) this, 0, 0);
+    memdc.SelectObject(wxNullBitmap);
+
+    wxImage image(bitmap);
+    image.DoFloodFill (x,y, GetBrush(), col, style, GetLogicalFunction());
+    bitmap = wxBitmap(image);
+    memdc.SelectObject(bitmap);
+    this->Blit(0, 0, width, height, &memdc, 0, 0);
+    memdc.SelectObject(wxNullBitmap);
 bool  wxDC::DoGetPixel( wxCoord x, wxCoord y, wxColour *col ) const 
 {
     wxCHECK_MSG( Ok(), false, wxT("wxDC::DoGetPixel  Invalid DC") );
 bool  wxDC::DoGetPixel( wxCoord x, wxCoord y, wxColour *col ) const 
 {
     wxCHECK_MSG( Ok(), false, wxT("wxDC::DoGetPixel  Invalid DC") );
index f44f47270f3340ead770515b6b186d31cc9cc7bb..2828b715c6f727d6f61d49424785862c2e5a9d60 100644 (file)
@@ -19,6 +19,7 @@
 #include "wx/dcmemory.h"
 #include "wx/region.h"
 #include "wx/image.h"
 #include "wx/dcmemory.h"
 #include "wx/region.h"
 #include "wx/image.h"
+#include "wx/log.h"
 
 
 #if __MSL__ >= 0x6000
 
 
 #if __MSL__ >= 0x6000
@@ -653,6 +654,34 @@ void  wxDC::DoFloodFill( wxCoord x, wxCoord y, const wxColour& col,
 {
 }
 
 {
 }
 
+    if (GetBrush().GetStyle() == wxTRANSPARENT)
+    {
+        wxLogDebug(wxT("In FloodFill, Current Brush is transparent, no filling done"));
+        return ;
+    }
+    int height = 0;
+    int width  = 0;
+    this->GetSize(&width, &height);
+    //it would be nice to fail if we don't get a sensible size...
+    if (width < 1 || height < 1)
+    {
+        wxLogError(wxT("In FloodFill, dc.GetSize routine failed, method not supported by this DC"));
+        return ;
+    }
+
+    //this is much faster than doing the individual pixels
+    wxMemoryDC memdc;
+    wxBitmap bitmap(width, height);
+    memdc.SelectObject(bitmap);
+    memdc.Blit(0, 0, width, height, (wxDC*) this, 0, 0);
+    memdc.SelectObject(wxNullBitmap);
+
+    wxImage image(bitmap);
+    image.DoFloodFill (x,y, GetBrush(), col, style, GetLogicalFunction());
+    bitmap = wxBitmap(image);
+    memdc.SelectObject(bitmap);
+    this->Blit(0, 0, width, height, &memdc, 0, 0);
+    memdc.SelectObject(wxNullBitmap);
 bool  wxDC::DoGetPixel( wxCoord x, wxCoord y, wxColour *col ) const 
 {
     wxCHECK_MSG( Ok(), false, wxT("wxDC::DoGetPixel  Invalid DC") );
 bool  wxDC::DoGetPixel( wxCoord x, wxCoord y, wxColour *col ) const 
 {
     wxCHECK_MSG( Ok(), false, wxT("wxDC::DoGetPixel  Invalid DC") );
index 60d8043928ac4377a4639e0c1ded735bcee2e844..e38597f4194a84c86c188b257bd0ed61af6291ed 100644 (file)
@@ -334,7 +334,34 @@ void wxDC::Clear()
 
 void wxDC::DoFloodFill(wxCoord x, wxCoord y, const wxColour& col, int style)
 {
 
 void wxDC::DoFloodFill(wxCoord x, wxCoord y, const wxColour& col, int style)
 {
-    wxFAIL_MSG( wxT("wxDC::DoFloodFill not implemented") );
+    if (GetBrush().GetStyle() == wxTRANSPARENT)
+    {
+        wxLogDebug(wxT("In FloodFill, Current Brush is transparent, no filling done"));
+        return ;
+    }
+    int height = 0;
+    int width  = 0;
+    this->GetSize(&width, &height);
+    //it would be nice to fail if we don't get a sensible size...
+    if (width < 1 || height < 1)
+    {
+        wxLogError(wxT("In FloodFill, dc.GetSize routine failed, method not supported by this DC"));
+        return ;
+    }
+
+    //this is much faster than doing the individual pixels
+    wxMemoryDC memdc;
+    wxBitmap bitmap(width, height);
+    memdc.SelectObject(bitmap);
+    memdc.Blit(0, 0, width, height, (wxDC*) this, 0, 0);
+    memdc.SelectObject(wxNullBitmap);
+
+    wxImage image(bitmap);
+    image.DoFloodFill (x,y, GetBrush(), col, style, GetLogicalFunction());
+    bitmap = wxBitmap(image);
+    memdc.SelectObject(bitmap);
+    this->Blit(0, 0, width, height, &memdc, 0, 0);
+    memdc.SelectObject(wxNullBitmap);
 }
 
 bool wxDC::DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const
 }
 
 bool wxDC::DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const
index f442f9ebcac12b0f00c4c76cb710c18589204d61..e9d28fdb10f41201a2cec5efc7146bc78caafd72 100644 (file)
@@ -45,6 +45,7 @@
 #include "wx/window.h"
 #include "wx/app.h"
 #include "wx/image.h"
 #include "wx/window.h"
 #include "wx/app.h"
 #include "wx/image.h"
+#include "wx/log.h"
 
 #include <math.h>
 
 
 #include <math.h>
 
@@ -230,12 +231,39 @@ wxWindowDC::~wxWindowDC()
     m_userRegion = (WXRegion) 0;
 }
 
     m_userRegion = (WXRegion) 0;
 }
 
-void wxWindowDC::DoFloodFill( wxCoord WXUNUSED(x1), wxCoord WXUNUSED(y1),
-                           const wxColour& WXUNUSED(col), int WXUNUSED(style) )
+void wxWindowDC::DoFloodFill( wxCoord x1, wxCoord y1,
+                             const wxColour& col, int style )
 {
 {
-    wxFAIL_MSG("not implemented");
-}
+    if (GetBrush().GetStyle() == wxTRANSPARENT)
+    {
+        wxLogDebug(wxT("In FloodFill, current brush is transparent, no filling done"));
+        return ;
+    }
+    int height = 0;
+    int width  = 0;
+    this->GetSize(&width, &height);
+    //it would be nice to fail if we don't get a sensible size...
+    if (width < 1 || height < 1)
+    {
+        wxLogError(wxT("In FloodFill, dc.GetSize routine failed, method not supported by this DC"));
+        return ;
+    }
 
 
+    //this is much faster than doing the individual pixels
+    wxMemoryDC memdc;
+    wxBitmap bitmap(width, height);
+    memdc.SelectObject(bitmap);
+    memdc.Blit(0, 0, width, height, (wxDC*) this, 0, 0);
+    memdc.SelectObject(wxNullBitmap);
+
+    wxImage image(bitmap);
+    image.DoFloodFill (x,y, GetBrush(), col, style, GetLogicalFunction());
+    bitmap = wxBitmap(image);
+    memdc.SelectObject(bitmap);
+    this->Blit(0, 0, width, height, &memdc, 0, 0);
+    memdc.SelectObject(wxNullBitmap);
+}
+  
 bool wxWindowDC::DoGetPixel( wxCoord x1, wxCoord y1, wxColour *col ) const
 {
     // Generic (and therefore rather inefficient) method.
 bool wxWindowDC::DoGetPixel( wxCoord x1, wxCoord y1, wxColour *col ) const
 {
     // Generic (and therefore rather inefficient) method.
index 659feec8ae453586a46bdb8c90b0d2e86d9836df..13cfe8ad9ab98006b61d618f9acf9211ff468775 100644 (file)
@@ -313,10 +313,37 @@ void wxWindowDC::DoGetSize( int* width, int* height ) const
     m_owner->GetSize(width, height);
 }
 
     m_owner->GetSize(width, height);
 }
 
-void wxWindowDC::DoFloodFill( wxCoord WXUNUSED(x1), wxCoord WXUNUSED(y1),
-                           const wxColour& WXUNUSED(col), int WXUNUSED(style) )
+void wxWindowDC::DoFloodFill( wxCoord x, wxCoord y,
+                           const wxColour & col, int style )
 {
 {
-    wxFAIL_MSG("not implemented");
+    if (GetBrush().GetStyle() == wxTRANSPARENT)
+    {
+        wxLogDebug(wxT("In FloodFill, current brush is transparent, no filling done"));
+        return ;
+    }
+    int height = 0;
+    int width  = 0;
+    this->GetSize(&width, &height);
+    //it would be nice to fail if we don't get a sensible size...
+    if (width < 1 || height < 1)
+    {
+        wxLogError(wxT("In FloodFill, dc.GetSize routine failed, method not supported by this DC"));
+        return ;
+    }
+
+    //this is much faster than doing the individual pixels
+    wxMemoryDC memdc;
+    wxBitmap bitmap(width, height);
+    memdc.SelectObject(bitmap);
+    memdc.Blit(0, 0, width, height, (wxDC*) this, 0, 0);
+    memdc.SelectObject(wxNullBitmap);
+
+    wxImage image(bitmap);
+    image.DoFloodFill (x,y, GetBrush(), col, style, GetLogicalFunction());
+    bitmap = wxBitmap(image);
+    memdc.SelectObject(bitmap);
+    this->Blit(0, 0, width, height, &memdc, 0, 0);
+    memdc.SelectObject(wxNullBitmap);
 }
 
 bool wxWindowDC::DoGetPixel( wxCoord x1, wxCoord y1, wxColour *col ) const
 }
 
 bool wxWindowDC::DoGetPixel( wxCoord x1, wxCoord y1, wxColour *col ) const