Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

more Motif fixes (still doesn't compile, but *really* close :-)

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@2716 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
1999-06-08 19:10:37 +00:00
parent ced859c3dc
commit af0bb3b161
15 changed files with 1195 additions and 1770 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
include/wx/dc.h
View File

@@ -65,7 +65,7 @@ public:
m_mappingMode = wxMM_TEXT;
m_backgroundBrush = *wxWHITE_BRUSH;
m_backgroundBrush = *wxTRANSPARENT_BRUSH;
m_textForegroundColour = *wxBLACK;
m_textBackgroundColour = *wxWHITE;
@@ -201,11 +201,11 @@ public:
virtual void Clear() = 0;
virtual bool StartDoc(const wxString& message) = 0;
virtual void EndDoc() = 0;
virtual bool StartDoc(const wxString& WXUNUSED(message)) { return TRUE; }
virtual void EndDoc() { }
virtual void StartPage() = 0;
virtual void EndPage() = 0;
virtual void StartPage() { }
virtual void EndPage() { }
// set objects to use for drawing
// ------------------------------

16
include/wx/generic/dcpsg.h
View File

@@ -22,8 +22,8 @@
#include "wx/dialog.h"
#include "wx/module.h"
#include "wx/cmndata.h"
#include <fstream.h>
#include <fstream.h>
//-----------------------------------------------------------------------------
// classes
@@ -125,12 +125,12 @@ public:
inline void SetBackgroundMode(int WXUNUSED(mode)) {}
inline void SetPalette(const wxPalette& WXUNUSED(palette)) {}
inline ofstream *GetStream(void) const { return m_pstream; }
ofstream *GetStream(void) const { return m_pstream; }
inline wxPrintData& GetPrintData() { return m_printData; }
inline void SetPrintData(const wxPrintData& data) { m_printData = data; }
wxPrintData& GetPrintData() { return m_printData; }
void SetPrintData(const wxPrintData& data) { m_printData = data; }
int GetDepth() const { return 24; }
virtual int GetDepth() const { return 24; }
protected:
@@ -170,13 +170,15 @@ public:
#endif
// Print Orientation (Should also add Left, Right)
enum {
enum
{
PS_PORTRAIT = 1,
PS_LANDSCAPE = 2
};// ps_orientation = PS_PORTRAIT;
// Print Actions
enum {
enum
{
PS_NONE,
PS_PREVIEW,
PS_FILE,

78
include/wx/generic/notebook.h
View File

@@ -35,30 +35,6 @@ class WXDLLEXPORT wxWindow;
typedef wxWindow wxNotebookPage; // so far, any window can be a page
WX_DEFINE_ARRAY(wxNotebookPage *, wxArrayPages);
// ----------------------------------------------------------------------------
// notebook events
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxNotebookEvent : public wxCommandEvent
{
public:
wxNotebookEvent(wxEventType commandType = wxEVT_NULL, int id = 0,
int nSel = -1, int nOldSel = -1)
: wxCommandEvent(commandType, id) { m_nSel = nSel; m_nOldSel = nOldSel; }
// accessors
int GetSelection() const { return m_nSel; }
int GetOldSelection() const { return m_nOldSel; }
void SetSelection(int sel) { m_nSel = sel; }
void SetOldSelection(int oldSel) { m_nOldSel = oldSel; }
private:
int m_nSel, // currently selected page
m_nOldSel; // previously selected page
DECLARE_DYNAMIC_CLASS(wxNotebookEvent)
};
// ----------------------------------------------------------------------------
// wxNotebook
// ----------------------------------------------------------------------------
@@ -191,11 +167,11 @@ public:
virtual void SetConstraintSizes(bool recurse = TRUE);
virtual bool DoPhase(int nPhase);
// Implementation
// Implementation
// wxNotebook on Motif uses a generic wxTabView to implement itself.
inline wxTabView *GetTabView() const { return m_tabView; }
inline void SetTabView(wxTabView *v) { m_tabView = v; }
wxTabView *GetTabView() const { return m_tabView; }
void SetTabView(wxTabView *v) { m_tabView = v; }
void OnMouseEvent(wxMouseEvent& event);
void OnPaint(wxPaintEvent& event);
@@ -224,52 +200,4 @@ protected:
DECLARE_EVENT_TABLE()
};
// ----------------------------------------------------------------------------
// event macros
// ----------------------------------------------------------------------------
typedef void (wxEvtHandler::*wxNotebookEventFunction)(wxNotebookEvent&);
// Because of name truncation!
#if defined(__BORLANDC__) && defined(__WIN16__)
#define EVT_NOTEBOOK_PAGE_CHANGED(id, fn) \
{ \
wxEVT_COMMAND_NB_PAGE_CHANGED, \
id, \
-1, \
(wxObjectEventFunction)(wxEventFunction)(wxNotebookEventFunction) &fn, \
NULL \
},
#define EVT_NOTEBOOK_PAGE_CHANGING(id, fn) \
{ \
wxEVT_COMMAND_NB_PAGE_CHANGING, \ \
id, \
-1, \
(wxObjectEventFunction)(wxEventFunction)(wxNotebookEventFunction) &fn, \
NULL \
},
#else
#define EVT_NOTEBOOK_PAGE_CHANGED(id, fn) \
{ \
wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED, \
id, \
-1, \
(wxObjectEventFunction)(wxEventFunction)(wxNotebookEventFunction) &fn, \
NULL \
},
#define EVT_NOTEBOOK_PAGE_CHANGING(id, fn) \
{ \
wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING, \ \
id, \
-1, \
(wxObjectEventFunction)(wxEventFunction)(wxNotebookEventFunction) &fn, \
NULL \
},
#endif
#endif // _WX_NOTEBOOK_H_

4
include/wx/motif/cursor.h
View File

@@ -68,8 +68,8 @@ public:
virtual bool Ok() const { return ((m_refData != NULL) && M_CURSORDATA->m_ok); }
inline wxCursor& operator = (const wxCursor& cursor) { if (*this == cursor) return (*this); Ref(cursor); return *this; }
inline bool operator == (const wxCursor& cursor) { return m_refData == cursor.m_refData; }
inline bool operator != (const wxCursor& cursor) { return m_refData != cursor.m_refData; }
inline bool operator == (const wxCursor& cursor) const { return m_refData == cursor.m_refData; }
inline bool operator != (const wxCursor& cursor) const { return m_refData != cursor.m_refData; }
// Motif-specific.
// Create/get a cursor for the current display

310
include/wx/motif/dc.h
View File

@@ -13,7 +13,7 @@
#define _WX_DC_H_
#ifdef __GNUG__
#pragma interface "dc.h"
#pragma interface "dc.h"
#endif
#include "wx/pen.h"
@@ -27,239 +27,56 @@
//-----------------------------------------------------------------------------
#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
#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
//-----------------------------------------------------------------------------
// global variables
//-----------------------------------------------------------------------------
extern int wxPageNumber;
//-----------------------------------------------------------------------------
// wxDC
//-----------------------------------------------------------------------------
class WXDLLEXPORT wxDC: public wxObject
class WXDLLEXPORT wxDC : public wxDCBase
{
DECLARE_ABSTRACT_CLASS(wxDC)
DECLARE_DYNAMIC_CLASS(wxDC)
public:
public:
wxDC();
~wxDC() { }
wxDC(void);
~wxDC(void);
// implement base class pure virtuals
// ----------------------------------
void BeginDrawing(void) {};
void EndDrawing(void) {};
virtual void DestroyClippingRegion();
virtual bool Ok(void) const { return m_ok; };
virtual wxSize GetPPI() const;
virtual void FloodFill( long x1, long y1, const wxColour& col, int style=wxFLOOD_SURFACE ) = 0;
inline void FloodFill(const wxPoint& pt, const wxColour& col, int style=wxFLOOD_SURFACE)
{
FloodFill(pt.x, pt.y, col, style);
}
virtual void SetMapMode(int mode);
virtual void SetUserScale(double x, double y);
virtual void SetSystemScale(double x, double y);
virtual void SetLogicalScale(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 SetLogicalFunction(int function);
virtual bool GetPixel( long x1, long y1, wxColour *col ) const = 0;
inline bool GetPixel(const wxPoint& pt, wxColour *col) const
{
return GetPixel(pt.x, pt.y, col);
}
protected:
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 DrawLine( long x1, long y1, long x2, long y2 ) = 0;
inline void DrawLine(const wxPoint& pt1, const wxPoint& pt2)
{
DrawLine(pt1.x, pt1.y, pt2.x, pt2.y);
}
virtual void DoSetClippingRegion(long x, long y,
long width, long height);
virtual void DoGetSize(int *width, int *height) const;
virtual void DoGetSizeMM(int* width, int* height) const;
virtual void CrossHair( long x, long y ) = 0;
inline void CrossHair(const wxPoint& pt)
{
CrossHair(pt.x, pt.y);
}
virtual void DrawArc( long x1, long y1, long x2, long y2, long xc, long yc ) = 0;
inline void DrawArc(const wxPoint& pt1, const wxPoint& pt2, const wxPoint& centre)
{
DrawArc(pt1.x, pt1.y, pt2.x, pt2.y, centre.x, centre.y);
}
virtual void DrawEllipticArc( long x, long y, long width, long height, double sa, double ea ) = 0;
virtual void DrawEllipticArc (const wxPoint& pt, const wxSize& sz, double sa, double ea)
{
DrawEllipticArc(pt.x, pt.y, sz.x, sz.y, sa, ea);
}
virtual void DrawPoint( long x, long y ) = 0;
virtual void DrawPoint( wxPoint& point );
virtual void DrawLines( int n, wxPoint points[], long xoffset = 0, long yoffset = 0 ) = 0;
virtual void DrawLines( wxList *points, long xoffset = 0, long yoffset = 0 );
virtual void DrawPolygon( int n, wxPoint points[], long xoffset = 0, long yoffset = 0,
int fillStyle=wxODDEVEN_RULE ) = 0;
virtual void DrawPolygon( wxList *lines, long xoffset = 0, long yoffset = 0,
int fillStyle=wxODDEVEN_RULE );
virtual void DrawRectangle( long x, long y, long width, long height ) = 0;
inline void DrawRectangle(const wxPoint& pt, const wxSize& sz)
{
DrawRectangle(pt.x, pt.y, sz.x, sz.y);
}
inline void DrawRectangle(const wxRect& rect)
{
DrawRectangle(rect.x, rect.y, rect.width, rect.height);
}
virtual void DrawRoundedRectangle( long x, long y, long width, long height, double radius = 20.0 ) = 0;
inline void DrawRoundedRectangle(const wxPoint& pt, const wxSize& sz, double radius = 20.0)
{
DrawRoundedRectangle(pt.x, pt.y, sz.x, sz.y, radius);
}
inline void DrawRoundedRectangle(const wxRect& rect, double radius = 20.0)
{
DrawRoundedRectangle(rect.x, rect.y, rect.width, rect.height, radius);
}
virtual void DrawEllipse( long x, long y, long width, long height ) = 0;
inline void DrawEllipse(const wxPoint& pt, const wxSize& sz)
{
DrawEllipse(pt.x, pt.y, sz.x, sz.y);
}
inline void DrawEllipse(const wxRect& rect)
{
DrawEllipse(rect.x, rect.y, rect.width, rect.height);
}
virtual void DrawSpline( long x1, long y1, long x2, long y2, long x3, long y3 );
virtual void DrawSpline( wxList *points ) = 0;
virtual void DrawSpline( int n, wxPoint points[] );
virtual bool CanDrawBitmap(void) const = 0;
virtual void DrawIcon( const wxIcon &icon, long x, long y);
inline void DrawIcon(const wxIcon& icon, const wxPoint& pt)
{
DrawIcon(icon, pt.x, pt.y);
}
// DrawBitmap is not always the same as DrawIcon, especially if bitmaps and
// icons are implemented differently.
virtual void DrawBitmap( const wxBitmap &bmp, long x, long y, bool useMask=FALSE ) ;
virtual bool Blit( long xdest, long ydest, long width, long height,
wxDC *source, long xsrc, long ysrc, int logical_func = wxCOPY, bool useMask=FALSE ) = 0;
inline bool Blit(const wxPoint& destPt, const wxSize& sz,
wxDC *source, const wxPoint& srcPt, int rop = wxCOPY, bool useMask = FALSE)
{
return Blit(destPt.x, destPt.y, sz.x, sz.y, source, srcPt.x, srcPt.y, rop, useMask);
}
virtual void DrawText( const wxString &text, long x, long y, bool use16 = FALSE ) = 0;
inline void DrawText(const wxString& text, const wxPoint& pt, bool use16bit = FALSE)
{
DrawText(text, pt.x, pt.y, use16bit);
}
virtual bool CanGetTextExtent(void) const = 0;
virtual void GetTextExtent( const wxString &string, long *width, long *height,
long *descent = NULL, long *externalLeading = NULL,
wxFont *theFont = NULL, bool use16 = FALSE ) = 0;
virtual long GetCharWidth(void) = 0;
virtual long GetCharHeight(void) = 0;
virtual void Clear(void) = 0;
virtual void SetFont( const wxFont &font ) = 0;
virtual wxFont& GetFont(void) const { return (wxFont&) m_font; };
virtual void SetPen( const wxPen &pen ) = 0;
virtual wxPen& GetPen(void) const { return (wxPen&) m_pen; };
virtual void SetBrush( const wxBrush &brush ) = 0;
virtual wxBrush& GetBrush(void) const { return (wxBrush&) m_brush; };
virtual void SetBackground( const wxBrush &brush ) = 0;
virtual wxBrush& GetBackground(void) const { return (wxBrush&) m_backgroundBrush; };
virtual void SetLogicalFunction( int function ) = 0;
virtual int GetLogicalFunction(void) const { return m_logicalFunction; };
virtual void SetTextForeground( const wxColour &col );
virtual void SetTextBackground( const wxColour &col );
virtual wxColour& GetTextBackground(void) const { return (wxColour&)m_textBackgroundColour; };
virtual wxColour& GetTextForeground(void) const { return (wxColour&)m_textForegroundColour; };
virtual void SetBackgroundMode( int mode ) = 0;
virtual int GetBackgroundMode(void) const { return m_backgroundMode; };
virtual void SetPalette( const wxPalette& palette ) = 0;
void SetColourMap( const wxPalette& palette ) { SetPalette(palette); };
// the first two must be overridden and called
virtual void SetClippingRegion( long x, long y, long width, long height );
virtual void DestroyClippingRegion(void);
virtual void GetClippingBox( long *x, long *y, long *width, long *height ) const;
virtual inline long MinX(void) const { return m_minX; }
virtual inline long MaxX(void) const { return m_maxX; }
virtual inline long MinY(void) const { return m_minY; }
virtual inline long MaxY(void) const { return m_maxY; }
// Size in device units
virtual void GetSize( int* width, int* height ) const;
inline wxSize GetSize(void) const { int w, h; GetSize(&w, &h); return wxSize(w, h); }
// Size in millimetres
virtual void GetSizeMM( int* width, int* height ) const;
inline wxSize GetSizeMM(void) const { int w, h; GetSizeMM(&w, &h); return wxSize(w, h); }
// Resolution in pixels per logical inch
wxSize GetPPI(void) const ;
virtual bool StartDoc( const wxString& WXUNUSED(message) ) { return TRUE; };
virtual void EndDoc(void) {};
virtual void StartPage(void) {};
virtual void EndPage(void) {};
virtual void SetMapMode( int mode );
virtual int GetMapMode(void) const { return m_mappingMode; };
virtual void SetUserScale( double x, double y );
virtual void GetUserScale( double *x, double *y );
virtual void SetLogicalScale( double x, double y );
virtual void GetLogicalScale( double *x, double *y );
virtual void SetLogicalOrigin( long x, long y );
virtual void GetLogicalOrigin( long *x, long *y );
virtual void SetDeviceOrigin( long x, long y );
virtual void GetDeviceOrigin( long *x, long *y );
virtual void SetInternalDeviceOrigin( long x, long y );
virtual void GetInternalDeviceOrigin( long *x, long *y );
virtual void SetAxisOrientation( bool xLeftRight, bool yBottomUp );
virtual void SetOptimization( bool optimize ) { m_optimize = optimize; };
virtual bool GetOptimization(void) { return m_optimize; };
virtual long DeviceToLogicalX(long x) const;
virtual long DeviceToLogicalY(long y) const;
virtual long DeviceToLogicalXRel(long x) const;
virtual long DeviceToLogicalYRel(long y) const;
virtual long LogicalToDeviceX(long x) const;
virtual long LogicalToDeviceY(long y) const;
virtual long LogicalToDeviceXRel(long x) const;
virtual long LogicalToDeviceYRel(long y) const;
public:
void CalcBoundingBox( long x, long y );
void ComputeScaleAndOrigin(void);
public:
void ComputeScaleAndOrigin();
long XDEV2LOG(long x) const
{
@@ -340,55 +157,26 @@ class WXDLLEXPORT wxDC: public wxObject
return (long)((double)(y) * m_scaleY - 0.5);
}
public:
bool m_ok;
bool m_colour;
// not sure, what these mean
bool m_clipping; // Is clipping on right now ?
bool m_optimize; // wxMSW only ?
bool m_isInteractive; // For wxPostScriptDC
wxPen m_pen;
wxBrush m_brush;
wxBrush m_backgroundBrush;
wxColour m_textForegroundColour;
wxColour m_textBackgroundColour;
wxFont m_font;
int m_logicalFunction;
int m_backgroundMode;
int m_textAlignment; // gone in wxWin 2.0 ?
int m_mappingMode;
void SetInternalDeviceOrigin( long x, long y );
void GetInternalDeviceOrigin( long *x, long *y );
public:
// not sure what for, but what is a mm on a screen you don't know the size of?
double m_mm_to_pix_x,m_mm_to_pix_y;
long m_internalDeviceOriginX,m_internalDeviceOriginY; // If un-scrolled is non-zero or
// d.o. changes with scrolling.
// Set using SetInternalDeviceOrigin().
// If un-scrolled is non-zero or d.o. changes with scrolling. Set using
// SetInternalDeviceOrigin().
long m_internalDeviceOriginX,m_internalDeviceOriginY;
long m_externalDeviceOriginX,m_externalDeviceOriginY; // To be set by external classes
// such as wxScrolledWindow
// using SetDeviceOrigin()
// To be set by external classes such as wxScrolledWindow using
// SetDeviceOrigin()
long m_externalDeviceOriginX,m_externalDeviceOriginY;
long m_deviceOriginX,m_deviceOriginY; // Sum of the two above.
// recompute scale?
bool m_needComputeScaleX, m_needComputeScaleY;
long m_logicalOriginX,m_logicalOriginY; // User defined.
double m_scaleX,m_scaleY;
double m_logicalScaleX,m_logicalScaleY;
double m_userScaleX,m_userScaleY;
long m_signX,m_signY;
bool m_needComputeScaleX,m_needComputeScaleY; // not yet used
float m_scaleFactor; // wxPSDC wants to have this. Will disappear.
long m_clipX1,m_clipY1,m_clipX2,m_clipY2;
long m_minX,m_maxX,m_minY,m_maxY;
// wxPSDC wants to have this. Will disappear.
float m_scaleFactor;
};
#endif

245
include/wx/motif/dcclient.h
View File

@@ -13,178 +13,128 @@
#define _WX_DCCLIENT_H_
#ifdef __GNUG__
#pragma interface "dcclient.h"
#pragma interface "dcclient.h"
#endif
#include "wx/dc.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// fwd declarations
// -----------------------------------------------------------------------------
class WXDLLEXPORT wxWindowDC;
class WXDLLEXPORT wxWindow;
// Under Windows, wxClientDC, wxPaintDC and wxWindowDC are implemented differently.
// On many platforms, however, they will be the same.
// Under Windows, wxClientDC, wxPaintDC and wxWindowDC are implemented
// differently. On many platforms, however, they will be the same.
//-----------------------------------------------------------------------------
// wxWindowDC
//-----------------------------------------------------------------------------
class WXDLLEXPORT wxWindowDC: public wxDC
class WXDLLEXPORT wxWindowDC : public wxDC
{
DECLARE_DYNAMIC_CLASS(wxWindowDC)
public:
wxWindowDC(void);
public:
wxWindowDC();
wxWindowDC( wxWindow *win );
~wxWindowDC(void);
~wxWindowDC();
virtual void FloodFill( long x1, long y1, const wxColour& col, int style=wxFLOOD_SURFACE );
inline void FloodFill(const wxPoint& pt, const wxColour& col, int style=wxFLOOD_SURFACE)
{
FloodFill(pt.x, pt.y, col, style);
}
// TODO this function is Motif-only for now - should it go into base class?
void Clear(const wxRect& rect);
virtual bool GetPixel( long x1, long y1, wxColour *col ) const;
inline bool GetPixel(const wxPoint& pt, wxColour *col) const
{
return GetPixel(pt.x, pt.y, col);
}
// implement base class pure virtuals
// ----------------------------------
virtual void DrawLine( long x1, long y1, long x2, long y2 );
inline void DrawLine(const wxPoint& pt1, const wxPoint& pt2)
{
DrawLine(pt1.x, pt1.y, pt2.x, pt2.y);
}
virtual void Clear();
virtual void CrossHair( long x, long y );
inline void CrossHair(const wxPoint& pt)
{
CrossHair(pt.x, pt.y);
}
virtual void DrawArc( long x1, long y1, long x2, long y2, long xc, long yc );
inline void DrawArc(const wxPoint& pt1, const wxPoint& pt2, const wxPoint& centre)
{
DrawArc(pt1.x, pt1.y, pt2.x, pt2.y, centre.x, centre.y);
}
virtual void DrawEllipticArc( long x, long y, long width, long height, double sa, double ea );
virtual void DrawEllipticArc (const wxPoint& pt, const wxSize& sz, double sa, double ea)
{
DrawEllipticArc(pt.x, pt.y, sz.x, sz.y, sa, ea);
}
virtual void DrawPoint( long x, long y );
inline void DrawPoint( wxPoint& point )
{ DrawPoint(point.x, point.y); }
virtual void DrawLines( int n, wxPoint points[], long xoffset = 0, long yoffset = 0 );
virtual void DrawLines( wxList *points, long xoffset = 0, long yoffset = 0 );
virtual void DrawPolygon( int n, wxPoint points[], long xoffset = 0, long yoffset = 0,
int fillStyle=wxODDEVEN_RULE );
virtual void DrawPolygon( wxList *lines, long xoffset = 0, long yoffset = 0,
int fillStyle=wxODDEVEN_RULE );
virtual void DrawRectangle( long x, long y, long width, long height );
inline void DrawRectangle(const wxPoint& pt, const wxSize& sz)
{
DrawRectangle(pt.x, pt.y, sz.x, sz.y);
}
inline void DrawRectangle(const wxRect& rect)
{
DrawRectangle(rect.x, rect.y, rect.width, rect.height);
}
virtual void DrawRoundedRectangle( long x, long y, long width, long height, double radius = 20.0 );
inline void DrawRoundedRectangle(const wxPoint& pt, const wxSize& sz, double radius = 20.0)
{
DrawRoundedRectangle(pt.x, pt.y, sz.x, sz.y, radius);
}
inline void DrawRoundedRectangle(const wxRect& rect, double radius = 20.0)
{
DrawRoundedRectangle(rect.x, rect.y, rect.width, rect.height, radius);
}
virtual void DrawEllipse( long x, long y, long width, long height );
inline void DrawEllipse(const wxPoint& pt, const wxSize& sz)
{
DrawEllipse(pt.x, pt.y, sz.x, sz.y);
}
inline void DrawEllipse(const wxRect& rect)
{
DrawEllipse(rect.x, rect.y, rect.width, rect.height);
}
virtual bool CanDrawBitmap(void) const;
virtual void DrawIcon( const wxIcon &icon, long x, long y);
inline void DrawIcon(const wxIcon& icon, const wxPoint& pt)
{
DrawIcon(icon, pt.x, pt.y);
}
virtual bool Blit( long xdest, long ydest, long width, long height,
wxDC *source, long xsrc, long ysrc, int logical_func = wxCOPY, bool useMask=FALSE );
inline bool Blit(const wxPoint& destPt, const wxSize& sz,
wxDC *source, const wxPoint& srcPt, int rop = wxCOPY, bool useMask = FALSE)
{
return Blit(destPt.x, destPt.y, sz.x, sz.y, source, srcPt.x, srcPt.y, rop, useMask);
}
virtual void DrawText( const wxString &text, long x, long y, bool use16 = FALSE );
inline void DrawText(const wxString& text, const wxPoint& pt, bool use16bit = FALSE)
{
DrawText(text, pt.x, pt.y, use16bit);
}
virtual bool CanGetTextExtent(void) const;
virtual void GetTextExtent( const wxString &string, long *width, long *height,
long *descent = NULL, long *externalLeading = NULL,
wxFont *theFont = NULL, bool use16 = FALSE );
virtual long GetCharWidth(void);
virtual long GetCharHeight(void);
virtual void Clear(void);
virtual void Clear(const wxRect& rect);
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 SetFont(const wxFont& font);
virtual void SetPen(const wxPen& pen);
virtual void SetBrush(const wxBrush& brush);
virtual void SetBackground(const wxBrush& brush);
virtual void SetBackgroundMode(int mode);
virtual void SetPalette(const wxPalette& palette);
virtual void SetLogicalFunction( int function );
virtual void SetTextForeground( const wxColour &col );
virtual void SetTextBackground( const wxColour &col );
virtual void SetBackgroundMode( int mode );
virtual void SetPalette( const wxPalette& palette );
virtual void SetClippingRegion( long x, long y, long width, long height );
virtual void SetClippingRegion( const wxRegion& region );
virtual void DestroyClippingRegion(void);
virtual void SetTextForeground(const wxColour& colour);
virtual void SetTextBackground(const wxColour& colour);
virtual void DrawSpline( wxList *points );
virtual void DrawSpline( long x1, long y1, long x2, long y2, long x3, long y3 )
{ wxDC::DrawSpline(x1, y1, x2, y2, x3, y3); }
virtual void DrawSpline( int n, wxPoint points[] )
{ wxDC::DrawSpline(n, points); }
virtual long GetCharHeight() const;
virtual long GetCharWidth() const;
virtual void GetTextExtent(const wxString& string,
long *x, long *y,
long *descent = NULL,
long *externalLeading = NULL,
wxFont *theFont = NULL) const;
// Resolution in pixels per logical inch
wxSize GetPPI(void) const;
virtual bool CanDrawBitmap() const;
virtual bool CanGetTextExtent() const;
// Motif-specific
void SetDCClipping (); // Helper function for setting clipping
virtual int GetDepth() const;
virtual wxSize GetPPI() const;
inline WXGC GetGC() const { return m_gc; }
inline WXGC GetBackingGC() const { return m_gcBacking; }
inline WXDisplay* GetDisplay() const { return m_display; }
inline bool GetAutoSetting() const { return m_autoSetting; }
inline void SetAutoSetting(bool flag) { m_autoSetting = flag; }
virtual void DestroyClippingRegion();
// Helper function for setting clipping
void SetDCClipping();
// implementation from now on
// --------------------------
WXGC GetGC() const { return m_gc; }
WXGC GetBackingGC() const { return m_gcBacking; }
WXDisplay* GetDisplay() const { return m_display; }
bool GetAutoSetting() const { return m_autoSetting; }
void SetAutoSetting(bool flag) { m_autoSetting = flag; }
protected:
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 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 DoSetClippingRegionAsRegion(const wxRegion& region);
virtual void DoSetClippingRegion(long x, long y,
long width, long height);
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);
#if wxUSE_SPLINES
virtual void DoDrawSpline(wxList *points);
#endif // wxUSE_SPLINES
WXGC m_gc;
WXGC m_gcBacking;
WXDisplay* m_display;
@@ -196,7 +146,7 @@ protected:
// Not sure if we'll need all of these
int m_backgroundPixel;
wxColour m_currentColour;
// int m_currentBkMode;
// int m_currentBkMode;
int m_currentPenWidth ;
int m_currentPenJoin ;
int m_currentPenCap ;
@@ -212,18 +162,21 @@ protected:
class WXDLLEXPORT wxPaintDC: public wxWindowDC
{
DECLARE_DYNAMIC_CLASS(wxPaintDC)
public:
wxPaintDC() {}
wxPaintDC() { }
wxPaintDC(wxWindow* win);
~wxPaintDC();
};
class WXDLLEXPORT wxClientDC: public wxWindowDC
{
DECLARE_DYNAMIC_CLASS(wxClientDC)
public:
wxClientDC() {}
wxClientDC(wxWindow* win): wxWindowDC(win) {}
wxClientDC() { }
wxClientDC(wxWindow* win) : wxWindowDC(win) { }
};
#endif

19
include/wx/motif/dcmemory.h
View File

@@ -13,26 +13,29 @@
#define _WX_DCMEMORY_H_
#ifdef __GNUG__
#pragma interface "dcmemory.h"
#pragma interface "dcmemory.h"
#endif
#include "wx/dcclient.h"
class WXDLLEXPORT wxMemoryDC: public wxWindowDC
class wxMemoryDC : public wxWindowDC
{
DECLARE_DYNAMIC_CLASS(wxMemoryDC)
DECLARE_DYNAMIC_CLASS(wxMemoryDC)
public:
wxMemoryDC(void);
public:
wxMemoryDC();
wxMemoryDC( wxDC *dc ); // Create compatible DC
~wxMemoryDC(void);
~wxMemoryDC();
virtual void SelectObject( const wxBitmap& bitmap );
void GetSize( int *width, int *height ) const;
inline wxBitmap& GetBitmap() const { return (wxBitmap&) m_bitmap; }
wxBitmap& GetBitmap() const { return (wxBitmap&) m_bitmap; }
private:
private:
friend wxPaintDC;
wxBitmap m_bitmap;
};

4
include/wx/motif/font.h
View File

@@ -91,8 +91,8 @@ public:
void SetUnderlined(bool underlined);
inline wxFont& operator = (const wxFont& font) { if (*this == font) return (*this); Ref(font); return *this; }
inline bool operator == (const wxFont& font) { return m_refData == font.m_refData; }
inline bool operator != (const wxFont& font) { return m_refData != font.m_refData; }
inline bool operator == (const wxFont& font) const { return m_refData == font.m_refData; }
inline bool operator != (const wxFont& font) const { return m_refData != font.m_refData; }
// Implementation

1
include/wx/motif/frame.h
View File

@@ -19,6 +19,7 @@
#include "wx/window.h"
#include "wx/toolbar.h"
#include "wx/accel.h"
#include "wx/icon.h"
WXDLLEXPORT_DATA(extern const char*) wxFrameNameStr;
WXDLLEXPORT_DATA(extern const char*) wxToolBarNameStr;

2
include/wx/motif/radiobox.h
View File

@@ -56,7 +56,7 @@ public:
void SetLabel(int item, const wxString& label) ;
wxString GetLabel(int item) const;
wxString GetLabel() const { return wxControl::GetLabel(); };
void Enable(bool enable);
bool Enable(bool enable);
void Enable(int item, bool enable);
void Show(int item, bool show) ;
bool Show(bool show) ;

162
include/wx/motif/window.h
View File

@@ -16,6 +16,12 @@
#pragma interface "window.h"
#endif
// ----------------------------------------------------------------------------
// A list of rectangles type used by wxWindow
// ----------------------------------------------------------------------------
WX_DECLARE_LIST(wxRect, wxRectList);
// ----------------------------------------------------------------------------
// wxWindow class for Motif - see also wxWindowBase
// ----------------------------------------------------------------------------
@@ -70,6 +76,9 @@ public:
const wxRect *rect = (const wxRect *) NULL );
virtual void Clear();
virtual bool SetBackgroundColour( const wxColour &colour );
virtual bool SetForegroundColour( const wxColour &colour );
virtual bool SetCursor( const wxCursor &cursor );
virtual bool SetFont( const wxFont &font );
@@ -93,6 +102,9 @@ public:
virtual void ScrollWindow( int dx, int dy,
const wxRect* rect = (wxRect *) NULL );
virtual void SetSizeHints(int minW, int minH,
int maxW, int maxH,
int incW, int incH);
#if wxUSE_DRAG_AND_DROP
virtual void SetDropTarget( wxDropTarget *dropTarget );
#endif // wxUSE_DRAG_AND_DROP
@@ -100,43 +112,11 @@ public:
// Accept files for dragging
virtual void DragAcceptFiles(bool accept);
protected:
// event handlers (not virtual by design)
void OnIdle(wxIdleEvent& event);
// Get the unique identifier of a window
virtual WXWidget GetHandle() const { return GetMainWidget(); }
// For implementation purposes - sometimes decorations make the client area
// smaller
virtual wxPoint GetClientAreaOrigin() const;
// Makes an adjustment to the window position (for example, a frame that has
// a toolbar that it manages itself).
virtual void AdjustForParentClientOrigin(int& x, int& y, int sizeFlags);
virtual void AddChild(wxWindow *child); // Adds reference to the child object
virtual void RemoveChild(wxWindow *child); // Removes reference to child
virtual void DestroyChildren(); // Removes and destroys all children
wxWindow *GetChild(int number) const
{ return GetChildren().Item(number)->GetData(); }
// Responds to colour changes: passes event on to children.
void OnSysColourChanged(wxSysColourChangedEvent& event);
// Motif-specific
// empties the m_updateRects list
void ClearUpdateRects();
// CanvasXXXSiize functions
void CanvasGetSize(int* width, int* height) const; // If have drawing area
void CanvasGetClientSize(int *width, int *height) const;
void CanvasGetPosition(int *x, int *y) const; // If have drawing area
void CanvasSetClientSize(int width, int size);
void CanvasSetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO);
// Gives window a chance to do something in response to a size message, e.g.
// arrange status bar, toolbar etc.
virtual bool PreResize() { return TRUE; }
// implementation from now on
// --------------------------
// accessors
// ---------
@@ -153,18 +133,78 @@ protected:
// implements this window.
virtual WXWidget GetTopWidget() const;
// base class pure virtual
virtual WXWidget GetHandle() const { return GetMainWidget(); }
// Get the underlying X window and display
WXWindow GetXWindow() const;
WXDisplay *GetXDisplay() const;
// called from Motif callbacks - and should only be called from there
void SetButton1(bool pressed) { m_button1Pressed = pressed; }
void SetButton2(bool pressed) { m_button2Pressed = pressed; }
void SetButton3(bool pressed) { m_button3Pressed = pressed; }
void SetLastClick(int button, long timestamp)
{ m_lastButton = button; m_lastTS = timestamp; }
int GetLastClickedButton() const { return m_lastButton; }
long GetLastClickTime() const { return m_lastTS; }
// Gives window a chance to do something in response to a size message, e.g.
// arrange status bar, toolbar etc.
virtual bool PreResize();
// Generates a paint event
virtual void DoPaint();
// update rectangle/region manipulation
// (for wxWindowDC and Motif callbacks only)
// -----------------------------------------
// read/write access to the update rect list
const wxRectList& GetUpdateRects() const { return m_updateRects; }
// Adds a recangle to the updates list
void AddUpdateRect(int x, int y, int w, int h)
{ m_updateRects.Append(new wxRect(x, y, w, h)); }
// Empties the m_updateRects list
void ClearUpdateRects();
void ClearUpdateRegion() { m_updateRegion.Clear(); }
void SetUpdateRegion(const wxRegion& region) { m_updateRegion = region; }
protected:
// event handlers (not virtual by design)
void OnIdle(wxIdleEvent& event);
// For implementation purposes - sometimes decorations make the client area
// smaller
virtual wxPoint GetClientAreaOrigin() const;
// Makes an adjustment to the window position (for example, a frame that has
// a toolbar that it manages itself).
virtual void AdjustForParentClientOrigin(int& x, int& y, int sizeFlags);
wxWindow *GetChild(int number) const
{ return GetChildren().Item(number)->GetData(); }
// Responds to colour changes: passes event on to children.
void OnSysColourChanged(wxSysColourChangedEvent& event);
// Motif-specific
// CanvasXXXSiize functions
void CanvasGetSize(int* width, int* height) const; // If have drawing area
void CanvasGetClientSize(int *width, int *height) const;
void CanvasGetPosition(int *x, int *y) const; // If have drawing area
void CanvasSetClientSize(int width, int size);
void CanvasSetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO);
void SetMainWidget(WXWidget w) { m_mainWidget = w; }
bool CanAddEventHandler() const { return m_canAddEventHandler; }
void SetCanAddEventHandler(bool flag) { m_canAddEventHandler = flag; }
// Get the underlying X window and display
WXWindow GetXWindow() const;
WXDisplay *GetXDisplay() const;
WXPixmap GetBackingPixmap() const { return m_backingPixmap; }
int GetPixmapWidth() const { return m_pixmapWidth; }
int GetPixmapHeight() const { return m_pixmapHeight; }
@@ -185,9 +225,6 @@ protected:
WXWidget formWidget, int x, int y, int width, int height);
bool DetachWidget(WXWidget widget);
// Generates a paint event
virtual void DoPaint();
// How to implement accelerators. If we find a key event, translate to
// wxWindows wxKeyEvent form. Find a widget for the window. Now find a
// wxWindow for the widget. If there isn't one, go up the widget hierarchy
@@ -202,7 +239,6 @@ protected:
// event and send it.
virtual bool ProcessAccelerator(wxKeyEvent& event);
protected:
// unmanage and destroy an X widget f it's !NULL (passing NULL is ok)
void UnmanageAndDestroy(WXWidget widget);
@@ -210,6 +246,13 @@ protected:
// mapped/unmapped
bool MapOrUnmap(WXWidget widget, bool map);
// scrolling stuff
// ---------------
// create/destroy window scrollbars
void CreateScrollbar(wxOrientation orientation);
void DestroyScrollbar(wxOrientation orientation);
// get either hor or vert scrollbar widget
WXWidget GetScrollbar(wxOrientation orient) const
{ return orient == wxHORIZONTAL ? m_hScrollBar : m_vScrollBar; }
@@ -224,6 +267,8 @@ protected:
}
// Motif-specific flags
// --------------------
bool m_needsRefresh:1; // repaint backing store?
bool m_canAddEventHandler:1; // ???
bool m_button1Pressed:1;
@@ -233,7 +278,9 @@ protected:
// For double-click detection
long m_lastTS; // last timestamp
int m_lastButton; // last pressed button
wxList m_updateRects; // List of wxRects representing damaged region
// List of wxRects representing damaged region
wxRectList m_updateRects;
protected:
WXWidget m_mainWidget;
@@ -280,21 +327,26 @@ private:
};
// ----------------------------------------------------------------------------
// A little class to switch off size optimization while an instance of the object
// exists
// A little class to switch off `size optimization' while an instance of the
// object exists: this may be useful to temporarily disable the optimisation
// which consists to do nothing when the new size is equal to the old size -
// although quite useful usually to avoid flicker, sometimes it leads to
// undesired effects.
//
// TODO what is it for??
// Usage: create an instance of this class on the stack to disable the size
// optimisation, it will be reenabled as soon as the object goes out from scope.
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxNoOptimize: public wxObject
class WXDLLEXPORT wxNoOptimize
{
public:
wxNoOptimize();
~wxNoOptimize();
wxNoOptimize() { ms_count++; }
~wxNoOptimize() { ms_count--; }
static bool CanOptimize();
static bool CanOptimize() { return ms_count == 0; }
protected:
static int m_count;
static int ms_count;
};
#endif

