int main(int argc, char * argv[])
{
IOReturn err;
CGDirectDisplayID dspy = CGMainDisplayID();
io_service_t framebuffer;
CGRect bounds;
vm_address_t buffer;
vm_size_t size, rowBytes;
framebuffer = CGDisplayIOServicePort(dspy);
assert (framebuffer != MACH_PORT_NULL);
dspy = CGMainDisplayID();
bounds = CGDisplayBounds(dspy);
rowBytes = CGDisplayBytesPerRow(dspy);
err = IOAccelReadFramebuffer(framebuffer, bounds.size.width, bounds.size.height, rowBytes,
&buffer, &size);
if (kIOReturnSuccess == err)
{
fprintf(stderr, "writing 0x%x bytes from 0x%x\n", size, buffer);
write(STDOUT_FILENO, (const void *) buffer, size);
vm_deallocate(mach_task_self(), buffer, size);
}
return (0);
}
bool RTCALL VBoxOglIs3DAccelerationSupported()
{
if (RTEnvGet("VBOX_CROGL_FORCE_SUPPORTED"))
{
LogRel(("VBOX_CROGL_FORCE_SUPPORTED is specified, skipping 3D test, and treating as supported\n"));
return true;
}
CGDirectDisplayID display = CGMainDisplayID ();
CGOpenGLDisplayMask cglDisplayMask = CGDisplayIDToOpenGLDisplayMask (display);
CGLPixelFormatObj pixelFormat = NULL;
GLint numPixelFormats = 0;
CGLPixelFormatAttribute attribs[] = {
kCGLPFADisplayMask,
(CGLPixelFormatAttribute)cglDisplayMask,
kCGLPFAAccelerated,
kCGLPFADoubleBuffer,
kCGLPFAWindow,
(CGLPixelFormatAttribute)NULL
};
display = CGMainDisplayID();
cglDisplayMask = CGDisplayIDToOpenGLDisplayMask(display);
CGLChoosePixelFormat(attribs, &pixelFormat, &numPixelFormats);
if (pixelFormat)
{
CGLContextObj cglContext = 0;
CGLCreateContext(pixelFormat, NULL, &cglContext);
CGLDestroyPixelFormat(pixelFormat);
if (cglContext)
{
GLboolean isSupported = GL_TRUE;
#ifdef VBOX_WITH_COCOA_QT
/* On the Cocoa port we depend on the GL_EXT_framebuffer_object &
* the GL_EXT_texture_rectangle extension. If they are not
* available, disable 3D support. */
CGLSetCurrentContext(cglContext);
const GLubyte* strExt;
strExt = glGetString(GL_EXTENSIONS);
isSupported = gluCheckExtension((const GLubyte*)"GL_EXT_framebuffer_object", strExt);
if (isSupported)
{
isSupported = gluCheckExtension((const GLubyte*)"GL_EXT_texture_rectangle", strExt);
if (!isSupported)
LogRel(("OpenGL Info: GL_EXT_texture_rectangle extension not supported\n"));
}
else
LogRel(("OpenGL Info: GL_EXT_framebuffer_object extension not supported\n"));
#endif /* VBOX_WITH_COCOA_QT */
CGLDestroyContext(cglContext);
return isSupported == GL_TRUE ? true : false;
}
}
return false;
}
static CGDirectDisplayID screen(void* w) {
HIRect bounds;
OSStatus err = HIWindowGetBounds((WindowRef)w, kWindowGlobalPortRgn,
kHICoordSpace72DPIGlobal, &bounds);
if (err) {
lprintf("HIWindowGetBounds failed: %d\n", err);
return CGMainDisplayID();
}
CGDirectDisplayID display;
CGDisplayCount displayCount;
CGDisplayErr e = CGGetDisplaysWithRect(bounds, 1,
&display, &displayCount);
return (displayCount && !e) ? display : CGMainDisplayID();
}
void GetMonitorProfile(wxString& profileName, cmsHPROFILE& profile)
{
ColorsyncIteratorData data;
data.dispuuid = CGDisplayCreateUUIDFromDisplayID(CGMainDisplayID());
if (data.dispuuid == NULL)
{
DEBUG_INFO("CGDisplayCreateUUIDFromDisplayID() failed.");
return;
}
data.url = NULL;
ColorSyncIterateDeviceProfiles(ColorSyncIterateCallback, (void *)&data);
CFRelease(data.dispuuid);
CFStringRef urlstr = CFURLCopyFileSystemPath(data.url, kCFURLPOSIXPathStyle);
CFRelease(data.url);
if (urlstr == NULL)
{
DEBUG_INFO("Failed to get URL in CFString");
}
else
{
CFRetain(urlstr);
profileName = wxCFStringRef(urlstr).AsString(wxLocale::GetSystemEncoding());
profile = cmsOpenProfileFromFile(profileName.c_str(), "r");
DEBUG_INFO("Found profile: " << profileName.c_str());
};
};
void
listDisplays(void)
{
CGDisplayErr dErr;
CGDisplayCount displayCount, i;
CGDirectDisplayID mainDisplay;
CGDisplayCount maxDisplays = MAX_DISPLAYS;
CGDirectDisplayID onlineDisplays[MAX_DISPLAYS];
mainDisplay = CGMainDisplayID();
dErr = CGGetOnlineDisplayList(maxDisplays, onlineDisplays, &displayCount);
if (dErr != kCGErrorSuccess) {
fprintf(stderr, "CGGetOnlineDisplayList: error %d.\n", dErr);
exit(1);
}
printf("Display ID Resolution\n");
for (i = 0; i < displayCount; i++) {
CGDirectDisplayID dID = onlineDisplays[i];
printf("%-16p %lux%lu %32s", dID,
CGDisplayPixelsWide(dID), CGDisplayPixelsHigh(dID),
(dID == mainDisplay) ? "[main display]\n" : "\n");
}
exit(0);
}
static int Open(void * hwnd)
{
CGLRendererInfoObj renderer;
long numRenderer;
CGDirectDisplayID l[32];
CGDisplayCount count;
SYS_ASSERT(g_pCGLC == 0);
UNUSED(hwnd);
CGGetActiveDisplayList (sizeof(l), l, &count);
#ifdef _DEBUG
// Debug in multiple monitor. Use the secondary monitor for rendering
g_cgDisplayID = l[count-1];
#else
g_cgDisplayID = CGMainDisplayID ();
#endif
g_cgPrevDisplayMode = CGDisplayCurrentMode (g_cgDisplayID);
g_cgDisplayModeList = CGDisplayAvailableModes (g_cgDisplayID);
CGLQueryRendererInfo(CGDisplayIDToOpenGLDisplayMask(g_cgDisplayID), &renderer, &numRenderer);
CGLDestroyRendererInfo(renderer);
return 0;
}
nglVideoMode::nglVideoMode()
{
#ifdef __NGL_MACHO__
mDisplay = CGMainDisplayID();
#endif
Init();
#ifdef __NGL_MACHO__
CFDictionaryRef displayMode ;
CFNumberRef number ;
displayMode = (CFDictionaryRef) CGDisplayCurrentMode((CGDirectDisplayID)mDisplay) ;
/* Get the height and width of this display mode. Print them out. */
number = (CFNumberRef)CFDictionaryGetValue( displayMode, kCGDisplayWidth ) ;
CFNumberGetValue( number, kCFNumberLongType, &mWidth ) ;
number = (CFNumberRef)CFDictionaryGetValue( displayMode, kCGDisplayHeight ) ;
CFNumberGetValue( number, kCFNumberLongType, &mHeight ) ;
number = (CFNumberRef)CFDictionaryGetValue( displayMode, kCGDisplayRefreshRate ) ;
CFNumberGetValue( number, kCFNumberLongType, &mRate ) ;
number = (CFNumberRef)CFDictionaryGetValue( displayMode, kCGDisplayBitsPerPixel ) ;
CFNumberGetValue( number, kCFNumberLongType, &mBPP ) ;
#else
mWidth = 800;
mHeight = 600;
mBPP = 32;
mRate = 60;
#endif
}
/***********************************************************************
* macdrv_displays_changed
*
* Handler for DISPLAYS_CHANGED events.
*/
void macdrv_displays_changed(const macdrv_event *event)
{
HWND hwnd = GetDesktopWindow();
/* A system display change will get delivered to all GUI-attached threads,
so the desktop-window-owning thread will get it and all others should
ignore it. A synthesized display change event due to activation
will only get delivered to the activated process. So, it needs to
process it (by sending it to the desktop window). */
if (event->displays_changed.activating ||
GetWindowThreadProcessId(hwnd, NULL) == GetCurrentThreadId())
{
CGDirectDisplayID mainDisplay = CGMainDisplayID();
CGDisplayModeRef mode = CGDisplayCopyDisplayMode(mainDisplay);
size_t width = CGDisplayModeGetWidth(mode);
size_t height = CGDisplayModeGetHeight(mode);
int mode_bpp = display_mode_bits_per_pixel(mode);
struct display_mode_descriptor* desc = create_original_display_mode_descriptor(mainDisplay);
BOOL is_original = display_mode_matches_descriptor(mode, desc);
free_display_mode_descriptor(desc);
CGDisplayModeRelease(mode);
if (is_original && retina_enabled)
{
width *= 2;
height *= 2;
}
SendMessageW(hwnd, WM_MACDRV_UPDATE_DESKTOP_RECT, mode_bpp,
MAKELPARAM(width, height));
}
}
int VID_GetGamma(unsigned short *ramps, int rampsize)
{
CGGammaValue table_red [GAMMA_TABLE_SIZE];
CGGammaValue table_green [GAMMA_TABLE_SIZE];
CGGammaValue table_blue [GAMMA_TABLE_SIZE];
CGTableCount actualsize = 0;
int i;
// Get the gamma ramps from the system
if (CGGetDisplayTransferByTable(CGMainDisplayID(), rampsize, table_red, table_green, table_blue, &actualsize) != CGDisplayNoErr)
{
Con_Print("VID_GetGamma: ERROR: CGGetDisplayTransferByTable failed!\n");
return false;
}
if (actualsize != (unsigned int)rampsize)
{
Con_Printf("VID_GetGamma: ERROR: invalid gamma table size (%u != %u)\n", actualsize, rampsize);
return false;
}
// Convert the 3 float tables into 1 unsigned short table
for (i = 0; i < rampsize; i++)
ramps[i] = table_red[i] * 65535.0f;
for (i = 0; i < rampsize; i++)
ramps[i + rampsize] = table_green[i] * 65535.0f;
for (i = 0; i < rampsize; i++)
ramps[i + 2 * rampsize] = table_blue[i] * 65535.0f;
return true;
}
size_t VID_ListModes(vid_mode_t *modes, size_t maxcount)
{
CGDirectDisplayID mainDisplay = CGMainDisplayID();
CFArrayRef vidmodes = CGDisplayAvailableModes(mainDisplay);
CFDictionaryRef thismode;
unsigned int n = CFArrayGetCount(vidmodes);
unsigned int i;
size_t k;
k = 0;
for(i = 0; i < n; ++i)
{
thismode = (CFDictionaryRef) CFArrayGetValueAtIndex(vidmodes, i);
if(!GetDictionaryBoolean(thismode, kCGDisplayModeIsSafeForHardware))
continue;
if(k >= maxcount)
break;
modes[k].width = GetDictionaryLong(thismode, kCGDisplayWidth);
modes[k].height = GetDictionaryLong(thismode, kCGDisplayHeight);
modes[k].bpp = GetDictionaryLong(thismode, kCGDisplayBitsPerPixel);
modes[k].refreshrate = GetDictionaryLong(thismode, kCGDisplayRefreshRate);
modes[k].pixelheight_num = 1;
modes[k].pixelheight_denom = 1; // OS X doesn't expose this either
++k;
}
return k;
}
/***********************************************************************
* macdrv_get_desktop_rect
*
* Returns the rectangle encompassing all the screens.
*/
CGRect macdrv_get_desktop_rect(void)
{
CGRect ret;
CGDirectDisplayID displayIDs[32];
uint32_t count, i;
EnterCriticalSection(&device_data_section);
if (!device_data_valid)
{
desktop_rect = CGRectNull;
if (CGGetActiveDisplayList(sizeof(displayIDs)/sizeof(displayIDs[0]),
displayIDs, &count) != kCGErrorSuccess ||
!count)
{
displayIDs[0] = CGMainDisplayID();
count = 1;
}
for (i = 0; i < count; i++)
desktop_rect = CGRectUnion(desktop_rect, CGDisplayBounds(displayIDs[i]));
}
ret = desktop_rect;
LeaveCriticalSection(&device_data_section);
TRACE("%s\n", wine_dbgstr_cgrect(ret));
return ret;
}
void
screeninit(void)
{
int fmt;
int dx, dy;
ProcessSerialNumber psn = { 0, kCurrentProcess };
TransformProcessType(&psn, kProcessTransformToForegroundApplication);
SetFrontProcess(&psn);
fmt = XBGR32; //XRGB32;
devRect = max_bounds();
dx = devRect.size.width;
dy = devRect.size.height;
gscreen = allocmemimage(Rect(0,0,dx,dy), fmt);
dataProviderRef = CGDataProviderCreateWithData(0, gscreen->data->bdata,
dx * dy * 4, 0);
fullScreenImage = CGImageCreate(dx, dy, 8, 32, dx * 4,
CGColorSpaceCreateDeviceRGB(),
kCGImageAlphaNoneSkipLast,
dataProviderRef, 0, 0, kCGRenderingIntentDefault);
devRect = CGDisplayBounds(CGMainDisplayID());
kproc("osxscreen", winproc, nil, 0);
kproc("osxflush", flushproc, nil, 0);
Sleep(&rend, isready, nil);
}
void Input::confineMouse(){
if (!bWarpMouse)
return;
#ifdef TARGET_WIN32
glutWarpPointer(renderer->windowX/2,renderer->windowY/2);
#endif
#ifdef TARGET_LINUX
glutWarpPointer(renderer->windowX/2,renderer->windowY/2);
#endif
#ifdef TARGET_MACOSX
CGPoint myPoint;
int centerX=renderer->windowX/2;
int centerY=renderer->windowY/2;
myPoint.x=centerX+renderer->windowPosX;
myPoint.y=centerY+renderer->windowPosY;
CGDisplayMoveCursorToPoint( CGMainDisplayID (),myPoint);
#endif
mouseX=renderer->windowX/2;
mouseY=renderer->windowY/2;
}
VideoMode VideoModeImpl::getDesktopMode()
{
CGDirectDisplayID display = CGMainDisplayID();
return VideoMode(CGDisplayPixelsWide(display),
CGDisplayPixelsHigh(display),
displayBitsPerPixel(display));
}
static void *gfx_ctx_cgl_init(void *video_driver)
{
CGError err;
gfx_ctx_cgl_data_t *cgl = (gfx_ctx_cgl_data_t*)calloc(1, sizeof(gfx_ctx_cgl_data_t));
if (!cgl)
goto error;
cgl->displayID = CGMainDisplayID();
err = CGDisplayCapture(cgl->displayID);
if (err != kCGErrorSuccess)
goto error;
cgl->glCtx = gfx_ctx_cgl_init_create();
if (!cgl->glCtx)
goto error;
attach_gl_context_to_window(cgl->glCtx,
CGShieldingWindowID(cgl->displayID), &cgl->width, &cgl->height);
printf("size:%dx%d\n", cgl->width, cgl->height);
CGLSetCurrentContext(cgl->glCtx);
return cgl;
error:
gfx_ctx_cgl_destroy(cgl);
return NULL;
}
static int mac_shadow_detect_monitors(macShadowSubsystem* subsystem)
{
size_t wide, high;
MONITOR_DEF* monitor;
CGDirectDisplayID displayId;
displayId = CGMainDisplayID();
CGDisplayModeRef mode = CGDisplayCopyDisplayMode(displayId);
subsystem->pixelWidth = CGDisplayModeGetPixelWidth(mode);
subsystem->pixelHeight = CGDisplayModeGetPixelHeight(mode);
wide = CGDisplayPixelsWide(displayId);
high = CGDisplayPixelsHigh(displayId);
CGDisplayModeRelease(mode);
subsystem->retina = ((subsystem->pixelWidth / wide) == 2) ? TRUE : FALSE;
if (subsystem->retina)
{
subsystem->width = wide;
subsystem->height = high;
}
else
{
subsystem->width = subsystem->pixelWidth;
subsystem->height = subsystem->pixelHeight;
}
subsystem->numMonitors = 1;
monitor = &(subsystem->monitors[0]);
monitor->left = 0;
monitor->top = 0;
monitor->right = subsystem->width;
monitor->bottom = subsystem->height;
monitor->flags = 1;
return 1;
}
// Returns depth of screen
int wxDisplayDepth()
{
int theDepth = 0;
#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1060
if ( UMAGetSystemVersion() >= 0x1060 )
{
CGDisplayModeRef currentMode = CGDisplayCopyDisplayMode(kCGDirectMainDisplay);
CFStringRef encoding = CGDisplayModeCopyPixelEncoding(currentMode);
if(CFStringCompare(encoding, CFSTR(IO32BitDirectPixels), kCFCompareCaseInsensitive) == kCFCompareEqualTo)
theDepth = 32;
else if(CFStringCompare(encoding, CFSTR(IO16BitDirectPixels), kCFCompareCaseInsensitive) == kCFCompareEqualTo)
theDepth = 16;
else if(CFStringCompare(encoding, CFSTR(IO8BitIndexedPixels), kCFCompareCaseInsensitive) == kCFCompareEqualTo)
theDepth = 8;
else
theDepth = 32; // some reasonable default
CFRelease(encoding);
CGDisplayModeRelease(currentMode);
}
else
#endif
{
#if MAC_OS_X_VERSION_MIN_REQUIRED < 1060
theDepth = (int) CGDisplayBitsPerPixel(CGMainDisplayID());
#endif
}
return theDepth;
}
//---------------------------------------------------------------------------
// AGL init
//---------------------------------------------------------------------------
bool Pipe::configInit()
{
CGDirectDisplayID displayID = CGMainDisplayID();
const uint32_t device = getPipe()->getDevice();
if( device != LB_UNDEFINED_UINT32 )
{
CGDirectDisplayID *displayIDs = static_cast< CGDirectDisplayID* >(
alloca( (device+1) * sizeof( displayIDs )));
CGDisplayCount nDisplays;
if( CGGetOnlineDisplayList( device+1, displayIDs, &nDisplays ) !=
kCGErrorSuccess )
{
sendError( ERROR_AGLPIPE_DISPLAYS_NOTFOUND );
return false;
}
if( nDisplays <= device )
{
sendError( ERROR_AGLPIPE_DEVICE_NOTFOUND );
return false;
}
displayID = displayIDs[device];
}
_setCGDisplayID( displayID );
LBVERB << "Using CG displayID " << displayID << std::endl;
return true;
}
OSStatus wxOverlayImpl::CreateOverlayWindow()
{
OSStatus err;
WindowAttributes overlayAttributes = kWindowIgnoreClicksAttribute;
if ( m_window )
{
m_overlayParentWindow =(WindowRef) m_window->MacGetTopLevelWindowRef();
Rect bounds ;
MacGetBounds(&bounds);
err = CreateNewWindow( kOverlayWindowClass, overlayAttributes, &bounds, &m_overlayWindow );
if ( err == noErr )
{
SetWindowGroup( m_overlayWindow, GetWindowGroup(m_overlayParentWindow)); // Put them in the same group so that their window layers are consistent
}
}
else
{
m_overlayParentWindow = NULL ;
CGRect cgbounds ;
cgbounds = CGDisplayBounds(CGMainDisplayID());
Rect bounds;
bounds.top = (short)cgbounds.origin.y;
bounds.left = (short)cgbounds.origin.x;
bounds.bottom = (short)(bounds.top + cgbounds.size.height);
bounds.right = (short)(bounds.left + cgbounds.size.width);
err = CreateNewWindow( kOverlayWindowClass, overlayAttributes, &bounds, &m_overlayWindow );
}
ShowWindow(m_overlayWindow);
return err;
}
void praat_reportGraphicalProperties () {
MelderInfo_open ();
MelderInfo_writeLine (U"Graphical properties of this edition of Praat on this computer:\n");
double x, y, width, height;
Gui_getWindowPositioningBounds (& x, & y, & width, & height);
MelderInfo_writeLine (U"Window positioning area: x = ", x, U", y = ", y,
U", width = ", width, U", height = ", height);
#if defined (macintosh)
CGDirectDisplayID screen = CGMainDisplayID ();
CGSize screenSize_mm = CGDisplayScreenSize (screen);
double diagonal_mm = sqrt (screenSize_mm. width * screenSize_mm. width + screenSize_mm. height * screenSize_mm. height);
double diagonal_inch = diagonal_mm / 25.4;
MelderInfo_writeLine (U"\nScreen size: ", screenSize_mm. width, U" x ", screenSize_mm. height,
U" mm (diagonal ", Melder_fixed (diagonal_mm, 1), U" mm = ", Melder_fixed (diagonal_inch, 1), U" inch)");
size_t screenWidth_pixels = CGDisplayPixelsWide (screen);
size_t screenHeight_pixels = CGDisplayPixelsHigh (screen);
MelderInfo_writeLine (U"Screen \"resolution\": ", screenWidth_pixels, U" x ", screenHeight_pixels, U" pixels");
double resolution = 25.4 * screenWidth_pixels / screenSize_mm. width;
MelderInfo_writeLine (U"Screen resolution: ", Melder_fixed (resolution, 1), U" pixels/inch");
#elif defined (_WIN32)
/*for (int i = 0; i <= 88; i ++)
MelderInfo_writeLine (U"System metric ", i, U": ", GetSystemMetrics (i));*/
#endif
MelderInfo_close ();
}
// Create a DC representing the whole screen
wxScreenDCImpl::wxScreenDCImpl( wxDC *owner ) :
wxWindowDCImpl( owner )
{
#if wxOSX_USE_COCOA_OR_CARBON
CGRect cgbounds ;
cgbounds = CGDisplayBounds(CGMainDisplayID());
m_width = (wxCoord)cgbounds.size.width;
m_height = (wxCoord)cgbounds.size.height;
#else
wxDisplaySize( &m_width, &m_height );
#endif
#if wxOSX_USE_COCOA_OR_IPHONE
SetGraphicsContext( wxGraphicsContext::Create() );
#else
Rect bounds;
bounds.top = (short)cgbounds.origin.y;
bounds.left = (short)cgbounds.origin.x;
bounds.bottom = bounds.top + (short)cgbounds.size.height;
bounds.right = bounds.left + (short)cgbounds.size.width;
WindowAttributes overlayAttributes = kWindowIgnoreClicksAttribute;
CreateNewWindow( kOverlayWindowClass, overlayAttributes, &bounds, (WindowRef*) &m_overlayWindow );
ShowWindow((WindowRef)m_overlayWindow);
SetGraphicsContext( wxGraphicsContext::CreateFromNativeWindow( m_overlayWindow ) );
#endif
m_ok = true ;
}
/* void lock (); */
NS_IMETHODIMP OSLock::Lock()
{
WindowRef maskWindow = NULL;
Rect winRect;
winRect.top = 0;
winRect.left = 0;
winRect.bottom = GetMBarHeight();
winRect.right = CGDisplayPixelsWide(CGMainDisplayID());
CreateNewWindow(kOverlayWindowClass, kWindowOpaqueForEventsAttribute |
kWindowDoesNotCycleAttribute,
&winRect, &maskWindow);
if (maskWindow == NULL) {
printf("maskWindow is NULL\n");
} else {
if (ChangeWindowAttributes(maskWindow, kWindowNoAttributes,
kWindowHideOnFullScreenAttribute) != 0) {
printf("Unable to remove kWindowHideOnFullScreenAttribute!\n");
}
ShowWindow(maskWindow);
}
SetSystemUIMode(kUIModeAllHidden, kUIOptionDisableAppleMenu |
kUIOptionDisableProcessSwitch); // | kUIOptionDisableForceQuit);
//CGCaptureAllDisplays();
return NS_OK;
}
void Overlay::toggleShow() {
if (g.ocIntercept) {
g.ocIntercept->hideGui();
} else {
foreach(OverlayClient *oc, qlClients) {
if (oc->uiPid) {
#if defined(Q_OS_WIN)
HWND hwnd = GetForegroundWindow();
DWORD pid = 0;
GetWindowThreadProcessId(hwnd, &pid);
if (pid != oc->uiPid)
continue;
#elif defined(Q_OS_MAC)
pid_t pid = 0;
ProcessSerialNumber psn;
GetFrontProcess(&psn);
GetProcessPID(&psn, &pid);
if (pid != oc->uiPid)
continue;
#if 0
// Fullscreen only.
if (! CGDisplayIsCaptured(CGMainDisplayID()))
continue;
#endif
#endif
oc->showGui();
return;
}
}
}
}
// Search for available resolutions - TODO: Move to Common?
static wxArrayString GetListOfResolutions()
{
wxArrayString retlist;
retlist.Add(_("Auto"));
#ifdef _WIN32
DWORD iModeNum = 0;
DEVMODE dmi;
ZeroMemory(&dmi, sizeof(dmi));
dmi.dmSize = sizeof(dmi);
std::vector<std::string> resos;
while (EnumDisplaySettings(nullptr, iModeNum++, &dmi) != 0)
{
char res[100];
sprintf(res, "%dx%d", dmi.dmPelsWidth, dmi.dmPelsHeight);
std::string strRes(res);
// Only add unique resolutions
if (std::find(resos.begin(), resos.end(), strRes) == resos.end())
{
resos.push_back(strRes);
retlist.Add(StrToWxStr(res));
}
ZeroMemory(&dmi, sizeof(dmi));
}
#elif defined(HAVE_XRANDR) && HAVE_XRANDR
std::vector<std::string> resos;
main_frame->m_XRRConfig->AddResolutions(resos);
for (auto res : resos)
retlist.Add(StrToWxStr(res));
#elif defined(__APPLE__)
CFArrayRef modes = CGDisplayCopyAllDisplayModes(CGMainDisplayID(), nullptr);
for (CFIndex i = 0; i < CFArrayGetCount(modes); i++)
{
std::stringstream res;
CGDisplayModeRef mode;
CFStringRef encoding;
size_t w, h;
bool is32;
mode = (CGDisplayModeRef)CFArrayGetValueAtIndex(modes, i);
w = CGDisplayModeGetWidth(mode);
h = CGDisplayModeGetHeight(mode);
encoding = CGDisplayModeCopyPixelEncoding(mode);
is32 = CFEqual(encoding, CFSTR(IO32BitDirectPixels));
CFRelease(encoding);
if (!is32)
continue;
if (CGDisplayModeGetIOFlags(mode) & kDisplayModeStretchedFlag)
continue;
res << w << "x" << h;
retlist.Add(res.str());
}
CFRelease(modes);
#endif
return retlist;
}
int main (int argc, const char * argv[])
{
Command cmd;
char lineBuff[100];
// http://developer.apple.com/library/mac/#documentation/GraphicsImaging/Reference/Quartz_Services_Ref/Reference/reference.html#//apple_ref/doc/uid/TP30001070
g_screenWidth = CGDisplayPixelsWide(CGDisplayPrimaryDisplay(CGMainDisplayID()));
g_screenHeight = CGDisplayPixelsHigh(CGDisplayPrimaryDisplay(CGMainDisplayID()));
while (true) {
readLine(lineBuff, 100);
parseCommand(&cmd, lineBuff);
execCommand(&cmd);
}
return 0;
}
InputContext* inputBegin() {
OSXInputContext* ctx = new OSXInputContext();
ctx->displayID = CGMainDisplayID();
printf("inputBegin complete\n");
return ctx;
}
void wxDisplaySizeMM(int *width, int *height)
{
CGSize size = CGDisplayScreenSize(CGMainDisplayID());
if ( width )
*width = (int)size.width ;
if ( height )
*height = (int)size.height;
}
// Get size of display
void wxDisplaySize(int *width, int *height)
{
// TODO adapt for multi-displays
CGRect bounds = CGDisplayBounds(CGMainDisplayID());
if ( width )
*width = (int)bounds.size.width ;
if ( height )
*height = (int)bounds.size.height;
}
CFDictionaryRef convertSFModeToCGMode(VideoMode sfmode)
{
// If sfmode is in VideoMode::GetFullscreenModes
// then this should be an exact match (see NULL parameter doc).
return CGDisplayBestModeForParameters(CGMainDisplayID(),
sfmode.BitsPerPixel,
sfmode.width,
sfmode.height,
NULL);
}
//--------------------------------------------------------------
bool ofxDetectDisplays::isMirroringEnabled()
{
#if defined(TARGET_OSX)
return CGDisplayIsInMirrorSet(CGMainDisplayID());
#elif defined(TARGET_WIN32)
// have not found yet how to do this on Windows
return false;
#endif
}
