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

wxX11:

Browse Source 
Updated wxColour for handling Colormaps and ref couting.
    Updated wxClientDC et al. for conforming to wxGTK. Many
      tricky parts, particularly the bitmap drawing and
      blitting is still missing.
    Any sample crashes now for some reason with an X error.


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@14136 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Robert Roebling
2002-02-11 20:41:24 +00:00
parent d8356fa39a
commit 3cd0b8c5b5
16 changed files with 2009 additions and 2229 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
include/wx/defs.h
View File

@@ -1860,6 +1860,7 @@ typedef void* WXWindow;
typedef void* WXWidget;
typedef void* WXAppContext;
typedef void* WXColormap;
typedef void* WXColor;
typedef void WXDisplay;
typedef void WXEvent;
typedef void* WXCursor;

91
include/wx/x11/colour.h
View File

@@ -1,11 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: colour.h
// Purpose: wxColour class
// Author: Julian Smart
// Author: Julian Smart, Robert Roebling
// Modified by:
// Created: 17/09/98
// RCS-ID: $Id$
// Copyright: (c) Julian Smart
// Copyright: (c) Julian Smart, Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -16,77 +16,82 @@
#pragma interface "colour.h"
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/string.h"
#include "wx/gdiobj.h"
#include "wx/palette.h"
// Colour
class WXDLLEXPORT wxColour : public wxObject
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
class wxDC;
class wxPaintDC;
class wxBitmap;
class wxWindow;
class wxColour;
//-----------------------------------------------------------------------------
// wxColour
//-----------------------------------------------------------------------------
class wxColour: public wxGDIObject
{
DECLARE_DYNAMIC_CLASS(wxColour)
public:
// ctors
// default
wxColour();
// from RGB
wxColour() { }
// Construct from RGB
wxColour( unsigned char red, unsigned char green, unsigned char blue );
wxColour( unsigned long colRGB ) { Set(colRGB); }
// implicit conversion from the colour name
// Implicit conversion from the colour name
wxColour( const wxString &colourName ) { InitFromName(colourName); }
wxColour( const char *colourName ) { InitFromName(colourName); }
// copy ctors and assignment operators
wxColour( const wxColour& col );
wxColour& operator = ( const wxColour& col );
wxColour( const wxColour& col ) { Ref(col); }
wxColour& operator = ( const wxColour& col ) { Ref(col); return *this; }
// dtor
~wxColour();
// Set() functions
bool Ok() const { return m_refData != NULL; }
bool operator == ( const wxColour& col ) const;
bool operator != ( const wxColour& col ) const { return !(*this == col); }
void Set( unsigned char red, unsigned char green, unsigned char blue );
void Set( unsigned long colRGB )
{
// we don't need to know sizeof(long) here because we assume that the three
// We don't need to know sizeof(long) here because we assume that the three
// least significant bytes contain the R, G and B values
Set((unsigned char)colRGB,
(unsigned char)(colRGB >> 8),
(unsigned char)(colRGB >> 16));
}
// accessors
bool Ok() const {return m_isInit; }
unsigned char Red() const { return m_red; }
unsigned char Green() const { return m_green; }
unsigned char Blue() const { return m_blue; }
unsigned char Red() const;
unsigned char Green() const;
unsigned char Blue() const;
int GetPixel() const { return m_pixel; };
void SetPixel(int pixel) { m_pixel = pixel; m_isInit = TRUE; };
// Implementation part
inline bool operator == (const wxColour& colour) const { return (m_red == colour.m_red && m_green == colour.m_green && m_blue == colour.m_blue); }
void CalcPixel( WXColormap cmap );
unsigned long GetPixel() const;
WXColor *GetColor() const;
inline bool operator != (const wxColour& colour) const { return (!(m_red == colour.m_red && m_green == colour.m_green && m_blue == colour.m_blue)); }
protected:
// ref counting code
virtual wxObjectRefData *CreateRefData() const;
virtual wxObjectRefData *CloneRefData(const wxObjectRefData *data) const;
// Allocate a colour, or nearest colour, using the given display.
// If realloc is TRUE, ignore the existing pixel, otherwise just return
// the existing one.
// Returns the allocated pixel.
// TODO: can this handle mono displays? If not, we should have an extra
// flag to specify whether this should be black or white by default.
int AllocColour(WXDisplay* display, bool realloc = FALSE);
void InitFromName(const wxString& col);
// Helper functions
void InitFromName(const wxString& colourName);
private:
bool m_isInit;
unsigned char m_red;
unsigned char m_blue;
unsigned char m_green;
public:
int m_pixel;
DECLARE_DYNAMIC_CLASS(wxColour)
};
#endif
// _WX_COLOUR_H_

28
include/wx/x11/dc.h
View File

@@ -43,8 +43,6 @@
class WXDLLEXPORT wxDC : public wxDCBase
{
DECLARE_DYNAMIC_CLASS(wxDC)
public:
wxDC();
~wxDC() { }
@@ -64,13 +62,8 @@ public:
virtual void SetAxisOrientation(bool xLeftRight, bool yBottomUp);
protected:
virtual void DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y);
virtual void DoDrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y,
bool useMask = FALSE);
virtual void DoSetClippingRegion(wxCoord x, wxCoord y,
wxCoord width, wxCoord height);
virtual void DoGetSize(int *width, int *height) const;
virtual void DoGetSizeMM(int* width, int* height) const;
public:
@@ -114,15 +107,6 @@ public:
else
return (wxCoord)((double)(new_x) * m_scaleX - 0.5) * m_signX + m_deviceOriginX;
}
// Without device translation, for backing pixmap purposes
wxCoord XLOG2DEV_2(wxCoord x) const
{
wxCoord new_x = x - m_logicalOriginX;
if (new_x > 0)
return (wxCoord)((double)(new_x) * m_scaleX + 0.5) * m_signX;
else
return (wxCoord)((double)(new_x) * m_scaleX - 0.5) * m_signX;
}
wxCoord XLOG2DEVREL(wxCoord x) const
{
if (x > 0)
@@ -138,15 +122,6 @@ public:
else
return (wxCoord)((double)(new_y) * m_scaleY - 0.5) * m_signY + m_deviceOriginY;
}
// Without device translation, for backing pixmap purposes
wxCoord YLOG2DEV_2(wxCoord y) const
{
wxCoord new_y = y - m_logicalOriginY;
if (new_y > 0)
return (wxCoord)((double)(new_y) * m_scaleY + 0.5) * m_signY;
else
return (wxCoord)((double)(new_y) * m_scaleY - 0.5) * m_signY;
}
wxCoord YLOG2DEVREL(wxCoord y) const
{
if (y > 0)
@@ -162,6 +137,9 @@ public:
// recompute scale?
bool m_needComputeScaleX, m_needComputeScaleY;
private:
DECLARE_ABSTRACT_CLASS(wxDC)
};
#endif

