Brush updates

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@8910 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

include/wx/os2/brush.h

@@ -23,14 +23,15 @@ class WXDLLEXPORT wxBrushRefData: public wxGDIRefData
     friend class WXDLLEXPORT wxBrush;
 public:
     wxBrushRefData();
-    wxBrushRefData(const wxBrushRefData& data);
+    wxBrushRefData(const wxBrushRefData& rData);
     ~wxBrushRefData();
 
 protected:
-    int           m_style;
+    int                             m_nStyle;
-    wxBitmap      m_stipple ;
+    wxBitmap                        m_vStipple ;
-    wxColour      m_colour;
+    wxColour                        m_vColour;
-    WXHBRUSH      m_hBrush;
+    WXHBRUSH                        m_hBrush; // in OS/2 GPI this will be the PS the pen is associated with
+    AREABUNDLE                      m_vBundle;
 };
 
 #define M_BRUSHDATA ((wxBrushRefData *)m_refData)
@@ -42,39 +43,46 @@ class WXDLLEXPORT wxBrush: public wxGDIObject
 
 public:
     wxBrush();
-  wxBrush(const wxColour& col, int style);
+    wxBrush( const wxColour& rCol
-  wxBrush(const wxBitmap& stipple);
+            ,int             nStyle
-  inline wxBrush(const wxBrush& brush) { Ref(brush); }
+           );
+    wxBrush(const wxBitmap& rStipple);
+    inline wxBrush(const wxBrush& rBrush) { Ref(rBrush); }
     ~wxBrush();
 
-  virtual void SetColour(const wxColour& col)  ;
+    inline wxBrush& operator = (const wxBrush& rBrush) { if (*this == rBrush) return (*this); Ref(rBrush); return *this; }
-  virtual void SetColour(unsigned char r, unsigned char g, unsigned char b)  ;
+    inline bool operator == (const wxBrush& rBrush) { return m_refData == rBrush.m_refData; }
-  virtual void SetStyle(int style)  ;
+    inline bool operator != (const wxBrush& rBrush) { return m_refData != rBrush.m_refData; }
-  virtual void SetStipple(const wxBitmap& stipple)  ;
 
-  inline wxBrush& operator = (const wxBrush& brush) { if (*this == brush) return (*this); Ref(brush); return *this; }
+    virtual void SetColour(const wxColour& rColour);
-  inline bool operator == (const wxBrush& brush) { return m_refData == brush.m_refData; }
+    virtual void SetColour( unsigned char cRed
-  inline bool operator != (const wxBrush& brush) { return m_refData != brush.m_refData; }
+                           ,unsigned char cGreen
+                           ,unsigned char cBrush
+                          );
+    virtual void SetPS(HPS hPS);
+    virtual void SetStyle(int nStyle)  ;
+    virtual void SetStipple(const wxBitmap& rStipple);
 
-  inline wxColour& GetColour() const { return (M_BRUSHDATA ? M_BRUSHDATA->m_colour : wxNullColour); };
+    inline wxColour& GetColour(void) const { return (M_BRUSHDATA ? M_BRUSHDATA->m_vColour : wxNullColour); };
-  inline int GetStyle() const { return (M_BRUSHDATA ? M_BRUSHDATA->m_style : 0); };
+    inline int       GetStyle(void) const { return (M_BRUSHDATA ? M_BRUSHDATA->m_nStyle : 0); };
-  inline wxBitmap *GetStipple() const { return (M_BRUSHDATA ? & M_BRUSHDATA->m_stipple : 0); };
+    inline wxBitmap* GetStipple(void) const { return (M_BRUSHDATA ? & M_BRUSHDATA->m_vStipple : 0); };
+    inline int       GetPS(void) const { return (M_BRUSHDATA ? M_BRUSHDATA->m_hBrush : 0); };
 
-  virtual bool Ok() const { return (m_refData != NULL) ; }
+    inline virtual bool Ok(void) const { return (m_refData != NULL) ; }
 
+    //
     // Implementation
+    //
 
+    //
     // Useful helper: create the brush resource
-  bool RealizeResource();
+    //
-
+    bool     RealizeResource(void);
     WXHANDLE GetResourceHandle(void) ;
-  bool FreeResource(bool force = FALSE);
+    bool     FreeResource(bool bForce = FALSE);
-  bool IsFree() const;
+    bool     IsFree(void) const;
-
+    void     Unshare(void);
-  // When setting properties, we must make sure we're not changing
+}; // end of CLASS wxBrush
-  // another object
-  void Unshare();
-};
 
 #endif
     // _WX_BRUSH_H_

