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 }