GHOST_TSuccess GHOST_DisplayManagerX11:: getNumDisplaySettings( GHOST_TUns8 display, GHOST_TInt32& numSettings) const { #ifdef WITH_X11_XF86VMODE int majorVersion, minorVersion; XF86VidModeModeInfo **vidmodes; Display *dpy = m_system->getXDisplay(); GHOST_ASSERT(display < 1, "Only single display systems are currently supported.\n"); if (dpy == NULL) return GHOST_kFailure; majorVersion = minorVersion = 0; if (!XF86VidModeQueryVersion(dpy, &majorVersion, &minorVersion)) { fprintf(stderr, "Error: XF86VidMode extension missing!\n"); return GHOST_kFailure; } if (XF86VidModeGetAllModeLines(dpy, DefaultScreen(dpy), &numSettings, &vidmodes)) { XFree(vidmodes); } #else /* We only have one X11 setting at the moment. */ GHOST_ASSERT(display < 1, "Only single display systems are currently supported.\n"); numSettings = 1; #endif return GHOST_kSuccess; }
GHOST_TSuccess GHOST_DisplayManagerX11:: getDisplaySetting( GHOST_TUns8 display, GHOST_TInt32 index, GHOST_DisplaySetting& setting) const { Display *dpy = m_system->getXDisplay(); if (dpy == NULL) return GHOST_kFailure; (void)display; #ifdef WITH_X11_XF86VMODE int majorVersion, minorVersion; GHOST_ASSERT(display < 1, "Only single display systems are currently supported.\n"); majorVersion = minorVersion = 0; if (XF86VidModeQueryVersion(dpy, &majorVersion, &minorVersion)) { XF86VidModeModeInfo **vidmodes; int numSettings; if (XF86VidModeGetAllModeLines(dpy, DefaultScreen(dpy), &numSettings, &vidmodes)) { GHOST_ASSERT(index < numSettings, "Requested setting outside of valid range.\n"); setting.xPixels = vidmodes[index]->hdisplay; setting.yPixels = vidmodes[index]->vdisplay; setting.bpp = DefaultDepth(dpy, DefaultScreen(dpy)); setting.frequency = calculate_rate(vidmodes[index]); XFree(vidmodes); return GHOST_kSuccess; } } else { fprintf(stderr, "Warning: XF86VidMode extension missing!\n"); /* fallback to non xf86vmode below */ } #endif /* WITH_X11_XF86VMODE */ GHOST_ASSERT(display < 1, "Only single display systems are currently supported.\n"); GHOST_ASSERT(index < 1, "Requested setting outside of valid range.\n"); (void)index; setting.xPixels = DisplayWidth(dpy, DefaultScreen(dpy)); setting.yPixels = DisplayHeight(dpy, DefaultScreen(dpy)); setting.bpp = DefaultDepth(dpy, DefaultScreen(dpy)); setting.frequency = 60.0f; return GHOST_kSuccess; }
void GHOST_EventManager::disposeEvents() { while (m_handled_events.empty() == false) { GHOST_ASSERT(m_handled_events[0], "invalid event"); delete m_handled_events[0]; m_handled_events.pop_front(); } while (m_events.empty() == false) { GHOST_ASSERT(m_events[0], "invalid event"); delete m_events[0]; m_events.pop_front(); } }
GHOST_TSuccess GHOST_WindowManager::beginFullScreen(GHOST_IWindow *window, bool /*stereoVisual*/) { GHOST_TSuccess success = GHOST_kFailure; GHOST_ASSERT(window, "GHOST_WindowManager::beginFullScreen(): invalid window"); GHOST_ASSERT(window->getValid(), "GHOST_WindowManager::beginFullScreen(): invalid window"); if (!getFullScreen()) { m_fullScreenWindow = window; m_activeWindowBeforeFullScreen = getActiveWindow(); setActiveWindow(m_fullScreenWindow); m_fullScreenWindow->beginFullScreen(); success = GHOST_kSuccess; } return success; }
GHOST_TSuccess GHOST_DisplayManagerWin32::getDisplaySetting(GHOST_TUns8 display, GHOST_TInt32 index, GHOST_DisplaySetting& setting) const { GHOST_ASSERT((display==kMainDisplay), "GHOST_DisplayManagerWin32::getDisplaySetting(): only main display is supported"); GHOST_TSuccess success; DEVMODE dm; if (::EnumDisplaySettings(NULL, index, &dm)) { #ifdef GHOST_DEBUG printf("display mode: width=%d, height=%d, bpp=%d, frequency=%d\n", dm.dmPelsWidth, dm.dmPelsHeight, dm.dmBitsPerPel, dm.dmDisplayFrequency); #endif // GHOST_DEBUG setting.xPixels = dm.dmPelsWidth; setting.yPixels = dm.dmPelsHeight; setting.bpp = dm.dmBitsPerPel; /* When you call the EnumDisplaySettings function, the dmDisplayFrequency member * may return with the value 0 or 1. These values represent the display hardware's * default refresh rate. This default rate is typically set by switches on a display * card or computer motherboard, or by a configuration program that does not use * Win32 display functions such as ChangeDisplaySettings. */ /* First, we tried to explicitly set the frequency to 60 if EnumDisplaySettings * returned 0 or 1 but this doesn't work since later on an exact match will * be searched. And this will never happen if we change it to 60. Now we rely * on the default h/w setting. */ setting.frequency = dm.dmDisplayFrequency; success = GHOST_kSuccess; } else { success = GHOST_kFailure; } return success; }
GHOST_TSuccess GHOST_System::beginFullScreen(const GHOST_DisplaySetting& setting, GHOST_IWindow **window, const bool stereoVisual, const bool alphaBackground, const GHOST_TUns16 numOfAASamples) { GHOST_TSuccess success = GHOST_kFailure; GHOST_ASSERT(m_windowManager, "GHOST_System::beginFullScreen(): invalid window manager"); if (m_displayManager) { if (!m_windowManager->getFullScreen()) { m_displayManager->getCurrentDisplaySetting(GHOST_DisplayManager::kMainDisplay, m_preFullScreenSetting); //GHOST_PRINT("GHOST_System::beginFullScreen(): activating new display settings\n"); success = m_displayManager->setCurrentDisplaySetting(GHOST_DisplayManager::kMainDisplay, setting); if (success == GHOST_kSuccess) { //GHOST_PRINT("GHOST_System::beginFullScreen(): creating full-screen window\n"); success = createFullScreenWindow((GHOST_Window **)window, setting, stereoVisual, alphaBackground, numOfAASamples); if (success == GHOST_kSuccess) { m_windowManager->beginFullScreen(*window, stereoVisual); } else { m_displayManager->setCurrentDisplaySetting(GHOST_DisplayManager::kMainDisplay, m_preFullScreenSetting); } } } } if (success == GHOST_kFailure) { GHOST_PRINT("GHOST_System::beginFullScreen(): could not enter full-screen mode\n"); } return success; }
GHOST_IWindow *GHOST_SystemCarbon::createWindow( const STR_String& title, GHOST_TInt32 left, GHOST_TInt32 top, GHOST_TUns32 width, GHOST_TUns32 height, GHOST_TWindowState state, GHOST_TDrawingContextType type, bool stereoVisual, const GHOST_TUns16 numOfAASamples, const GHOST_TEmbedderWindowID parentWindow) { GHOST_IWindow *window = 0; window = new GHOST_WindowCarbon(title, left, top, width, height, state, type); if (window) { if (window->getValid()) { // Store the pointer to the window GHOST_ASSERT(m_windowManager, "m_windowManager not initialized"); m_windowManager->addWindow(window); m_windowManager->setActiveWindow(window); pushEvent(new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowSize, window)); } else { GHOST_PRINT("GHOST_SystemCarbon::createWindow(): window invalid\n"); delete window; window = 0; } } else { GHOST_PRINT("GHOST_SystemCarbon::createWindow(): could not create window\n"); } return window; }
void GHOST_WindowCarbon::setTitle(const STR_String& title) { GHOST_ASSERT(getValid(), "GHOST_WindowCarbon::setTitle(): window invalid") Str255 title255; gen2mac(title, title255); ::SetWTitle(m_windowRef, title255); }
GHOST_TSuccess GHOST_DisplayManagerCarbon::setCurrentDisplaySetting(GHOST_TUns8 display, const GHOST_DisplaySetting& setting) { GHOST_ASSERT((display==kMainDisplay), "GHOST_DisplayManagerCarbon::setCurrentDisplaySetting(): only main display is supported"); #ifdef GHOST_DEBUG printf("GHOST_DisplayManagerCarbon::setCurrentDisplaySetting(): requested settings:\n"); printf(" setting.xPixels=%d\n", setting.xPixels); printf(" setting.yPixels=%d\n", setting.yPixels); printf(" setting.bpp=%d\n", setting.bpp); printf(" setting.frequency=%d\n", setting.frequency); #endif // GHOST_DEBUG CFDictionaryRef displayModeValues = ::CGDisplayBestModeForParametersAndRefreshRate( m_displayIDs[display], (size_t)setting.bpp, (size_t)setting.xPixels, (size_t)setting.yPixels, (CGRefreshRate)setting.frequency, NULL); #ifdef GHOST_DEBUG printf("GHOST_DisplayManagerCarbon::setCurrentDisplaySetting(): switching to:\n"); printf(" setting.xPixels=%d\n", getValue(displayModeValues, kCGDisplayWidth)); printf(" setting.yPixels=%d\n", getValue(displayModeValues, kCGDisplayHeight)); printf(" setting.bpp=%d\n", getValue(displayModeValues, kCGDisplayBitsPerPixel)); printf(" setting.frequency=%d\n", getValue(displayModeValues, kCGDisplayRefreshRate)); #endif // GHOST_DEBUG CGDisplayErr err = ::CGDisplaySwitchToMode(m_displayIDs[display], displayModeValues); return err == CGDisplayNoErr ? GHOST_kSuccess : GHOST_kFailure; }
void GHOST_SystemSDL::addDirtyWindow(GHOST_WindowSDL *bad_wind) { GHOST_ASSERT((bad_wind != NULL), "addDirtyWindow() NULL ptr trapped (window)"); m_dirty_windows.push_back(bad_wind); }
void GHOST_WindowCarbon::getTitle(STR_String& title) const { GHOST_ASSERT(getValid(), "GHOST_WindowCarbon::getTitle(): window invalid") Str255 title255; ::GetWTitle(m_windowRef, title255); mac2gen(title255, title); }
GHOST_TUns8 GHOST_SystemWin32::getNumDisplays() const { GHOST_ASSERT(m_displayManager, "GHOST_SystemWin32::getNumDisplays(): m_displayManager==0\n"); GHOST_TUns8 numDisplays; m_displayManager->getNumDisplays(numDisplays); return numDisplays; }
GHOST_TSuccess GHOST_System::endFullScreen(void) { GHOST_TSuccess success = GHOST_kFailure; GHOST_ASSERT(m_windowManager, "GHOST_System::endFullScreen(): invalid window manager"); if (m_windowManager->getFullScreen()) { //GHOST_IWindow* window = m_windowManager->getFullScreenWindow(); //GHOST_PRINT("GHOST_System::endFullScreen(): leaving window manager full-screen mode\n"); success = m_windowManager->endFullScreen(); GHOST_ASSERT(m_displayManager, "GHOST_System::endFullScreen(): invalid display manager"); //GHOST_PRINT("GHOST_System::endFullScreen(): leaving full-screen mode\n"); success = m_displayManager->setCurrentDisplaySetting(GHOST_DisplayManager::kMainDisplay, m_preFullScreenSetting); } else { success = GHOST_kFailure; } return success; }
void GHOST_EventManager::disposeEvents() { while (m_events.size() > 0) { GHOST_ASSERT(m_events[0], "invalid event"); delete m_events[0]; m_events.pop_front(); } }
/* * When you call EnumDisplaySettings with iModeNum set to zero, the operating system * initializes and caches information about the display device. When you call * EnumDisplaySettings with iModeNum set to a non-zero value, the function returns * the information that was cached the last time the function was called with iModeNum * set to zero. */ GHOST_TSuccess GHOST_DisplayManagerWin32::getNumDisplaySettings(GHOST_TUns8 display, GHOST_TInt32& numSettings) const { GHOST_ASSERT((display==kMainDisplay), "GHOST_DisplayManagerWin32::getNumDisplaySettings(): only main displlay is supported"); numSettings = 0; DEVMODE dm; while (::EnumDisplaySettings(NULL, numSettings, &dm)) { numSettings++; } return GHOST_kSuccess; }
GHOST_TSuccess GHOST_WindowCarbon::setClientWidth(GHOST_TUns32 width) { GHOST_ASSERT(getValid(), "GHOST_WindowCarbon::setClientWidth(): window invalid") GHOST_Rect cBnds, wBnds; getClientBounds(cBnds); if (((GHOST_TUns32)cBnds.getWidth()) != width) { ::SizeWindow(m_windowRef, width, cBnds.getHeight(), true); } return GHOST_kSuccess; }
void GHOST_WindowCarbon::getWindowBounds(GHOST_Rect& bounds) const { OSStatus success; Rect rect; GHOST_ASSERT(getValid(), "GHOST_WindowCarbon::getWindowBounds(): window invalid") success = ::GetWindowBounds(m_windowRef, kWindowStructureRgn, &rect); bounds.m_b = rect.bottom; bounds.m_l = rect.left; bounds.m_r = rect.right; bounds.m_t = rect.top; }
GHOST_TSuccess GHOST_DisplayManagerCarbon::getNumDisplaySettings(GHOST_TUns8 display, GHOST_TInt32& numSettings) const { GHOST_ASSERT((display==kMainDisplay), "GHOST_DisplayManagerCarbon::getNumDisplaySettings(): only main display is supported"); CFArrayRef displayModes; displayModes = ::CGDisplayAvailableModes(m_displayIDs[display]); CFIndex numModes = ::CFArrayGetCount(displayModes); numSettings = (GHOST_TInt32)numModes; return GHOST_kSuccess; }
GHOST_SystemCarbon::GHOST_SystemCarbon() : m_modifierMask(0) { m_displayManager = new GHOST_DisplayManagerCarbon(); GHOST_ASSERT(m_displayManager, "GHOST_SystemCarbon::GHOST_SystemCarbon(): m_displayManager==0\n"); m_displayManager->initialize(); UnsignedWide micros; ::Microseconds(µs); m_start_time = UnsignedWideToUInt64(micros) / 1000; m_ignoreWindowSizedMessages = false; }
GHOST_TSuccess GHOST_System::updateFullScreen(const GHOST_DisplaySetting& setting, GHOST_IWindow ** /*window*/) { GHOST_TSuccess success = GHOST_kFailure; GHOST_ASSERT(m_windowManager, "GHOST_System::updateFullScreen(): invalid window manager"); if (m_displayManager) { if (m_windowManager->getFullScreen()) { success = m_displayManager->setCurrentDisplaySetting(GHOST_DisplayManager::kMainDisplay, setting); } } return success; }
GHOST_TSuccess GHOST_DisplayManagerSDL::getDisplaySetting(GHOST_TUns8 display, GHOST_TInt32 index, GHOST_DisplaySetting& setting) const { GHOST_ASSERT(display < 1, "Only single display systems are currently supported.\n"); int i; SDL_Rect **vidmodes; /* NULL is passed in here to get the modes for the current bit depth. * Other bit depths may be possible; in that case, an SDL_PixelFormat struct * should be passed in. To get a complete profile, all possible bit depths * would need to be iterated over. - z0r */ vidmodes = SDL_ListModes(NULL, SDL_HWSURFACE | SDL_OPENGL | SDL_FULLSCREEN | SDL_HWPALETTE); if (!vidmodes) { fprintf(stderr, "Could not get available video modes: %s.\n", SDL_GetError()); return GHOST_kFailure; } for (i = 0; vidmodes[i]; i++); GHOST_ASSERT(index < i, "Requested setting outside of valid range.\n"); setting.xPixels = vidmodes[index]->w; setting.yPixels = vidmodes[index]->h; SDL_Surface *surf; surf = SDL_GetVideoSurface(); if (surf == NULL) { fprintf(stderr, "Getting display setting: %s\n", SDL_GetError()); /* Just guess the bit depth */ setting.bpp = 32; } else { setting.bpp = surf->format->BitsPerPixel; } /* Just guess the frequency :( */ setting.frequency = 60; return GHOST_kSuccess; }
GHOST_TSuccess GHOST_EventManager::pushEvent(GHOST_IEvent* event) { GHOST_TSuccess success; GHOST_ASSERT(event, "invalid event"); if (m_events.size() < m_events.max_size()) { m_events.push_front(event); success = GHOST_kSuccess; } else { success = GHOST_kFailure; } return success; }
GHOST_TSuccess GHOST_DisplayManager::findMatch( GHOST_TUns8 display, const GHOST_DisplaySetting& setting, GHOST_DisplaySetting& match) const { GHOST_TSuccess success = GHOST_kSuccess; GHOST_ASSERT(m_settingsInitialized, "GHOST_DisplayManager::findMatch(): m_settingsInitialized=false"); int criteria[4] = { (int)setting.xPixels, (int)setting.yPixels, (int)setting.bpp, (int)setting.frequency }; int capabilities[4]; double field, score; double best = 1e12; // A big number int found = 0; // Look at all the display modes for (int i = 0; (i < (int)m_settings[display].size()); i++) { // Store the capabilities of the display device capabilities[0] = m_settings[display][i].xPixels; capabilities[1] = m_settings[display][i].yPixels; capabilities[2] = m_settings[display][i].bpp; capabilities[3] = m_settings[display][i].frequency; // Match against all the fields of the display settings score = 0; for (int j = 0; j < 4; j++) { field = capabilities[j] - criteria[j]; score += field * field; } if (score < best) { found = i; best = score; } } match = m_settings[display][found]; GHOST_PRINT("GHOST_DisplayManager::findMatch(): settings of match:\n"); GHOST_PRINT(" setting.xPixels=" << match.xPixels << "\n"); GHOST_PRINT(" setting.yPixels=" << match.yPixels << "\n"); GHOST_PRINT(" setting.bpp=" << match.bpp << "\n"); GHOST_PRINT(" setting.frequency=" << match.frequency << "\n"); return success; }
void GHOST_WindowCarbon::clientToScreen(GHOST_TInt32 inX, GHOST_TInt32 inY, GHOST_TInt32& outX, GHOST_TInt32& outY) const { GHOST_ASSERT(getValid(), "GHOST_WindowCarbon::clientToScreen(): window invalid") Point point; point.h = inX; point.v = inY; GrafPtr oldPort; ::GetPort(&oldPort); ::SetPort(m_grafPtr); ::LocalToGlobal(&point); ::SetPort(oldPort); outX = point.h; outY = point.v; }
GHOST_SystemWin32::GHOST_SystemWin32() : m_hasPerformanceCounter(false), m_freq(0), m_start(0) { m_displayManager = new GHOST_DisplayManagerWin32 (); GHOST_ASSERT(m_displayManager, "GHOST_SystemWin32::GHOST_SystemWin32(): m_displayManager==0\n"); m_displayManager->initialize(); // Check if current keyboard layout uses AltGr and save keylayout ID for // specialized handling if keys like VK_OEM_*. I.e. french keylayout // generates VK_OEM_8 for their exclamation key (key left of right shift) this->handleKeyboardChange(); // Require COM for GHOST_DropTargetWin32 created in GHOST_WindowWin32. OleInitialize(0); }
GHOST_DisplayManagerCarbon::GHOST_DisplayManagerCarbon(void) { if (::CGGetActiveDisplayList(0, NULL, &m_numDisplays) != CGDisplayNoErr) { m_numDisplays = 0; m_displayIDs = NULL; } if (m_numDisplays > 0) { m_displayIDs = new CGDirectDisplayID [m_numDisplays]; GHOST_ASSERT((m_displayIDs!=NULL), "GHOST_DisplayManagerCarbon::GHOST_DisplayManagerCarbon(): memory allocation failed"); ::CGGetActiveDisplayList(m_numDisplays, m_displayIDs, &m_numDisplays); } }
GHOST_TWindowState GHOST_WindowCarbon::getState() const { GHOST_ASSERT(getValid(), "GHOST_WindowCarbon::getState(): window invalid") GHOST_TWindowState state; if (::IsWindowVisible(m_windowRef) == false) { state = GHOST_kWindowStateMinimized; } else if (::IsWindowInStandardState(m_windowRef, nil, nil)) { state = GHOST_kWindowStateMaximized; } else { state = GHOST_kWindowStateNormal; } return state; }
GHOST_TSuccess GHOST_WindowCarbon::setClientHeight(GHOST_TUns32 height) { GHOST_ASSERT(getValid(), "GHOST_WindowCarbon::setClientHeight(): window invalid") GHOST_Rect cBnds, wBnds; getClientBounds(cBnds); #ifdef GHOST_DRAW_CARBON_GUTTER if (((GHOST_TUns32)cBnds.getHeight()) != height+s_sizeRectSize) { ::SizeWindow(m_windowRef, cBnds.getWidth(), height+s_sizeRectSize, true); } #else //GHOST_DRAW_CARBON_GUTTER if (((GHOST_TUns32)cBnds.getHeight()) != height) { ::SizeWindow(m_windowRef, cBnds.getWidth(), height, true); } #endif //GHOST_DRAW_CARBON_GUTTER return GHOST_kSuccess; }
void GHOST_NDOFManager::sendButtonEvent(NDOF_ButtonT button, bool press, GHOST_TUns64 time, GHOST_IWindow *window) { GHOST_ASSERT(button > NDOF_BUTTON_NONE && button < NDOF_BUTTON_LAST, "rogue button trying to escape NDOF manager"); GHOST_EventNDOFButton *event = new GHOST_EventNDOFButton(time, window); GHOST_TEventNDOFButtonData *data = (GHOST_TEventNDOFButtonData *) event->getData(); data->action = press ? GHOST_kPress : GHOST_kRelease; data->button = button; #ifdef DEBUG_NDOF_BUTTONS printf("%s %s\n", ndof_button_names[button], press ? "pressed" : "released"); #endif m_system.pushEvent(event); }
GHOST_TSuccess GHOST_DisplayManagerCarbon::getCurrentDisplaySetting(GHOST_TUns8 display, GHOST_DisplaySetting& setting) const { GHOST_ASSERT((display==kMainDisplay), "GHOST_DisplayManagerCarbon::getCurrentDisplaySetting(): only main display is supported"); CFDictionaryRef displayModeValues = ::CGDisplayCurrentMode(m_displayIDs[display]); setting.xPixels = getValue(displayModeValues, kCGDisplayWidth); setting.yPixels = getValue(displayModeValues, kCGDisplayHeight); setting.bpp = getValue(displayModeValues, kCGDisplayBitsPerPixel); setting.frequency = getValue(displayModeValues, kCGDisplayRefreshRate); #ifdef GHOST_DEBUG printf("current display mode: width=%d, height=%d, bpp=%d, frequency=%d\n", setting.xPixels, setting.yPixels, setting.bpp, setting.frequency); #endif // GHOST_DEBUG return GHOST_kSuccess; }