src/os2/brush.cpp

@@ -29,164 +29,232 @@ IMPLEMENT_DYNAMIC_CLASS(wxBrush, wxGDIObject)
 
 wxBrushRefData::wxBrushRefData()
 {
-    m_style = wxSOLID;
+    m_nStyle = wxSOLID;
     m_hBrush = 0;
-}
+    memset(&m_vBundle, '\0', sizeof(AREABUNDLE));
+} // end of wxBrushRefData::wxBrushRefData
 
-wxBrushRefData::wxBrushRefData(const wxBrushRefData& data)
+wxBrushRefData::wxBrushRefData(
+  const wxBrushRefData&             rData
+)
 {
-    m_style = data.m_style;
+    m_nStyle   = rData.m_nStyle;
-    m_stipple = data.m_stipple;
+    m_vStipple = rData.m_vStipple;
-    m_colour = data.m_colour;
+    m_vColour  = rData.m_vColour;
     m_hBrush   = 0;
-}
+    memcpy(&m_vBundle, &rData.m_vBundle, sizeof(AREABUNDLE));
+} // end of wxBrushRefData::wxBrushRefData
 
 wxBrushRefData::~wxBrushRefData()
 {
-// TODO: delete data
+} // end of wxBrushRefData::~wxBrushRefData
-}
 
+//
 // Brushes
+//
 wxBrush::wxBrush()
 {
     if ( wxTheBrushList )
         wxTheBrushList->AddBrush(this);
-}
+} // end of wxBrush::wxBrush
 
 wxBrush::~wxBrush()
 {
     if ( wxTheBrushList )
         wxTheBrushList->RemoveBrush(this);
-}
+} // end of wxBrush::~wxBrush
 
-wxBrush::wxBrush(const wxColour& col, int Style)
+wxBrush::wxBrush(
+  const wxColour&                   rColour
+, int                               nStyle
+)
 {
     m_refData = new wxBrushRefData;
 
-    M_BRUSHDATA->m_colour = col;
+    M_BRUSHDATA->m_vColour = rColour;
-    M_BRUSHDATA->m_style = Style;
+    M_BRUSHDATA->m_nStyle  = nStyle;
     M_BRUSHDATA->m_hBrush  = 0;
+    memset(&M_BRUSHDATA->m_vBundle, '\0', sizeof(AREABUNDLE));
 
     RealizeResource();
 
     if ( wxTheBrushList )
         wxTheBrushList->AddBrush(this);
-}
+} // end of wxBrush::wxBrush
 