312
src/motif/dc.cpp
View File

@@ -10,14 +10,14 @@
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "dc.h"
#pragma implementation "dc.h"
#endif
#include "wx/dc.h"
#include "wx/dcmemory.h"
#if !USE_SHARED_LIBRARY
IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
#endif
//-----------------------------------------------------------------------------
@@ -35,212 +35,90 @@ IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
// wxDC
//-----------------------------------------------------------------------------
wxDC::wxDC(void)
wxDC::wxDC()
{
m_ok = FALSE;
m_optimize = FALSE;
m_colour = TRUE;
m_clipping = FALSE;
m_mm_to_pix_x = 1.0;
m_mm_to_pix_y = 1.0;
m_logicalOriginX = 0;
m_logicalOriginY = 0;
m_deviceOriginX = 0;
m_deviceOriginY = 0;
m_internalDeviceOriginX = 0;
m_internalDeviceOriginY = 0;
m_externalDeviceOriginX = 0;
m_externalDeviceOriginY = 0;
m_logicalScaleX = 1.0;
m_logicalScaleY = 1.0;
m_userScaleX = 1.0;
m_userScaleY = 1.0;
m_scaleX = 1.0;
m_scaleY = 1.0;
m_mappingMode = wxMM_TEXT;
m_needComputeScaleX = FALSE;
m_needComputeScaleY = FALSE;
m_signX = 1; // default x-axis left to right
m_signY = 1; // default y-axis top down
m_maxX = m_maxY = 0;
m_minX = m_minY = 0;
m_logicalFunction = wxCOPY;
// m_textAlignment = wxALIGN_TOP_LEFT;
m_backgroundMode = wxTRANSPARENT;
m_textForegroundColour = *wxBLACK;
m_textBackgroundColour = *wxWHITE;
m_pen = *wxBLACK_PEN;
m_font = *wxNORMAL_FONT;
m_brush = *wxTRANSPARENT_BRUSH;
m_backgroundBrush = *wxWHITE_BRUSH;
m_isInteractive = FALSE;
}
// m_palette = wxAPP_COLOURMAP;
};
wxDC::~wxDC(void)
void wxDC::DoDrawIcon( const wxIcon &icon, long x, long y)
{
};
wxCHECK_RET( Ok(), "invalid dc" );
wxCHECK_RET( icon.Ok(), "invalid icon" );
void wxDC::DrawIcon( const wxIcon &WXUNUSED(icon), long WXUNUSED(x), long WXUNUSED(y))
{
};
DoDrawBitmap(icon, x, y, TRUE);
}
void wxDC::DrawBitmap( const wxBitmap& bitmap, long x, long y, bool useMask )
void wxDC::DoDrawBitmap( const wxBitmap& bitmap, long x, long y, bool useMask )
{
if (!bitmap.Ok())
return;
wxCHECK_RET( bitmap.Ok(), "invalid bitmap" );
wxMemoryDC memDC;
memDC.SelectObject(bitmap);
/* Not sure if we need this. The mask should leave the
* masked areas as per the original background of this DC.
#if 0
// Not sure if we need this. The mask should leave the masked areas as per
// the original background of this DC.
if (useMask)
{
// There might be transparent areas, so make these
// the same colour as this DC
// There might be transparent areas, so make these the same colour as this
// DC
memDC.SetBackground(* GetBackground());
memDC.Clear();
}
*/
#endif // 0
Blit(x, y, bitmap.GetWidth(), bitmap.GetHeight(), & memDC, 0, 0, wxCOPY, useMask);
Blit(x, y, bitmap.GetWidth(), bitmap.GetHeight(), &memDC, 0, 0, wxCOPY, useMask);
memDC.SelectObject(wxNullBitmap);
};
}
void wxDC::DrawPoint( wxPoint& point )
{
DrawPoint( point.x, point.y );
};
void wxDC::DrawPolygon( wxList *list, long xoffset, long yoffset, int fillStyle )
{
int n = list->Number();
wxPoint *points = new wxPoint[n];
int i = 0;
for( wxNode *node = list->First(); node; node = node->Next() )
{
wxPoint *point = (wxPoint *)node->Data();
points[i].x = point->x;
points[i++].y = point->y;
};
DrawPolygon( n, points, xoffset, yoffset, fillStyle );
delete[] points;
};
void wxDC::DrawLines( wxList *list, long xoffset, long yoffset )
{
int n = list->Number();
wxPoint *points = new wxPoint[n];
int i = 0;
for( wxNode *node = list->First(); node; node = node->Next() )
{
wxPoint *point = (wxPoint *)node->Data();
points[i].x = point->x;
points[i++].y = point->y;
};
DrawLines( n, points, xoffset, yoffset );
delete []points;
};
void wxDC::DrawSpline( long x1, long y1, long x2, long y2, long x3, long y3 )
{
wxList list;
list.Append( (wxObject*)new wxPoint(x1, y1) );
list.Append( (wxObject*)new wxPoint(x2, y2) );
list.Append( (wxObject*)new wxPoint(x3, y3) );
DrawSpline(&list);
wxNode *node = list.First();
while (node)
{
wxPoint *p = (wxPoint*)node->Data();
delete p;
node = node->Next();
};
};
void wxDC::DrawSpline( int n, wxPoint points[] )
{
wxList list;
for (int i = 0; i < n; i++) list.Append( (wxObject*)&points[i] );
DrawSpline( &list );
};
void wxDC::SetClippingRegion( long x, long y, long width, long height )
void wxDC::DoSetClippingRegion( long x, long y, long width, long height )
{
m_clipping = TRUE;
m_clipX1 = x;
m_clipY1 = y;
m_clipX2 = x + width;
m_clipY2 = y + height;
};
}
void wxDC::DestroyClippingRegion(void)
void wxDC::DestroyClippingRegion()
{
m_clipping = FALSE;
};
}
void wxDC::GetClippingBox( long *x, long *y, long *width, long *height ) const
void wxDC::DoGetSize( int* width, int* height ) const
{
if (m_clipping)
{
if (x) *x = m_clipX1;
if (y) *y = m_clipY1;
if (width) *width = (m_clipX2 - m_clipX1);
if (height) *height = (m_clipY2 - m_clipY1);
}
else
*x = *y = *width = *height = 0;
};
if ( width )
*width = m_maxX - m_minX;
if ( height )
*height = m_maxY - m_minY;
}
void wxDC::GetSize( int* width, int* height ) const
void wxDC::DoGetSizeMM( int* width, int* height ) const
{
*width = m_maxX-m_minX;
*height = m_maxY-m_minY;
};
void wxDC::GetSizeMM( int* width, int* height ) const
{
int w = 0;
int h = 0;
int w, h;
GetSize( &w, &h );
if ( width )
*width = int( double(w) / (m_scaleX*m_mm_to_pix_x) );
if ( height )
*height = int( double(h) / (m_scaleY*m_mm_to_pix_y) );
};
}
// Resolution in pixels per logical inch
wxSize wxDC::GetPPI(void) const
wxSize wxDC::GetPPI() const
{
// TODO (should probably be pure virtual)
return wxSize(0, 0);
}
void wxDC::SetTextForeground( const wxColour &col )
{
if (!Ok()) return;
m_textForegroundColour = col;
};
void wxDC::SetTextBackground( const wxColour &col )
{
if (!Ok()) return;
m_textBackgroundColour = col;
};
void wxDC::SetMapMode( int mode )
{
switch (mode)
@@ -261,139 +139,101 @@ void wxDC::SetMapMode( int mode )
case wxMM_TEXT:
SetLogicalScale( 1.0, 1.0 );
break;
};
}
if (mode != wxMM_TEXT)
{
m_needComputeScaleX = TRUE;
m_needComputeScaleY = TRUE;
};
};
}
}
void wxDC::SetUserScale( double x, double y )
{
// allow negative ? -> no
m_userScaleX = x;
m_userScaleY = y;
wxDCBase::SetUserScale(x, y);
ComputeScaleAndOrigin();
};
void wxDC::GetUserScale( double *x, double *y )
{
if (x) *x = m_userScaleX;
if (y) *y = m_userScaleY;
};
}
void wxDC::SetLogicalScale( double x, double y )
{
// allow negative ?
m_logicalScaleX = x;
m_logicalScaleY = y;
wxDCBase::SetLogicalScale(x, y);
ComputeScaleAndOrigin();
};
void wxDC::GetLogicalScale( double *x, double *y )
{
if (x) *x = m_logicalScaleX;
if (y) *y = m_logicalScaleY;
};
}
void wxDC::SetLogicalOrigin( long x, long y )
{
m_logicalOriginX = x * m_signX; // is this still correct ?
m_logicalOriginY = y * m_signY;
ComputeScaleAndOrigin();
};
void wxDC::GetLogicalOrigin( long *x, long *y )
{
if (x) *x = m_logicalOriginX;
if (y) *y = m_logicalOriginY;
};
}
void wxDC::SetDeviceOrigin( long x, long y )
{
m_externalDeviceOriginX = x;
m_externalDeviceOriginY = y;
ComputeScaleAndOrigin();
};
void wxDC::GetDeviceOrigin( long *x, long *y )
{
// if (x) *x = m_externalDeviceOriginX;
// if (y) *y = m_externalDeviceOriginY;
if (x) *x = m_deviceOriginX;
if (y) *y = m_deviceOriginY;
};
}
void wxDC::SetInternalDeviceOrigin( long x, long y )
{
m_internalDeviceOriginX = x;
m_internalDeviceOriginY = y;
ComputeScaleAndOrigin();
};
}
void wxDC::GetInternalDeviceOrigin( long *x, long *y )
{
if (x) *x = m_internalDeviceOriginX;
if (y) *y = m_internalDeviceOriginY;
};
}
void wxDC::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
{
m_signX = (xLeftRight ? 1 : -1);
m_signY = (yBottomUp ? -1 : 1);
m_signX = xLeftRight ? 1 : -1;
m_signY = yBottomUp ? -1 : 1;
ComputeScaleAndOrigin();
};
}
long wxDC::DeviceToLogicalX(long x) const
long wxDCBase::DeviceToLogicalX(long x) const
{
return XDEV2LOG(x);
};
return ((wxDC *)this)->XDEV2LOG(x);
}
long wxDC::DeviceToLogicalY(long y) const
long wxDCBase::DeviceToLogicalY(long y) const
{
return YDEV2LOG(y);
};
return ((wxDC *)this)->YDEV2LOG(y);
}
long wxDC::DeviceToLogicalXRel(long x) const
long wxDCBase::DeviceToLogicalXRel(long x) const
{
return XDEV2LOGREL(x);
};
return ((wxDC *)this)->XDEV2LOGREL(x);
}
long wxDC::DeviceToLogicalYRel(long y) const
long wxDCBase::DeviceToLogicalYRel(long y) const
{
return YDEV2LOGREL(y);
};
return ((wxDC *)this)->YDEV2LOGREL(y);
}
long wxDC::LogicalToDeviceX(long x) const
long wxDCBase::LogicalToDeviceX(long x) const
{
return XLOG2DEV(x);
};
return ((wxDC *)this)->XLOG2DEV(x);
}
long wxDC::LogicalToDeviceY(long y) const
long wxDCBase::LogicalToDeviceY(long y) const
{
return YLOG2DEV(y);
};
return ((wxDC *)this)->YLOG2DEV(y);
}
long wxDC::LogicalToDeviceXRel(long x) const
long wxDCBase::LogicalToDeviceXRel(long x) const
{
return XLOG2DEVREL(x);
};
return ((wxDC *)this)->XLOG2DEVREL(x);
}
long wxDC::LogicalToDeviceYRel(long y) const
long wxDCBase::LogicalToDeviceYRel(long y) const
{
return YLOG2DEVREL(y);
};
return ((wxDC *)this)->YLOG2DEVREL(y);
}
void wxDC::CalcBoundingBox( long x, long y )
{
if (x < m_minX) m_minX = x;
if (y < m_minY) m_minY = y;
if (x > m_maxX) m_maxX = x;
if (y > m_maxY) m_maxY = y;
};
void wxDC::ComputeScaleAndOrigin(void)
void wxDC::ComputeScaleAndOrigin()
{
// CMB: copy scale to see if it changes
double origScaleX = m_scaleX;
@@ -415,5 +255,5 @@ void wxDC::ComputeScaleAndOrigin(void)
m_pen = tempPen;
SetPen(* pen);
}
};
}

