自学教程：C++ CGMainDisplayID函数代码示例

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);}

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());                };            };

voidlistDisplays(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;}

voidscreeninit(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;}

// Returns depth of screenint 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 screenwxScreenDCImpl::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 displayvoid 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}