-wxBrush::wxBrush(const wxBitmap& stipple)
+wxBrush::wxBrush(
+  const wxBitmap&                   rStipple
+)
 {
     m_refData = new wxBrushRefData;
 
-    M_BRUSHDATA->m_style = wxSTIPPLE;
+    M_BRUSHDATA->m_nStyle   = wxSTIPPLE;
-    M_BRUSHDATA->m_stipple = stipple;
+    M_BRUSHDATA->m_vStipple = rStipple;
     M_BRUSHDATA->m_hBrush  = 0;
+    memset(&M_BRUSHDATA->m_vBundle, '\0', sizeof(AREABUNDLE));
 
     RealizeResource();
 
     if ( wxTheBrushList )
         wxTheBrushList->AddBrush(this);
+} // end of wxBrush::wxBrush
+
+bool wxBrush::RealizeResource()
+{
+    BOOL                            bOk;
+    ERRORID                         vError;
+    wxString                        sError;
+
+    if (M_BRUSHDATA && M_BRUSHDATA->m_hBrush == 0L)
+    {
+        SIZEL                   vSize = {0, 0};
+        DEVOPENSTRUC            vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
+        HDC                     hDC = ::DevOpenDC( vHabmain
+                                                  ,OD_MEMORY
+                                                  ,"*"
+                                                  ,5L
+                                                  ,(PDEVOPENDATA)&vDop
+                                                  ,NULLHANDLE
+                                                 );
+        M_BRUSHDATA->m_hBrush = (WXHPEN)::GpiCreatePS( vHabmain
+                                                      ,hDC
+                                                      ,&vSize
+                                                      ,PU_PELS | GPIT_MICRO | GPIA_ASSOC
+                                                     );
+    }
+    if (M_BRUSHDATA)
+    {
+        //
+        // Set the color table to RGB mode
+        //
+        if (!::GpiCreateLogColorTable( (HPS)M_BRUSHDATA->m_hBrush
+                                      ,0L
+                                      ,LCOLF_RGB
+                                      ,0L
+                                      ,0L
+                                      ,NULL
+                                     ))
+        {
+            vError = ::WinGetLastError(vHabmain);
+            sError = wxPMErrorToStr(vError);
+            wxLogError("Unable to set current color table to RGB mode. Error: %s\n", sError);
+            return FALSE;
         }
 
-bool wxBrush::RealizeResource(void)
+        if (M_BRUSHDATA->m_nStyle==wxTRANSPARENT)
         {
-// TODO:
-/*
-    if (M_BRUSHDATA && (M_BRUSHDATA->m_hBrush == 0))
-    {
-        if (M_BRUSHDATA->m_style==wxTRANSPARENT)
-        {
-            M_BRUSHDATA->m_hBrush = (WXHBRUSH) ::GetStockObject(NULL_BRUSH);
             return TRUE;
         }
-        COLORREF ms_colour = 0 ;
+        COLORREF                    vPmColour = 0L;
 
-        ms_colour = M_BRUSHDATA->m_colour.GetPixel() ;
+        vPmColour = M_BRUSHDATA->m_vColour.GetPixel() ;
 
-        switch (M_BRUSHDATA->m_style)
+        M_BRUSHDATA->m_vBundle.usSet = LCID_DEFAULT;
+        switch (M_BRUSHDATA->m_nStyle)
         {
-//
-    // Don't reset cbrush, wxTRANSPARENT is handled by wxBrush::SelectBrush()
-    // this could save (many) time if frequently switching from
-    // wxSOLID to wxTRANSPARENT, because Create... is not always called!!
-    //
-    // NB August 95: now create and select a Null brush instead.
-    // This could be optimized as above.
             case wxTRANSPARENT:
                 M_BRUSHDATA->m_hBrush = NULL;  // Must always select a suitable background brush
-                      // - could choose white always for a quick solution
+                break;                         // - could choose white always for a quick solution
-      break;
+
-//
             case wxBDIAGONAL_HATCH:
-                M_BRUSHDATA->m_hBrush = (WXHBRUSH) CreateHatchBrush(HS_BDIAGONAL,ms_colour) ;
+                M_BRUSHDATA->m_vBundle.usSymbol = PATSYM_DIAG3;
                 break;
 
             case wxCROSSDIAG_HATCH:
-                M_BRUSHDATA->m_hBrush = (WXHBRUSH) CreateHatchBrush(HS_DIAGCROSS,ms_colour) ;
+                M_BRUSHDATA->m_vBundle.usSymbol = PATSYM_DIAGHATCH;
                 break;
 
             case wxFDIAGONAL_HATCH:
-                M_BRUSHDATA->m_hBrush = (WXHBRUSH) CreateHatchBrush(HS_FDIAGONAL,ms_colour) ;
+                M_BRUSHDATA->m_vBundle.usSymbol = PATSYM_DIAG1;
                 break;
 
             case wxCROSS_HATCH:
-                M_BRUSHDATA->m_hBrush = (WXHBRUSH) CreateHatchBrush(HS_CROSS,ms_colour) ;
+                M_BRUSHDATA->m_vBundle.usSymbol = PATSYM_HATCH;
                 break;
 
             case wxHORIZONTAL_HATCH:
-                M_BRUSHDATA->m_hBrush = (WXHBRUSH) CreateHatchBrush(HS_HORIZONTAL,ms_colour) ;
+                M_BRUSHDATA->m_vBundle.usSymbol = PATSYM_HORIZ;
                 break;
 
             case wxVERTICAL_HATCH:
-                M_BRUSHDATA->m_hBrush = (WXHBRUSH) CreateHatchBrush(HS_VERTICAL,ms_colour) ;
+                M_BRUSHDATA->m_vBundle.usSymbol = PATSYM_VERT;
                 break;
 
             case wxSTIPPLE:
-                if (M_BRUSHDATA->m_stipple.Ok())
+                if (M_BRUSHDATA->m_vStipple.Ok())
-                    M_BRUSHDATA->m_hBrush = (WXHBRUSH) CreatePatternBrush((HBITMAP) M_BRUSHDATA->m_stipple.GetHBITMAP()) ;
+                {
+                    ::GpiSetBitmapId( M_BRUSHDATA->m_hBrush
+                                     ,(USHORT)M_BRUSHDATA->m_vStipple.GetHBITMAP()
+                                     ,(USHORT)M_BRUSHDATA->m_vStipple.GetId()
+                                    );
+                    ::GpiSetPatternSet( M_BRUSHDATA->m_hBrush
+                                       ,(USHORT)M_BRUSHDATA->m_vStipple.GetId()
+                                      );
+                }
                 else
-                    M_BRUSHDATA->m_hBrush = (WXHBRUSH) CreateSolidBrush(ms_colour) ;
+                    M_BRUSHDATA->m_vBundle.usSymbol = PATSYM_SOLID;
                 break ;
 
             case wxSOLID:
             default:
-                M_BRUSHDATA->m_hBrush = (WXHBRUSH) CreateSolidBrush(ms_colour) ;
+                M_BRUSHDATA->m_vBundle.usSymbol = PATSYM_SOLID;
                 break;
         }
 #ifdef WXDEBUG_CREATE
         if (M_BRUSHDATA->m_hBrush==NULL) wxError("Cannot create brush","Internal error") ;
 #endif
-        return TRUE;
+        M_BRUSHDATA->m_vBundle.lColor        = vPmColour;
-    }
+        M_BRUSHDATA->m_vBundle.lBackColor    = CLR_DEFAULT;
-    else
+        M_BRUSHDATA->m_vBundle.usMixMode     = FM_OVERPAINT;
-        return FALSE;
+        M_BRUSHDATA->m_vBundle.usBackMixMode = BM_OVERPAINT;
-*/
-    return FALSE;
-}
 
-WXHANDLE wxBrush::GetResourceHandle(void)
+        bOk = ::GpiSetAttrs( M_BRUSHDATA->m_hBrush
+                            ,PRIM_AREA
+                            ,ABB_COLOR | ABB_BACK_COLOR | ABB_MIX_MODE | ABB_BACK_MIX_MODE |
+                             ABB_SET | ABB_SYMBOL
+                            ,ABB_REF_POINT
+                            ,&M_BRUSHDATA->m_vBundle
+                           );
+        if (!bOk)
         {
-  return (WXHANDLE) M_BRUSHDATA->m_hBrush;
+            vError = ::WinGetLastError(vHabmain);
+            sError = wxPMErrorToStr(vError);
+            wxLogError("Can't set Gpi attributes for an AREABUNDLE. Error: %s\n", sError);
         }
+        return bOk;
+    }
+    return FALSE;
+} // end of wxBrush::RealizeResource
 
