1. fixed bug with MDI child frames changign state when parent frame was

[wxWidgets.git] / include / wx / gdicmn.h

diff --git a/include/wx/gdicmn.h b/include/wx/gdicmn.h
index 564ed2e3fefc9779d8476dbe9b2b845c455a8ae1..f78f14eb95d92e423c9857203bd590ff8e5b4bd9 100644 (file)
--- a/include/wx/gdicmn.h
+++ b/include/wx/gdicmn.h
@@ -26,6 +26,7 @@
 #include "wx/string.h"
 #include "wx/setup.h"
 #include "wx/colour.h"
 #include "wx/string.h"
 #include "wx/setup.h"
 #include "wx/colour.h"

+#include "wx/font.h"

 
 // ---------------------------------------------------------------------------
 // forward declarations
 
 // ---------------------------------------------------------------------------
 // forward declarations


@@ -49,7 +50,8 @@ class WXDLLEXPORT wxString;
 // Bitmap flags
 enum
 {
 // Bitmap flags
 enum
 {

-    wxBITMAP_TYPE_BMP = 1,
+    wxBITMAP_TYPE_INVALID,          // should be == 0 for compatibility!
+    wxBITMAP_TYPE_BMP,

     wxBITMAP_TYPE_BMP_RESOURCE,
     wxBITMAP_TYPE_RESOURCE = wxBITMAP_TYPE_BMP_RESOURCE,
     wxBITMAP_TYPE_ICO,
     wxBITMAP_TYPE_BMP_RESOURCE,
     wxBITMAP_TYPE_RESOURCE = wxBITMAP_TYPE_BMP_RESOURCE,
     wxBITMAP_TYPE_ICO,


@@ -68,6 +70,16 @@ enum
     wxBITMAP_TYPE_PNG_RESOURCE,
     wxBITMAP_TYPE_JPEG,
     wxBITMAP_TYPE_JPEG_RESOURCE,
     wxBITMAP_TYPE_PNG_RESOURCE,
     wxBITMAP_TYPE_JPEG,
     wxBITMAP_TYPE_JPEG_RESOURCE,

+    wxBITMAP_TYPE_PNM,
+    wxBITMAP_TYPE_PNM_RESOURCE,
+    wxBITMAP_TYPE_PCX,
+    wxBITMAP_TYPE_PCX_RESOURCE,
+    wxBITMAP_TYPE_PICT,
+    wxBITMAP_TYPE_PICT_RESOURCE,
+    wxBITMAP_TYPE_ICON,
+    wxBITMAP_TYPE_ICON_RESOURCE,
+    wxBITMAP_TYPE_MACCURSOR,
+    wxBITMAP_TYPE_MACCURSOR_RESOURCE,

     wxBITMAP_TYPE_ANY = 50
 };
 
     wxBITMAP_TYPE_ANY = 50
 };
 


@@ -100,6 +112,9 @@ enum wxStockCursor
     wxCURSOR_WAIT,
     wxCURSOR_WATCH,
     wxCURSOR_BLANK,
     wxCURSOR_WAIT,
     wxCURSOR_WATCH,
     wxCURSOR_BLANK,

+#ifdef __WXGTK__
+    wxCURSOR_DEFAULT, // standard X11 cursor
+#endif

 #ifdef __X__
     // Not yet implemented for Windows
     wxCURSOR_CROSS_REVERSE,
 #ifdef __X__
     // Not yet implemented for Windows
     wxCURSOR_CROSS_REVERSE,


@@ -111,6 +126,10 @@ enum wxStockCursor
     wxCURSOR_MAX
 };
 
     wxCURSOR_MAX
 };
 

+#ifndef __WXGTK__
+    #define wxCURSOR_DEFAULT wxCURSOR_ARROW
+#endif
+

 // ---------------------------------------------------------------------------
 // macros
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 // macros
 // ---------------------------------------------------------------------------


@@ -128,6 +147,9 @@ enum wxStockCursor
 #ifdef __WXMSW__
     // Load from a resource
     #define wxICON(X) wxIcon("" #X "")
 #ifdef __WXMSW__
     // Load from a resource
     #define wxICON(X) wxIcon("" #X "")

+#elif defined(__WXPM__)
+    // Load from a resource
+    #define wxICON(X) wxIcon("" #X "")

 #elif defined(__WXGTK__)
     // Initialize from an included XPM
     #define wxICON(X) wxIcon( (const char**) X##_xpm )
 #elif defined(__WXGTK__)
     // Initialize from an included XPM
     #define wxICON(X) wxIcon( (const char**) X##_xpm )