758
src/motif/dcclient.cpp
View File

File diff suppressed because it is too large Load Diff

7
src/motif/radiobox.cpp
View File

@@ -345,13 +345,16 @@ void wxRadioBox::Enable(int n, bool enable)
}
// Enable all controls
void wxRadioBox::Enable(bool enable)
bool wxRadioBox::Enable(bool enable)
{
wxControl::Enable(enable);
if ( !wxControl::Enable(enable) )
return FALSE;
int i;
for (i = 0; i < m_noItems; i++)
XtSetSensitive ((Widget) m_radioButtons[i], (Boolean) enable);
return TRUE;
}
bool wxRadioBox::Show(bool show)

221
src/motif/window.cpp
View File

@@ -40,6 +40,8 @@
#include "wx/menuitem.h"
#include "wx/log.h"
#include "wx/listimpl.cpp"
#if wxUSE_DRAG_AND_DROP
#include "wx/dnd.h"
#endif
@@ -126,6 +128,12 @@ static int str16len(const char *s)
// implementation
// ============================================================================
// ----------------------------------------------------------------------------
// list types
// ----------------------------------------------------------------------------
WX_DEFINE_LIST(wxRectList);
// ----------------------------------------------------------------------------
// helper functions
// ----------------------------------------------------------------------------
@@ -416,7 +424,7 @@ wxWindow::~wxWindow()
// ----------------------------------------------------------------------------
// Helper function
void wxWindow::CreateScrollbar(int orientation)
void wxWindow::CreateScrollbar(wxOrientation orientation)
{
wxCHECK_RET( m_drawingArea, "this window can't have scrollbars" );
@@ -493,7 +501,7 @@ void wxWindow::CreateScrollbar(int orientation)
XtVaSetValues((Widget) m_scrolledWindow, XmNresizePolicy, XmRESIZE_ANY, NULL);
}
void wxWindow::DestroyScrollbar(int orientation)
void wxWindow::DestroyScrollbar(wxOrientation orientation)
{
wxCHECK_RET( m_drawingArea, "this window can't have scrollbars" );
@@ -543,7 +551,7 @@ void wxWindow::SetFocus()
}
// Get the window with the focus
wxWindow *wxWindow::FindFocus()
wxWindow *wxWindowBase::FindFocus()
{
// TODO Problems:
// (1) Can there be multiple focussed widgets in an application?
@@ -571,12 +579,12 @@ wxWindow *wxWindow::FindFocus()
return winFocus;
}
void wxWindow::Enable(bool enable)
bool wxWindow::Enable(bool enable)
{
if ( !wxWindowBase::Enable(enable) )
return FALSE;
Widget wMain = GetMainWidget();
Widget wMain = (Widget)GetMainWidget();
if ( wMain )
{
XtSetSensitive(wMain, enable);
@@ -630,14 +638,17 @@ void wxWindow::Lower()
XLowerWindow(XtDisplay(wTop), window);
}
void wxWindow::SetTitle( const wxString& title)
void wxWindow::SetTitle(const wxString& title)
{
SetWindowText(GetHwnd(), title.c_str());
XtVaSetValues((Widget)GetMainWidget(), XmNtitle, title.c_str(), NULL);
}
wxString wxWindow::GetTitle() const
{
return wxGetWindowText(GetHWND());
char *title;
XtVaGetValues((Widget)GetMainWidget(), XmNtitle, &title, NULL);
return wxString(title);
}
void wxWindow::CaptureMouse()
@@ -645,7 +656,7 @@ void wxWindow::CaptureMouse()
if ( m_winCaptured )
return;
Widget wMain = GetMainWidget();
Widget wMain = (Widget)GetMainWidget();
if ( wMain )
XtAddGrab(wMain, TRUE, FALSE);
@@ -657,7 +668,7 @@ void wxWindow::ReleaseMouse()
if ( !m_winCaptured )
return;
Widget wMain = GetMainWidget();
Widget wMain = (Widget)GetMainWidget();
if ( wMain )
XtRemoveGrab(wMain);
@@ -694,6 +705,8 @@ bool wxWindow::SetCursor(const wxCursor& cursor)
Widget w = (Widget) GetMainWidget();
Window win = XtWindow(w);
XDefineCursor((Display*) dpy, win, (Cursor) x_cursor);
return TRUE;
}
// Coordinates relative to the window
@@ -732,7 +745,7 @@ int wxWindow::GetScrollPos(int orient) const
// can scroll.
int wxWindow::GetScrollRange(int orient) const
{
Widget scrollBar = (Widget)GetScrollbar(orient);
Widget scrollBar = (Widget)GetScrollbar((wxOrientation)orient);
wxCHECK_MSG( scrollBar, 0, "no such scrollbar" );
int range;
@@ -742,7 +755,7 @@ int wxWindow::GetScrollRange(int orient) const
int wxWindow::GetScrollThumb(int orient) const
{
Widget scrollBar = (Widget)GetScrollbar(orient);
Widget scrollBar = (Widget)GetScrollbar((wxOrientation)orient);
wxCHECK_MSG( scrollBar, 0, "no such scrollbar" );
int thumb;
@@ -752,14 +765,14 @@ int wxWindow::GetScrollThumb(int orient) const
void wxWindow::SetScrollPos(int orient, int pos, bool WXUNUSED(refresh))
{
Widget scrollBar = (Widget)GetScrollbar(orient);
Widget scrollBar = (Widget)GetScrollbar((wxOrientation)orient);
if ( scrollBar )
{
XtVaSetValues (scrollBar, XmNvalue, pos, NULL);
}
SetInternalScrollPos(orient, pos);
SetInternalScrollPos((wxOrientation)orient, pos);
}
// New function that will replace some of the above.
@@ -778,7 +791,7 @@ void wxWindow::SetScrollbar(int orient, int pos, int thumbVisible,
thumbVisible = range;
// Save the old state to see if it changed
WXWidget oldScrollBar = GetScrollbar(orient);
WXWidget oldScrollBar = GetScrollbar((wxOrientation)orient);
if (orient == wxHORIZONTAL)
{
@@ -806,7 +819,7 @@ void wxWindow::SetScrollbar(int orient, int pos, int thumbVisible,
CreateScrollbar(wxVERTICAL);
}
}
WXWidget newScrollBar = GetScrollbar(orient);
WXWidget newScrollBar = GetScrollbar((wxOrientation)orient);
if (oldScrollBar != newScrollBar)
{
@@ -827,7 +840,7 @@ void wxWindow::SetScrollbar(int orient, int pos, int thumbVisible,
NULL);
}
SetInternalScrollPos(orient, pos);
SetInternalScrollPos((wxOrientation)orient, pos);
int newW, newH;
GetSize(& newW, & newH);
@@ -1037,7 +1050,7 @@ bool wxWindow::PreResize()
}
// Get total size
void wxWindow::GetSize(int *x, int *y) const
void wxWindow::DoGetSize(int *x, int *y) const
{
if (m_drawingArea)
{
@@ -1051,7 +1064,7 @@ void wxWindow::GetSize(int *x, int *y) const
*x = xx; *y = yy;
}
void wxWindow::GetPosition(int *x, int *y) const
void wxWindow::DoGetPosition(int *x, int *y) const
{
if (m_drawingArea)
{
@@ -1074,7 +1087,7 @@ void wxWindow::GetPosition(int *x, int *y) const
*x = xx; *y = yy;
}
void wxWindow::ScreenToClient(int *x, int *y) const
void wxWindow::DoScreenToClient(int *x, int *y) const
{
Widget widget = (Widget) GetClientWidget();
Display *display = XtDisplay((Widget) GetMainWidget());
@@ -1087,7 +1100,7 @@ void wxWindow::ScreenToClient(int *x, int *y) const
XTranslateCoordinates(display, rootWindow, thisWindow, xx, yy, x, y, &childWindow);
}
void wxWindow::ClientToScreen(int *x, int *y) const
void wxWindow::DoClientToScreen(int *x, int *y) const
{
Widget widget = (Widget) GetClientWidget();
Display *display = XtDisplay(widget);
@@ -1102,7 +1115,7 @@ void wxWindow::ClientToScreen(int *x, int *y) const
// Get size *available for subwindows* i.e. excluding menu bar etc.
void wxWindow::GetClientSize(int *x, int *y) const
void wxWindow::DoGetClientSize(int *x, int *y) const
{
Widget widget = (Widget) GetClientWidget();
Dimension xx, yy;
@@ -1257,9 +1270,9 @@ void wxWindow::SetSizeHints(int minW, int minH, int maxW, int maxH, int incW, in
int wxWindow::GetCharHeight() const
{
wxCHECK_MSG( m_windowFont.Ok(), 0, "valid window font needed" );
wxCHECK_MSG( m_font.Ok(), 0, "valid window font needed" );
WXFontStructPtr pFontStruct = m_windowFont.GetFontStruct(1.0, GetXDisplay());
WXFontStructPtr pFontStruct = m_font.GetFontStruct(1.0, GetXDisplay());
int direction, ascent, descent;
XCharStruct overall;
@@ -1272,9 +1285,9 @@ int wxWindow::GetCharHeight() const
int wxWindow::GetCharWidth() const
{
wxCHECK_MSG( m_windowFont.Ok(), 0, "valid window font needed" );
wxCHECK_MSG( m_font.Ok(), 0, "valid window font needed" );
WXFontStructPtr pFontStruct = m_windowFont.GetFontStruct(1.0, GetXDisplay());
WXFontStructPtr pFontStruct = m_font.GetFontStruct(1.0, GetXDisplay());
int direction, ascent, descent;
XCharStruct overall;
@@ -1291,9 +1304,9 @@ void wxWindow::GetTextExtent(const wxString& string,
{
wxFont *fontToUse = (wxFont *)theFont;
if (!fontToUse)
fontToUse = (wxFont *) & m_windowFont;
fontToUse = (wxFont *) & m_font;
wxCHECK_RET( fontToUse.Ok(), "valid window font needed" );
wxCHECK_RET( fontToUse->Ok(), "valid window font needed" );
WXFontStructPtr pFontStruct = theFont->GetFontStruct(1.0, GetXDisplay());
@@ -1378,13 +1391,14 @@ void wxWindow::Clear()
void wxWindow::ClearUpdateRects()
{
wxNode* node = m_updateRects.First();
wxRectList::Node* node = m_updateRects.GetFirst();
while (node)
{
wxRect* rect = (wxRect*) node->Data();
wxRect* rect = node->GetData();
delete rect;
node = node->Next();
node = node->GetNext();
}
m_updateRects.Clear();
}
@@ -1666,7 +1680,7 @@ bool wxWindow::DetachWidget(WXWidget widget)
// Get the underlying X window
WXWindow wxWindow::GetXWindow() const
{
Widget wMain = GetMainWidget();
Widget wMain = (Widget)GetMainWidget();
if ( wMain )
return (WXWindow) XtWindow(wMain);
else
@@ -1676,7 +1690,7 @@ WXWindow wxWindow::GetXWindow() const
// Get the underlying X display
WXDisplay *wxWindow::GetXDisplay() const
{
Widget wMain = GetMainWidget();
Widget wMain = (Widget)GetMainWidget();
if ( wMain )
return (WXDisplay*) XtDisplay(wMain);
else
@@ -1740,17 +1754,11 @@ static void wxCanvasRepaintProc(Widget drawingArea,
XEvent * event = cbs->event;
wxWindow * win = (wxWindow *) clientData;
Display * display = (Display *) win->GetXDisplay();
switch (event->type)
{
case Expose:
{
wxRect* rect = new wxRect(event->xexpose.x, event->xexpose.y,
event->xexpose.width, event->xexpose.height);
win->m_updateRects.Append((wxObject*) rect);
if (event -> xexpose.count == 0)
{
#if 0
@@ -1762,6 +1770,11 @@ static void wxCanvasRepaintProc(Widget drawingArea,
win->DoPaint();
win->ClearUpdateRects();
}
else
{
win->AddUpdateRect(event->xexpose.x, event->xexpose.y,
event->xexpose.width, event->xexpose.height);
}
break;
}
}
@@ -1863,17 +1876,17 @@ static void wxCanvasInputEvent(Widget drawingArea,
if (local_event.xbutton.button == Button1)
{
eventType = wxEVT_LEFT_DOWN;
canvas->m_button1Pressed = TRUE;
canvas->SetButton1(TRUE);
}
else if (local_event.xbutton.button == Button2)
{
eventType = wxEVT_MIDDLE_DOWN;
canvas->m_button2Pressed = TRUE;
canvas->SetButton2(TRUE);
}
else if (local_event.xbutton.button == Button3)
{
eventType = wxEVT_RIGHT_DOWN;
canvas->m_button3Pressed = TRUE;
canvas->SetButton3(TRUE);
}
}
else if (local_event.xany.type == ButtonRelease)
@@ -1881,22 +1894,21 @@ static void wxCanvasInputEvent(Widget drawingArea,
if (local_event.xbutton.button == Button1)
{
eventType = wxEVT_LEFT_UP;
canvas->m_button1Pressed = FALSE;
canvas->SetButton1(FALSE);
}
else if (local_event.xbutton.button == Button2)
{
eventType = wxEVT_MIDDLE_UP;
canvas->m_button2Pressed = FALSE;
canvas->SetButton2(FALSE);
}
else if (local_event.xbutton.button == Button3)
{
eventType = wxEVT_RIGHT_UP;
canvas->m_button3Pressed = FALSE;
canvas->SetButton3(FALSE);
}
}
wxMouseEvent wxevent (eventType);
wxevent.m_eventHandle = (char *) &local_event;
wxevent.m_leftDown = ((eventType == wxEVT_LEFT_DOWN)
|| (event_left_is_down (&local_event)
@@ -1923,15 +1935,21 @@ static void wxCanvasInputEvent(Widget drawingArea,
// get button and time-stamp
int button = 0;
if (wxevent.LeftDown()) button = 1;
else if (wxevent.MiddleDown()) button = 2;
else if (wxevent.RightDown()) button = 3;
if (wxevent.LeftDown())
button = 1;
else if (wxevent.MiddleDown())
button = 2;
else if (wxevent.RightDown())
button = 3;
long ts = wxevent.GetTimestamp();
// check, if single or double click
if (canvas->m_lastButton && canvas->m_lastButton==button && (ts - canvas->m_lastTS) < dclickTime)
int buttonLast = canvas->GetLastClickedButton();
long lastTS = canvas->GetLastClickTime();
if ( buttonLast && buttonLast == button && (ts - lastTS) < dclickTime )
{
// I have a dclick
canvas->m_lastButton = 0;
canvas->SetLastClick(0, ts);
switch ( eventType )
{
case wxEVT_LEFT_DOWN:
@@ -1952,8 +1970,7 @@ static void wxCanvasInputEvent(Widget drawingArea,
else
{
// not fast enough or different button
canvas->m_lastTS = ts;
canvas->m_lastButton = button;
canvas->SetLastClick(button, ts);
}
}
}
@@ -2084,7 +2101,7 @@ static void wxPanelItemEventHandler(Widget wid,
{
// Widget can be a label or the actual widget.
wxWindow *window = wxGetWindowFromTable(drawingArea);
wxWindow *window = wxGetWindowFromTable(wid);
if (window)
{
wxMouseEvent wxevent(0);
@@ -2108,7 +2125,6 @@ static void wxScrollBarCallback(Widget scrollbar,
XtPointer clientData,
XmScaleCallbackStruct *cbs)
{
Widget scrolledWindow = XtParent (scrollbar);
wxWindow *win = wxGetWindowFromTable(scrollbar);
int orientation = (int) clientData;
@@ -2185,21 +2201,23 @@ void wxUniversalRepaintProc(Widget w, XtPointer WXUNUSED(c_data), XEvent *event,
switch(event -> type)
{
case Expose :
case Expose:
{
window = (Window) win -> GetXWindow();
display = (Display *) win -> GetXDisplay();
wxRect* rect = new wxRect(event->xexpose.x, event->xexpose.y,
event->xexpose.width, event->xexpose.height);
win->m_updateRects.Append((wxObject*) rect);
if (event -> xexpose.count == 0)
{
win->DoPaint();
win->ClearUpdateRects();
}
else
{
win->AddUpdateRect(event->xexpose.x, event->xexpose.y,
event->xexpose.width, event->xexpose.height);
}
break;
}
}
@@ -2243,7 +2261,7 @@ void wxWindow::CanvasSetSize (int x, int y, int w, int h, int sizeFlags)
if (managed)
XtUnmanageChild (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
XtVaSetValues((Widget) m_drawingArea, XmNresizePolicy, XmRESIZE_ANY, NULL);
XtVaSetValues(drawingArea, XmNresizePolicy, XmRESIZE_ANY, NULL);
int xx = x; int yy = y;
AdjustForParentClientOrigin(xx, yy, sizeFlags);
@@ -2295,7 +2313,9 @@ void wxWindow::CanvasSetSize (int x, int y, int w, int h, int sizeFlags)
w -= (spacing + wsbar);
// XtVaSetValues ((Widget) m_drawingArea, XmNwidth, w, NULL);
#if 0
XtVaSetValues(drawingArea, XmNwidth, w, NULL);
#endif // 0
}
if (h > -1)
{
@@ -2326,14 +2346,15 @@ void wxWindow::CanvasSetSize (int x, int y, int w, int h, int sizeFlags)
h -= (spacing + wsbar);
// XtVaSetValues ((Widget) m_drawingArea, XmNheight, h, NULL);
#if 0
XtVaSetValues(drawingArea, XmNheight, h, NULL);
#endif // 0
}
}
if (managed)
XtManageChild (m_borderWidget ? (Widget) m_borderWidget : (Widget) m_scrolledWindow);
XtVaSetValues((Widget) m_drawingArea, XmNresizePolicy, XmRESIZE_NONE, NULL);
XtVaSetValues(drawingArea, XmNresizePolicy, XmRESIZE_NONE, NULL);
#if 0
int ww, hh;
@@ -2349,12 +2370,12 @@ void wxWindow::CanvasSetClientSize (int w, int h)
{
Widget drawingArea = (Widget) m_drawingArea;
XtVaSetValues((Widget) m_drawingArea, XmNresizePolicy, XmRESIZE_ANY, NULL);
XtVaSetValues(drawingArea, XmNresizePolicy, XmRESIZE_ANY, NULL);
if (w > -1)
XtVaSetValues ((Widget) m_drawingArea, XmNwidth, w, NULL);
XtVaSetValues(drawingArea, XmNwidth, w, NULL);
if (h > -1)
XtVaSetValues ((Widget) m_drawingArea, XmNheight, h, NULL);
XtVaSetValues(drawingArea, XmNheight, h, NULL);
#if 0
// TODO: is this necessary?
@@ -2370,7 +2391,7 @@ void wxWindow::CanvasSetClientSize (int w, int h)
}
#endif // 0
XtVaSetValues((Widget) m_drawingArea, XmNresizePolicy, XmRESIZE_NONE, NULL);
XtVaSetValues(drawingArea, XmNresizePolicy, XmRESIZE_NONE, NULL);
#if 0
allowRepainting = TRUE;
@@ -2443,9 +2464,9 @@ bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win, Widget widget,
if (xevent->xany.type == LeaveNotify)
{
win->m_button1Pressed = FALSE;
win->m_button2Pressed = FALSE;
win->m_button3Pressed = FALSE;
win->SetButton1(FALSE);
win->SetButton2(FALSE);
win->SetButton3(FALSE);
return FALSE;
}
else if (xevent->xany.type == MotionNotify)
@@ -2457,17 +2478,17 @@ bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win, Widget widget,
if (xevent->xbutton.button == Button1)
{
eventType = wxEVT_LEFT_DOWN;
win->m_button1Pressed = TRUE;
win->SetButton1(TRUE);
}
else if (xevent->xbutton.button == Button2)
{
eventType = wxEVT_MIDDLE_DOWN;
win->m_button2Pressed = TRUE;
win->SetButton2(TRUE);
}
else if (xevent->xbutton.button == Button3)
{
eventType = wxEVT_RIGHT_DOWN;
win->m_button3Pressed = TRUE;
win->SetButton3(TRUE);
}
}
else if (xevent->xany.type == ButtonRelease)
@@ -2475,23 +2496,25 @@ bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win, Widget widget,
if (xevent->xbutton.button == Button1)
{
eventType = wxEVT_LEFT_UP;
win->m_button1Pressed = FALSE;
win->SetButton1(FALSE);
}
else if (xevent->xbutton.button == Button2)
{
eventType = wxEVT_MIDDLE_UP;
win->m_button2Pressed = FALSE;
win->SetButton2(FALSE);
}
else if (xevent->xbutton.button == Button3)
{
eventType = wxEVT_RIGHT_UP;
win->m_button3Pressed = FALSE;
win->SetButton3(FALSE);
}
else return FALSE;
}
else return FALSE;
else
{
return FALSE;
}
wxevent.m_eventHandle = (char *)xevent;
wxevent.SetEventType(eventType);
Position x1, y1;
@@ -2713,16 +2736,24 @@ void wxWindow::DoChangeBackgroundColour(WXWidget widget, wxColour& backgroundCol
NULL);
}
void wxWindow::SetBackgroundColour(const wxColour& col)
bool wxWindow::SetBackgroundColour(const wxColour& col)
{
m_backgroundColour = col;
if ( !wxWindowBase::SetBackgroundColour(col) )
return FALSE;
ChangeBackgroundColour();
return TRUE;
}
void wxWindow::SetForegroundColour(const wxColour& col)
bool wxWindow::SetForegroundColour(const wxColour& col)
{
m_foregroundColour = col;
if ( !wxWindowBase::SetForegroundColour(col) )
return FALSE;
ChangeForegroundColour();
return TRUE;
}
void wxWindow::ChangeFont(bool keepOriginalSize)
@@ -2731,7 +2762,7 @@ void wxWindow::ChangeFont(bool keepOriginalSize)
// to its original size! We therefore have to set the size
// back again. TODO: a better way in Motif?
Widget w = (Widget) GetLabelWidget(); // Usually the main widget
if (w && m_windowFont.Ok())
if (w && m_font.Ok())
{
int width, height, width1, height1;
GetSize(& width, & height);
@@ -2739,7 +2770,7 @@ void wxWindow::ChangeFont(bool keepOriginalSize)
// lesstif 0.87 hangs here
#ifndef LESSTIF_VERSION
XtVaSetValues (w,
XmNfontList, (XmFontList) m_windowFont.GetFontList(1.0, XtDisplay(w)),
XmNfontList, (XmFontList) m_font.GetFontList(1.0, XtDisplay(w)),
NULL);
#endif
@@ -2765,20 +2796,4 @@ wxWindow *wxGetActiveWindow()
// wxNoOptimize: switch off size optimization
// ----------------------------------------------------------------------------
int wxNoOptimize::m_count = 0;
wxNoOptimize::wxNoOptimize()
{
m_count ++;
}
wxNoOptimize::~wxNoOptimize()
{
m_count --;
}
bool wxNoOptimize::CanOptimize()
{
return (m_count == 0);
}
int wxNoOptimize::ms_count = 0;