-bool wxBrush::FreeResource(bool WXUNUSED(force))
+WXHANDLE wxBrush::GetResourceHandle()
+{
+    if (!M_BRUSHDATA)
+        return 0;
+    return (WXHANDLE)M_BRUSHDATA->m_hBrush;
+} // end of wxBrush::GetResourceHandle
+
+bool wxBrush::FreeResource(
+  bool                              WXUNUSED(bForce)
+)
 {
     if (M_BRUSHDATA && (M_BRUSHDATA->m_hBrush != 0))
     {
-// TODO    DeleteObject((HBRUSH) M_BRUSHDATA->m_hBrush);
         M_BRUSHDATA->m_hBrush = 0;
         return TRUE;
     }
     else return FALSE;
-}
+} // end of wxBrush::FreeResource
 
 bool wxBrush::IsFree() const
 {
   return (M_BRUSHDATA && (M_BRUSHDATA->m_hBrush == 0));
-}
+} // end of wxBrush::IsFree
 
 void wxBrush::Unshare()
 {
+    //
     // Don't change shared data
+    //
     if (!m_refData)
     {
         m_refData = new wxBrushRefData();
@@ -197,41 +265,57 @@ void wxBrush::Unshare()
         UnRef();
         m_refData = ref;
     }
-}
+} // end of wxBrush::Unshare
 
-void wxBrush::SetColour(const wxColour& col)
+void wxBrush::SetColour(
+  const wxColour&                   rColour
+)
 {
     Unshare();
-
+    M_BRUSHDATA->m_vColour = rColour;
-    M_BRUSHDATA->m_colour = col;
-
     RealizeResource();
 }
 
