]> git.saurik.com Git - wxWidgets.git/blobdiff - include/wx/os2/dc.h
don't draw borders for bitmap buttons with wxBORDER_NONE style
[wxWidgets.git] / include / wx / os2 / dc.h
index 8c0bd11552b56954305e9559106ff69e4a14f6dc..82ead95e433c5a5ef86ca4a6397ae66e6d9cf049 100644 (file)
 /////////////////////////////////////////////////////////////////////////////
 // Name:        dc.h
 // Purpose:     wxDC class
-// Author:      AUTHOR
+// Author:      David Webster
 // Modified by:
-// Created:     ??/??/98
+// Created:     08/26/99
 // RCS-ID:      $Id$
-// Copyright:   (c) AUTHOR
-// Licence:    wxWindows licence
+// Copyright:   (c) David Webster
+// Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef _WX_DC_H_
 #define _WX_DC_H_
 
-#ifdef __GNUG__
-#pragma interface "dc.h"
-#endif
+#include "wx/defs.h"
+#include "wx/dc.h"
 
-#include "wx/window.h"
-#include "wx/pen.h"
-#include "wx/brush.h"
-#include "wx/icon.h"
-#include "wx/font.h"
-#include "wx/gdicmn.h"
-
-//-----------------------------------------------------------------------------
-// constants
-//-----------------------------------------------------------------------------
-
-#ifndef MM_TEXT
-#define MM_TEXT               0
-#define MM_ISOTROPIC          1
-#define MM_ANISOTROPIC        2
-#define MM_LOMETRIC           3
-#define MM_HIMETRIC           4
-#define MM_TWIPS              5
-#define MM_POINTS             6
-#define MM_METRIC             7
-#endif
+// ---------------------------------------------------------------------------
+// macros
+// ---------------------------------------------------------------------------
+
+// Logical to device
+// Absolute
+#define XLOG2DEV(x) (x)
+#define YLOG2DEV(y) (y)
+
+// Relative
+#define XLOG2DEVREL(x) (x)
+#define YLOG2DEVREL(y) (y)
+
+// Device to logical
+// Absolute
+#define XDEV2LOG(x) (x)
+
+#define YDEV2LOG(y) (y)
+
+// Relative
+#define XDEV2LOGREL(x) (x)
+#define YDEV2LOGREL(y) (y)
+
+/*
+ * Have the same macros as for XView but not for every operation:
+ * just for calculating window/viewport extent (a better way of scaling).
+ */
+
+// Logical to device
+// Absolute
+#define MS_XLOG2DEV(x) LogicalToDevice(x)
 
-//-----------------------------------------------------------------------------
-// global variables
-//-----------------------------------------------------------------------------
+#define MS_YLOG2DEV(y) LogicalToDevice(y)
 
-extern int wxPageNumber;
+// Relative
+#define MS_XLOG2DEVREL(x) LogicalToDeviceXRel(x)
+#define MS_YLOG2DEVREL(y) LogicalToDeviceYRel(y)
 
-//-----------------------------------------------------------------------------
-// wxDC
-//-----------------------------------------------------------------------------
+// Device to logical
+// Absolute
+#define MS_XDEV2LOG(x) DeviceToLogicalX(x)
 