180
include/wx/x11/dcclient.h
View File

@@ -17,87 +17,45 @@
#endif
#include "wx/dc.h"
#include "wx/region.h"
// -----------------------------------------------------------------------------
// fwd declarations
// -----------------------------------------------------------------------------
class WXDLLEXPORT wxWindowDC;
class WXDLLEXPORT wxWindow;
class wxWindow;
// Under Windows, wxClientDC, wxPaintDC and wxWindowDC are implemented
// differently. On many platforms, however, they will be the same.
class wxWindowDC;
class wxPaintDC;
class wxClientDC;
//-----------------------------------------------------------------------------
// wxWindowDC
//-----------------------------------------------------------------------------
class WXDLLEXPORT wxWindowDC : public wxDC
class wxWindowDC : public wxDC
{
DECLARE_DYNAMIC_CLASS(wxWindowDC)
public:
wxWindowDC();
wxWindowDC( wxWindow *win );
~wxWindowDC();
// TODO this function is Motif-only for now - should it go into base class?
void Clear(const wxRect& rect);
// implement base class pure virtuals
// ----------------------------------
virtual void Clear();
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& colour);
virtual void SetTextBackground(const wxColour& colour);
virtual wxCoord GetCharHeight() const;
virtual wxCoord GetCharWidth() const;
virtual void DoGetTextExtent(const wxString& string,
wxCoord *x, wxCoord *y,
wxCoord *descent = NULL,
wxCoord *externalLeading = NULL,
wxFont *theFont = NULL) const;
virtual bool CanDrawBitmap() const;
virtual bool CanGetTextExtent() const;
virtual int GetDepth() const;
virtual wxSize GetPPI() const;
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; }
virtual bool CanDrawBitmap() const { return TRUE; }
virtual bool CanGetTextExtent() const { return TRUE; }
protected:
virtual void DoFloodFill(wxCoord x, wxCoord y, const wxColour& col,
int style = wxFLOOD_SURFACE);
virtual bool DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const;
virtual void DoGetSize(int *width, int *height) const;
virtual void DoFloodFill( wxCoord x, wxCoord y, const wxColour& col, int style = wxFLOOD_SURFACE );
virtual bool DoGetPixel( wxCoord x, wxCoord y, wxColour *col ) const;
virtual void DoDrawPoint(wxCoord x, wxCoord y);
virtual void DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2);
virtual void DoDrawIcon( const wxIcon &icon, wxCoord x, wxCoord y );
virtual void DoDrawBitmap( const wxBitmap &bitmap, wxCoord x, wxCoord y,
bool useMask = FALSE );
virtual void DoDrawArc(wxCoord x1, wxCoord y1,
wxCoord x2, wxCoord y2,
wxCoord xc, wxCoord yc);
@@ -129,48 +87,88 @@ protected:
wxCoord xoffset, wxCoord yoffset,
int fillStyle = wxODDEVEN_RULE);
WXGC m_gc;
WXGC m_gcBacking;
WXDisplay* m_display;
wxWindow* m_window;
WXRegion m_currentRegion; // Current clipping region (incl. paint clip region)
WXRegion m_userRegion; // User-defined clipping region
WXPixmap m_pixmap; // Pixmap for drawing on
// Not sure if we'll need all of these
int m_backgroundPixel;
wxColour m_currentColour;
// int m_currentBkMode;
int m_currentPenWidth ;
int m_currentPenJoin ;
int m_currentPenCap ;
int m_currentPenDashCount ;
wxX11Dash* m_currentPenDash ;
wxBitmap m_currentStipple ;
int m_currentStyle ;
int m_currentFill ;
int m_autoSetting ; // See comment in dcclient.cpp
WXFont m_oldFont;
};
class WXDLLEXPORT wxPaintDC: public wxWindowDC
{
DECLARE_DYNAMIC_CLASS(wxPaintDC)
public:
wxPaintDC() { }
wxPaintDC(wxWindow* win);
virtual void Clear();
~wxPaintDC();
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& colour);
virtual void SetTextBackground(const wxColour& colour);
virtual wxCoord GetCharHeight() const;
virtual wxCoord GetCharWidth() const;
virtual void DoGetTextExtent(const wxString& string,
wxCoord *x, wxCoord *y,
wxCoord *descent = NULL,
wxCoord *externalLeading = NULL,
wxFont *theFont = NULL) const;
virtual int GetDepth() const;
virtual wxSize GetPPI() const;
virtual void DestroyClippingRegion();
protected:
// implementation
// --------------
WXDisplay *m_display;
WXWindow m_window;
WXGC m_penGC;
WXGC m_brushGC;
WXGC m_textGC;
WXGC m_bgGC;
WXColormap m_cmap;
bool m_isMemDC;
bool m_isScreenDC;
wxWindow *m_owner;
wxRegion m_currentClippingRegion;
wxRegion m_paintClippingRegion;
void SetUpDC();
void Destroy();
void ComputeScaleAndOrigin();
private:
DECLARE_DYNAMIC_CLASS(wxWindowDC)
};
class WXDLLEXPORT wxClientDC: public wxWindowDC
{
DECLARE_DYNAMIC_CLASS(wxClientDC)
//-----------------------------------------------------------------------------
// wxClientDC
//-----------------------------------------------------------------------------
class wxClientDC : public wxWindowDC
{
public:
wxClientDC() { }
wxClientDC(wxWindow* win) : wxWindowDC(win) { }
wxClientDC( wxWindow *win );
protected:
virtual void DoGetSize(int *width, int *height) const;
private:
DECLARE_DYNAMIC_CLASS(wxClientDC)
};
//-----------------------------------------------------------------------------
// wxPaintDC
//-----------------------------------------------------------------------------
class wxPaintDC : public wxClientDC
{
public:
wxPaintDC() { }
wxPaintDC( wxWindow *win );
private:
DECLARE_DYNAMIC_CLASS(wxPaintDC)
};
#endif

11
include/wx/x11/dcmemory.h
View File

@@ -20,23 +20,18 @@
class wxMemoryDC : public wxWindowDC
{
DECLARE_DYNAMIC_CLASS(wxMemoryDC)
public:
wxMemoryDC();
wxMemoryDC( wxDC *dc ); // Create compatible DC
~wxMemoryDC();
virtual void SelectObject( const wxBitmap& bitmap );
void DoGetSize( int *width, int *height ) const;
wxBitmap& GetBitmap() const { return (wxBitmap&) m_bitmap; }
// implementation
wxBitmap m_selected;
private:
friend class wxPaintDC;
wxBitmap m_bitmap;
DECLARE_DYNAMIC_CLASS(wxMemoryDC)
};
#endif

35
include/wx/x11/dcscreen.h
View File

@@ -18,31 +18,34 @@
#include "wx/dcclient.h"
class WXDLLEXPORT wxScreenDC: public wxWindowDC
//-----------------------------------------------------------------------------
// wxScreenDC
//-----------------------------------------------------------------------------
class wxScreenDC : public wxPaintDC
{
DECLARE_DYNAMIC_CLASS(wxScreenDC)
public:
// Create a DC representing the whole screen
wxScreenDC();
~wxScreenDC();
virtual ~wxScreenDC();
// Compatibility with X's requirements for
// drawing on top of all windows
static bool StartDrawingOnTop(wxWindow* window);
static bool StartDrawingOnTop(wxRect* rect = NULL);
static bool StartDrawingOnTop( wxWindow *window );
static bool StartDrawingOnTop( wxRect *rect = (wxRect *) NULL );
static bool EndDrawingOnTop();
private:
static WXWindow sm_overlayWindow;
// implementation
// If we have started transparent drawing at a non-(0,0) point
// then we will have to adjust the device origin in the
// constructor.
static int sm_overlayWindowX;
static int sm_overlayWindowY;
static WXWindow *sm_overlayWindow;
static int sm_overlayWindowX;
static int sm_overlayWindowY;
protected:
virtual void DoGetSize(int *width, int *height) const;
private:
DECLARE_DYNAMIC_CLASS(wxScreenDC)
};
#endif
// _WX_DCSCREEN_H_

3
include/wx/x11/window.h
View File

@@ -123,6 +123,9 @@ public:
// Generates paint events
void X11SendPaintEvents();
// Clip to paint region?
bool GetClipPaintRegion() { return m_clipPaintRegion; }
// sets the fore/background colour for the given widget
static void DoChangeForegroundColour(WXWindow widget, wxColour& foregroundColour);
static void DoChangeBackgroundColour(WXWindow widget, wxColour& backgroundColour, bool changeArmColour = FALSE);

4
src/gtk/dcclient.cpp
View File

@@ -246,6 +246,8 @@ wxWindowDC::wxWindowDC()
wxWindowDC::wxWindowDC( wxWindow *window )
{
wxASSERT_MSG( window, wxT("DC needs a window") );
m_penGC = (GdkGC *) NULL;
m_brushGC = (GdkGC *) NULL;
m_textGC = (GdkGC *) NULL;
@@ -256,8 +258,6 @@ wxWindowDC::wxWindowDC( wxWindow *window )
m_isScreenDC = FALSE;
m_font = window->GetFont();
wxASSERT_MSG( window, wxT("DC needs a window") );
GtkWidget *widget = window->m_wxwindow;
// some controls don't have m_wxwindow - like wxStaticBox, but the user

4
src/gtk1/dcclient.cpp
View File

@@ -246,6 +246,8 @@ wxWindowDC::wxWindowDC()
wxWindowDC::wxWindowDC( wxWindow *window )
{
wxASSERT_MSG( window, wxT("DC needs a window") );
m_penGC = (GdkGC *) NULL;
m_brushGC = (GdkGC *) NULL;
m_textGC = (GdkGC *) NULL;
@@ -256,8 +258,6 @@ wxWindowDC::wxWindowDC( wxWindow *window )
m_isScreenDC = FALSE;
m_font = window->GetFont();
wxASSERT_MSG( window, wxT("DC needs a window") );
GtkWidget *widget = window->m_wxwindow;
// some controls don't have m_wxwindow - like wxStaticBox, but the user

2
src/x11/bitmap.cpp
View File

@@ -531,11 +531,13 @@ wxBitmap wxCreateMaskedBitmap(const wxBitmap& bitmap, wxColour& colour)
srcDC.SelectObject(bitmap);
destDC.SelectObject(newBitmap);
#if 0
wxBrush brush(colour, wxSOLID);
destDC.SetOptimization(FALSE);
destDC.SetBackground(brush);
destDC.Clear();
destDC.Blit(0, 0, bitmap.GetWidth(), bitmap.GetHeight(), & srcDC, 0, 0, wxCOPY, TRUE);
#endif
return newBitmap;
}

412
src/x11/colour.cpp
View File

@@ -1,214 +1,254 @@
/////////////////////////////////////////////////////////////////////////////
// Name: colour.cpp
// Purpose: wxColour class
// Author: Julian Smart
// Author: Julian Smart, Robert Roebling
// Modified by:
// Created: 17/09/98
// RCS-ID: $Id$
// Copyright: (c) Julian Smart
// Copyright: (c) Julian Smart, Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
//// TODO: make wxColour a ref-counted object,
//// so pixel values get shared.
#ifdef __GNUG__
#pragma implementation "colour.h"
#endif
#include "wx/gdicmn.h"
#include "wx/colour.h"
#include "wx/app.h"
#ifdef __VMS__
#pragma message disable nosimpint
#endif
#include <Xm/Xm.h>
#ifdef __VMS__
#pragma message enable nosimpint
#endif
#include "wx/x11/private.h"
IMPLEMENT_DYNAMIC_CLASS(wxColour, wxObject)
//-----------------------------------------------------------------------------
// wxColour
//-----------------------------------------------------------------------------
// Colour
wxColour::wxColour ()
class wxColourRefData: public wxObjectRefData
{
m_isInit = FALSE;
m_red = m_blue = m_green = 0;
m_pixel = -1;
}
wxColour::wxColour (unsigned char r, unsigned char g, unsigned char b)
{
m_red = r;
m_green = g;
m_blue = b;
m_isInit = TRUE;
m_pixel = -1;
}
wxColour::wxColour (const wxColour& col)
{
m_red = col.m_red;
m_green = col.m_green;
m_blue = col.m_blue;
m_isInit = col.m_isInit;
m_pixel = col.m_pixel;
}
wxColour& wxColour::operator =(const wxColour& col)
{
m_red = col.m_red;
m_green = col.m_green;
m_blue = col.m_blue;
m_isInit = col.m_isInit;
m_pixel = col.m_pixel;
return *this;
}
void wxColour::InitFromName(const wxString& col)
{
wxColour *the_colour = wxTheColourDatabase->FindColour (col);
if (the_colour)
public:
wxColourRefData()
{
m_red = the_colour->Red ();
m_green = the_colour->Green ();
m_blue = the_colour->Blue ();
m_pixel = the_colour->m_pixel;
m_isInit = TRUE;
m_color.red = 0;
m_color.green = 0;
m_color.blue = 0;
m_color.pixel = 0;
m_colormap = (WXColormap *) NULL;
m_hasPixel = FALSE;
}
~wxColourRefData()
{
FreeColour();
}
bool operator == (const wxColourRefData& data) const
{
return (m_colormap == data.m_colormap &&
m_hasPixel == data.m_hasPixel &&
m_color.red == data.m_color.red &&
m_color.green == data.m_color.green &&
m_color.blue == data.m_color.blue &&
m_color.pixel == data.m_color.pixel);
}
void FreeColour();
void AllocColour( WXColormap cmap );
XColor m_color;
WXColormap m_colormap;
bool m_hasPixel;
friend class wxColour;
// reference counter for systems with <= 8-Bit display
static unsigned short colMapAllocCounter[ 256 ];
};
unsigned short wxColourRefData::colMapAllocCounter[ 256 ] =
{
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
void wxColourRefData::FreeColour()
{
if (m_colormap)
{
Colormap cm = (Colormap)m_colormap;
#if 0
GdkColormapPrivate *private_colormap = (GdkColormapPrivate*) m_colormap;
if ((private_colormap->visual->type == GDK_VISUAL_GRAYSCALE) ||
(private_colormap->visual->type == GDK_VISUAL_PSEUDO_COLOR))
{
int idx = m_color.pixel;
colMapAllocCounter[ idx ] = colMapAllocCounter[ idx ] - 1;
if (colMapAllocCounter[ idx ] == 0)
gdk_colormap_free_colors( m_colormap, &m_color, 1 );
}
#endif
}
}
void wxColourRefData::AllocColour( WXColormap cmap )
{
if (m_hasPixel && (m_colormap == cmap))
return;
FreeColour();
#if 0
GdkColormapPrivate *private_colormap = (GdkColormapPrivate*) cmap;
if ((private_colormap->visual->type == GDK_VISUAL_GRAYSCALE) ||
(private_colormap->visual->type == GDK_VISUAL_PSEUDO_COLOR))
{
m_hasPixel = gdk_colormap_alloc_color( cmap, &m_color, FALSE, TRUE );
int idx = m_color.pixel;
colMapAllocCounter[ idx ] = colMapAllocCounter[ idx ] + 1;
}
else
#endif
{
m_hasPixel = XAllocColor( wxGlobalDisplay(), (Colormap) cmap, &m_color );
}
m_colormap = cmap;
}
//-----------------------------------------------------------------------------
#define M_COLDATA ((wxColourRefData *)m_refData)
#define SHIFT (8*(sizeof(short int)-sizeof(char)))
IMPLEMENT_DYNAMIC_CLASS(wxColour,wxGDIObject)
wxColour::wxColour( unsigned char red, unsigned char green, unsigned char blue )
{
m_refData = new wxColourRefData();
M_COLDATA->m_color.red = ((unsigned short)red) << SHIFT;
M_COLDATA->m_color.green = ((unsigned short)green) << SHIFT;
M_COLDATA->m_color.blue = ((unsigned short)blue) << SHIFT;
M_COLDATA->m_color.pixel = 0;
}
void wxColour::InitFromName( const wxString &colourName )
{
wxNode *node = (wxNode *) NULL;
if ( (wxTheColourDatabase) && (node = wxTheColourDatabase->Find(colourName)) )
{
wxColour *col = (wxColour*)node->Data();
UnRef();
if (col) Ref( *col );
}
else
{
m_red = 0;
m_green = 0;
m_blue = 0;
m_isInit = FALSE;
}
}
wxColour::~wxColour ()
{
}
void wxColour::Set (unsigned char r, unsigned char g, unsigned char b)
{
m_red = r;
m_green = g;
m_blue = b;
m_isInit = TRUE;
m_pixel = -1;
}
// Allocate a colour, or nearest colour, using the given display.
// If realloc is TRUE, ignore the existing pixel, otherwise just return
// the existing one.
// Returns the old or allocated pixel.
// TODO: can this handle mono displays? If not, we should have an extra
// flag to specify whether this should be black or white by default.
int wxColour::AllocColour(WXDisplay* display, bool realloc)
{
if ((m_pixel != -1) && !realloc)
return m_pixel;
XColor color;
color.red = (unsigned short) Red ();
color.red |= color.red << 8;
color.green = (unsigned short) Green ();
color.green |= color.green << 8;
color.blue = (unsigned short) Blue ();
color.blue |= color.blue << 8;
color.flags = DoRed | DoGreen | DoBlue;
WXColormap cmap = wxTheApp->GetMainColormap(display);
if (!XAllocColor ((Display*) display, (Colormap) cmap, &color))
{
m_pixel = wxGetBestMatchingPixel((Display*) display, &color,(Colormap) cmap);
return m_pixel;
}
else
{
m_pixel = (int) color.pixel;
return m_pixel;
}
}
/*-------------------------------------------
Markus Emmenegger <mege@iqe.ethz.ch>
Find the pixel value with an assigned color closest to the desired color
Used if color cell allocation fails
As the returned pixel value may be in use by another application,
the color might change anytime.
But in many cases, that is still better than always using black.
--
Chris Breeze <chris@hel.co.uk>
Improvements:
1) More efficient calculation of RGB distance of colour cell from
the desired colour. There is no need to take the sqrt of 'dist', and
since we are only interested in the top 8-bits of R, G and B we
can perform integer arithmetic.
2) Attempt to allocate a read-only colour when a close match is found.
A read-only colour will not change.
3) Fall back to the closest match if no read-only colours are available.
Possible further improvements:
1) Scan the lookup table and sort the colour cells in order of
increasing
distance from the desired colour. Then attempt to allocate a
read-only
colour starting from the nearest match.
2) Linear RGB distance is not a particularly good method of colour
matching
(though it is quick). Converting the colour to HLS and then comparing
may give better matching.
-------------------------------------------*/
int wxGetBestMatchingPixel(Display *display, XColor *desiredColor, Colormap cmap)
{
if (cmap == (Colormap) NULL)
cmap = (Colormap) wxTheApp->GetMainColormap(display);
int numPixVals = XDisplayCells(display, DefaultScreen (display));
int mindist = 256 * 256 * 3;
int bestpixel = (int) BlackPixel (display, DefaultScreen (display));
int red = desiredColor->red >> 8;
int green = desiredColor->green >> 8;
int blue = desiredColor->blue >> 8;
const int threshold = 2 * 2 * 3; // allow an error of up to 2 in R,G & B
for (int pixelcount = 0; pixelcount < numPixVals; pixelcount++)
{
XColor matching_color;
matching_color.pixel = pixelcount;
XQueryColor(display,cmap,&matching_color);
int delta_red = red - (matching_color.red >> 8);
int delta_green = green - (matching_color.green >> 8);
int delta_blue = blue - (matching_color.blue >> 8);
int dist = delta_red * delta_red +
delta_green * delta_green +
delta_blue * delta_blue;
if (dist <= threshold)
m_refData = new wxColourRefData();
if (!XParseColor( wxGlobalDisplay(), (Colormap) M_COLDATA->m_colormap, colourName.mb_str(), &M_COLDATA->m_color ))
{
// try to allocate a read-only colour...
if (XAllocColor (display, cmap, &matching_color))
{
return matching_color.pixel;
}
}
if (dist < mindist)
{
bestpixel = pixelcount;
mindist = dist;
// VZ: asserts are good in general but this one is triggered by
// calling wxColourDatabase::FindColour() with an
// unrecognized colour name and this can't be avoided from the
// user code, so don't give it here
//
// a better solution would be to changed code in FindColour()
//wxFAIL_MSG( wxT("wxColour: couldn't find colour") );
delete m_refData;
m_refData = (wxObjectRefData *) NULL;
}
}
return bestpixel;
}
wxColour::~wxColour()
{
}
bool wxColour::operator == ( const wxColour& col ) const
{
if (m_refData == col.m_refData) return TRUE;
if (!m_refData || !col.m_refData) return FALSE;
XColor *own = &(((wxColourRefData*)m_refData)->m_color);
XColor *other = &(((wxColourRefData*)col.m_refData)->m_color);
if (own->red != other->red) return FALSE;
if (own->blue != other->blue) return FALSE;
if (own->green != other->green) return FALSE;
return TRUE;
}
wxObjectRefData *wxColour::CreateRefData() const
{
return new wxColourRefData;
}
wxObjectRefData *wxColour::CloneRefData(const wxObjectRefData *data) const
{
return new wxColourRefData(*(wxColourRefData *)data);
}
void wxColour::Set( unsigned char red, unsigned char green, unsigned char blue )
{
AllocExclusive();
m_refData = new wxColourRefData();
M_COLDATA->m_color.red = ((unsigned short)red) << SHIFT;
M_COLDATA->m_color.green = ((unsigned short)green) << SHIFT;
M_COLDATA->m_color.blue = ((unsigned short)blue) << SHIFT;
M_COLDATA->m_color.pixel = 0;
}
unsigned char wxColour::Red() const
{
wxCHECK_MSG( Ok(), 0, wxT("invalid colour") );
return (unsigned char)(M_COLDATA->m_color.red >> SHIFT);
}
unsigned char wxColour::Green() const
{
wxCHECK_MSG( Ok(), 0, wxT("invalid colour") );
return (unsigned char)(M_COLDATA->m_color.green >> SHIFT);
}
unsigned char wxColour::Blue() const
{
wxCHECK_MSG( Ok(), 0, wxT("invalid colour") );
return (unsigned char)(M_COLDATA->m_color.blue >> SHIFT);
}
void wxColour::CalcPixel( WXColormap cmap )
{
if (!Ok()) return;
M_COLDATA->AllocColour( cmap );
}
unsigned long wxColour::GetPixel() const
{
wxCHECK_MSG( Ok(), 0, wxT("invalid colour") );
return M_COLDATA->m_color.pixel;
}
WXColor *wxColour::GetColor() const
{
wxCHECK_MSG( Ok(), (WXColor *) NULL, wxT("invalid colour") );
return (WXColor*) &M_COLDATA->m_color;
}

58
src/x11/dc.cpp
View File

@@ -38,44 +38,28 @@ wxDC::wxDC()
{
m_ok = FALSE;
#if 1
m_mm_to_pix_x = 1.0;
m_mm_to_pix_y = 1.0;
#else
m_mm_to_pix_x = (double)wxGetDisplaySize().GetWidth() /
(double)wxGetDisplaySizeMM().GetWidth();
m_mm_to_pix_y = (double)wxGetDisplaySize().GetHeight() /
(double)wxGetDisplaySizeMM().GetHeight();
#endif
m_needComputeScaleX = FALSE; /* not used yet */
m_needComputeScaleY = FALSE; /* not used yet */
m_logicalFunction = wxCOPY;
m_pen = *wxBLACK_PEN;
m_font = *wxNORMAL_FONT;
m_brush = *wxWHITE_BRUSH;
m_backgroundMode = wxTRANSPARENT;
m_isInteractive = FALSE;
}
void wxDC::DoDrawIcon( const wxIcon &icon, wxCoord x, wxCoord y)
{
wxCHECK_RET( Ok(), "invalid dc" );
wxCHECK_RET( icon.Ok(), "invalid icon" );
DoDrawBitmap(icon, x, y, TRUE);
}
void wxDC::DoDrawBitmap( const wxBitmap& bitmap, wxCoord x, wxCoord y, bool useMask )
{
wxCHECK_RET( bitmap.Ok(), "invalid bitmap" );
wxMemoryDC memDC;
memDC.SelectObject(bitmap);
#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
memDC.SetBackground(* GetBackground());
memDC.Clear();
}
#endif // 0
Blit(x, y, bitmap.GetWidth(), bitmap.GetHeight(), &memDC, 0, 0, wxCOPY, useMask);
memDC.SelectObject(wxNullBitmap);
m_isInteractive = FALSE; // ???
}
void wxDC::DoSetClippingRegion( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
@@ -92,14 +76,6 @@ void wxDC::DestroyClippingRegion()
m_clipping = FALSE;
}
void wxDC::DoGetSize( int* width, int* height ) const
{
if ( width )
*width = m_maxX - m_minX;
if ( height )
*height = m_maxY - m_minY;
}
void wxDC::DoGetSizeMM( int* width, int* height ) const
{
int w, h;

2995
src/x11/dcclient.cpp
View File

File diff suppressed because it is too large Load Diff

144
src/x11/dcmemory.cpp
View File

@@ -17,142 +17,72 @@
#include "wx/settings.h"
#include "wx/utils.h"
#ifdef __VMS__
#pragma message disable nosimpint
#endif
#ifdef __VMS__
#pragma message enable nosimpint
#endif
#include "wx/x11/private.h"
//-----------------------------------------------------------------------------
// wxMemoryDC
//-----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxMemoryDC,wxWindowDC)
IMPLEMENT_DYNAMIC_CLASS(wxMemoryDC, wxWindowDC)
wxMemoryDC::wxMemoryDC(void)
wxMemoryDC::wxMemoryDC() : wxWindowDC()
{
m_ok = TRUE;
m_display = wxGetDisplay();
m_ok = FALSE;
Display* display = (Display*) m_display;
m_display = (WXDisplay *) wxGlobalDisplay();
XGCValues gcvalues;
gcvalues.foreground = BlackPixel (display, DefaultScreen (display));
gcvalues.background = WhitePixel (display, DefaultScreen (display));
gcvalues.graphics_exposures = False;
gcvalues.subwindow_mode = IncludeInferiors;
gcvalues.line_width = 1;
m_gc = (WXGC) XCreateGC (display, RootWindow (display, DefaultScreen (display)),
GCForeground | GCBackground | GCGraphicsExposures | GCLineWidth | GCSubwindowMode,
&gcvalues);
int screen = DefaultScreen( wxGlobalDisplay() );
m_cmap = (WXColormap) DefaultColormap( wxGlobalDisplay(), screen );
}
m_backgroundPixel = (int) gcvalues.background;
// Get the current Font so we can set it back later
XGCValues valReturn;
XGetGCValues((Display*) m_display, (GC) m_gc, GCFont, &valReturn);
m_oldFont = (WXFont) valReturn.font;
SetBrush (* wxWHITE_BRUSH);
SetPen (* wxBLACK_PEN);
SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
};
wxMemoryDC::wxMemoryDC( wxDC* dc )
wxMemoryDC::wxMemoryDC( wxDC *WXUNUSED(dc) )
: wxWindowDC()
{
m_ok = TRUE;
if (dc && dc->IsKindOf(CLASSINFO(wxWindowDC)))
m_display = ((wxWindowDC*)dc)->GetDisplay();
else
m_display = wxGetDisplay();
m_ok = FALSE;
Display* display = (Display*) m_display;
m_display = (WXDisplay *) wxGlobalDisplay();
XGCValues gcvalues;
gcvalues.foreground = BlackPixel (display, DefaultScreen (display));
gcvalues.background = WhitePixel (display, DefaultScreen (display));
gcvalues.graphics_exposures = False;
gcvalues.subwindow_mode = IncludeInferiors;
gcvalues.line_width = 1;
m_gc = (WXGC) XCreateGC (display, RootWindow (display, DefaultScreen (display)),
GCForeground | GCBackground | GCGraphicsExposures | GCLineWidth | GCSubwindowMode,
&gcvalues);
int screen = DefaultScreen( wxGlobalDisplay() );
m_cmap = (WXColormap) DefaultColormap( wxGlobalDisplay(), screen );
}
m_backgroundPixel = (int) gcvalues.background;
// Get the current Font so we can set it back later
XGCValues valReturn;
XGetGCValues((Display*) m_display, (GC) m_gc, GCFont, &valReturn);
m_oldFont = (WXFont) valReturn.font;
SetBrush (* wxWHITE_BRUSH);
SetPen (* wxBLACK_PEN);
};
wxMemoryDC::~wxMemoryDC(void)
wxMemoryDC::~wxMemoryDC()
{
};
}
void wxMemoryDC::SelectObject( const wxBitmap& bitmap )
{
m_bitmap = bitmap;
Destroy();
if (m_gc)
XFreeGC((Display*) m_display, (GC) m_gc);
m_gc = (WXGC) NULL;
if (m_bitmap.Ok() && (bitmap.GetDisplay() == m_display))
m_selected = bitmap;
if (m_selected.Ok())
{
m_pixmap = m_bitmap.GetPixmap();
Display* display = (Display*) m_display;
if (m_selected.GetPixmap())
{
m_window = (WXWindow) m_selected.GetPixmap();
}
else
{
// m_window = m_selected.GetBitmap();
}
XGCValues gcvalues;
gcvalues.foreground = BlackPixel (display, DefaultScreen (display));
gcvalues.background = WhitePixel (display, DefaultScreen (display));
gcvalues.graphics_exposures = False;
gcvalues.subwindow_mode = IncludeInferiors;
gcvalues.line_width = 1;
m_gc = (WXGC) XCreateGC (display, RootWindow (display, DefaultScreen (display)),
GCForeground | GCBackground | GCGraphicsExposures | GCLineWidth | GCSubwindowMode,
&gcvalues);
m_isMemDC = TRUE;
m_backgroundPixel = (int) gcvalues.background;
// Get the current Font so we can set it back later
XGCValues valReturn;
XGetGCValues((Display*) m_display, (GC) m_gc, GCFont, &valReturn);
m_oldFont = (WXFont) valReturn.font;
bool oldOpt = GetOptimization();
SetOptimization(FALSE);
SetBrush (* wxWHITE_BRUSH);
SetPen (* wxBLACK_PEN);
SetOptimization(oldOpt);
m_ok = TRUE;
SetUpDC();
}
else
{
m_ok = FALSE;
m_pixmap = (WXPixmap) 0;
};
};
m_window = NULL;
}
}
void wxMemoryDC::DoGetSize( int *width, int *height ) const
{
if (m_bitmap.Ok())
if (m_selected.Ok())
{
if (width) (*width) = m_bitmap.GetWidth();
if (height) (*height) = m_bitmap.GetHeight();
if (width) (*width) = m_selected.GetWidth();
if (height) (*height) = m_selected.GetHeight();
}
else
{
if (width) (*width) = 0;
if (height) (*height) = 0;
};
};
}
}