-void wxBrush::SetColour(unsigned char r, unsigned char g, unsigned char b)
+void wxBrush::SetColour(
+  unsigned char                     cRed
+, unsigned char                     cGreen
+, unsigned char                     cBlue
+)
 {
     Unshare();
-
+    M_BRUSHDATA->m_vColour.Set( cRed
-    M_BRUSHDATA->m_colour.Set(r, g, b);
+                               ,cGreen
-
+                               ,cBlue
+                              );
     RealizeResource();
-}
+} // end of wxBrush::SetColour
 
-void wxBrush::SetStyle(int Style)
+void wxBrush::SetStyle(
+  int                               nStyle
+)
 {
     Unshare();
-
+    M_BRUSHDATA->m_nStyle = nStyle;
-    M_BRUSHDATA->m_style = Style;
-
     RealizeResource();
-}
+} // end of wxBrush::SetStyle
 
-void wxBrush::SetStipple(const wxBitmap& Stipple)
+void wxBrush::SetStipple(
+  const wxBitmap&                   rStipple
+)
 {
     Unshare();
-
+    M_BRUSHDATA->m_vStipple = rStipple;
-    M_BRUSHDATA->m_stipple = Stipple;
-
     RealizeResource();
-}
+} // end of wxBrush::SetStipple
+
+void wxBrush::SetPS(
+  HPS                               hPS
+)
+{
+    Unshare();
+    if (M_BRUSHDATA->m_hBrush)
+        ::GpiDestroyPS(M_BRUSHDATA->m_hBrush);
+    M_BRUSHDATA->m_hBrush = hPS;
+    RealizeResource();
+} // end of WxWinGdi_CPen::SetPS
 

src/os2/dc.cpp

@@ -1011,15 +1011,43 @@ void wxDC::SetPen(
                 m_hOldPen = m_pen.GetPS();
         }
     }
-
 }
 
 void wxDC::SetBrush(
   const wxBrush&                    rBrush
 )
 {
-   // TODO
+    wxCHECK_RET( Ok(), wxT("invalid window dc") );
+
+    if (m_brush == rBrush)
+        return;
+    m_brush = rBrush;
+    if (!m_brush.Ok())
+        return;
+
+    if (m_hOldBrush)
+        m_hOldBrush = 0L;
+    m_brush = rBrush;
+
+    if (!m_brush.Ok())
+    {
+        if (m_hOldBrush)
+        {
+            m_brush.SetPS((HPS)m_hOldBrush);
         }
+        m_hOldBrush = 0L;
+    }
+
+    if (m_brush.Ok())
+    {
+        if (m_brush.GetResourceHandle())
+        {
+            m_brush.SetPS(m_hPS);
+            if (!m_hOldBrush)
+                m_hOldBrush = m_brush.GetPS();
+        }
+    }
+} // end of wxDC::SetBrush
 
 void wxDC::SetBackground(const wxBrush& brush)
 {

src/os2/dcclient.cpp

@@ -274,36 +274,6 @@ wxPaintDC::wxPaintDC(
         HPS                         hPS;
         HRGN                        hRgn;
 
-        memset(&g_paintStruct, '\0', sizeof(RECTL));
-        if (!::WinQueryUpdateRect(GetWinHwnd(m_pCanvas), &g_paintStruct))
-        {
-             wxLogLastError("CreateRectRgn");
-//             return;
-        }
-        m_hDC = (WXHDC) ::WinOpenWindowDC(GetWinHwnd(m_pCanvas));
-        m_hPS = ::GpiCreatePS( wxGetInstance()
-                              ,m_hDC
-                              ,&vSizl
-                              ,PU_PELS | GPIF_LONG | GPIA_ASSOC
-                             );
-
-        // Set the wxWindows color table
-        ::GpiCreateLogColorTable( m_hPS
-                                 ,0L
-                                 ,LCOLF_CONSECRGB
-                                 ,0L
-                                 ,(LONG)wxTheColourDatabase->m_nSize
-                                 ,(PLONG)wxTheColourDatabase->m_palTable
-                                );
-        ::GpiCreateLogColorTable( m_hPS
-                                 ,0L
-                                 ,LCOLF_RGB
-                                 ,0L
-                                 ,0L
-                                 ,NULL
-                                );
-
-#if 0
         hPS = ::WinBeginPaint( GetWinHwnd(m_pCanvas)
                               ,NULLHANDLE
                               ,&g_paintStruct
@@ -327,7 +297,6 @@ wxPaintDC::wxPaintDC(
                                      ,NULL
                                     );
         }
-#endif
 
         m_bIsPaintTime   = TRUE;
         m_hDC = (WXHDC) -1; // to satisfy those anonizmous efforts