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);
}
int main ( int argc, const char * argv[])
{
CGDirectDisplayID displays[ MAX_DISPLAYS ];
CGDisplayCount displayCount = 0;
CGDisplayErr err =
CGGetOnlineDisplayList( MAX_DISPLAYS, displays, &displayCount );
if ( err == kCGErrorSuccess ) {
int i;
for ( i = 0; i < displayCount; i++ ) {
io_service_t service = CGDisplayIOServicePort( displays[ i ]);
if ( service )
IOServiceRequestProbe( service, kIOFBUserRequestProbe );
}
} else {
fprintf( stderr, "CGGetOnlineDisplayList returned error code %d\n",
( int )err );
return ( int )err;
}
return EXIT_SUCCESS;
}
//---------------------------------------------------------------------------
// 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;
}
uint32 CGGetOnlineDisplayCount_wrap(void* FH) {
uint32 count;
CGDisplayErr e = CGGetOnlineDisplayList( 0, NULL, &count);
return e != CGDisplayNoErr
? (uint32)reportOSError(e, "CGGetOnlineDisplayCount", FH)
: count;
}
CGDirectDisplayID CGGetOnlineDisplayAt_wrap(uint32 n, void* FH) {
uint32 count;
ResourceMark rm;
CGDirectDisplayID *displays = NEW_RESOURCE_ARRAY(CGDirectDisplayID, n + 1);
CGDisplayErr e = CGGetOnlineDisplayList( n + 1, displays, &count);
return e != CGDisplayNoErr ? (CGDirectDisplayID)reportOSError(e, "CGGetOnlineDisplayAt", FH)
: count < n + 1 ? (CGDirectDisplayID)(failure(FH, "not enough displays"), NULL)
: displays[n];
}
static CGDisplayErr wxOSXGetDisplayList(CGDisplayCount maxDisplays,
CGDirectDisplayID *displays,
CGDisplayCount *displayCount)
{
CGDisplayErr error = kCGErrorSuccess;
CGDisplayCount onlineCount;
error = CGGetOnlineDisplayList(0,NULL,&onlineCount);
if ( error == kCGErrorSuccess )
{
*displayCount = 0;
if ( onlineCount > 0 )
{
CGDirectDisplayID *onlineDisplays = new CGDirectDisplayID[onlineCount];
error = CGGetOnlineDisplayList(onlineCount,onlineDisplays,&onlineCount);
if ( error == kCGErrorSuccess )
{
for ( CGDisplayCount i = 0; i < onlineCount; ++i )
{
if ( CGDisplayMirrorsDisplay(onlineDisplays[i]) != kCGNullDirectDisplay )
continue;
if ( displays == NULL )
*displayCount += 1;
else
{
if ( *displayCount < maxDisplays )
{
displays[*displayCount] = onlineDisplays[i];
*displayCount += 1;
}
}
}
}
delete[] onlineDisplays;
}
}
return error;
}
void
setMainDisplay(CGDirectDisplayID targetDisplay)
{
int deltaX, deltaY, flag;
CGDisplayErr dErr;
CGDisplayCount displayCount, i;
CGDirectDisplayID mainDisplay;
CGDisplayCount maxDisplays = MAX_DISPLAYS;
CGDirectDisplayID onlineDisplays[MAX_DISPLAYS];
CGDisplayConfigRef config;
mainDisplay = CGMainDisplayID();
if (mainDisplay == targetDisplay) {
exit(0);
}
dErr = CGGetOnlineDisplayList(maxDisplays, onlineDisplays, &displayCount);
if (dErr != kCGErrorSuccess) {
fprintf(stderr, "CGGetOnlineDisplayList: error %d.\n", dErr);
exit(1);
}
flag = 0;
for (i = 0; i < displayCount; i++) {
CGDirectDisplayID dID = onlineDisplays[i];
if (dID == targetDisplay) { flag = 1; }
}
if (flag == 0) {
fprintf(stderr, "No such display ID: %10p.\n", targetDisplay);
exit(1);
}
deltaX = -CGRectGetMinX (CGDisplayBounds (targetDisplay));
deltaY = -CGRectGetMinY (CGDisplayBounds (targetDisplay));
CGBeginDisplayConfiguration (&config);
for (i = 0; i < displayCount; i++) {
CGDirectDisplayID dID = onlineDisplays[i];
CGConfigureDisplayOrigin (config, dID,
CGRectGetMinX (CGDisplayBounds (dID)) + deltaX,
CGRectGetMinY (CGDisplayBounds (dID)) + deltaY );
}
CGCompleteDisplayConfiguration (config, kCGConfigureForSession);
exit(0);
}
void
infoDisplays(void)
{
CGDisplayErr dErr;
CGDisplayCount displayCount, i;
CGDirectDisplayID mainDisplay;
CGDisplayCount maxDisplays = MAX_DISPLAYS;
CGDirectDisplayID onlineDisplays[MAX_DISPLAYS];
CGEventRef ourEvent = CGEventCreate(NULL);
CGPoint ourLoc = CGEventGetLocation(ourEvent);
CFRelease(ourEvent);
mainDisplay = CGMainDisplayID();
dErr = CGGetOnlineDisplayList(maxDisplays, onlineDisplays, &displayCount);
if (dErr != kCGErrorSuccess) {
fprintf(stderr, "CGGetOnlineDisplayList: error %d.\n", dErr);
exit(1);
}
printf("# Display_ID Resolution ____Display_Bounds____ Rotation\n");
for (i = 0; i < displayCount; i++) {
CGDirectDisplayID dID = onlineDisplays[i];
printf("%-2d %10p %4lux%-4lu %5.0f %5.0f %5.0f %5.0f %3.0f %s%s%s",
CGDisplayUnitNumber (dID), dID,
CGDisplayPixelsWide(dID), CGDisplayPixelsHigh(dID),
CGRectGetMinX (CGDisplayBounds (dID)),
CGRectGetMinY (CGDisplayBounds (dID)),
CGRectGetMaxX (CGDisplayBounds (dID)),
CGRectGetMaxY (CGDisplayBounds (dID)),
CGDisplayRotation (dID),
(CGDisplayIsActive (dID)) ? "" : "[inactive]",
(dID == mainDisplay) ? "[main]" : "",
(CGDisplayIsBuiltin (dID)) ? "[internal]\n" : "\n");
}
printf("Mouse Cursor Position: ( %5.0f , %5.0f )\n",
(float)ourLoc.x, (float)ourLoc.y);
exit(0);
}
// Get the display ICC profile of the monitor associated with the widget.
// For X display, uses the ICC profile specifications version 0.2 from
// http://burtonini.com/blog/computers/xicc
// Based on code from Gimp's modules/cdisplay_lcms.c
void dt_ctl_set_display_profile()
{
if(!dt_control_running()) return;
// make sure that no one gets a broken profile
// FIXME: benchmark if the try is really needed when moving/resizing the window. Maybe we can just lock it and block
if(pthread_rwlock_trywrlock(&darktable.control->xprofile_lock))
return; // we are already updating the profile. Or someone is reading right now. Too bad we can't distinguish that. Whatever ...
GtkWidget *widget = dt_ui_center(darktable.gui->ui);
guint8 *buffer = NULL;
gint buffer_size = 0;
gchar *profile_source = NULL;
#if defined GDK_WINDOWING_X11
// we will use the xatom no matter what configured when compiled without colord
gboolean use_xatom = TRUE;
#if defined USE_COLORDGTK
gboolean use_colord = TRUE;
gchar *display_profile_source = dt_conf_get_string("ui_last/display_profile_source");
if(display_profile_source)
{
if(!strcmp(display_profile_source, "xatom"))
use_colord = FALSE;
else if(!strcmp(display_profile_source, "colord"))
use_xatom = FALSE;
g_free(display_profile_source);
}
#endif
/* let's have a look at the xatom, just in case ... */
if(use_xatom)
{
GdkScreen *screen = gtk_widget_get_screen(widget);
if ( screen==NULL )
screen = gdk_screen_get_default();
int monitor = gdk_screen_get_monitor_at_window (screen, gtk_widget_get_window(widget));
char *atom_name;
if (monitor > 0)
atom_name = g_strdup_printf("_ICC_PROFILE_%d", monitor);
else
atom_name = g_strdup("_ICC_PROFILE");
profile_source = g_strdup_printf("xatom %s", atom_name);
GdkAtom type = GDK_NONE;
gint format = 0;
gdk_property_get(gdk_screen_get_root_window(screen),
gdk_atom_intern(atom_name, FALSE), GDK_NONE,
0, 64 * 1024 * 1024, FALSE,
&type, &format, &buffer_size, &buffer);
g_free(atom_name);
}
#ifdef USE_COLORDGTK
/* also try to get the profile from colord. this will set the value asynchronously! */
if(use_colord)
{
CdWindow *window = cd_window_new();
GtkWidget *center_widget = dt_ui_center(darktable.gui->ui);
cd_window_get_profile(window, center_widget, NULL, dt_ctl_get_display_profile_colord_callback, NULL);
}
#endif
#elif defined GDK_WINDOWING_QUARTZ
GdkScreen *screen = gtk_widget_get_screen(widget);
if ( screen==NULL )
screen = gdk_screen_get_default();
int monitor = gdk_screen_get_monitor_at_window(screen, gtk_widget_get_window(widget));
CGDirectDisplayID ids[monitor + 1];
uint32_t total_ids;
CMProfileRef prof = NULL;
if(CGGetOnlineDisplayList(monitor + 1, &ids[0], &total_ids) == kCGErrorSuccess && total_ids == monitor + 1)
CMGetProfileByAVID(ids[monitor], &prof);
if ( prof!=NULL )
{
CFDataRef data;
data = CMProfileCopyICCData(NULL, prof);
CMCloseProfile(prof);
UInt8 *tmp_buffer = (UInt8 *) g_malloc(CFDataGetLength(data));
CFDataGetBytes(data, CFRangeMake(0, CFDataGetLength(data)), tmp_buffer);
buffer = (guint8 *) tmp_buffer;
buffer_size = CFDataGetLength(data);
CFRelease(data);
}
profile_source = g_strdup("osx color profile api");
#elif defined G_OS_WIN32
(void)widget;
HDC hdc = GetDC (NULL);
if ( hdc!=NULL )
{
DWORD len = 0;
GetICMProfile (hdc, &len, NULL);
gchar *path = g_new (gchar, len);
if (GetICMProfile (hdc, &len, path))
{
gsize size;
g_file_get_contents(path, (gchar**)&buffer, &size, NULL);
buffer_size = size;
}
g_free (path);
ReleaseDC (NULL, hdc);
}
profile_source = g_strdup("windows color profile api");
#endif
int profile_changed = buffer_size > 0 &&
(darktable.control->xprofile_size != buffer_size || memcmp(darktable.control->xprofile_data, buffer, buffer_size) != 0);
if(profile_changed)
{
cmsHPROFILE profile = NULL;
char name[512];
// thanks to ufraw for this!
g_free(darktable.control->xprofile_data);
darktable.control->xprofile_data = buffer;
darktable.control->xprofile_size = buffer_size;
profile = cmsOpenProfileFromMem(buffer, buffer_size);
if(profile)
{
dt_colorspaces_get_profile_name(profile, "en", "US", name, sizeof(name));
cmsCloseProfile(profile);
}
dt_print(DT_DEBUG_CONTROL, "[color profile] we got a new screen profile `%s' from the %s (size: %d)\n", *name?name:"(unknown)", profile_source, buffer_size);
}
pthread_rwlock_unlock(&darktable.control->xprofile_lock);
if(profile_changed)
dt_control_signal_raise(darktable.signals, DT_SIGNAL_CONTROL_PROFILE_CHANGED);
g_free(profile_source);
}
int screen_InitCapture(demux_t *p_demux)
{
demux_sys_t *p_sys = p_demux->p_sys;
screen_data_t *p_data;
CGLError returnedError;
p_sys->p_data = p_data = calloc(1, sizeof(screen_data_t));
if (!p_data)
return VLC_ENOMEM;
/* fetch the screen we should capture */
p_data->display_id = kCGDirectMainDisplay;
p_data->rate = var_InheritFloat (p_demux, "screen-fps");
unsigned int displayCount = 0;
returnedError = CGGetOnlineDisplayList(0, NULL, &displayCount);
if (!returnedError) {
CGDirectDisplayID *ids;
ids = (CGDirectDisplayID *)malloc(displayCount * sizeof(CGDirectDisplayID));
returnedError = CGGetOnlineDisplayList(displayCount, ids, &displayCount);
if (!returnedError) {
if (p_sys->i_display_id > 0) {
for (unsigned int i = 0; i < displayCount; i++) {
if (p_sys->i_display_id == ids[i]) {
p_data->display_id = ids[i];
break;
}
}
} else if (p_sys->i_screen_index > 0 && p_sys->i_screen_index <= displayCount)
p_data->display_id = ids[p_sys->i_screen_index - 1];
}
free(ids);
}
/* Get the device context for the whole screen */
CGRect rect = CGDisplayBounds(p_data->display_id);
p_data->screen_left = rect.origin.x;
p_data->screen_top = rect.origin.y;
p_data->screen_width = rect.size.width;
p_data->screen_height = rect.size.height;
p_data->width = p_sys->i_width;
p_data->height = p_sys->i_height;
if (p_data->width <= 0 || p_data->height <= 0) {
p_data->width = p_data->screen_width;
p_data->height = p_data->screen_height;
}
/* setup format */
es_format_Init(&p_sys->fmt, VIDEO_ES, VLC_CODEC_RGB32);
p_sys->fmt.video.i_visible_width =
p_sys->fmt.video.i_width = rect.size.width;
p_sys->fmt.video.i_visible_height =
p_sys->fmt.video.i_height = rect.size.height;
p_sys->fmt.video.i_bits_per_pixel = 32;
p_sys->fmt.video.i_chroma = VLC_CODEC_RGB32;
p_sys->fmt.video.i_rmask = 0x00ff0000;
p_sys->fmt.video.i_gmask = 0x0000ff00;
p_sys->fmt.video.i_bmask = 0x000000ff;
p_sys->fmt.video.i_frame_rate = 1000 * p_data->rate;
p_sys->fmt.video.i_frame_rate_base = 1000;
p_sys->fmt.video.i_sar_num =
p_sys->fmt.video.i_sar_den = 1;
return VLC_SUCCESS;
}
int
quartz_start(quartz_state_t *state)
{
int r;
CGError error;
uint32_t display_count;
/* Get display count */
error = CGGetOnlineDisplayList(0, NULL, &display_count);
if (error != kCGErrorSuccess) return -1;
state->display_count = display_count;
CGDirectDisplayID* displays =
malloc(sizeof(CGDirectDisplayID)*display_count);
if (displays == NULL) {
perror("malloc");
return -1;
}
/* Get list of displays */
error = CGGetOnlineDisplayList(display_count, displays,
&display_count);
if (error != kCGErrorSuccess) {
free(displays);
return -1;
}
/* Allocate list of display state */
state->displays = malloc(display_count *
sizeof(quartz_display_state_t));
if (state->displays == NULL) {
perror("malloc");
free(displays);
return -1;
}
/* Copy display indentifiers to display state */
for (int i = 0; i < display_count; i++) {
state->displays[i].display = displays[i];
state->displays[i].saved_ramps = NULL;
}
free(displays);
/* Save gamma ramps for all displays in display state */
for (int i = 0; i < display_count; i++) {
CGDirectDisplayID display = state->displays[i].display;
uint32_t ramp_size = CGDisplayGammaTableCapacity(display);
if (ramp_size == 0) {
fprintf(stderr, _("Gamma ramp size too small: %i\n"),
ramp_size);
return -1;
}
state->displays[i].ramp_size = ramp_size;
/* Allocate space for saved ramps */
state->displays[i].saved_ramps =
malloc(3 * ramp_size * sizeof(float));
if (state->displays[i].saved_ramps == NULL) {
perror("malloc");
return -1;
}
float *gamma_r = &state->displays[i].saved_ramps[0*ramp_size];
float *gamma_g = &state->displays[i].saved_ramps[1*ramp_size];
float *gamma_b = &state->displays[i].saved_ramps[2*ramp_size];
/* Copy the ramps to allocated space */
uint32_t sample_count;
error = CGGetDisplayTransferByTable(display, ramp_size,
gamma_r, gamma_g, gamma_b,
&sample_count);
if (error != kCGErrorSuccess ||
sample_count != ramp_size) {
fputs(_("Unable to save current gamma ramp.\n"),
stderr);
return -1;
}
}
return 0;
}
int screen_InitCapture( demux_t *p_demux )
{
demux_sys_t *p_sys = p_demux->p_sys;
screen_data_t *p_data;
CGLError returnedError;
unsigned int i;
p_sys->p_data = p_data =
( screen_data_t * )calloc( 1, sizeof( screen_data_t ) );
p_data->display_id = kCGDirectMainDisplay;
unsigned int displayCount;
displayCount = 0;
returnedError = CGGetOnlineDisplayList( 0, NULL, &displayCount );
if( !returnedError )
{
CGDirectDisplayID *ids;
ids = ( CGDirectDisplayID * )malloc( displayCount * sizeof( CGDirectDisplayID ) );
returnedError = CGGetOnlineDisplayList( displayCount, ids, &displayCount );
if( !returnedError )
{
if ( p_sys->i_display_id > 0 )
{
for( i = 0; i < displayCount; i ++ )
{
if( p_sys->i_display_id == ids[i] )
{
p_data->display_id = ids[i];
break;
}
}
}
else if ( p_sys->i_screen_index > 0 && p_sys->i_screen_index <= displayCount )
{
p_data->display_id = ids[p_sys->i_screen_index - 1];
}
}
free( ids );
}
/* CGImage Function
* CGDisplayCreateImageForRect is available in Mac OS X v10.6 and later */
p_data->myCGDisplayCreateImageForRect = NULL;
CFURLRef frameworkURL = NULL;
CFStringRef path = CFSTR( "file://localhost/System/Library/Frameworks/ApplicationServices.framework/Frameworks/CoreGraphics.framework" );
frameworkURL = CFURLCreateWithString( kCFAllocatorDefault, path, NULL );
if( frameworkURL != NULL )
{
p_data->bundle = CFBundleCreate( kCFAllocatorDefault, frameworkURL );
if( p_data->bundle != NULL )
{
p_data->myCGDisplayCreateImageForRect =
( typeofCGDisplayCreateImageForRect )CFBundleGetFunctionPointerForName
( p_data->bundle, CFSTR( "CGDisplayCreateImageForRect" ) );
}
CFRelease( frameworkURL );
}
/* Screen Size */
CGRect rect = CGDisplayBounds( p_data->display_id );
p_data->screen_left = rect.origin.x;
p_data->screen_top = rect.origin.y;
p_data->screen_width = rect.size.width;
p_data->screen_height = rect.size.height;
p_data->width = p_sys->i_width;
p_data->height = p_sys->i_height;
if( p_data->width <= 0 || p_data->height <= 0 )
{
p_data->width = p_data->screen_width;
p_data->height = p_data->screen_height;
}
/* Screen Context */
if( p_data->myCGDisplayCreateImageForRect == NULL )
{
returnedError =
screen_CreateContext( &p_data->screen,
kCGLPFAFullScreen,
kCGLPFADisplayMask,
( CGLPixelFormatAttribute )CGDisplayIDToOpenGLDisplayMask( p_data->display_id ),
( CGLPixelFormatAttribute )0 );
if( returnedError )
goto errorHandling;
returnedError = CGLSetCurrentContext( p_data->screen );
if( returnedError )
goto errorHandling;
returnedError = CGLSetFullScreen( p_data->screen );
if( returnedError )
goto errorHandling;
}
/* Clipped Context */
returnedError =
screen_CreateContext( &p_data->clipped,
kCGLPFAOffScreen,
kCGLPFAColorSize,
( CGLPixelFormatAttribute )32,
( CGLPixelFormatAttribute )0 );
if( returnedError )
goto errorHandling;
returnedError = CGLSetCurrentContext( p_data->clipped );
if( returnedError )
goto errorHandling;
/* Clipped Image */
p_data->clipped_image =
( char * )malloc( p_data->width * p_data->height * 4 );
returnedError = CGLSetOffScreen( p_data->clipped, p_data->width, p_data->height, p_data->width * 4, p_data->clipped_image );
if( returnedError )
goto errorHandling;
/* Screen Image */
if( p_data->myCGDisplayCreateImageForRect != NULL )
{
p_data->screen_image =
( char * )malloc( p_data->screen_width * p_data->screen_height * 4 );
}
else
{
p_data->screen_image =
( char * )malloc( p_data->width * p_data->height * 4 );
}
/* Cursor */
CGSNewConnection( NULL, &( p_data->connection ) );
p_data->cursor_need_update = 1;
p_data->cursor_seed = 0;
glGenTextures( 1, &( p_data->cursor_texture ) );
glBindTexture( GL_TEXTURE_2D, p_data->cursor_texture );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP );
/* System */
es_format_Init( &p_sys->fmt, VIDEO_ES, VLC_CODEC_RGB32 );
/* p_sys->fmt.video.i_* must set to screen size, not subscreen size */
p_sys->fmt.video.i_width = p_data->screen_width;
p_sys->fmt.video.i_visible_width = p_data->screen_width;
p_sys->fmt.video.i_height = p_data->screen_height;
p_sys->fmt.video.i_bits_per_pixel = 32;
return VLC_SUCCESS;
errorHandling:
msg_Err( p_demux, "Core OpenGL failure: %s", CGLErrorString( returnedError ) );
return VLC_EGENERIC;
}
int main(int argc, char * argv[])
{
io_service_t service;
CGError err;
int i;
CGDisplayCount max;
CGDirectDisplayID displayIDs[8];
uint32_t mask;
IOOptionBits options;
CFNumberRef num;
SInt32 value;
err = CGGetOnlineDisplayList(8, displayIDs, &max);
if(err != kCGErrorSuccess)
exit(1);
if(max > 8)
max = 8;
if( argc < 2)
options = kIOFBUserRequestProbe;
else
options = strtol( argv[1], 0, 0 );
if (strstr(argv[0], "rotate"))
{
switch (options)
{
case 90:
options = kIOFBSetTransform | (kIOScaleRotate90 << 16);
break;
case 180:
options = kIOFBSetTransform | (kIOScaleRotate180 << 16);
break;
case 270:
options = kIOFBSetTransform | (kIOScaleRotate270 << 16);
break;
case 0:
default:
options = kIOFBSetTransform | (kIOScaleRotate0 << 16);
break;
}
}
if( argc < 3)
mask = 0xffffffff;
else
mask = strtol( argv[2], 0, 0 );
for(i = 0; i < max; i++ )
{
if (!(mask & (1 << i)))
continue;
service = CGDisplayIOServicePort(displayIDs[i]);
num = (CFNumberRef) IORegistryEntryCreateCFProperty( service,
CFSTR(kIOFBTransformKey),
kCFAllocatorDefault, kNilOptions);
if (num)
CFNumberGetValue( num, kCFNumberSInt32Type, (SInt32 *) &value );
else
value = 0;
value &= kIOScaleRotateFlags;
printf("Display %p: current transform: ", displayIDs[i]);
switch (value)
{
case kIOScaleRotate90:
printf("90\n");
break;
case kIOScaleRotate180:
printf("180\n");
break;
case kIOScaleRotate270:
printf("270\n");
break;
case kIOScaleRotate0:
default:
printf("0\n");
break;
}
num = (CFNumberRef) IORegistryEntryCreateCFProperty( service,
CFSTR(kIOFBProbeOptionsKey),
kCFAllocatorDefault, kNilOptions);
if (num)
CFNumberGetValue( num, kCFNumberSInt32Type, (SInt32 *) &value );
else
value = 0;
printf("Display %p: does %ssupport kIOFBSetTransform\n", displayIDs[i], value & kIOFBSetTransform ? "" : "not ");
if (value & kIOFBSetTransform)
{
err = IOServiceRequestProbe(service, options );
printf("Display %p: IOServiceRequestProbe(%d)\n", displayIDs[i], err);
}
}
exit(0);
return(0);
}
