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

wxDisplay cleanup/rewrite:

Browse Source 
- wxDisplay is now a concrete class and uses a pImpl-based design
- got rid of four duplicate but subtly different versions of trivial
  single display-only wxDisplay implementation (but 2 versions of Mac
  Classic and Mac CoreGraphics implementations each still remain...)
- assorted code simplifications and memory leaks fixes


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@38127 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
2006-03-16 04:23:07 +00:00
parent 8072477d51
commit ef1717a963
23 changed files with 1739 additions and 2073 deletions
Download Patch File Download Diff File Expand all files Collapse all files

45
include/wx/cocoa/display.h
View File

@@ -1,45 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// Name: include/wx/cocoa/display.h
// Purpose: wxDisplay class for wxCocoa
// Author: Ryan Norton
// Modified by:
// Created: 2004-10-03
// RCS-ID: $Id$
// Copyright: (c) Ryan Norton
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_COCOA_DISPLAY_H_
#define _WX_COCOA_DISPLAY_H_
#include "wx/object.h"
#include "wx/display.h"
class wxRect;
class wxString;
class WXDLLEXPORT wxDisplay : public wxDisplayBase
{
public:
wxDisplay ( size_t index = 0 );
~wxDisplay();
virtual wxRect GetGeometry() const;
virtual int GetDepth() const;
virtual wxString GetName() const;
virtual wxArrayVideoModes
GetModes(const wxVideoMode& mode = wxDefaultVideoMode) const;
virtual wxVideoMode GetCurrentMode() const;
virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode);
private:
struct _CGDirectDisplayID * m_id;
DECLARE_NO_COPY_CLASS(wxDisplay)
};
#endif // _WX_COCOA_DISPLAY_H_

105
include/wx/display.h
View File

@@ -1,37 +1,43 @@
/////////////////////////////////////////////////////////////////////////////
// Name: wx/display.h
// Purpose: wxDisplay class
// Author: Royce Mitchell III
// Modified by: Vadim Zeitlin (resolution changes, display modes, ...)
// Author: Royce Mitchell III, Vadim Zeitlin
// Created: 06/21/02
// RCS-ID: $Id$
// Copyright: (c) 2002-2003 wxWidgets team
// Copyright: (c) 2002-2006 wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DISPLAY_H_BASE_
#define _WX_DISPLAY_H_BASE_
#if wxUSE_DISPLAY
// NB: no #if wxUSE_DISPLAY here, the display geometry part of this class (but
// not the video mode stuff) is always available but if wxUSE_DISPLAY == 0
// it becomes just a trivial wrapper around the old wxDisplayXXX() functions
#include "wx/dynarray.h"
#include "wx/vidmode.h"
#if wxUSE_DISPLAY
#include "wx/dynarray.h"
#include "wx/vidmode.h"
WX_DECLARE_EXPORTED_OBJARRAY(wxVideoMode, wxArrayVideoModes);
// default, uninitialized, video mode object
extern WXDLLEXPORT_DATA(const wxVideoMode) wxDefaultVideoMode;
#endif // wxUSE_DISPLAY
class WXDLLEXPORT wxWindow;
class WXDLLEXPORT wxPoint;
class WXDLLEXPORT wxRect;
class WXDLLEXPORT wxString;
WX_DECLARE_EXPORTED_OBJARRAY(wxVideoMode, wxArrayVideoModes);
// default, uninitialized, video mode object
extern WXDLLEXPORT_DATA(const wxVideoMode) wxDefaultVideoMode;
class WXDLLEXPORT wxDisplayFactory;
class WXDLLEXPORT wxDisplayImpl;
// ----------------------------------------------------------------------------
// wxDisplayBase: represents a display/monitor attached to the system
// wxDisplay: represents a display/monitor attached to the system
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxDisplayBase
class WXDLLEXPORT wxDisplay
{
public:
// initialize the object containing all information about the given
@@ -39,7 +45,12 @@ public:
//
// the displays are numbered from 0 to GetCount() - 1, 0 is always the
// primary display and the only one which is always supported
wxDisplayBase(size_t index = 0);
wxDisplay(size_t n = 0);
// dtor is not virtual as this is a concrete class not meant to be derived
// from
~wxDisplay();
// return the number of available displays, valid parameters to
// wxDisplay ctor are from 0 up to this number
@@ -55,18 +66,19 @@ public:
// return true if the object was initialized successfully
virtual bool IsOk() const { return true; }
bool IsOk() const { return m_impl != NULL; }
// get the display size
virtual wxRect GetGeometry() const = 0;
wxRect GetGeometry() const;
// name may be empty
virtual wxString GetName() const = 0;
wxString GetName() const;
// display 0 is usually the primary display
virtual bool IsPrimary() const { return m_index == 0; }
bool IsPrimary() const;
#if wxUSE_DISPLAY
// enumerate all video modes supported by this display matching the given
// one (in the sense of wxVideoMode::Match())
//
@@ -74,49 +86,40 @@ public:
// always at least one video mode supported by display, the returned array
// is only empty for the default value of the argument if this function is
// not supported at all on this platform
virtual wxArrayVideoModes
GetModes(const wxVideoMode& mode = wxDefaultVideoMode) const = 0;
wxArrayVideoModes
GetModes(const wxVideoMode& mode = wxDefaultVideoMode) const;
// get current video mode
virtual wxVideoMode GetCurrentMode() const = 0;
wxVideoMode GetCurrentMode() const;
// change current mode, return true if succeeded, false otherwise
//
// for the default value of the argument restores the video mode to default
virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode) = 0;
bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode);
// restore the default video mode (just a more readable synonym)
void ResetMode() { (void)ChangeMode(); }
// virtual dtor as for any base class
virtual ~wxDisplayBase() { }
protected:
// the index of this display (0 is always the primary one)
size_t m_index;
DECLARE_NO_COPY_CLASS(wxDisplayBase)
};
#if defined(__WXMSW__)
#include "wx/msw/display.h"
#elif defined(__WXMOTIF__)
#include "wx/unix/displayx11.h"
#elif defined(__WXGTK__)
#include "wx/unix/displayx11.h"
#elif defined(__WXX11__)
#include "wx/unix/displayx11.h"
#elif defined(__WXCOCOA__)
#include "wx/cocoa/display.h"
#elif defined(__WXMAC__)
#include "wx/mac/display.h"
#elif defined(__WXPM__)
#include "wx/os2/display.h"
#elif defined(__WXMGL__)
#include "wx/mgl/display.h"
#endif
#endif // wxUSE_DISPLAY
private:
// returns the factory used to implement our static methods and create new
// displays
static wxDisplayFactory& Factory();
// creates the factory object, called by Factory() when it is called for
// the first time and should return a pointer allocated with new (the
// caller will delete it)
//
// this method must be implemented in platform-specific code if
// wxUSE_DISPLAY == 1 (if it is 0 we provide the stub in common code)
static wxDisplayFactory *CreateFactory();
// the real implementation
wxDisplayImpl *m_impl;
DECLARE_NO_COPY_CLASS(wxDisplay)
};
#endif // _WX_DISPLAY_H_BASE_

105
include/wx/display_impl.h Normal file
View File

@@ -0,0 +1,105 @@
/////////////////////////////////////////////////////////////////////////////
// Name: wx/display_impl.h
// Purpose: wxDisplayImpl class declaration
// Author: Vadim Zeitlin
// Created: 2006-03-15
// RCS-ID: $Id$
// Copyright: (c) 2002-2006 Vadim Zeitlin <vadim@wxwindows.org>
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DISPLAY_IMPL_H_BASE_
#define _WX_DISPLAY_IMPL_H_BASE_
// ----------------------------------------------------------------------------
// wxDisplayFactory: allows to create wxDisplay objects
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxDisplayFactory
{
public:
wxDisplayFactory() { }
virtual ~wxDisplayFactory() { }
// create a new display object
//
// it can return a NULL pointer if the display creation failed
virtual wxDisplayImpl *CreateDisplay(size_t n) = 0;
// get the total number of displays
virtual size_t GetCount() = 0;
// return the display for the given point or wxNOT_FOUND
virtual int GetFromPoint(const wxPoint& pt) = 0;
// return the display for the given window or wxNOT_FOUND
//
// the window pointer must not be NULL (i.e. caller should check it)
virtual int GetFromWindow(wxWindow *window);
};
// ----------------------------------------------------------------------------
// wxDisplayImpl: base class for all wxDisplay implementations
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxDisplayImpl
{
public:
// virtual dtor for this base class
virtual ~wxDisplayImpl() { }
// return the full area of this display
virtual wxRect GetGeometry() const = 0;
// return the name (may be empty)
virtual wxString GetName() const = 0;
// return the index of this display
size_t GetIndex() const { return m_index; }
// return true if this is the primary monitor (usually one with index 0)
virtual bool IsPrimary() const { return GetIndex() == 0; }
#if wxUSE_DISPLAY
// implements wxDisplay::GetModes()
virtual wxArrayVideoModes GetModes(const wxVideoMode& mode) const = 0;
// get current video mode
virtual wxVideoMode GetCurrentMode() const = 0;
// change current mode, return true if succeeded, false otherwise
virtual bool ChangeMode(const wxVideoMode& mode) = 0;
#endif // wxUSE_DISPLAY
protected:
// create the object providing access to the display with the given index
wxDisplayImpl(size_t n) : m_index(n) { }
// the index of this display (0 is always the primary one)
const size_t m_index;
friend class wxDisplayFactory;
DECLARE_NO_COPY_CLASS(wxDisplayImpl)
};
// ----------------------------------------------------------------------------
// wxDisplayFactorySingle
// ----------------------------------------------------------------------------
// this is a stub implementation using single/main display only, it is
// available even if wxUSE_DISPLAY == 0
class WXDLLEXPORT wxDisplayFactorySingle : public wxDisplayFactory
{
public:
virtual wxDisplayImpl *CreateDisplay(size_t n);
virtual size_t GetCount() { return 1; }
virtual int GetFromPoint(const wxPoint& pt);
};
#endif // _WX_DISPLAY_IMPL_H_BASE_

46
include/wx/mac/carbon/display.h
View File

@@ -1,46 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// Name: display.h
// Purpose: wxDisplay class customization for Mac
// Author: Brian Victor/Royce Mitchel for non OSX / Ryan Norton for OS X
// Modified by:
// Created: 06/21/02
// RCS-ID: $Id$
// Copyright: (c) wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MAC_DISPLAY_H_
#define _WX_MAC_DISPLAY_H_
#include "wx/object.h"
#include "wx/display.h"
class wxDisplayMacPriv;
class wxRect;
class wxString;
class WXDLLEXPORT wxDisplay : public wxDisplayBase
{
public:
wxDisplay ( size_t index = 0 );
~wxDisplay();
virtual wxRect GetGeometry() const;
virtual int GetDepth() const;
virtual wxString GetName() const;
virtual wxArrayVideoModes
GetModes(const wxVideoMode& mode = wxDefaultVideoMode) const;
virtual wxVideoMode GetCurrentMode() const;
virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode);
private:
wxDisplayMacPriv* m_priv;
DECLARE_NO_COPY_CLASS(wxDisplay)
};
#endif // _WX_MAC_DISPLAY_H_

46
include/wx/mac/classic/display.h
View File

@@ -1,46 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// Name: display.h
// Purpose: wxDisplay class customization for Mac
// Author: Brian Victor
// Modified by: Royce Mitchell III
// Created: 06/21/02
// RCS-ID: $Id$
// Copyright: (c) wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MAC_DISPLAY_H_
#define _WX_MAC_DISPLAY_H_
#include "wx/object.h"
#include "wx/display.h"
class wxDisplayMacPriv;
class wxRect;
class wxString;
class WXDLLEXPORT wxDisplay : public wxDisplayBase
{
public:
wxDisplay ( size_t index = 0 );
~wxDisplay();
virtual wxRect GetGeometry() const;
virtual int GetDepth() const;
virtual wxString GetName() const;
virtual wxArrayVideoModes
GetModes(const wxVideoMode& mode = wxDefaultVideoMode) const;
virtual wxVideoMode GetCurrentMode() const;
virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode);
private:
wxDisplayMacPriv* m_priv;
DECLARE_NO_COPY_CLASS(wxDisplay)
};
#endif // _WX_MAC_DISPLAY_H_