-class WXDLLEXPORT wxDC: public wxDCBase
+#define MS_YDEV2LOG(y) DeviceToLogicalY(y)
+
+// Relative
+#define MS_XDEV2LOGREL(x) DeviceToLogicalXRel(x)
+#define MS_YDEV2LOGREL(y) DeviceToLogicalYRel(y)
+
+#define YSCALE(y) (yorigin - (y))
+
+#define     wx_round(a)    (int)((a)+.5)
+
+#if wxUSE_DC_CACHEING
+/*
+ * Cached blitting, maintaining a cache
+ * of bitmaps required for transparent blitting
+ * instead of constant creation/deletion
+ */
+
+class wxDCCacheEntry : public wxObject
 {
-  DECLARE_ABSTRACT_CLASS(wxDC)
-
-  public:
-
-    wxDC(void);
-    ~wxDC(void);
-
-    virtual void BeginDrawing(void) { };
-    virtual void EndDrawing(void) { };
-
-//-----------------------------------------------------------------------------
-// Pure virtuals from wxDCBase that need defining
-//-----------------------------------------------------------------------------
-    virtual bool   CanDrawBitmap(void) const { return TRUE; };
-    virtual bool   CanGetTextExtent(void) const { return TRUE; };
-    virtual int    GetDepth(void) const;
-    virtual wxSize GetPPI(void) const;
-    virtual void   GetTextExtent( const wxString& string
-                                 ,long*           width
-                                 ,long*           height
-                                 ,long*           descent = NULL
-                                 ,long*           externalLeading = NULL
-                                 ,wxFont*         theFont = NULL
-                                ) const;
-    virtual long   GetCharWidth(void) const;
-    virtual long   GetCharHeight(void) const;
-    virtual void   Clear(void);
-    virtual void   SetFont(const wxFont& font);
-    virtual void   SetPen(const wxPen& pen);
-    virtual void   SetBrush(const wxBrush& brush);
-    virtual void   SetBackground(const wxBrush& brush);
-    virtual void   SetLogicalFunction(int function);
-    virtual void   SetBackgroundMode(int mode);
-    virtual void   SetPalette(const wxPalette& palette);
-    virtual void   SetMapMode(int mode);
-    virtual void   DestroyClippingRegion(void);
-    virtual void   SetUserScale(double x, double y);
-    virtual void   SetLogicalOrigin(long x, long y);
-    virtual void   SetDeviceOrigin(long x, long y);
-    virtual void   SetAxisOrientation(bool xLeftRight, bool yBottomUp);
-
-    virtual void   DoFloodFill( long x
-                               ,long y
-                               ,const wxColour& col
-                               ,int style = wxFLOOD_SURFACE
-                              );
-    virtual bool   DoGetPixel(long x, long y, wxColour *col) const;
-    virtual void   DoDrawPoint(long x, long y);
-    virtual void   DoDrawLine(long x1, long y1, long x2, long y2);
-    virtual void   DoDrawArc(long x1, long y1,
-                             long x2, long y2,
-                             long xc, long yc
-                            );
-    virtual void   DoDrawEllipticArc( long x, long y
-                                     ,long w, long h
-                                     ,double sa, double ea
-                                    );
-    virtual void   DoDrawRectangle(long x, long y, long width, long height);
-    virtual void   DoDrawRoundedRectangle( long x, long y
-                                          ,long width, long height
-                                          ,double radius
-                                         );
-    virtual void   DoDrawEllipse(long x, long y, long width, long height);
-    virtual void   DoCrossHair(long x, long y);
-    virtual void   DoDrawIcon(const wxIcon& icon, long x, long y);
-    virtual void   DoDrawBitmap( const wxBitmap &bmp
-                                ,long x, long y
-                                ,bool useMask = FALSE
-                               );
-    virtual void   DoDrawText(const wxString& text, long x, long y);
-    virtual bool   DoBlit( long xdest, long ydest
-                          ,long width, long height
-                          ,wxDC *source
-                          ,long xsrc, long ysrc
-                          ,int rop = wxCOPY, bool useMask = FALSE
-                         );
-    virtual void   DoGetSize(int *width, int *height) const;
-    virtual void   DoGetSizeMM(int* width, int* height) const;
-    virtual void   DoDrawLines( int n, wxPoint points[]
-                               ,long xoffset, long yoffset
-                              );
-    virtual void   DoDrawPolygon( int n, wxPoint points[]
-                                 ,long xoffset, long yoffset
-                                 ,int fillStyle = wxODDEVEN_RULE
-                                );
-    virtual void   DoSetClippingRegionAsRegion(const wxRegion& region);
-    virtual void   DoSetClippingRegion( long x, long y
-                                       ,long width, long height
-                                      );
-#if wxUSE_SPLINES
-    virtual void DoDrawSpline(wxList *points);
+public:
+    wxDCCacheEntry( WXHBITMAP hBitmap
+                   ,int       nWidth
+                   ,int       nHeight
+                   ,int       nDepth
+                  );
+    wxDCCacheEntry( HPS   hPS
+                   ,int   nDepth
+                  );
+    virtual ~wxDCCacheEntry();
+
+    WXHBITMAP                       m_hBitmap;
+    HPS                             m_hPS;
+    int                             m_nWidth;
+    int                             m_nHeight;
+    int                             m_nDepth;
+}; // end of CLASS wxDCCacheEntry
 #endif
 