@@ -139,6 +161,19 @@ enum wxStockCursor
     #define wxICON(X) wxIcon("" #X "")
 #endif // platform
 
     #define wxICON(X) wxIcon("" #X "")
 #endif // platform
 

+/* Another macro: this one is for portable creation of bitmaps. We assume that
+   under Unix bitmaps live in XPMs and under Windows they're in ressources.
+ */
+
+#if defined(__WXMSW__) || defined(__WXPM__)
+    #define wxBITMAP(name) wxBitmap(#name, wxBITMAP_TYPE_RESOURCE)
+#elif defined(__WXGTK__) || defined(__WXMOTIF__)
+    // Initialize from an included XPM
+    #define wxBITMAP(name) wxBitmap( (const char**) name##_xpm )
+#else // other platforms
+    #define wxBITMAP(name) wxBitmap(name##_xpm, wxBITMAP_TYPE_XPM)
+#endif // platform
+

 // ===========================================================================
 // classes
 // ===========================================================================
 // ===========================================================================
 // classes
 // ===========================================================================


@@ -149,31 +184,39 @@ enum wxStockCursor
 class WXDLLEXPORT wxSize
 {
 public:
 class WXDLLEXPORT wxSize
 {
 public:

-    // members are public for compatibility
-    long x;
-    long y;
+    // members are public for compatibility (don't use them directly,
+    // especially that there names were chosen very unfortunately - they should
+    // have been called width and height)
+    int x, y;

 
     // constructors
     wxSize() { x = y = 0; }
 
     // constructors
     wxSize() { x = y = 0; }

-    wxSize(long xx, long yy) { Set(xx, yy); }
+    wxSize(int xx, int yy) { Set(xx, yy); }

 
     // no copy ctor or assignment operator - the defaults are ok
 
     // no copy ctor or assignment operator - the defaults are ok

-

     bool operator==(const wxSize& sz) const { return x == sz.x && y == sz.y; }
 
     // FIXME are these really useful? If they're, we should have += &c as well
     wxSize operator+(const wxSize& sz) { return wxSize(x + sz.x, y + sz.y); }
     wxSize operator-(const wxSize& sz) { return wxSize(x - sz.x, y - sz.y); }
 
     bool operator==(const wxSize& sz) const { return x == sz.x && y == sz.y; }
 
     // FIXME are these really useful? If they're, we should have += &c as well
     wxSize operator+(const wxSize& sz) { return wxSize(x + sz.x, y + sz.y); }
     wxSize operator-(const wxSize& sz) { return wxSize(x - sz.x, y - sz.y); }
 

-    void Set(long xx, long yy) { x = xx; y = yy; }
+    // accessors
+    void Set(int xx, int yy) { x = xx; y = yy; }
+    void SetWidth(int w) { x = w; }
+    void SetHeight(int h) { y = h; }
+
+    int GetWidth() const { return x; }
+    int GetHeight() const { return y; }

 
 

-    long GetX() const { return x; }
-    long GetY() const { return y; }
+    // compatibility
+    int GetX() const { return x; }
+    int GetY() const { return y; }

 };
 
 // ---------------------------------------------------------------------------
 // Point classes: with real or integer coordinates
 // ---------------------------------------------------------------------------
 };
 
 // ---------------------------------------------------------------------------
 // Point classes: with real or integer coordinates
 // ---------------------------------------------------------------------------