5
include/wx/mac/display.h
View File

@@ -1,5 +0,0 @@
#ifdef __WXMAC_CLASSIC__
#include "wx/mac/classic/display.h"
#else
#include "wx/mac/carbon/display.h"
#endif

5
include/wx/mgl/chkconf.h
View File

@@ -56,6 +56,11 @@
# define wxUSE_CLIPBOARD 0
#endif /* wxUSE_CLIPBOARD */
#if wxUSE_DISPLAY
# undef wxUSE_DISPLAY
# define wxUSE_DISPLAY 0
#endif /* wxUSE_DISPLAY */
#if wxUSE_SOCKETS
# undef wxUSE_SOCKETS
# define wxUSE_SOCKETS 0

40
include/wx/mgl/display.h
View File

@@ -1,40 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// Name: wx/mgl/display.h
// Purpose: wxDisplay class customization for WXMGL
// Author: Wlodzimierz ABX Skiba
// Modified by:
// Created: 05/03/2006
// RCS-ID: $Id$
// Copyright: (c) Wlodzimierz Skiba
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MGL_DISPLAY_H_
#define _WX_MGL_DISPLAY_H_
class WXDLLEXPORT wxDisplay : public wxDisplayBase
{
public:
// create the display object for the given physical display
wxDisplay(size_t index = 0);
virtual ~wxDisplay();
// implement base class pure virtuals
virtual bool IsOk() const;
virtual wxRect GetGeometry() const;
virtual wxString GetName() const;
virtual wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode) const;
virtual wxVideoMode GetCurrentMode() const;
virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode);
virtual bool IsPrimary() const;
private:
DECLARE_NO_COPY_CLASS(wxDisplay)
};
#endif // _WX_MGL_DISPLAY_H_

51
include/wx/msw/display.h
View File

@@ -1,51 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// Name: display.h
// Purpose: wxDisplay class customization for WXMSW
// Author: Royce Mitchell III
// Modified by:
// Created: 06/21/02
// RCS-ID: $Id$
// Copyright: (c) wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_DISPLAY_H_
#define _WX_MSW_DISPLAY_H_
class WXDLLEXPORT wxDisplay : public wxDisplayBase
{
public:
// this function may be called *before* using any other wxDisplay methods
// to tell it to use DirectX functions instead of the standard Windows ones
static void UseDirectX(bool useDX);
// create the display object for the given physical display
wxDisplay(size_t index = 0);
virtual ~wxDisplay();
// implement base class pure virtuals
virtual bool IsOk() const;
virtual wxRect GetGeometry() const;
virtual wxString GetName() const;
virtual wxArrayVideoModes
GetModes(const wxVideoMode& mode = wxVideoMode()) const;
virtual wxVideoMode GetCurrentMode() const;
virtual bool ChangeMode(const wxVideoMode& mode = wxVideoMode());
virtual bool IsPrimary() const;
private:
// we have different implementations using DirectDraw and without it
wxArrayVideoModes DoGetModesDirectX(const wxVideoMode& modeMatch) const;
bool DoChangeModeDirectX(const wxVideoMode& mode);
wxArrayVideoModes DoGetModesWindows(const wxVideoMode& modeMatch) const;
bool DoChangeModeWindows(const wxVideoMode& mode);
DECLARE_NO_COPY_CLASS(wxDisplay)
};
#endif // _WX_MSW_DISPLAY_H_

5
include/wx/os2/chkconf.h
View File

@@ -21,6 +21,11 @@
to disable here features not supported currently or enable
features required */
#if wxUSE_DISPLAY
# undef wxUSE_DISPLAY
# define wxUSE_DISPLAY 0
#endif /* wxUSE_DISPLAY */
#if wxUSE_STACKWALKER
# undef wxUSE_STACKWALKER
# define wxUSE_STACKWALKER 0

44
include/wx/os2/display.h
View File

@@ -1,44 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// Name: displayx11.h
// Purpose: wxDisplay class for Unix/X11
// Author: Brian Victor
// Modified by:
// Created: 12/05/02
// RCS-ID: $Id$
// Copyright: (c) wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DISPLAY_H_
#define _WX_DISPLAY_H_
#if wxUSE_DISPLAY
class wxRect;
class wxString;
class wxDisplayUnixPriv;
class WXDLLEXPORT wxDisplay : public wxDisplayBase
{
public:
wxDisplay (size_t index = 0);
~wxDisplay();
virtual wxRect GetGeometry() const;
virtual int GetDepth() const;
virtual wxString GetName() const;
virtual wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode) const;
virtual wxVideoMode GetCurrentMode() const;
virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode);
private:
DECLARE_NO_COPY_CLASS(wxDisplay)
};
#endif // wxUSE_DISPLAY
#endif // _WX_DISPLAY_H_

3
include/wx/palmos/chkconf.h
View File

@@ -52,6 +52,9 @@
#undef wxUSE_CLIPBOARD
#define wxUSE_CLIPBOARD 0
#undef wxUSE_DISPLAY
#define wxUSE_DISPLAY 0
#undef wxUSE_COMBOBOX
#define wxUSE_COMBOBOX 0

52
include/wx/palmos/display.h
View File

@@ -1,52 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// Name: wx/palmos/display.h
// Purpose: wxDisplay class customization for Palm OS
// Author: William Osborne - minimal working wxPalmOS port
// Modified by:
// Created: 10/13/04
// RCS-ID: $Id$
// Copyright: (c) William Osborne
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_PALMOS_DISPLAY_H_
#define _WX_PALMOS_DISPLAY_H_
class WXDLLEXPORT wxDisplay : public wxDisplayBase
{
public:
// this function may be called *before* using any other wxDisplay methods
// to tell it to use DirectX functions instead of the standard Windows ones
static void UseDirectX(bool useDX);
// create the display object for the given physical display
wxDisplay(size_t index = 0);
virtual ~wxDisplay();
// implement base class pure virtuals
virtual bool IsOk() const;
virtual wxRect GetGeometry() const;
virtual wxString GetName() const;
virtual wxArrayVideoModes
GetModes(const wxVideoMode& mode = wxVideoMode()) const;
virtual wxVideoMode GetCurrentMode() const;
virtual bool ChangeMode(const wxVideoMode& mode = wxVideoMode());
private:
// get the display name to use with EnumDisplaySettings()
wxString GetNameForEnumSettings() const;
// we have different implementations using DirectDraw and without it
wxArrayVideoModes DoGetModesDirectX(const wxVideoMode& modeMatch) const;
bool DoChangeModeDirectX(const wxVideoMode& mode);
wxArrayVideoModes DoGetModesWindows(const wxVideoMode& modeMatch) const;
bool DoChangeModeWindows(const wxVideoMode& mode);
DECLARE_NO_COPY_CLASS(wxDisplay)
};
#endif // _WX_PALMOS_DISPLAY_H_

48
include/wx/unix/displayx11.h
View File

@@ -1,48 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// Name: displayx11.h
// Purpose: wxDisplay class for Unix/X11
// Author: Brian Victor
// Modified by:
// Created: 12/05/02
// RCS-ID: $Id$
// Copyright: (c) wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DISPLAYX11_H_
#define _WX_DISPLAYX11_H_
#if wxUSE_DISPLAY
class wxRect;
class wxString;
class wxDisplayUnixPriv;
class WXDLLEXPORT wxDisplay : public wxDisplayBase
{
public:
wxDisplay ( size_t index = 0 );
virtual wxRect GetGeometry() const;
virtual int GetDepth() const;
virtual wxString GetName() const;
virtual wxArrayVideoModes
GetModes(const wxVideoMode& mode = wxDefaultVideoMode) const;
virtual wxVideoMode GetCurrentMode() const;
virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode);
~wxDisplay();
private:
wxDisplayUnixPriv *m_priv;
DECLARE_NO_COPY_CLASS(wxDisplay)
};
#endif // wxUSE_DISPLAY
#endif // _WX_GTK_DISPLAY_H_

138
src/cocoa/display.mm
View File