153
src/x11/dcscreen.cpp
View File

@@ -1,11 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: dcscreen.cpp
// Purpose: wxScreenDC class
// Author: Julian Smart
// Author: Julian Smart, Robert Roebling
// Modified by:
// Created: 17/09/98
// RCS-ID: $Id$
// Copyright: (c) Julian Smart
// Copyright: (c) Julian Smart, Robert Roebling
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -18,117 +18,102 @@
#include "wx/dcscreen.h"
#include "wx/utils.h"
#ifdef __VMS__
#pragma message disable nosimpint
#endif
#ifdef __VMS__
#pragma message enable nosimpint
#endif
#include "wx/x11/private.h"
IMPLEMENT_DYNAMIC_CLASS(wxScreenDC, wxWindowDC)
//-----------------------------------------------------------------------------
// global data initialization
//-----------------------------------------------------------------------------
WXWindow wxScreenDC::sm_overlayWindow = 0;
WXWindow *wxScreenDC::sm_overlayWindow = (WXWindow*) NULL;
int wxScreenDC::sm_overlayWindowX = 0;
int wxScreenDC::sm_overlayWindowY = 0;
// Create a DC representing the whole screen
//-----------------------------------------------------------------------------
// wxScreenDC
//-----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxScreenDC,wxPaintDC)
wxScreenDC::wxScreenDC()
{
m_display = wxGetDisplay();
Display* display = (Display*) m_display;
m_ok = FALSE;
if (sm_overlayWindow)
{
m_pixmap = sm_overlayWindow;
m_deviceOriginX = - sm_overlayWindowX;
m_deviceOriginY = - sm_overlayWindowY;
}
else
m_pixmap = (WXPixmap) RootWindow(display, DefaultScreen(display));
m_display = (WXDisplay *) wxGlobalDisplay();
XGCValues gcvalues;
gcvalues.foreground = BlackPixel (display, DefaultScreen (display));
gcvalues.background = WhitePixel (display, DefaultScreen (display));
gcvalues.graphics_exposures = False;
gcvalues.subwindow_mode = IncludeInferiors;
gcvalues.line_width = 1;
m_gc = XCreateGC (display, RootWindow (display, DefaultScreen (display)),
GCForeground | GCBackground | GCGraphicsExposures | GCLineWidth | GCSubwindowMode,
&gcvalues);
int screen = DefaultScreen( (Display*) m_display );
m_cmap = (WXColormap) DefaultColormap( (Display*) m_display, screen );
m_backgroundPixel = (int) gcvalues.background;
m_ok = TRUE;
m_window = (WXWindow) RootWindow( (Display*) m_display, screen );
m_isScreenDC = TRUE;
SetUpDC();
XSetSubwindowMode( (Display*) m_display, (GC) m_penGC, IncludeInferiors );
XSetSubwindowMode( (Display*) m_display, (GC) m_brushGC, IncludeInferiors );
XSetSubwindowMode( (Display*) m_display, (GC) m_textGC, IncludeInferiors );
XSetSubwindowMode( (Display*) m_display, (GC) m_bgGC, IncludeInferiors );
}
wxScreenDC::~wxScreenDC()
{
XSetSubwindowMode( (Display*) m_display, (GC) m_penGC, ClipByChildren );
XSetSubwindowMode( (Display*) m_display, (GC) m_brushGC, ClipByChildren );
XSetSubwindowMode( (Display*) m_display, (GC) m_textGC, ClipByChildren );
XSetSubwindowMode( (Display*) m_display, (GC) m_bgGC, ClipByChildren );
EndDrawingOnTop();
}
bool wxScreenDC::StartDrawingOnTop(wxWindow* window)
bool wxScreenDC::StartDrawingOnTop( wxWindow *window )
{
wxRect rect;
int x, y, width, height;
window->GetPosition(& x, & y);
if (window->GetParent() && !window->IsKindOf(CLASSINFO(wxFrame)))
window->GetParent()->ClientToScreen(& x, & y);
window->GetSize(& width, & height);
rect.x = x; rect.y = y;
rect.width = width; rect.height = height;
return StartDrawingOnTop(& rect);
}
bool wxScreenDC::StartDrawingOnTop(wxRect* rect)
{
if (sm_overlayWindow)
return FALSE;
Display *dpy = (Display*) wxGetDisplay();
Pixmap screenPixmap = RootWindow(dpy, DefaultScreen(dpy));
if (!window) return StartDrawingOnTop();
int x = 0;
int y = 0;
int width, height;
wxDisplaySize(&width, &height);
window->GetPosition( &x, &y );
int w = 0;
int h = 0;
window->GetSize( &w, &h );
window->ClientToScreen( &x, &y );
wxRect rect;
rect.x = x;
rect.y = y;
rect.width = 0;
rect.height = 0;
return StartDrawingOnTop( &rect );
}
bool wxScreenDC::StartDrawingOnTop( wxRect *rect )
{
int x = 0;
int y = 0;
#if 0
int width = gdk_screen_width();
int height = gdk_screen_height();
#else
int width = 1024;
int height = 768;
#endif
if (rect)
{
x = rect->x; y = rect->y;
width = rect->width; height = rect->height;
x = rect->x;
y = rect->y;
width = rect->width;
height = rect->height;
}
sm_overlayWindowX = x;
sm_overlayWindowY = y;
XSetWindowAttributes attributes;
attributes.override_redirect = True;
unsigned long valueMask = CWOverrideRedirect;
sm_overlayWindow = (WXWindow) XCreateWindow(dpy, screenPixmap, x, y, width, height, 0,
wxDisplayDepth(), InputOutput,
DefaultVisual(dpy, 0), valueMask,
& attributes);
if (sm_overlayWindow)
{
XMapWindow(dpy, (Window) sm_overlayWindow);
return TRUE;
}
else
return FALSE;
return TRUE;
}
bool wxScreenDC::EndDrawingOnTop()
{
if (sm_overlayWindow)
{
XDestroyWindow((Display*) wxGetDisplay(), (Window) sm_overlayWindow);
sm_overlayWindow = 0;
return TRUE;
}
else
return FALSE;
return TRUE;
}
void wxScreenDC::DoGetSize(int *width, int *height) const
{
wxDisplaySize(width, height);
}