+

 class WXDLLEXPORT wxRealPoint
 {
 public:
 class WXDLLEXPORT wxRealPoint
 {
 public:


@@ -192,23 +235,23 @@ public:
 class WXDLLEXPORT wxPoint
 {
 public:
 class WXDLLEXPORT wxPoint
 {
 public:

-#if defined(__WXMSW__) && !defined(__WIN32__)
-    int x;
-    int y;
-#else
-    long x;
-    long y;
-#endif
+    int x, y;

 
     wxPoint() { x = y = 0; };
 
     wxPoint() { x = y = 0; };

-    wxPoint(long xx, long yy) { x = xx; y = yy; };
+    wxPoint(int xx, int yy) { x = xx; y = yy; };

 
     // no copy ctor or assignment operator - the defaults are ok
 
 
     // no copy ctor or assignment operator - the defaults are ok
 

-    bool operator==(const wxPoint& pt) const { return x == pt.x && y == pt.y; }
+    // comparison
+    bool operator==(const wxPoint& p) const { return x == p.x && y == p.y; }
+    bool operator!=(const wxPoint& p) const { return !(*this == p); }

 
 

-    wxPoint operator + (const wxPoint& pt) { return wxPoint(x + pt.x, y + pt.y); }
-    wxPoint operator - (const wxPoint& pt) { return wxPoint(x - pt.x, y - pt.y); }
+    // arithmetic operations (component wise)
+    wxPoint operator+(const wxPoint& p) { return wxPoint(x + p.x, y + p.y); }
+    wxPoint operator-(const wxPoint& p) { return wxPoint(x - p.x, y - p.y); }
+
+    wxPoint& operator+=(const wxPoint& p) { x += p.x; y += p.y; return *this; }
+    wxPoint& operator-=(const wxPoint& p) { x -= p.x; y -= p.y; return *this; }

 };
 
 #if WXWIN_COMPATIBILITY
 };
 
 #if WXWIN_COMPATIBILITY


@@ -224,38 +267,57 @@ class WXDLLEXPORT wxRect
 {
 public:
     wxRect() { x = y = width = height = 0; }
 {
 public:
     wxRect() { x = y = width = height = 0; }

-    wxRect(long xx, long yy, long ww, long hh)
+    wxRect(int xx, int yy, int ww, int hh)

         { x = xx; y = yy; width = ww; height = hh; }
     wxRect(const wxPoint& topLeft, const wxPoint& bottomRight);
     wxRect(const wxPoint& pos, const wxSize& size);
 
     // default copy ctor and assignment operators ok
 
         { x = xx; y = yy; width = ww; height = hh; }
     wxRect(const wxPoint& topLeft, const wxPoint& bottomRight);
     wxRect(const wxPoint& pos, const wxSize& size);
 
     // default copy ctor and assignment operators ok
 

-    long GetX() const { return x; }
-    void SetX(long xx) { x = xx; }
+    int GetX() const { return x; }
+    void SetX(int xx) { x = xx; }
+
+    int GetY() const { return y; }
+    void SetY(int yy) { y = yy; }
+
+    int GetWidth() const { return width; }
+    void SetWidth(int w) { width = w; }
+
+    int GetHeight() const { return height; }
+    void SetHeight(int h) { height = h; }
+
+    wxPoint GetPosition() const { return wxPoint(x, y); }
+    wxSize GetSize() const { return wxSize(width, height); }

 
 

-    long GetY() const { return y; }
-    void SetY(long yy) { y = yy; }
+    int GetLeft()   const { return x; }
+    int GetTop()    const { return y; }
+    int GetBottom() const { return y + height - 1; }
+    int GetRight()  const { return x + width - 1; }

 
 

-    long GetWidth() const { return width; }
-    void SetWidth(long w) { width = w; }
+    void SetLeft(int left) { x = left; }
+    void SetRight(int right) { width = right - x + 1; }
+    void SetTop(int top) { y = top; }
+    void SetBottom(int bottom) { height = bottom - y + 1; }

 
 

-    long GetHeight() const { return height; }
-    void SetHeight(long h) { height = h; }
+    void Inflate(wxCoord dx, wxCoord dy)
+    {
+        x -= dx;
+        y -= dy;
+        width += 2*dx;
+        height += 2*dy;
+    }

 
 

-    wxPoint GetPosition() { return wxPoint(x, y); }
-    wxSize GetSize() { return wxSize(width, height); }
+    void Inflate(wxCoord d) { Inflate(d, d); }

 
 

-    long GetLeft()   const { return x; }
-    long GetTop()    const { return y; }
-    long GetBottom() const { return y + height; }
-    long GetRight()  const { return x + width; }
+    bool operator==(const wxRect& rect) const;
+    bool operator!=(const wxRect& rect) const { return !(*this == rect); }

 
 

-    bool operator == (const wxRect& rect) const;
-    bool operator != (const wxRect& rect) const { return !(*this == rect); }
+    bool Inside(int cx, int cy) const;
+    wxRect operator+(const wxRect& rect) const;
+    wxRect& operator+=(const wxRect& rect);

 
 public:
 
 public:

-    long x, y, width, height;
+    int x, y, width, height;

 };
 
 // ---------------------------------------------------------------------------
 };
 
 // ---------------------------------------------------------------------------


@@ -302,7 +364,8 @@ public:
     void RemoveFont(wxFont *font);
     wxFont *FindOrCreateFont(int pointSize, int family, int style, int weight,
                              bool underline = FALSE,
     void RemoveFont(wxFont *font);
     wxFont *FindOrCreateFont(int pointSize, int family, int style, int weight,
                              bool underline = FALSE,

-                             const wxString& face = wxEmptyString);
+                             const wxString& face = wxEmptyString,
+                             wxFontEncoding encoding = wxFONTENCODING_DEFAULT);

 };
 
 class WXDLLEXPORT wxColourDatabase : public wxList
 };
 
 class WXDLLEXPORT wxColourDatabase : public wxList