@@ -2,7 +2,7 @@
// Name: src/cocoa/display.mm
// Purpose: Cocoa implementation of wxDisplay class
// Author: Ryan Norton
// Modified by:
// Modified by:
// Created: 2004-10-03
// RCS-ID: $Id$
// Copyright: (c) Ryan Norton
@@ -23,36 +23,74 @@
#endif
#include "wx/display.h"
#include "wx/display_impl.h"
#include "wx/gdicmn.h"
#include "wx/string.h"
#import <Foundation/Foundation.h>
// ----------------------------------------------------------------------------
// private classes
// display classes implementation
// ----------------------------------------------------------------------------
size_t wxDisplayBase::GetCount()
class wxDisplayImplMacOSX : public wxDisplayImpl
{
public:
wxDisplayImplMacOSX(CGDirectDisplayID id_) : m_id(id_) { }
virtual wxRect GetGeometry() const;
virtual wxString GetName() const { return wxString(); }
virtual wxArrayVideoModes GetModes(const wxVideoMode& mode) const;
virtual wxVideoMode GetCurrentMode() const;
virtual bool ChangeMode(const wxVideoMode& mode);
private:
CGDirectDisplayID m_id;
DECLARE_NO_COPY_CLASS(wxDisplayImplMacOSX)
};
class wxDisplayFactoryMacOSX : public wxDisplayFactory
{
public:
wxDisplayFactoryMacOSX();
virtual wxDisplayImpl *CreateDisplay(size_t n);
virtual size_t GetCount();
virtual int GetFromPoint(const wxPoint& pt);
protected:
DECLARE_NO_COPY_CLASS(wxDisplayFactoryMacOSX)
};
// ============================================================================
// wxDisplayFactoryMacOSX implementation
// ============================================================================
size_t wxDisplayFactoryMacOSX::GetCount()
{
CGDisplayCount count;
#ifdef __WXDEBUG__
CGDisplayErr err =
CGDisplayErr err =
#endif
CGGetActiveDisplayList(0, NULL, &count);
wxASSERT(err == CGDisplayNoErr);
return count;
}
int wxDisplayBase::GetFromPoint(const wxPoint &p)
{
int wxDisplayFactoryMacOSX::GetFromPoint(const wxPoint& p)
{
CGPoint thePoint = {(float)p.x, (float)p.y};
CGDirectDisplayID theID;
CGDisplayCount theCount;
CGDisplayErr err = CGGetDisplaysWithPoint(thePoint, 1, &theID, &theCount);
wxASSERT(err == CGDisplayNoErr);
int nWhich = -1;
int nWhich = wxNOT_FOUND;
if (theCount)
{
theCount = GetCount();
@@ -60,61 +98,54 @@ int wxDisplayBase::GetFromPoint(const wxPoint &p)
err = CGGetActiveDisplayList(theCount, theIDs, &theCount);
wxASSERT(err == CGDisplayNoErr);
for(nWhich = 0; nWhich < (int) theCount; ++nWhich)
for (nWhich = 0; nWhich < (int) theCount; ++nWhich)
{
if(theIDs[nWhich] == theID)
if (theIDs[nWhich] == theID)
break;
}
delete[] theIDs;
if(nWhich == (int) theCount)
delete [] theIDs;
if (nWhich == (int) theCount)
{
wxFAIL_MSG(wxT("Failed to find display in display list"));
nWhich = -1;
nWhich = wxNOT_FOUND;
}
}
return nWhich;
}//CFUserNotification[NSBundle bundleForClass:[self class]]
wxDisplay::wxDisplay(size_t index) : wxDisplayBase ( index )
return nWhich;
}
wxDisplayImpl *wxDisplayFactoryMacOSX::CreateDisplay(size_t n)
{
CGDisplayCount theCount = GetCount();
CGDirectDisplayID* theIDs = new CGDirectDisplayID[theCount];
#ifdef __WXDEBUG__
CGDisplayErr err =
CGDisplayErr err =
#endif
CGGetActiveDisplayList(theCount, theIDs, &theCount);
wxASSERT(err == CGDisplayNoErr);
wxASSERT(index < theCount);
m_id = theIDs[index];
delete[] theIDs;
wxASSERT( err == CGDisplayNoErr );
wxASSERT( n < theCount );
wxDisplayImplMacOSX *display = new wxDisplayImplMacOSX(theIDs[n]);
delete [] theIDs;
return display;
}
wxRect wxDisplay::GetGeometry() const
wxRect wxDisplayImplMacOSX::GetGeometry() const
{
CGRect theRect = CGDisplayBounds(m_id);
return wxRect( (int)theRect.origin.x,
return wxRect( (int)theRect.origin.x,
(int)theRect.origin.y,
(int)theRect.size.width,
(int)theRect.size.height ); //floats
}
int wxDisplay::GetDepth() const
{
return (int) CGDisplayBitsPerPixel(m_id); //size_t
}
wxString wxDisplay::GetName() const
{
// Macs don't name their displays...
return wxEmptyString;
}
static int wxCFDictKeyToInt( CFDictionaryRef desc, CFStringRef key )
{
CFNumberRef value;
@@ -126,40 +157,39 @@ static int wxCFDictKeyToInt( CFDictionaryRef desc, CFStringRef key )
return num;
}
wxArrayVideoModes
wxDisplay::GetModes(const wxVideoMode& mode) const
wxArrayVideoModes wxDisplayImplMacOSX::GetModes(const wxVideoMode& mode) const
{
wxArrayVideoModes Modes;
CFArrayRef theArray = CGDisplayAvailableModes(m_id);
for(CFIndex i = 0; i < CFArrayGetCount(theArray); ++i)
{
CFDictionaryRef theValue = (CFDictionaryRef) CFArrayGetValueAtIndex(theArray, i);
wxVideoMode theMode(wxCFDictKeyToInt(theValue, kCGDisplayWidth),
wxCFDictKeyToInt(theValue, kCGDisplayHeight),
wxCFDictKeyToInt(theValue, kCGDisplayBitsPerPixel),
wxCFDictKeyToInt(theValue, kCGDisplayRefreshRate));
if (theMode.Matches(mode))
Modes.Add(theMode);
}
return Modes;
}
wxVideoMode wxDisplay::GetCurrentMode() const
wxVideoMode wxDisplayImplMacOSX::GetCurrentMode() const
{
CFDictionaryRef theValue = CGDisplayCurrentMode (m_id);
return wxVideoMode(wxCFDictKeyToInt(theValue, kCGDisplayWidth),
wxCFDictKeyToInt(theValue, kCGDisplayHeight),
wxCFDictKeyToInt(theValue, kCGDisplayBitsPerPixel),
wxCFDictKeyToInt(theValue, kCGDisplayRefreshRate));
}
bool wxDisplay::ChangeMode(const wxVideoMode& mode)
bool wxDisplayImplMacOSX::ChangeMode(const wxVideoMode& mode)
{
//Changing to default mode (wxDefualtVideoMode) doesn't
//work because we don't have access to the system's 'scrn'
@@ -173,17 +203,23 @@ bool wxDisplay::ChangeMode(const wxVideoMode& mode)
(size_t)mode.h,
(double)mode.refresh,
&bExactMatch);
bool bOK = bExactMatch;
if(bOK)
bOK = CGDisplaySwitchToMode(m_id, theCGMode) == CGDisplayNoErr;
return bOK;
}
wxDisplay::~wxDisplay()
// ============================================================================
// wxDisplay::CreateFactory()
// ============================================================================
/* static */ wxDisplayFactory *wxDisplay::CreateFactory()
{
return new wxDisplayFactoryMac;
}
#endif // wxUSE_DISPLAY

228
src/common/dpycmn.cpp
View File