53
src/x11/window.cpp
View File

@@ -121,11 +121,7 @@ bool wxWindowX11::Create(wxWindow *parent, wxWindowID id,
CreateBase(parent, id, pos, size, style, wxDefaultValidator, name);
if (parent)
parent->AddChild(this);
m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
m_foregroundColour = *wxBLACK;
parent->AddChild(this);
int w = size.GetWidth();
int h = size.GetHeight();
@@ -136,18 +132,25 @@ bool wxWindowX11::Create(wxWindow *parent, wxWindowID id,
if (x == -1) x = 0;
if (y == -1) y = 0;
int screen = DefaultScreen(wxGlobalDisplay());
Display *xdisplay = (Display*) wxGlobalDisplay();
int xscreen = DefaultScreen( xdisplay );
Colormap cm = DefaultColormap( xdisplay, xscreen );
Window parentWindow;
if (parent)
parentWindow = (Window) parent->GetMainWindow();
else
parentWindow = RootWindow(wxGlobalDisplay(), screen);
m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
m_backgroundColour.CalcPixel( (WXColormap) cm );
Window window = XCreateSimpleWindow(wxGlobalDisplay(), parentWindow,
m_foregroundColour = *wxBLACK;
m_foregroundColour.CalcPixel( (WXColormap) cm );
Window parentWindow = (Window) parent->GetMainWindow();
Window window = XCreateSimpleWindow(
xdisplay, parentWindow,
x, y, w, h, 0,
m_backgroundColour.AllocColour(wxGlobalDisplay()),
m_foregroundColour.AllocColour(wxGlobalDisplay()));
m_backgroundColour.GetPixel(),
m_foregroundColour.GetPixel() );
m_mainWidget = (WXWindow) window;
// Select event types wanted
@@ -411,6 +414,7 @@ void wxWindowX11::WarpPointer (int x, int y)
// Does a physical scroll
void wxWindowX11::ScrollWindow(int dx, int dy, const wxRect *rect)
{
#if 0
int x, y, w, h;
if (rect)
{
@@ -573,10 +577,7 @@ void wxWindowX11::ScrollWindow(int dx, int dy, const wxRect *rect)
delete rect;
node = node->Next();
}
// TODO
// XmUpdateDisplay((Widget) GetMainWidget());
#endif
}
// ---------------------------------------------------------------------------
@@ -697,7 +698,7 @@ void wxWindowX11::DoGetClientSize(int *x, int *y) const
if (window)
{
XWindowAttributes attr;
Status status = XGetWindowAttributes(wxGlobalDisplay(), window, & attr);
Status status = XGetWindowAttributes( wxGlobalDisplay(), window, &attr );
wxASSERT(status);
if (status)
@@ -972,9 +973,9 @@ void wxWindowX11::X11SendPaintEvents()
m_clearRegion.Clear();
}
wxNcPaintEvent nc_paint_event( GetId() );
nc_paint_event.SetEventObject( this );
GetEventHandler()->ProcessEvent( nc_paint_event );
// wxNcPaintEvent nc_paint_event( GetId() );
// nc_paint_event.SetEventObject( this );
// GetEventHandler()->ProcessEvent( nc_paint_event );
wxPaintEvent paint_event( GetId() );
paint_event.SetEventObject( this );
@@ -1314,9 +1315,15 @@ bool wxWindowX11::SetBackgroundColour(const wxColour& col)
if (!GetMainWindow())
return FALSE;
Display *xdisplay = (Display*) wxGlobalDisplay();
int xscreen = DefaultScreen( xdisplay );
Colormap cm = DefaultColormap( xdisplay, xscreen );
wxColour colour( col );
colour.CalcPixel( (WXColormap) cm );
XSetWindowAttributes attrib;
attrib.background_pixel = colour.AllocColour(wxGlobalDisplay());
attrib.background_pixel = colour.GetPixel();
XChangeWindowAttributes(wxGlobalDisplay(),
(Window) GetMainWindow(),