-//-----------------------------------------------------------------------------
-// Other virtuals from wxDCBase that are overridden here
-//-----------------------------------------------------------------------------
+// this is an ABC: use one of the derived classes to create a DC associated
+// with a window, screen, printer and so on
+class WXDLLIMPEXP_CORE wxPMDCImpl : public wxDCImpl
+{
+    DECLARE_DYNAMIC_CLASS(wxDC)
+
+public:
+    wxPMDCImpl(wxDC *owner, WXHDC hDC);
+    virtual ~wxPMDCImpl();
+
+    // implement base class pure virtuals
+    // ----------------------------------
+
+    virtual void Clear();
+
+    virtual bool    StartDoc(const wxString& rsMessage);
+    virtual void    EndDoc();
+
+    virtual void    StartPage();
+    virtual void    EndPage();
 
-    virtual void SetLogicalScale( double x, double y );
+    virtual void    SetFont(const wxFont& rFont);
+    virtual void    SetPen(const wxPen& rPen);
+    virtual void    SetBrush(const wxBrush& rBrush);
+    virtual void    SetBackground(const wxBrush& rBrush);
+    virtual void    SetBackgroundMode(int nMode);
+    virtual void    SetPalette(const wxPalette& rPalette);
 
-//-----------------------------------------------------------------------------
-// Our own new stuff
-//-----------------------------------------------------------------------------
-    virtual void SetInternalDeviceOrigin( long x, long y );
-    virtual void GetInternalDeviceOrigin( long *x, long *y );
+    virtual void    DestroyClippingRegion();
 
-    virtual void SetRop(WXHDC cdc);
-    virtual void DoClipping(WXHDC cdc);
-    virtual void SelectOldObjects(WXHDC dc);
+    virtual wxCoord GetCharHeight() const;
+    virtual wxCoord GetCharWidth() const;
 
-    wxWindow *GetWindow() const { return m_canvas; }
-    void SetWindow(wxWindow *win) { m_canvas = win; }
+    virtual bool    CanDrawBitmap() const;
+    virtual bool    CanGetTextExtent() const;
+    virtual int     GetDepth() const;
+    virtual wxSize  GetPPI() const;
 
-    WXHDC GetHDC() const { return m_hDC; }
-    void SetHDC(WXHDC dc, bool bOwnsDC = FALSE)
+    virtual void    SetMapMode(wxMappingMode nMode);
+    virtual void    SetUserScale( double dX
+                                 ,double dY
+                                );
+    virtual void    SetLogicalScale( double dX
+                                    ,double dY
+                                   );
+    virtual void    SetLogicalOrigin( wxCoord vX
+                                     ,wxCoord vY
+                                    );
+    virtual void    SetDeviceOrigin( wxCoord vX
+                                    ,wxCoord vY
+                                   );
+    virtual void    SetAxisOrientation( bool bXLeftRight
+                                       ,bool bYBottomUp
+                                      );
+    virtual void    SetLogicalFunction(wxRasterOperationMode nFunction);
+
+    // implementation from now on
+    // --------------------------
+
+    virtual void    SetRop(WXHDC hCdc);
+    virtual void    SelectOldObjects(WXHDC hDc);
+
+    wxWindow*       GetWindow() const { return m_pCanvas; }
+    void            SetWindow(wxWindow* pWin) { m_pCanvas = pWin; }
+
+    WXHDC           GetHDC() const { return m_hDC; }
+    void            SetHDC( WXHDC hDc
+                           ,bool  bOwnsDC = FALSE
+                          )
     {
-        m_hDC = dc;
+        m_hDC = hDc;
         m_bOwnsDC = bOwnsDC;
     }
 
-private:
-
-#if WXWIN_COMPATIBILITY
-    // function hiding warning supression
-    virtual void   GetTextExtent( const wxString& string
-                                 ,long*           width
-                                 ,long*           height
-                                 ,long*           descent = NULL
-                                 ,long*           externalLeading = NULL
-                                 ,wxFont*         theFont = NULL
-                                 ,bool            use16 = FALSE
-                                ) const
-    { wxDCBase::GetTextExtent(string, width, height, descent, externalLeading, theFont, use16); };
+    HPS             GetHPS() const { return m_hPS; }
+    void            SetHPS(HPS hPS)
+    {
+        m_hPS = hPS;
+    }
+    const wxBitmap& GetSelectedBitmap() const { return m_vSelectedBitmap; }
+    wxBitmap&       GetSelectedBitmap() { return m_vSelectedBitmap; }
+
+    void            UpdateClipBox();
+
+#if wxUSE_DC_CACHEING
+    static wxDCCacheEntry* FindBitmapInCache( HPS hPS
+                                             ,int nWidth
+                                             ,int nHeight
+                                            );
+    static wxDCCacheEntry* FindDCInCache( wxDCCacheEntry* pNotThis
+                                         ,HPS             hPS
+                                        );
+
+    static void AddToBitmapCache(wxDCCacheEntry* pEntry);
+    static void AddToDCCache(wxDCCacheEntry* pEntry);
+    static void ClearCache();
 #endif
 
 protected:
+    void Init()
+    {
+        m_pCanvas      = NULL;
+        m_hOldBitmap   = 0;
+        m_hOldPen      = 0;
+        m_hOldBrush    = 0;
+        m_hOldFont     = 0;
+#if wxUSE_PALETTE
+        m_hOldPalette  = 0;
+#endif // wxUSE_PALETTE
+
+        m_bOwnsDC      = false;
+        m_hDC          = 0;
+        m_hOldPS       = NULL;
+        m_hPS          = NULL;
+        m_bIsPaintTime = false; // True at Paint Time
+
+        m_pen.SetColour(*wxBLACK);
+        m_brush.SetColour(*wxWHITE);
+    }
+
+    // create an uninitialized DC: this should be only used by the derived
+    // classes
+    wxPMDCImpl( wxDC *owner ) : wxDCImpl( owner ) { Init(); }
+
+public:
+    virtual void    DoGetTextExtent( const wxString& rsString
+                                    ,wxCoord*        pX
+                                    ,wxCoord*        pY
+                                    ,wxCoord*        pDescent = NULL
+                                    ,wxCoord*        pExternalLeading = NULL
+                                    ,const wxFont*   pTheFont = NULL
+                                   ) const;
+    virtual bool DoFloodFill( wxCoord          vX
+                             ,wxCoord          vY
+                             ,const wxColour&  rCol
+                             ,wxFloodFillStyle nStyle = wxFLOOD_SURFACE
+                            );
+
+    virtual bool DoGetPixel( wxCoord   vX
+                            ,wxCoord   vY
+                            ,wxColour* pCol
+                           ) const;
 
-    // ------------------------------------------------------------------------
-    // Some additional data we need
-    // ------------------------------------------------------------------------
+    virtual void DoDrawPoint( wxCoord vX
+                             ,wxCoord vY
+                            );
+    virtual void DoDrawLine( wxCoord vX1
+                            ,wxCoord vY1
+                            ,wxCoord vX2
+                            ,wxCoord vY2
+                           );
+
+    virtual void DoDrawArc( wxCoord vX1
+                           ,wxCoord vY1
+                           ,wxCoord vX2
+                           ,wxCoord vY2
+                           ,wxCoord vXc
+                           ,wxCoord vYc
+                          );
+    virtual void DoDrawCheckMark( wxCoord vX
+                                 ,wxCoord vY
+                                 ,wxCoord vWidth
+                                 ,wxCoord vHeight
+                                );
+    virtual void DoDrawEllipticArc( wxCoord vX
+                                   ,wxCoord vY
+                                   ,wxCoord vW
+                                   ,wxCoord vH
+                                   ,double  dSa
+                                   ,double  dEa
+                                  );
 
-    // Owner canvas and selected in bitmap (if bitmap is GDI object selected)
-    wxWindow*         m_canvas;
-    wxBitmap          m_selectedBitmap;
+    virtual void DoDrawRectangle( wxCoord vX
+                                 ,wxCoord vY
+                                 ,wxCoord vWidth
+                                 ,wxCoord vHeight
+                                );
+    virtual void DoDrawRoundedRectangle( wxCoord vX
+                                        ,wxCoord vY
+                                        ,wxCoord vWidth
+                                        ,wxCoord vHeight
+                                        ,double  dRadius
+                                       );
+    virtual void DoDrawEllipse( wxCoord vX
+                               ,wxCoord vY
+                               ,wxCoord vWidth
+                               ,wxCoord vHeight
+                              );
+
+    virtual void DoCrossHair( wxCoord vX
+                             ,wxCoord vY
+                            );
 
-    // our HDC and its usage count: we only free it when the usage count drops
-    // to 0
-    WXHDC             m_hDC;
-    int               m_hDCCount;
-    bool              m_bOwnsDC:1;
+    virtual void DoDrawIcon( const wxIcon& rIcon
+                            ,wxCoord       vX
+                            ,wxCoord       vY
+                           );
+    virtual void DoDrawBitmap( const wxBitmap& rBmp
+                              ,wxCoord         vX
+                              ,wxCoord         vY
+                              ,bool            bUseMask = FALSE
+                             );
 
+    virtual void DoDrawText( const wxString& rsText
+                            ,wxCoord         vX
+                            ,wxCoord         vY
+                           );
+    virtual void DoDrawRotatedText( const wxString& rsText
+                                   ,wxCoord         vX
+                                   ,wxCoord         vY
+                                   ,double          dAngle
+                                  );
+
+    virtual bool DoBlit( wxCoord vXdest
+                        ,wxCoord vYdest
+                        ,wxCoord vWidth
+                        ,wxCoord vHeight
+                        ,wxDC*   pSource
+                        ,wxCoord vXsrc
+                        ,wxCoord vYsrc
+                        ,wxRasterOperationMode     nRop = wxCOPY
+                        ,bool    bUseMask = FALSE
+                        ,wxCoord vXsrcMask = -1
+                        ,wxCoord vYsrcMask = -1
+                       );
+
+    virtual void DoSetClippingRegion( wxCoord vX
+                                     ,wxCoord vY
+                                     ,wxCoord vWidth
+                                     ,wxCoord vHeight
+                                    );
+    virtual void DoSetDeviceClippingRegion(const wxRegion& rRegion);
+
+    virtual void DoGetSize( int* pWidth
+                           ,int* pHeight
+                          ) const;
+    virtual void DoGetSizeMM( int* pWidth
+                             ,int* pHeight
+                            ) const;
+
+    virtual void DoDrawLines( int     n
+                             ,wxPoint vaPoints[]
+                             ,wxCoord vXoffset
+                             ,wxCoord yYoffset
+                            );
+    virtual void DoDrawPolygon( int     n
+                               ,wxPoint vaPoints[]
+                               ,wxCoord vXoffset
+                               ,wxCoord vYoffset
+                               ,wxPolygonFillMode     nFillStyle = wxODDEVEN_RULE
+                              );
+
+#if wxUSE_PALETTE
+    void DoSelectPalette(bool bRealize = FALSE);
+    void InitializePalette();
+#endif // wxUSE_PALETTE
+
+protected:
+    //
+    // common part of DoDrawText() and DoDrawRotatedText()
+    //
+    void DrawAnyText( const wxString& rsText
+                     ,wxCoord         vX
+                     ,wxCoord         vY
+                    );
+
+    // OS2-specific member variables ?? do we even need this under OS/2?
+    int                             m_nWindowExtX;
+    int                             m_nWindowExtY;
+
+    //
+    // the window associated with this DC (may be NULL)
+    //
+    wxWindow*                       m_pCanvas;
+    wxBitmap                        m_vSelectedBitmap;
+
+public:
+    // PM specific stuff
+    HPS                             m_hPS;
+    HPS                             m_hOldPS;   // old hPS, if any
+    bool                            m_bIsPaintTime;// True at Paint Time
+
+    RECTL                           m_vRclPaint; // Bounding rectangle at Paint time etc.
+    //
+    // TRUE => DeleteDC() in dtor, FALSE => only ReleaseDC() it
+    //
+    bool                            m_bOwnsDC:1;
+
+    //
+    // our HDC
+    //
+    WXHDC                           m_hDC;
+
+    //
     // Store all old GDI objects when do a SelectObject, so we can select them
     // back in (this unselecting user's objects) so we can safely delete the
     // DC.
-    WXHBITMAP         m_oldBitmap;
-    WXHPEN            m_oldPen;
-    WXHBRUSH          m_oldBrush;
-    WXHFONT           m_oldFont;
-    WXHPALETTE        m_oldPalette;
-};
+    //
+    WXHBITMAP                       m_hOldBitmap;
+    WXHPEN                          m_hOldPen;
+    WXHBRUSH                        m_hOldBrush;
+    WXHFONT                         m_hOldFont;
+    WXHPALETTE                      m_hOldPalette;
 
+#if wxUSE_DC_CACHEING
+    static wxList                   m_svBitmapCache;
+    static wxList                   m_svDCCache;
+#endif
+}; // end of CLASS wxDC
 #endif
     // _WX_DC_H_