@@ -1,11 +1,11 @@
///////////////////////////////////////////////////////////////////////////////
// Name: src/common/dpycmn.cpp
// Purpose: wxDisplayBase implementation
// Purpose: wxDisplay and wxDisplayImplSingle implementation
// Author: Vadim Zeitlin
// Modified by:
// Created: 01.03.03
// RCS-ID: $Id$
// Copyright: (c) 2003 Vadim Zeitlin <vadim@wxwindows.org>
// Copyright: (c) 2003-2006 Vadim Zeitlin <vadim@wxwindows.org>
// License: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
@@ -24,43 +24,239 @@
#pragma hdrstop
#endif
#if wxUSE_DISPLAY
#ifndef WX_PRECOMP
#include "wx/gdicmn.h"
#include "wx/window.h"
#endif //WX_PRECOMP
#include "wx/display.h"
#include "wx/display_impl.h"
#include "wx/module.h"
#include "wx/gdicmn.h" // for wxDisplaySize()
#if wxUSE_DISPLAY
#include "wx/arrimpl.cpp"
WX_DEFINE_OBJARRAY(wxArrayVideoModes)
const wxVideoMode wxDefaultVideoMode;
#endif // wxUSE_DISPLAY
// ----------------------------------------------------------------------------
// globals
// ----------------------------------------------------------------------------
// the factory object used by wxDisplay
//
// created on demand and destroyed by wxDisplayModule
static wxDisplayFactory *gs_factory = NULL;
// ----------------------------------------------------------------------------
// wxDisplayImplSingle: trivial implementation working for main display only
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxDisplayImplSingle : public wxDisplayImpl
{
public:
wxDisplayImplSingle() : wxDisplayImpl(0) { }
virtual wxRect GetGeometry() const
{
wxRect r;
wxDisplaySize(&r.width, &r.height);
return r;
}
virtual wxString GetName() const { return wxString(); }
#if wxUSE_DISPLAY
// no video modes support for us, provide just the stubs
virtual wxArrayVideoModes GetModes(const wxVideoMode& WXUNUSED(mode)) const
{
return wxArrayVideoModes();
}
virtual wxVideoMode GetCurrentMode() const { return wxVideoMode(); }
virtual bool ChangeMode(const wxVideoMode& WXUNUSED(mode)) { return false; }
#endif // wxUSE_DISPLAY
DECLARE_NO_COPY_CLASS(wxDisplayImplSingle)
};
// ----------------------------------------------------------------------------
// wxDisplayModule is used to cleanup gs_factory
// ----------------------------------------------------------------------------
class wxDisplayModule : public wxModule
{
public:
virtual bool OnInit() { return true; }
virtual void OnExit()
{
if ( gs_factory )
{
delete gs_factory;
gs_factory = NULL;
}
}
DECLARE_DYNAMIC_CLASS(wxDisplayModule)
};
IMPLEMENT_DYNAMIC_CLASS(wxDisplayModule, wxModule)
// ============================================================================
// implementation
// wxDisplay implementation
// ============================================================================
wxDisplayBase::wxDisplayBase(size_t index)
: m_index (index)
// ----------------------------------------------------------------------------
// ctor/dtor
// ----------------------------------------------------------------------------
wxDisplay::wxDisplay(size_t n)
{
wxASSERT_MSG( m_index < GetCount(),
wxASSERT_MSG( n < GetCount(),
wxT("An invalid index was passed to wxDisplay") );
m_impl = Factory().CreateDisplay(n);
}
// MSW has its own specific implementation of this
#ifndef __WXMSW__
int wxDisplayBase::GetFromWindow(wxWindow *window)
wxDisplay::~wxDisplay()
{
wxCHECK_MSG( window, wxNOT_FOUND, _T("NULL window") );
delete m_impl;
}
// consider that the window belong to the display containing its centre
// ----------------------------------------------------------------------------
// static functions forwarded to wxDisplayFactory
// ----------------------------------------------------------------------------
/* static */ size_t wxDisplay::GetCount()
{
return Factory().GetCount();
}
/* static */ int wxDisplay::GetFromPoint(const wxPoint& pt)
{
return Factory().GetFromPoint(pt);
}
/* static */ int wxDisplay::GetFromWindow(wxWindow *window)
{
wxCHECK_MSG( window, wxNOT_FOUND, _T("invalid window") );
return Factory().GetFromWindow(window);
}
// ----------------------------------------------------------------------------
// functions forwarded to wxDisplayImpl
// ----------------------------------------------------------------------------
wxRect wxDisplay::GetGeometry() const
{
wxCHECK_MSG( IsOk(), wxRect(), _T("invalid wxDisplay object") );
return m_impl->GetGeometry();
}
wxString wxDisplay::GetName() const
{
wxCHECK_MSG( IsOk(), wxString(), _T("invalid wxDisplay object") );
return m_impl->GetName();
}
bool wxDisplay::IsPrimary() const
{
return m_impl && m_impl->GetIndex() == 0;
}
#if wxUSE_DISPLAY
wxArrayVideoModes wxDisplay::GetModes(const wxVideoMode& mode) const
{
wxCHECK_MSG( IsOk(), wxArrayVideoModes(), _T("invalid wxDisplay object") );
return m_impl->GetModes(mode);
}
wxVideoMode wxDisplay::GetCurrentMode() const
{
wxCHECK_MSG( IsOk(), wxVideoMode(), _T("invalid wxDisplay object") );
return m_impl->GetCurrentMode();
}
bool wxDisplay::ChangeMode(const wxVideoMode& mode)
{
wxCHECK_MSG( IsOk(), false, _T("invalid wxDisplay object") );
return m_impl->ChangeMode(mode);
}
#endif // wxUSE_DIRECTDRAW
// ----------------------------------------------------------------------------
// static functions implementation
// ----------------------------------------------------------------------------
// if wxUSE_DISPLAY == 1 this is implemented in port-specific code
#if !wxUSE_DISPLAY
/* static */ wxDisplayFactory *wxDisplay::CreateFactory()
{
return new wxDisplayFactorySingle;
}
#endif // !wxUSE_DISPLAY
/* static */ wxDisplayFactory& wxDisplay::Factory()
{
if ( !gs_factory )
{
gs_factory = CreateFactory();
}
return *gs_factory;
}
// ============================================================================
// wxDisplayFactory implementation
// ============================================================================
int wxDisplayFactory::GetFromWindow(wxWindow *window)
{
// consider that the window belongs to the display containing its centre
const wxRect r(window->GetRect());
return GetFromPoint(wxPoint(r.x + r.width/2, r.y + r.height/2));
}
#endif // !__WXMSW__
// ============================================================================
// wxDisplayFactorySingle implementation
// ============================================================================
/* static */
wxDisplayImpl *wxDisplayFactorySingle::CreateDisplay(size_t n)
{
// we recognize the main display only
return n != 0 ? NULL : new wxDisplayImplSingle;
}
int wxDisplayFactorySingle::GetFromPoint(const wxPoint& pt)
{
if ( pt.x >= 0 && pt.y >= 0 )
{
int w, h;
wxDisplaySize(&w, &h);
if ( pt.x < w && pt.y < h )
return 0;
}
// the point is outside of the screen
return wxNOT_FOUND;
}
#endif // wxUSE_DISPLAY

267
src/mac/carbon/display.cpp
View File

@@ -1,14 +1,22 @@
/////////////////////////////////////////////////////////////////////////////
// Name: display.cpp
// Name: src/mac/carbon/display.cpp
// Purpose: Mac implementation of wxDisplay class
// Author: Ryan Norton & Brian Victor
// Modified by: Royce Mitchell III
// Modified by: Royce Mitchell III, Vadim Zeitlin
// Created: 06/21/02
// RCS-ID: $Id$
// Copyright: (c) wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// ============================================================================
// declarations
// ============================================================================
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#include "wx/wxprec.h"
#ifdef __BORLANDC__
@@ -20,7 +28,6 @@
#ifndef WX_PRECOMP
#include "wx/dynarray.h"
#include "wx/log.h"
#include "wx/msgdlg.h"
#endif
#ifdef __DARWIN__
@@ -35,32 +42,65 @@
#endif
#include "wx/display.h"
#include "wx/display_impl.h"
#include "wx/gdicmn.h"
#include "wx/string.h"
// ----------------------------------------------------------------------------
// private classes
// display classes implementation
// ----------------------------------------------------------------------------
#ifdef __WXMAC_OSX__
class wxDisplayMacPriv
class wxDisplayImplMacOSX : public wxDisplayImpl
{
public:
wxDisplayImplMacOSX(CGDirectDisplayID id) : m_id(id) { }
virtual wxRect GetGeometry() const;
virtual wxString GetName() const { return wxString(); }
virtual wxArrayVideoModes GetModes(const wxVideoMode& mode) const;
virtual wxVideoMode GetCurrentMode() const;
virtual bool ChangeMode(const wxVideoMode& mode);
private:
CGDirectDisplayID m_id;
DECLARE_NO_COPY_CLASS(wxDisplayImplMacOSX)
};
size_t wxDisplayBase::GetCount()
class wxDisplayFactoryMacOSX : public wxDisplayFactory
{
public:
wxDisplayFactoryMacOSX();
virtual wxDisplayImpl *CreateDisplay(size_t n);
virtual size_t GetCount();
virtual int GetFromPoint(const wxPoint& pt);
protected:
DECLARE_NO_COPY_CLASS(wxDisplayFactoryMacOSX)
};
// ============================================================================
// wxDisplayFactoryMacOSX implementation
// ============================================================================
size_t wxDisplayFactoryMacOSX::GetCount()
{
CGDisplayCount count;
CGDisplayErr err = CGGetActiveDisplayList(0, NULL, &count);
#ifdef __WXDEBUG__
CGDisplayErr err =
#endif
CGGetActiveDisplayList(0, NULL, &count);
wxASSERT(err == CGDisplayNoErr);
return count;
}
int wxDisplayBase::GetFromPoint(const wxPoint &p)
int wxDisplayFactoryMacOSX::GetFromPoint(const wxPoint& p)
{
CGPoint thePoint = {(float)p.x, (float)p.y};
CGDirectDisplayID theID;
@@ -68,7 +108,7 @@ int wxDisplayBase::GetFromPoint(const wxPoint &p)
CGDisplayErr err = CGGetDisplaysWithPoint(thePoint, 1, &theID, &theCount);
wxASSERT(err == CGDisplayNoErr);
int nWhich = -1;
int nWhich = wxNOT_FOUND;
if (theCount)
{
@@ -88,50 +128,46 @@ int wxDisplayBase::GetFromPoint(const wxPoint &p)
if (nWhich == (int) theCount)
{
wxFAIL_MSG(wxT("Failed to find display in display list"));
nWhich = -1;
nWhich = wxNOT_FOUND;
}
}
return nWhich;
}
wxDisplay::wxDisplay(size_t index)
: wxDisplayBase( index ) ,
m_priv( new wxDisplayMacPriv() )
wxDisplayImpl *wxDisplayFactoryMacOSX::CreateDisplay(size_t n)
{
CGDisplayCount theCount = GetCount();
CGDirectDisplayID* theIDs = new CGDirectDisplayID[theCount];
CGDisplayErr err = CGGetActiveDisplayList(theCount, theIDs, &theCount);
#ifdef __WXDEBUG__
CGDisplayErr err =
#endif
CGGetActiveDisplayList(theCount, theIDs, &theCount);
wxASSERT( err == CGDisplayNoErr );
wxASSERT( index < theCount );
wxASSERT( n < theCount );
m_priv->m_id = theIDs[index];
wxDisplayImplMacOSX *display = new wxDisplayImplMacOSX(theIDs[n]);
delete [] theIDs;
return display;
}
wxRect wxDisplay::GetGeometry() const
// ============================================================================
// wxDisplayImplMacOSX implementation
// ============================================================================
wxRect wxDisplayImplMacOSX::GetGeometry() const
{
CGRect theRect = CGDisplayBounds(m_priv->m_id);
CGRect theRect = CGDisplayBounds(m_id);
return wxRect( (int)theRect.origin.x,
(int)theRect.origin.y,
(int)theRect.size.width,
(int)theRect.size.height ); //floats
}
int wxDisplay::GetDepth() const
{
return (int) CGDisplayBitsPerPixel( m_priv->m_id ); //size_t
}
wxString wxDisplay::GetName() const
{
// Macs don't name their displays...
return wxEmptyString;
}
static int wxCFDictKeyToInt( CFDictionaryRef desc, CFStringRef key )
{
CFNumberRef value = (CFNumberRef) CFDictionaryGetValue( desc, key );
@@ -144,12 +180,11 @@ static int wxCFDictKeyToInt( CFDictionaryRef desc, CFStringRef key )
return num;
}
wxArrayVideoModes
wxDisplay::GetModes(const wxVideoMode& mode) const
wxArrayVideoModes wxDisplayImplMacOSX::GetModes(const wxVideoMode& mode) const
{
wxArrayVideoModes resultModes;
CFArrayRef theArray = CGDisplayAvailableModes( m_priv->m_id );
CFArrayRef theArray = CGDisplayAvailableModes( m_id );
for (CFIndex i = 0; i < CFArrayGetCount(theArray); ++i)
{
@@ -168,9 +203,9 @@ wxArrayVideoModes
return resultModes;
}
wxVideoMode wxDisplay::GetCurrentMode() const
wxVideoMode wxDisplayImplMacOSX::GetCurrentMode() const
{
CFDictionaryRef theValue = CGDisplayCurrentMode( m_priv->m_id );
CFDictionaryRef theValue = CGDisplayCurrentMode( m_id );
return wxVideoMode(
wxCFDictKeyToInt( theValue, kCGDisplayWidth ),
@@ -179,7 +214,7 @@ wxVideoMode wxDisplay::GetCurrentMode() const
wxCFDictKeyToInt( theValue, kCGDisplayRefreshRate ));
}
bool wxDisplay::ChangeMode( const wxVideoMode& mode )
bool wxDisplayImplMacOSX::ChangeMode( const wxVideoMode& mode )
{
// Changing to default mode (wxDefaultVideoMode) doesn't
// work because we don't have access to the system's 'scrn'
@@ -187,7 +222,7 @@ bool wxDisplay::ChangeMode( const wxVideoMode& mode )
// will return to after this app is done
boolean_t bExactMatch;
CFDictionaryRef theCGMode = CGDisplayBestModeForParametersAndRefreshRate(
m_priv->m_id,
m_id,
(size_t)mode.bpp,
(size_t)mode.w,
(size_t)mode.h,
@@ -197,49 +232,74 @@ bool wxDisplay::ChangeMode( const wxVideoMode& mode )
bool bOK = bExactMatch;
if (bOK)
bOK = CGDisplaySwitchToMode( m_priv->m_id, theCGMode ) == CGDisplayNoErr;
bOK = CGDisplaySwitchToMode( m_id, theCGMode ) == CGDisplayNoErr;
return bOK;
}
wxDisplay::~wxDisplay()
// ============================================================================
// wxDisplay::CreateFactory()
// ============================================================================
/* static */ wxDisplayFactory *wxDisplay::CreateFactory()
{
if ( m_priv )
{
delete m_priv;
m_priv = 0;
}
return new wxDisplayFactoryMacOSX;
}
#else
#else // !__WXMAC_OSX__
class wxDisplayMacPriv
class wxDisplayImplMac : public wxDisplayImpl
{
public:
wxDisplayImplMac(GDHandle hndl) : m_hndl(hndl) { }
virtual wxRect GetGeometry() const;
virtual wxString GetName() const { return wxString(); }
virtual wxArrayVideoModes GetModes(const wxVideoMode& mode) const;
virtual wxVideoMode GetCurrentMode() const;
virtual bool ChangeMode(const wxVideoMode& mode);
private:
GDHandle m_hndl;
DECLARE_NO_COPY_CLASS(wxDisplayImplMac)
};
size_t wxDisplayBase::GetCount()
class wxDisplayFactoryMac : public wxDisplayFactory
{
public:
wxDisplayFactoryMac();
virtual wxDisplayImpl *CreateDisplay(size_t n);
virtual size_t GetCount();
virtual int GetFromPoint(const wxPoint& pt);
protected:
DECLARE_NO_COPY_CLASS(wxDisplayFactoryMac)
};
// ============================================================================
// wxDisplayFactoryMac implementation
// ============================================================================
size_t wxDisplayFactoryMac::GetCount()
{
GDHandle hndl;
size_t num = 0;
hndl = DMGetFirstScreenDevice(true);
while (hndl)
GDHandle hndl = DMGetFirstScreenDevice(true);
while(hndl)
{
num++;
hndl = DMGetNextScreenDevice(hndl, true);
}
return num;
}
int wxDisplayBase::GetFromPoint(const wxPoint &p)
int wxDisplayFactoryMac::GetFromPoint(const wxPoint &p)
{
GDHandle hndl;
size_t num = 0;
hndl = DMGetFirstScreenDevice(true);
while (hndl)
GDHandle hndl = DMGetFirstScreenDevice(true);
while(hndl)
{
Rect screenrect = (*hndl)->gdRect;
if (p.x >= screenrect.left &&
@@ -249,63 +309,39 @@ int wxDisplayBase::GetFromPoint(const wxPoint &p)
{
return num;
}
num++;
hndl = DMGetNextScreenDevice(hndl, true);
}
return -1;
return wxNOT_FOUND;
}
wxDisplay::wxDisplay( size_t index )
: wxDisplayBase( index ),
m_priv( new wxDisplayMacPriv() )
wxDisplayImpl *wxDisplayFactoryMac::CreateDisplay(size_t n)
{
GDHandle hndl;
hndl = DMGetFirstScreenDevice(true);
m_priv->m_hndl = NULL;
while (hndl)
GDHandle hndl = DMGetFirstScreenDevice(true);
while(hndl)
{
if (index == 0)
m_priv->m_hndl = hndl;
index--;
if (n == 0)
{
return new wxDisplayImplMac(hndl);
}
n--;
hndl = DMGetNextScreenDevice(hndl, true);
}
return NULL;
}
wxRect wxDisplay::GetGeometry() const
// ============================================================================
// wxDisplayImplMac implementation
// ============================================================================
wxRect wxDisplayImplMac::GetGeometry() const
{
if ((m_priv == NULL) || (m_priv->m_hndl == NULL))
return wxRect(0, 0, 0, 0);
Rect screenrect = (*(m_priv->m_hndl))->gdRect;
return wxRect(
screenrect.left, screenrect.top,
screenrect.right - screenrect.left,
screenrect.bottom - screenrect.top );
}
int wxDisplay::GetDepth() const
{
if ((m_priv == NULL) || (m_priv->m_hndl == NULL))
return 0;
// This cryptic looking code is based on Apple's sample code:
// http://developer.apple.com/samplecode/Sample_Code/Graphics_2D/GDevVideo/Gen.cp.htm
// RN - according to the docs
// gdPMap is a bitmap-type representation of the GDevice, and all
// 0x0000FFFF does is get the lower 16 bits of pixelSize. However,
// since pixelSize is only 16 bits (a short)...
return ((*(*(m_priv->m_hndl))->gdPMap)->pixelSize) & 0x0000FFFF;
}
wxString wxDisplay::GetName() const
{
// Macs don't name their displays...
return wxEmptyString;
Rect screenrect = (*m_hndl)->gdRect;
return wxRect(screenrect.left, screenrect.top,
screenrect.right - screenrect.left,
screenrect.bottom - screenrect.top);
}
struct DMModeIteratorRec
@@ -415,8 +451,7 @@ pascal void DMModeTransProc(
#undef pDBI
}
wxArrayVideoModes
wxDisplay::GetModes(const wxVideoMode& mode) const
wxArrayVideoModes wxDisplayImplMac::GetModes(const wxVideoMode& mode) const
{
wxArrayVideoModes Modes;
unsigned long dwDMVer;
@@ -432,7 +467,7 @@ wxArrayVideoModes
DisplayIDType nDisplayID;
OSErr err;
err = DMGetDisplayIDByGDevice(m_priv->m_hndl, &nDisplayID, false);
err = DMGetDisplayIDByGDevice(m_hndl, &nDisplayID, false);
verify_noerr( err );
// Create a new list...
@@ -468,7 +503,7 @@ wxArrayVideoModes
return Modes;
}
wxVideoMode wxDisplay::GetCurrentMode() const
wxVideoMode wxDisplayImplMac::GetCurrentMode() const
{
unsigned long dwDMVer;
wxVideoMode RetMode;
@@ -481,7 +516,7 @@ wxVideoMode wxDisplay::GetCurrentMode() const
VDSwitchInfoRec sMode; // Note: csMode member also contains the bit depth
OSErr err;
err = DMGetDisplayMode( m_priv->m_hndl, &sMode );
err = DMGetDisplayMode( m_hndl, &sMode );
if (err == noErr)
{
DMListIndexType nNumModes;
@@ -489,7 +524,7 @@ wxVideoMode wxDisplay::GetCurrentMode() const
DMDisplayModeListIteratorUPP uppMLI;
DisplayIDType nDisplayID;
err = DMGetDisplayIDByGDevice(m_priv->m_hndl, &nDisplayID, false);
err = DMGetDisplayIDByGDevice(m_hndl, &nDisplayID, false);
verify_noerr( err );
// Create a new list...
@@ -538,7 +573,7 @@ wxVideoMode wxDisplay::GetCurrentMode() const
return RetMode;
}
bool wxDisplay::ChangeMode(const wxVideoMode& mode)
bool wxDisplayImplMac::ChangeMode(const wxVideoMode& mode)
{
unsigned long dwDMVer;
@@ -580,7 +615,7 @@ bool wxDisplay::ChangeMode(const wxVideoMode& mode)
DisplayIDType nDisplayID;
OSErr err;
err = DMGetDisplayIDByGDevice(m_priv->m_hndl, &nDisplayID, false);
err = DMGetDisplayIDByGDevice(m_hndl, &nDisplayID, false);
verify_noerr( err );
// Create a new list...
@@ -618,7 +653,7 @@ bool wxDisplay::ChangeMode(const wxVideoMode& mode)
// For the really paranoid -
// unsigned long flags;
// Boolean bok;
// wxASSERT(noErr == DMCheckDisplayMode(m_priv->m_hndl, sMode.csData,
// wxASSERT(noErr == DMCheckDisplayMode(m_hndl, sMode.csData,
// sMode.csMode, &flags, NULL, &bok));
// wxASSERT(bok);
@@ -632,7 +667,7 @@ bool wxDisplay::ChangeMode(const wxVideoMode& mode)
unsigned long dwBPP = (unsigned long) mode.bpp;
err = DMSetDisplayMode(
m_priv->m_hndl, sMode.csData,
m_hndl, sMode.csData,
(unsigned long*) &(dwBPP),
NULL, //(unsigned long) &sMode
hDisplayState );
@@ -640,7 +675,7 @@ bool wxDisplay::ChangeMode(const wxVideoMode& mode)
if (err != noErr)
{
DMEndConfigureDisplays(hDisplayState);
wxMessageBox( wxString::Format(wxT("Could not set the display mode")) );
wxLogError(wxT("Could not set the display mode"));
return false;
}
@@ -660,13 +695,13 @@ bool wxDisplay::ChangeMode(const wxVideoMode& mode)
return true;
}
wxDisplay::~wxDisplay()
// ============================================================================
// wxDisplay::CreateFactory()
// ============================================================================
/* static */ wxDisplayFactory *wxDisplay::CreateFactory()
{
if ( m_priv )
{
delete m_priv;
m_priv = 0;
}
return new wxDisplayFactoryMac;
}
#endif // !OSX

537
src/mac/classic/display.cpp
View File

@@ -1,14 +1,22 @@
/////////////////////////////////////////////////////////////////////////////
// Name: display.cpp
// Name: src/mac/classic/display.cpp
// Purpose: Mac implementation of wxDisplay class
// Author: Brian Victor
// Modified by: Royce Mitchell III & Ryan Norton
// Modified by: Royce Mitchell III & Ryan Norton, Vadim Zeitlin
// Created: 06/21/02
// RCS-ID: $Id$
// Copyright: (c) wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// ============================================================================
// declarations
// ============================================================================
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
@@ -21,7 +29,6 @@
#ifndef WX_PRECOMP
#include "wx/dynarray.h"
#include "wx/log.h"
#include "wx/msgdlg.h"
#endif
#ifdef __DARWIN__
@@ -35,24 +42,53 @@
#endif
#include "wx/display.h"
#include "wx/display_impl.h"
#include "wx/gdicmn.h"
#include "wx/string.h"
// ----------------------------------------------------------------------------
// private classes
// display implementation classes
// ----------------------------------------------------------------------------
class wxDisplayMacPriv
class wxDisplayImplMac : public wxDisplayImpl
{
public:
wxDisplayImplMac(GDHandle hndl) : m_hndl(hndl) { }
virtual wxRect GetGeometry() const;
virtual wxString GetName() const { return wxString(); }
virtual wxArrayVideoModes GetModes(const wxVideoMode& mode) const;
virtual wxVideoMode GetCurrentMode() const;
virtual bool ChangeMode(const wxVideoMode& mode);
private:
GDHandle m_hndl;
DECLARE_NO_COPY_CLASS(wxDisplayImplMac)
};
size_t wxDisplayBase::GetCount()
class wxDisplayFactoryMac : public wxDisplayFactory
{
public:
wxDisplayFactoryMac();
virtual wxDisplayImpl *CreateDisplay(size_t n);
virtual size_t GetCount();
virtual int GetFromPoint(const wxPoint& pt);
protected:
DECLARE_NO_COPY_CLASS(wxDisplayFactoryMac)
};
// ============================================================================
// wxDisplayFactoryMac implementation
// ============================================================================
size_t wxDisplayFactoryMac::GetCount()
{
GDHandle hndl;
size_t num = 0;
hndl = DMGetFirstScreenDevice(true);
GDHandle hndl = DMGetFirstScreenDevice(true);
while(hndl)
{
num++;
@@ -61,11 +97,10 @@ size_t wxDisplayBase::GetCount()
return num;
}
int wxDisplayBase::GetFromPoint(const wxPoint &p)
int wxDisplayFactoryMac::GetFromPoint(const wxPoint &p)
{
GDHandle hndl;
size_t num = 0;
hndl = DMGetFirstScreenDevice(true);
GDHandle hndl = DMGetFirstScreenDevice(true);
while(hndl)
{
Rect screenrect = (*hndl)->gdRect;
@@ -79,154 +114,134 @@ int wxDisplayBase::GetFromPoint(const wxPoint &p)
num++;
hndl = DMGetNextScreenDevice(hndl, true);
}
return -1;
return wxNOT_FOUND;
}
wxDisplay::wxDisplay(size_t index) : wxDisplayBase ( index ),
m_priv ( new wxDisplayMacPriv() )
wxDisplayImpl *wxDisplayFactoryMac::CreateDisplay(size_t n)
{
GDHandle hndl;
hndl = DMGetFirstScreenDevice(true);
m_priv->m_hndl = NULL;
GDHandle hndl = DMGetFirstScreenDevice(true);
while(hndl)
{
if (index == 0)
if (n == 0)
{
m_priv->m_hndl = hndl;
return new wxDisplayImplMac(hndl);
}
index--;
n--;
hndl = DMGetNextScreenDevice(hndl, true);
}
return NULL;
}
wxRect wxDisplay::GetGeometry() const
// ============================================================================
// wxDisplayImplMac implementation
// ============================================================================
wxRect wxDisplayImplMac::GetGeometry() const
{
if (!(m_priv)) return wxRect(0, 0, 0, 0);
if (!(m_priv->m_hndl)) return wxRect(0, 0, 0, 0);
Rect screenrect = (*(m_priv->m_hndl))->gdRect;
return wxRect( screenrect.left, screenrect.top,
screenrect.right - screenrect.left, screenrect.bottom - screenrect.top);
}
int wxDisplay::GetDepth() const
{
if (!(m_priv)) return 0;
if (!(m_priv->m_hndl)) return 0;
// This cryptic looking code is based on Apple's sample code:
// http://developer.apple.com/samplecode/Sample_Code/Graphics_2D/GDevVideo/Gen.cp.htm
//RN - according to the docs
//gdPMap is a bitmap-type representation of the GDevice, and all
//0x0000FFFF does is get the lower 16 bits of pixelSize. However,
//since pixelSize is only 16 bits (a short)...
return ((*(*(m_priv->m_hndl))->gdPMap)->pixelSize) & 0x0000FFFF;
}
wxString wxDisplay::GetName() const
{
// Macs don't name their displays...
return wxEmptyString;
Rect screenrect = (*m_hndl)->gdRect;
return wxRect(screenrect.left, screenrect.top,
screenrect.right - screenrect.left,
screenrect.bottom - screenrect.top);
}
struct DMModeIteratorRec
{
wxArrayVideoModes* pModes;
const wxVideoMode* pMatchMode;
wxArrayVideoModes* pModes;
const wxVideoMode* pMatchMode;
};
pascal void DMModeListIteratorProc ( void* pData,
DMListIndexType nIndex,
DMDisplayModeListEntryPtr pInfo)
pascal void DMModeListIteratorProc ( void* pData,
DMListIndexType nIndex,
DMDisplayModeListEntryPtr pInfo)
{
DMModeIteratorRec* pInfoData = (DMModeIteratorRec*) pData;
//Note that in testing the refresh rate is always 0 on my ibook - RN
//Note that in testing the refresh rate is always 0 on my ibook - RN
int refresh = (int) Fix2Long(pInfo->displayModeResolutionInfo->csRefreshRate);
for(unsigned long i = 0; i < pInfo->displayModeDepthBlockInfo->depthBlockCount; ++i)
{
for(unsigned long i = 0; i < pInfo->displayModeDepthBlockInfo->depthBlockCount; ++i)
{
#define pDBI pInfo->displayModeDepthBlockInfo->depthVPBlock[i].depthVPBlock
if (wxVideoMode((int) pInfo->displayModeResolutionInfo->csHorizontalPixels,
(int) pInfo->displayModeResolutionInfo->csVerticalLines,
(int) pDBI->vpPixelSize,
refresh).Matches(*pInfoData->pMatchMode) )
{
pInfoData->pModes->Add(wxVideoMode((int) pInfo->displayModeResolutionInfo->csHorizontalPixels,
(int) pInfo->displayModeResolutionInfo->csVerticalLines,
(int) pDBI->vpPixelSize,
refresh));
}
if (wxVideoMode((int) pInfo->displayModeResolutionInfo->csHorizontalPixels,
(int) pInfo->displayModeResolutionInfo->csVerticalLines,
(int) pDBI->vpPixelSize,
refresh).Matches(*pInfoData->pMatchMode) )
{
pInfoData->pModes->Add(wxVideoMode((int) pInfo->displayModeResolutionInfo->csHorizontalPixels,
(int) pInfo->displayModeResolutionInfo->csVerticalLines,
(int) pDBI->vpPixelSize,
refresh));
}
#undef pDBI
}
}
}
struct DMModeInfoRec
{
const wxVideoMode* pMode;
VDSwitchInfoRec sMode;
bool bMatched;
const wxVideoMode* pMode;
VDSwitchInfoRec sMode;
bool bMatched;
};
pascal void DMModeInfoProc ( void* pData,
DMListIndexType nIndex,
DMDisplayModeListEntryPtr pInfo)
pascal void DMModeInfoProc ( void* pData,
DMListIndexType nIndex,
DMDisplayModeListEntryPtr pInfo)
{
DMModeInfoRec* pInfoData = (DMModeInfoRec*) pData;
Fixed refresh = Long2Fix(pInfoData->pMode->refresh);
DMModeInfoRec* pInfoData = (DMModeInfoRec*) pData;
Fixed refresh = Long2Fix(pInfoData->pMode->refresh);
for(unsigned long i = 0; i < pInfo->displayModeDepthBlockInfo->depthBlockCount; ++i)
{
for(unsigned long i = 0; i < pInfo->displayModeDepthBlockInfo->depthBlockCount; ++i)
{
#define pDBI pInfo->displayModeDepthBlockInfo->depthVPBlock[i].depthVPBlock
if (pInfoData->pMode->w == (int&) pInfo->displayModeResolutionInfo->csHorizontalPixels &&
pInfoData->pMode->h == (int&) pInfo->displayModeResolutionInfo->csVerticalLines &&
pInfoData->pMode->bpp == (int) pDBI->vpPixelSize &&
refresh == pInfo->displayModeResolutionInfo->csRefreshRate)
{
memcpy(&pInfoData->sMode, pInfo->displayModeDepthBlockInfo->depthVPBlock[i].depthSwitchInfo,
sizeof(VDSwitchInfoRec));
pInfoData->sMode.csMode = pDBI->vpPixelSize;
pInfoData->bMatched = true;
break;
}
if (pInfoData->pMode->w == (int&) pInfo->displayModeResolutionInfo->csHorizontalPixels &&
pInfoData->pMode->h == (int&) pInfo->displayModeResolutionInfo->csVerticalLines &&
pInfoData->pMode->bpp == (int) pDBI->vpPixelSize &&
refresh == pInfo->displayModeResolutionInfo->csRefreshRate)
{
memcpy(&pInfoData->sMode, pInfo->displayModeDepthBlockInfo->depthVPBlock[i].depthSwitchInfo,
sizeof(VDSwitchInfoRec));
pInfoData->sMode.csMode = pDBI->vpPixelSize;
pInfoData->bMatched = true;
break;
}
#undef pDBI
}
}
}
struct DMModeTransRec
{
wxVideoMode Mode;
const VDSwitchInfoRec* psMode;
bool bMatched;
wxVideoMode Mode;
const VDSwitchInfoRec* psMode;
bool bMatched;
};
pascal void DMModeTransProc ( void* pData,
DMListIndexType nIndex,
DMDisplayModeListEntryPtr pInfo)
pascal void DMModeTransProc ( void* pData,
DMListIndexType nIndex,
DMDisplayModeListEntryPtr pInfo)
{
DMModeTransRec* pInfoData = (DMModeTransRec*) pData;
DMModeTransRec* pInfoData = (DMModeTransRec*) pData;
for(unsigned long i = 0; i < pInfo->displayModeDepthBlockInfo->depthBlockCount; ++i)
{
for(unsigned long i = 0; i < pInfo->displayModeDepthBlockInfo->depthBlockCount; ++i)
{
#define pDBI pInfo->displayModeDepthBlockInfo->depthVPBlock[i].depthVPBlock
if (pInfoData->psMode->csData == pInfo->displayModeDepthBlockInfo->depthVPBlock[i].depthSwitchInfo->csData)
{
pInfoData->Mode = wxVideoMode((int) pInfo->displayModeResolutionInfo->csHorizontalPixels,
(int) pInfo->displayModeResolutionInfo->csVerticalLines,
(int) pDBI->vpPixelSize,
(int) Fix2Long(pInfo->displayModeResolutionInfo->csRefreshRate) );
pInfoData->bMatched = true;
break;
}
if (pInfoData->psMode->csData == pInfo->displayModeDepthBlockInfo->depthVPBlock[i].depthSwitchInfo->csData)
{
pInfoData->Mode = wxVideoMode((int) pInfo->displayModeResolutionInfo->csHorizontalPixels,
(int) pInfo->displayModeResolutionInfo->csVerticalLines,
(int) pDBI->vpPixelSize,
(int) Fix2Long(pInfo->displayModeResolutionInfo->csRefreshRate) );
pInfoData->bMatched = true;
break;
}
#undef pDBI
}
}
}
wxArrayVideoModes
wxDisplay::GetModes(const wxVideoMode& mode) const
wxArrayVideoModes wxDisplayImplMac::GetModes(const wxVideoMode& mode) const
{
wxArrayVideoModes Modes;
unsigned long dwDMVer;
@@ -236,207 +251,207 @@ wxArrayVideoModes
if (dwDMVer >= 0x020000) //version 2?
{
DMListIndexType nNumModes;
DMListType pModes;
DMDisplayModeListIteratorUPP uppMLI;
DisplayIDType nDisplayID;
DMListIndexType nNumModes;
DMListType pModes;
DMDisplayModeListIteratorUPP uppMLI;
DisplayIDType nDisplayID;
wxASSERT(DMGetDisplayIDByGDevice(m_priv->m_hndl, &nDisplayID, false) == noErr);
//Create a new list...
wxASSERT_MSG(DMNewDisplayModeList(nDisplayID, NULL, NULL, &nNumModes, &pModes) == noErr, wxT("Could not create a new display mode list") );
wxASSERT(DMGetDisplayIDByGDevice(m_hndl, &nDisplayID, false) == noErr);
//Create a new list...
wxASSERT_MSG(DMNewDisplayModeList(nDisplayID, NULL, NULL, &nNumModes, &pModes) == noErr, wxT("Could not create a new display mode list") );
uppMLI = NewDMDisplayModeListIteratorUPP(DMModeListIteratorProc);
wxASSERT(uppMLI);
uppMLI = NewDMDisplayModeListIteratorUPP(DMModeListIteratorProc);
wxASSERT(uppMLI);
DMModeIteratorRec sModeInfo;
sModeInfo.pModes = &Modes;
sModeInfo.pMatchMode = &mode;
for (DMListIndexType i = 0; i < nNumModes; ++i)
{
wxASSERT(DMGetIndexedDisplayModeFromList(pModes, i, NULL,
uppMLI, &sModeInfo) == noErr);
}
DisposeDMDisplayModeListIteratorUPP(uppMLI);
wxASSERT(DMDisposeList(pModes) == noErr);
DMModeIteratorRec sModeInfo;
sModeInfo.pModes = &Modes;
sModeInfo.pMatchMode = &mode;
for (DMListIndexType i = 0; i < nNumModes; ++i)
{
wxASSERT(DMGetIndexedDisplayModeFromList(pModes, i, NULL,
uppMLI, &sModeInfo) == noErr);
}
DisposeDMDisplayModeListIteratorUPP(uppMLI);
wxASSERT(DMDisposeList(pModes) == noErr);
}
else //DM 1.0, 1.2, 1.x
{
wxLogSysError(wxString::Format(wxT("Display Manager Version %u Not Supported! Present? %s"),
(unsigned int) dwDMVer / 0x10000,
(dwDMVer & (1 << gestaltDisplayMgrPresent) ? wxT("Yes") : wxT("No")) )
);
wxLogSysError(wxString::Format(wxT("Display Manager Version %u Not Supported! Present? %s"),
(unsigned int) dwDMVer / 0x10000,
(dwDMVer & (1 << gestaltDisplayMgrPresent) ? wxT("Yes") : wxT("No")) )
);
}
return Modes;
}
wxVideoMode wxDisplay::GetCurrentMode() const
wxVideoMode wxDisplayImplMac::GetCurrentMode() const
{
unsigned long dwDMVer;
wxVideoMode RetMode;
Gestalt(gestaltDisplayMgrVers, (long*) &dwDMVer);
Gestalt(gestaltDisplayMgrVers, (long*) &dwDMVer);
//Check DM version (for backward compatibility only - 7.5.3+ use 2.0)
if (dwDMVer >= 0x020000) //version 2?
{
VDSwitchInfoRec sMode; //Note - csMode member also contains the bit depth
if (DMGetDisplayMode(m_priv->m_hndl, &sMode) == noErr)
{
DMListIndexType nNumModes;
DMListType pModes;
DMDisplayModeListIteratorUPP uppMLI;
DisplayIDType nDisplayID;
VDSwitchInfoRec sMode; //Note - csMode member also contains the bit depth
if (DMGetDisplayMode(m_hndl, &sMode) == noErr)
{
DMListIndexType nNumModes;
DMListType pModes;
DMDisplayModeListIteratorUPP uppMLI;
DisplayIDType nDisplayID;
wxASSERT(DMGetDisplayIDByGDevice(m_priv->m_hndl, &nDisplayID, false) == noErr);
//Create a new list...
wxASSERT_MSG(DMNewDisplayModeList(nDisplayID, NULL, NULL, &nNumModes, &pModes) == noErr,
wxT("Could not create a new display mode list") );
uppMLI = NewDMDisplayModeListIteratorUPP(DMModeTransProc);
wxASSERT(uppMLI);
wxASSERT(DMGetDisplayIDByGDevice(m_hndl, &nDisplayID, false) == noErr);
//Create a new list...
wxASSERT_MSG(DMNewDisplayModeList(nDisplayID, NULL, NULL, &nNumModes, &pModes) == noErr,
wxT("Could not create a new display mode list") );
DMModeTransRec sModeInfo;
sModeInfo.bMatched = false;
sModeInfo.psMode = &sMode;
for (DMListIndexType i = 0; i < nNumModes; ++i)
{
wxASSERT(DMGetIndexedDisplayModeFromList(pModes, i, NULL,
uppMLI, &sModeInfo) == noErr);
uppMLI = NewDMDisplayModeListIteratorUPP(DMModeTransProc);
wxASSERT(uppMLI);
if ( sModeInfo.bMatched == true )
{
RetMode = sModeInfo.Mode;
break;
}
}
DMModeTransRec sModeInfo;
sModeInfo.bMatched = false;
sModeInfo.psMode = &sMode;
for (DMListIndexType i = 0; i < nNumModes; ++i)
{
wxASSERT(DMGetIndexedDisplayModeFromList(pModes, i, NULL,
uppMLI, &sModeInfo) == noErr);
DisposeDMDisplayModeListIteratorUPP(uppMLI);
wxASSERT(DMDisposeList(pModes) == noErr);
}
else //Can't get current mode?
{
wxLogSysError(wxString::Format(wxT("Couldn't obtain current display mode!!!\ndwDMVer:%u"),
(unsigned int) dwDMVer));
}
if ( sModeInfo.bMatched == true )
{
RetMode = sModeInfo.Mode;
break;
}
}
DisposeDMDisplayModeListIteratorUPP(uppMLI);
wxASSERT(DMDisposeList(pModes) == noErr);
}
else //Can't get current mode?
{
wxLogSysError(wxString::Format(wxT("Couldn't obtain current display mode!!!\ndwDMVer:%u"),
(unsigned int) dwDMVer));
}
}
else //DM ver 1
{
wxLogSysError(wxString::Format(wxT("Display Manager Version %u Not Supported! Present? %s"),
(unsigned int) dwDMVer / 0x10000,
(dwDMVer & (1 << gestaltDisplayMgrPresent) ? wxT("Yes") : wxT("No")) )
);
wxLogSysError(wxString::Format(wxT("Display Manager Version %u Not Supported! Present? %s"),
(unsigned int) dwDMVer / 0x10000,
(dwDMVer & (1 << gestaltDisplayMgrPresent) ? wxT("Yes") : wxT("No")) )
);
}
return RetMode;
}
bool wxDisplay::ChangeMode(const wxVideoMode& mode)
bool wxDisplayImplMac::ChangeMode(const wxVideoMode& mode)
{
unsigned long dwDMVer;
Gestalt(gestaltDisplayMgrVers, (long*)&dwDMVer);
if (GetCount() == 1 || dwDMVer >= 0x020000)
{
if (mode == wxDefaultVideoMode)
{
if (mode == wxDefaultVideoMode)
{
//#ifndef __DARWIN__
// Handle hDisplayState;
// if (DMBeginConfigureDisplays(&hDisplayState) != noErr)
// {
// wxLogSysError(wxT("Could not lock display for display mode changing!"));
// return false;
// }
// wxASSERT( DMUseScreenPrefs(true, hDisplayState) == noErr);
// DMEndConfigureDisplays(hDisplayState);
// return true;
// Handle hDisplayState;
// if (DMBeginConfigureDisplays(&hDisplayState) != noErr)
// {
// wxLogSysError(wxT("Could not lock display for display mode changing!"));
// return false;
// }
// wxASSERT( DMUseScreenPrefs(true, hDisplayState) == noErr);
// DMEndConfigureDisplays(hDisplayState);
// return true;
//#else
//hmmmmm....
return true;
//hmmmmm....
return true;
//#endif
}
//0 & NULL for params 2 & 3 of DMSetVideoMode signal it to use defaults (current mode)
//DM 2.0+ doesn't use params 2 & 3 of DMSetDisplayMode
//so we have to use this icky structure
VDSwitchInfoRec sMode;
memset(&sMode, 0, sizeof(VDSwitchInfoRec) );
}
DMListIndexType nNumModes;
DMListType pModes;
DMDisplayModeListIteratorUPP uppMLI;
DisplayIDType nDisplayID;
//0 & NULL for params 2 & 3 of DMSetVideoMode signal it to use defaults (current mode)
//DM 2.0+ doesn't use params 2 & 3 of DMSetDisplayMode
//so we have to use this icky structure
VDSwitchInfoRec sMode;
memset(&sMode, 0, sizeof(VDSwitchInfoRec) );
wxASSERT(DMGetDisplayIDByGDevice(m_priv->m_hndl, &nDisplayID, false) == noErr);
//Create a new list...
wxASSERT_MSG(DMNewDisplayModeList(nDisplayID, NULL, NULL, &nNumModes, &pModes) == noErr,
wxT("Could not create a new display mode list") );
DMListIndexType nNumModes;
DMListType pModes;
DMDisplayModeListIteratorUPP uppMLI;
DisplayIDType nDisplayID;
uppMLI = NewDMDisplayModeListIteratorUPP(DMModeInfoProc);
wxASSERT(uppMLI);
wxASSERT(DMGetDisplayIDByGDevice(m_hndl, &nDisplayID, false) == noErr);
//Create a new list...
wxASSERT_MSG(DMNewDisplayModeList(nDisplayID, NULL, NULL, &nNumModes, &pModes) == noErr,
wxT("Could not create a new display mode list") );
DMModeInfoRec sModeInfo;
sModeInfo.bMatched = false;
sModeInfo.pMode = &mode;
unsigned int i;
for(i = 0; i < nNumModes; ++i)
{
wxASSERT(DMGetIndexedDisplayModeFromList(pModes, i, NULL,
uppMLI, &sModeInfo) == noErr);
if (sModeInfo.bMatched == true)
{
sMode = sModeInfo.sMode;
break;
}
}
if(i == nNumModes)
return false;
uppMLI = NewDMDisplayModeListIteratorUPP(DMModeInfoProc);
wxASSERT(uppMLI);
DisposeDMDisplayModeListIteratorUPP(uppMLI);
wxASSERT(DMDisposeList(pModes) == noErr);
// For the really paranoid -
// unsigned long flags;
// Boolean bok;
// wxASSERT(noErr == DMCheckDisplayMode(m_priv->m_hndl, sMode.csData,
// sMode.csMode, &flags, NULL, &bok));
// wxASSERT(bok);
Handle hDisplayState;
if (DMBeginConfigureDisplays(&hDisplayState) != noErr)
{
wxLogSysError(wxT("Could not lock display for display mode changing!"));
return false;
}
unsigned long dwBPP = (unsigned long) mode.bpp;
if (DMSetDisplayMode(m_priv->m_hndl, sMode.csData,
(unsigned long*) &(dwBPP), NULL
//(unsigned long) &sMode
, hDisplayState
) != noErr)
{
DMEndConfigureDisplays(hDisplayState);
wxMessageBox(wxString::Format(wxT("Could not set the display mode")));
DMModeInfoRec sModeInfo;
sModeInfo.bMatched = false;
sModeInfo.pMode = &mode;
unsigned int i;
for(i = 0; i < nNumModes; ++i)
{
wxASSERT(DMGetIndexedDisplayModeFromList(pModes, i, NULL,
uppMLI, &sModeInfo) == noErr);
if (sModeInfo.bMatched == true)
{
sMode = sModeInfo.sMode;
break;
}
}
if(i == nNumModes)
return false;
}
DMEndConfigureDisplays(hDisplayState);
DisposeDMDisplayModeListIteratorUPP(uppMLI);
wxASSERT(DMDisposeList(pModes) == noErr);
// For the really paranoid -
// unsigned long flags;
// Boolean bok;
// wxASSERT(noErr == DMCheckDisplayMode(m_hndl, sMode.csData,
// sMode.csMode, &flags, NULL, &bok));
// wxASSERT(bok);
Handle hDisplayState;
if (DMBeginConfigureDisplays(&hDisplayState) != noErr)
{
wxLogSysError(wxT("Could not lock display for display mode changing!"));
return false;
}
unsigned long dwBPP = (unsigned long) mode.bpp;
if (DMSetDisplayMode(m_hndl, sMode.csData,
(unsigned long*) &(dwBPP), NULL
//(unsigned long) &sMode
, hDisplayState
) != noErr)
{
DMEndConfigureDisplays(hDisplayState);
wxLogError(wxT("Could not set the display mode"));
return false;
}
DMEndConfigureDisplays(hDisplayState);
}
else //DM 1.0, 1.2, 1.x
{
wxLogSysError(wxString::Format(wxT("Monitor gravitation not supported yet. dwDMVer:%u"),
(unsigned int) dwDMVer));
return false;
wxLogSysError(wxString::Format(wxT("Monitor gravitation not supported yet. dwDMVer:%u"),
(unsigned int) dwDMVer));
return false;
}
return true;
}
wxDisplay::~wxDisplay()
// ============================================================================
// wxDisplay::CreateFactory()
// ============================================================================
/* static */ wxDisplayFactory *wxDisplay::CreateFactory()
{
if ( m_priv )
{
delete m_priv;
m_priv = 0;
}
return new wxDisplayFactoryMac;
}
#endif // wxUSE_DISPLAY

99
src/mgl/display.cpp
View File

@@ -1,99 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// Name: src/mgl/display.cpp
// Purpose: MGL Implementation of wxDisplay class
// Author: Wlodzimierz ABX Skiba
// Modified by:
// Created: 05/03/2006
// RCS-ID: $Id$
// Copyright: (c) Wlodzimierz Skiba
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#if wxUSE_DISPLAY
#ifndef WX_PRECOMP
#include "wx/gdicmn.h"
#endif
#include "wx/display.h"
/* static */
int wxDisplayBase::GetFromPoint ( const wxPoint& WXUNUSED(pt) )
{
// TODO
return wxNOT_FOUND;
}
/* static */
size_t wxDisplayBase::GetCount()
{
// TODO
return 1;
}
// ----------------------------------------------------------------------------
// wxDisplay ctor/dtor
// ----------------------------------------------------------------------------
wxDisplay::wxDisplay ( size_t n )
: wxDisplayBase ( n )
{
}
wxDisplay::~wxDisplay()
{
}
bool wxDisplay::IsOk() const
{
// TODO
return m_index < GetCount();
}
wxRect wxDisplay::GetGeometry() const
{
wxRect rect;
// TODO
return rect;
}
wxString wxDisplay::GetName() const
{
// TODO
return wxEmptyString;
}
wxArrayVideoModes wxDisplay::GetModes(const wxVideoMode& WXUNUSED(modeMatch)) const
{
wxArrayVideoModes modes;
// TODO
return modes;
}
wxVideoMode wxDisplay::GetCurrentMode() const
{
wxVideoMode mode;
// TODO
return mode;
}
bool wxDisplay::ChangeMode(const wxVideoMode& WXUNUSED(mode))
{
// TODO
return false;
}
bool wxDisplay::IsPrimary() const
{
// TODO
return false;
}
#endif // wxUSE_DISPLAY

1334
src/msw/display.cpp
View File

File diff suppressed because it is too large Load Diff

87
src/os2/display.cpp
View File

@@ -1,87 +0,0 @@
///////////////////////////////////////////////////////////////////////////
// Name: displayx11.cpp
// Purpose: Unix/X11 implementation of wxDisplay class
// Author: Brian Victor
// Modified by:
// Created: 12/05/02
// RCS-ID: $Id$
// Copyright: (c) wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#include "wx/display.h"
#include "wx/intl.h"
#include "wx/log.h"
#ifndef WX_PRECOMP
#include "wx/dynarray.h"
#include "wx/gdicmn.h"
#include "wx/string.h"
#include "wx/utils.h"
#endif /* WX_PRECOMP */
#if wxUSE_DISPLAY
size_t wxDisplayBase::GetCount()
{
return 1;
}
int wxDisplayBase::GetFromPoint(const wxPoint &p)
{
return -1;
}
wxDisplay::wxDisplay(size_t index)
: wxDisplayBase ( index )
{
}
wxDisplay::~wxDisplay()
{
}
wxRect wxDisplay::GetGeometry() const
{
wxRect vRect(0,0,0,0);
return vRect;
}
int wxDisplay::GetDepth() const
{
return 24;
}
wxString wxDisplay::GetName() const
{
return wxEmptyString;
}
wxArrayVideoModes wxDisplay::GetModes(const wxVideoMode& mode) const
{
wxArrayVideoModes modes;
return modes;
}
wxVideoMode wxDisplay::GetCurrentMode() const
{
// Not implemented
return wxVideoMode();
}
bool wxDisplay::ChangeMode(const wxVideoMode& mode)
{
// Not implemented
return false;
}
#endif /* wxUSE_DISPLAY */

272
src/palmos/display.cpp
View File

@@ -1,272 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// Name: src/palmos/display.cpp
// Purpose: Palm OS Implementation of wxDisplay class
// Author: William Osborne - minimal working wxPalmOS port
// Modified by:
// Created: 10.13.04
// RCS-ID: $Id$
// Copyright: (c) William Osborne
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// ===========================================================================
// declarations
// ===========================================================================
// ---------------------------------------------------------------------------
// headers
// ---------------------------------------------------------------------------
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#if wxUSE_DISPLAY
#ifndef WX_PRECOMP
#include "wx/app.h"
#include "wx/dynarray.h"
#include "wx/frame.h"
#endif
#include "wx/dynload.h"
#include "wx/display.h"
// ----------------------------------------------------------------------------
// macros
// ----------------------------------------------------------------------------
#ifdef _UNICODE
#define WINFUNC(x) _T(#x) L"W"
#else
#define WINFUNC(x) #x "A"
#endif
// ----------------------------------------------------------------------------
// private classes
// ----------------------------------------------------------------------------
class wxDisplayInfo
{
public:
// handle of this monitor used by MonitorXXX() functions, never NULL
HMONITOR m_hmon;
// IDirectDraw object used to control this display, may be NULL
IDirectDraw2 *m_pDD2;
// DirectDraw GUID for this display, only valid when using DirectDraw
GUID m_guid;
// the entire area of this monitor in virtual screen coordinates
wxRect m_rect;
// the display device name for this monitor, empty initially and retrieved
// on demand by DoGetName()
wxString m_devName;
wxDisplayInfo() { m_hmon = NULL; m_pDD2 = NULL; }
~wxDisplayInfo() { if ( m_pDD2 ) m_pDD2->Release(); }
};
WX_DECLARE_OBJARRAY(wxDisplayInfo, wxDisplayInfoArray);
#include "wx/arrimpl.cpp"
WX_DEFINE_OBJARRAY(wxDisplayInfoArray);
// this module is used to cleanup gs_displays array
class wxDisplayModule : public wxModule
{
public:
virtual bool OnInit() { return true; }
virtual void OnExit();
DECLARE_DYNAMIC_CLASS(wxDisplayModule)
};
IMPLEMENT_DYNAMIC_CLASS(wxDisplayModule, wxModule)
// ----------------------------------------------------------------------------
// globals
// ----------------------------------------------------------------------------
// this is not really MT-unsafe as wxDisplay is only going to be used from the
// main thread, i.e. we consider that it's a GUI class and so don't protect it
static wxDisplayInfoArray *gs_displays = NULL;
// ===========================================================================
// implementation
// ===========================================================================
// ----------------------------------------------------------------------------
// local functions
// ----------------------------------------------------------------------------
// initialize gs_displays using DirectX functions
static bool DoInitDirectX()
{
return false;
}
// initialize gs_displays using the standard Windows functions
static void DoInitStdWindows()
{
}
// this function must be called before accessing gs_displays array as it
// creates and initializes it
static void InitDisplays()
{
}
// convert a DEVMODE to our wxVideoMode
wxVideoMode ConvertToVideoMode(const DEVMODE& dm)
{
return wxVideoMode(160,
160,
16,
0);
}
// ----------------------------------------------------------------------------
// wxDisplayModule
// ----------------------------------------------------------------------------
void wxDisplayModule::OnExit()
{
}
// ---------------------------------------------------------------------------
// wxDisplay
// ---------------------------------------------------------------------------
/* static */
void wxDisplay::UseDirectX(bool useDX)
{
}
// helper of GetFromPoint() and GetFromWindow()
static int DisplayFromHMONITOR(HMONITOR hmon)
{
return wxNOT_FOUND;
}
/* static */
size_t wxDisplayBase::GetCount()
{
return 0;
}
/* static */
int wxDisplayBase::GetFromPoint ( const wxPoint& pt )
{
return 0;
}
/* static */
int wxDisplayBase::GetFromWindow(wxWindow *window)
{
return 0;
}
// ----------------------------------------------------------------------------
// wxDisplay ctor/dtor
// ----------------------------------------------------------------------------
wxDisplay::wxDisplay ( size_t n )
: wxDisplayBase ( n )
{
}
wxDisplay::~wxDisplay()
{
}
// ----------------------------------------------------------------------------
// wxDisplay simple accessors
// ----------------------------------------------------------------------------
bool wxDisplay::IsOk() const
{
return false;
}
wxRect wxDisplay::GetGeometry() const
{
wxRect rect;
return rect;
}
wxString wxDisplay::GetName() const
{
wxString ret;
return ret;
}
wxString wxDisplay::GetNameForEnumSettings() const
{
wxString ret;
return ret;
}
// ----------------------------------------------------------------------------
// video modes enumeration
// ----------------------------------------------------------------------------
wxArrayVideoModes
wxDisplay::DoGetModesDirectX(const wxVideoMode& WXUNUSED(modeMatch)) const
{
wxArrayVideoModes modes;
return modes;
}
wxArrayVideoModes
wxDisplay::DoGetModesWindows(const wxVideoMode& modeMatch) const
{
wxArrayVideoModes modes;
return modes;
}
wxArrayVideoModes wxDisplay::GetModes(const wxVideoMode& modeMatch) const
{
return gs_useDirectX ? DoGetModesDirectX(modeMatch)
: DoGetModesWindows(modeMatch);
}
wxVideoMode wxDisplay::GetCurrentMode() const
{
wxVideoMode mode;
return mode;
}
// ----------------------------------------------------------------------------
// video mode switching
// ----------------------------------------------------------------------------
bool wxDisplay::DoChangeModeDirectX(const wxVideoMode& mode)
{
return false;
}
bool wxDisplay::DoChangeModeWindows(const wxVideoMode& mode)
{
return false;
}
bool wxDisplay::ChangeMode(const wxVideoMode& mode)
{
return gs_useDirectX ? DoChangeModeDirectX(mode)
: DoChangeModeWindows(mode);
}
#endif // wxUSE_DISPLAY

250
src/unix/displayx11.cpp
View File

@@ -1,7 +1,7 @@
///////////////////////////////////////////////////////////////////////////
// Name: displayx11.cpp
// Name: src/unix/displayx11.cpp
// Purpose: Unix/X11 implementation of wxDisplay class
// Author: Brian Victor
// Author: Brian Victor, Vadim Zeitlin
// Modified by:
// Created: 12/05/02
// RCS-ID: $Id$
@@ -9,6 +9,14 @@
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// ============================================================================
// declarations
// ============================================================================
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
@@ -17,6 +25,7 @@
#endif
#include "wx/display.h"
#include "wx/display_impl.h"
#include "wx/intl.h"
#include "wx/log.h"
@@ -31,132 +40,119 @@
/* These must be included after the wx files. Otherwise the Data macro in
* Xlibint.h conflicts with a function declaration in wx/list.h. */
extern "C" {
#include <X11/Xlib.h>
#ifndef __VMS
#include <X11/Xlibint.h>
# include <X11/extensions/Xinerama.h>
#ifdef HAVE_X11_EXTENSIONS_XF86VMODE_H
#include <X11/extensions/xf86vmode.h>
#endif
#endif
extern "C"
{
#include <X11/Xlib.h>
#include <X11/Xlibint.h>
#include <X11/extensions/Xinerama.h>
#ifdef HAVE_X11_EXTENSIONS_XF86VMODE_H
#include <X11/extensions/xf86vmode.h>
#endif
}
class wxDisplayUnixPriv
// ----------------------------------------------------------------------------
// helper class to automatically free XineramaQueryScreens() return value
// ----------------------------------------------------------------------------
class ScreensInfo
{
public:
wxRect m_rect;
int m_depth;
public:
ScreensInfo()
{
m_screens = XineramaQueryScreens((Display *)wxGetDisplay(), &m_num);
}
~ScreensInfo()
{
XFree(m_screens);
}
operator const XineramaScreenInfo *() const { return m_screens; }
size_t GetCount() const { return wx_static_cast(size_t, m_num); }
private:
XineramaScreenInfo *m_screens;
int m_num;
};
size_t wxDisplayBase::GetCount()
// ----------------------------------------------------------------------------
// display and display factory classes
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxDisplayImplX11 : public wxDisplayImpl
{
Display *disp = (Display*)wxGetDisplay();
#ifndef __VMS
if ( XineramaIsActive(disp) )
{
XineramaScreenInfo *screenarr;
int numscreens;
screenarr = XineramaQueryScreens(disp, &numscreens);
XFree(screenarr);
return numscreens;
}
else
#endif
{
return 1;
}
}
int wxDisplayBase::GetFromPoint(const wxPoint &p)
{
Display *disp = (Display*)wxGetDisplay();
#ifndef __VMS
if ( XineramaIsActive(disp) )
{
int which_screen = -1;
XineramaScreenInfo *screenarr;
int numscreens;
screenarr = XineramaQueryScreens(disp, &numscreens);
int i;
for (i = 0; i < numscreens; ++i)
public:
wxDisplayImplX11(const XineramaScreenInfo& info)
: m_rect(info.x_org, info.y_org, info.width, info.height)
{
if (p.x >= screenarr[i].x_org &&
p.x < screenarr[i].x_org + screenarr[i].width &&
p.y >= screenarr[i].y_org &&
p.y < screenarr[i].y_org + screenarr[i].height)
{
which_screen = i;
}
}
XFree(screenarr);
return which_screen;
}
else
#endif
{
wxSize size = wxGetDisplaySize();
if (p.x >= 0 &&
p.x < size.GetWidth() &&
p.y >= 0 &&
p.y < size.GetHeight())
virtual wxRect GetGeometry() const { return m_rect; }
virtual wxString GetName() const { return wxString(); }
virtual wxArrayVideoModes GetModes(const wxVideoMode& mode) const;
virtual wxVideoMode GetCurrentMode() const;
virtual bool ChangeMode(const wxVideoMode& mode);
private:
wxRect m_rect;
int m_depth;
DECLARE_NO_COPY_CLASS(wxDisplayImplX11)
};
class wxDisplayFactoryX11 : public wxDisplayFactory
{
public:
wxDisplayFactoryX11();
virtual wxDisplayImpl *CreateDisplay(size_t n);
virtual size_t GetCount();
virtual int GetFromPoint(const wxPoint& pt);
protected:
DECLARE_NO_COPY_CLASS(wxDisplayFactoryX11)
};
// ============================================================================
// wxDisplayFactoryX11 implementation
// ============================================================================
size_t wxDisplayFactoryX11::GetCount()
{
return ScreensInfo().GetCount();
}
int wxDisplayFactoryX11::GetFromPoint(const wxPoint& p)
{
ScreensInfo screens;
const size_t numscreens(screens.GetCount());
for ( size_t i = 0; i < numscreens; ++i )
{
return 0;
const XineramaScreenInfo& s = screens[i];
if ( p.x >= s.x_org && p.x < s.x_org + s.width &&
p.y >= s.y_org && p.y < s.y_org + s.height )
{
return i;
}
}
return -1;
}
return wxNOT_FOUND;
}
wxDisplay::wxDisplay(size_t index) : wxDisplayBase ( index ), m_priv( new wxDisplayUnixPriv )
wxDisplayImpl *wxDisplayFactoryX11::CreateDisplay(size_t n)
{
Display *disp = (Display*)wxGetDisplay();
ScreensInfo screens;
#ifndef __VMS
if ( XineramaIsActive(disp) )
{
XineramaScreenInfo *screenarr;
int numscreens;
screenarr = XineramaQueryScreens(disp, &numscreens);
m_priv->m_rect = wxRect(screenarr[index].x_org, screenarr[index].y_org,
screenarr[index].width, screenarr[index].height);
m_priv->m_depth = DefaultDepth(disp, DefaultScreen(disp));
XFree(screenarr);
}
else
#endif
{
wxSize size = wxGetDisplaySize();
m_priv->m_rect = wxRect(0, 0, size.GetWidth(), size.GetHeight());
m_priv->m_depth = wxDisplayDepth();
}
}
wxDisplay::~wxDisplay()
{
delete m_priv;
}
wxRect wxDisplay::GetGeometry() const
{
return m_priv->m_rect;
}
int wxDisplay::GetDepth() const
{
return m_priv->m_depth;
}
wxString wxDisplay::GetName() const
{
return wxEmptyString;
return n < screens.GetCount() ? new wxDisplayImplX11(screens[n]) : NULL;
}
// ============================================================================
// wxDisplayImplX11 implementation
// ============================================================================
#ifdef HAVE_X11_EXTENSIONS_XF86VMODE_H
@@ -269,19 +265,19 @@ bool wxDisplay::ChangeMode(const wxVideoMode& mode)
wxArrayVideoModes wxDisplay::GetModes(const wxVideoMode& mode) const
{
Display *disp = (Display*)wxGetDisplay();
int count_return;
int* depths = XListDepths(disp, 0, &count_return);
wxArrayVideoModes modes;
if (depths)
{
int x;
for (x = 0; x < count_return; ++x)
int count_return;
int* depths = XListDepths((Display*)wxGetDisplay(), 0, &count_return);
wxArrayVideoModes modes;
if ( depths )
{
modes.Add(wxVideoMode(m_priv->m_rect.GetWidth(), m_priv->m_rect.GetHeight(), depths[x]));
for ( int x = 0; x < count_return; ++x )
{
modes.Add(wxVideoMode(m_rect.GetWidth(), m_rect.GetHeight(), depths[x]));
}
XFree(depths);
}
}
return modes;
return modes;
}
wxVideoMode wxDisplay::GetCurrentMode() const
@@ -298,4 +294,16 @@ bool wxDisplay::ChangeMode(const wxVideoMode& mode)
#endif // !HAVE_X11_EXTENSIONS_XF86VMODE_H
// ============================================================================
// wxDisplay::CreateFactory()
// ============================================================================
/* static */ wxDisplayFactory *wxDisplay::CreateFactory()
{
Display *disp = (Display*)wxGetDisplay();
return XineramaIsActive(disp) ? new wxDisplayFactoryX11
: new wxDisplayFactorySingle;
}
#endif /* wxUSE_DISPLAY */