void ofAppGLFWWindow::changeMode(){
//glfwToggleFullscreen();
if( windowMode == OF_FULLSCREEN){
nonFullScreenW = ofGetWidth();
nonFullScreenH = ofGetHeight();
//----------------------------------------------------
ofAppGLFWWindow::setWindowShape(getScreenSize().x, getScreenSize().y);
ofAppGLFWWindow::setWindowPosition(0,0);
#ifdef TARGET_OSX
SetSystemUIMode(kUIModeAllHidden,NULL);
#endif
}else if( windowMode == OF_WINDOW ){
ofAppGLFWWindow::setWindowShape(nonFullScreenW, nonFullScreenH);
//----------------------------------------------------
// if we have recorded the screen posion, put it there
// if not, better to let the system do it (and put it where it wants)
if (nFrameCount > 0){
ofAppGLFWWindow::setWindowPosition(nonFullScreenX,nonFullScreenY);
}
//----------------------------------------------------
#ifdef TARGET_OSX
SetSystemUIMode(kUIModeNormal,NULL);
#endif
}
}
/* 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 UIMachineLogicFullscreen::setPresentationModeEnabled(bool fEnabled)
{
/* First check if we are on a screen which contains the Dock or the
* Menubar (which hasn't to be the same), only than the
* presentation mode have to be changed. */
if ( fEnabled
&& m_pScreenLayout->isHostTaskbarCovert())
{
QString testStr = vboxGlobal().virtualBox().GetExtraData(GUI_PresentationModeEnabled).toLower();
/* Default to false if it is an empty value */
if (testStr.isEmpty() || testStr == "false")
SetSystemUIMode(kUIModeAllHidden, 0);
else
SetSystemUIMode(kUIModeAllSuppressed, 0);
}
else
SetSystemUIMode(kUIModeNormal, 0);
}
/* void unlock (); */
NS_IMETHODIMP OSLock::Unlock()
{
SetSystemUIMode(kUIModeNormal, NULL);
//CGReleaseAllDisplays();
return NS_OK;
}
OP_STATUS MacOpPluginAdapter::ProcessMessage(const OpTypedMessage* message)
{
switch (message->GetType())
{
case OpPeerConnectedMessage::Type:
if (m_plugin_window)
// Send initial top-level window coordinates.
m_plugin_window->OnDesktopWindowMoved(NULL);
break;
case OpPeerDisconnectedMessage::Type:
m_plugin_channel = NULL;
break;
case OpMacPluginUpdateViewMessage::Type:
if (m_plugin_window)
m_plugin_window->UpdatePluginView();
break;
case OpMacPluginFullscreenMessage::Type:
{
SystemUIMode outMode;
SystemUIOptions outOptions;
GetSystemUIMode(&outMode, &outOptions);
ProcessSerialNumber psn;
if (OpMacPluginFullscreenMessage::Cast(message)->GetFullscreen())
{
// Hide menu and dock
SetSystemUIMode(kUIModeAllHidden, outOptions);
// Set the plugin as the front process
psn.highLongOfPSN = OpMacPluginFullscreenMessage::Cast(message)->GetHighLongOfPSN();
psn.lowLongOfPSN = OpMacPluginFullscreenMessage::Cast(message)->GetLowLongOfPSN();
SetFrontProcess(&psn);
}
else
{
// Set Opera as the front process
GetCurrentProcess(&psn);
SetFrontProcess(&psn);
// Show menu and dock
SetSystemUIMode(kUIModeNormal, outOptions);
}
}
break;
case OpMacPluginWindowShownMessage::Type:
{
ProcessSerialNumber psn;
if (OpMacPluginWindowShownMessage::Cast(message)->GetShow())
{
// Set the plugin as the front process
psn.highLongOfPSN = OpMacPluginWindowShownMessage::Cast(message)->GetHighLongOfPSN();
psn.lowLongOfPSN = OpMacPluginWindowShownMessage::Cast(message)->GetLowLongOfPSN();
SetFrontProcess(&psn);
}
else
{
// Set Opera as the front process
GetCurrentProcess(&psn);
SetFrontProcess(&psn);
}
}
break;
case OpMacPluginInfoMessage::Type:
return message->Reply(OpMacPluginInfoResponseMessage::Create(CommandLineManager::GetInstance()->GetArgument(CommandLineManager::DisableCoreAnimation) ? TRUE : FALSE,
CommandLineManager::GetInstance()->GetArgument(CommandLineManager::DisableInvalidatingCoreAnimation) ? TRUE : FALSE));
case OpMacPluginCursorShownMessage::Type:
{
if (OpMacPluginCursorShownMessage::Cast(message)->GetShow())
{
CGDisplayShowCursor(CGMainDisplayID());
}
else
{
CGDisplayHideCursor(CGMainDisplayID());
}
}
break;
case OpMacPluginContextMenuShownMessage::Type:
{
gHandlingContextMenu = OpMacPluginContextMenuShownMessage::Cast(message)->GetShow();
}
break;
}
return OpStatus::OK;
}
//------------------------------------------------------------
void ofAppGlutWindow::display(void){
//--------------------------------
// when I had "glutFullScreen()"
// in the initOpenGl, I was gettings a "heap" allocation error
// when debugging via visual studio. putting it here, changes that.
// maybe it's voodoo, or I am getting rid of the problem
// by removing something unrelated, but everything seems
// to work if I put fullscreen on the first frame of display.
if (windowMode != OF_GAME_MODE){
if ( bNewScreenMode ){
if( windowMode == OF_FULLSCREEN){
//----------------------------------------------------
// before we go fullscreen, take a snapshot of where we are:
nonFullScreenX = glutGet(GLUT_WINDOW_X);
nonFullScreenY = glutGet(GLUT_WINDOW_Y);
//----------------------------------------------------
glutFullScreen();
#ifdef TARGET_OSX
SetSystemUIMode(kUIModeAllHidden,NULL);
#endif
}else if( windowMode == OF_WINDOW ){
glutReshapeWindow(requestedWidth, requestedHeight);
//----------------------------------------------------
// if we have recorded the screen posion, put it there
// if not, better to let the system do it (and put it where it wants)
if (nFrameCount > 0){
glutPositionWindow(nonFullScreenX,nonFullScreenY);
}
//----------------------------------------------------
#ifdef TARGET_OSX
SetSystemUIMode(kUIModeNormal,NULL);
#endif
}
bNewScreenMode = false;
}
}
// set viewport, clear the screen
ofViewport(0, 0, glutGet(GLUT_WINDOW_WIDTH), glutGet(GLUT_WINDOW_HEIGHT)); // used to be glViewport( 0, 0, width, height );
float * bgPtr = ofBgColorPtr();
bool bClearAuto = ofbClearBg();
// to do non auto clear on PC for now - we do something like "single" buffering --
// it's not that pretty but it work for the most part
#ifdef TARGET_WIN32
if (bClearAuto == false){
glDrawBuffer (GL_FRONT);
}
#endif
if ( bClearAuto == true || nFrameCount < 3){
ofClear(bgPtr[0]*255,bgPtr[1]*255,bgPtr[2]*255, bgPtr[3]*255);
}
if( bEnableSetupScreen )ofSetupScreen();
ofNotifyDraw();
#ifdef TARGET_WIN32
if (bClearAuto == false){
// on a PC resizing a window with this method of accumulation (essentially single buffering)
// is BAD, so we clear on resize events.
if (nFramesSinceWindowResized < 3){
ofClear(bgPtr[0]*255,bgPtr[1]*255,bgPtr[2]*255, bgPtr[3]*255);
} else {
if (nFrameCount < 3 || nFramesSinceWindowResized < 3) glutSwapBuffers();
else glFlush();
}
} else {
glutSwapBuffers();
}
#else
if (bClearAuto == false){
// in accum mode resizing a window is BAD, so we clear on resize events.
if (nFramesSinceWindowResized < 3){
ofClear(bgPtr[0]*255,bgPtr[1]*255,bgPtr[2]*255, bgPtr[3]*255);
}
}
glutSwapBuffers();
#endif
nFramesSinceWindowResized++;
//fps calculation moved to idle_cb as we were having fps speedups when heavy drawing was occuring
//wasn't reflecting on the actual app fps which was in reality slower.
//could be caused by some sort of deferred drawing?
nFrameCount++; // increase the overall frame count
//setFrameNum(nFrameCount); // get this info to ofUtils for people to access
}
//------------------------------------------------------------
void ofAppGlutWindow::display(void){
static ofEventArgs voidEventArgs;
//--------------------------------
// when I had "glutFullScreen()"
// in the initOpenGl, I was gettings a "heap" allocation error
// when debugging via visual studio. putting it here, changes that.
// maybe it's voodoo, or I am getting rid of the problem
// by removing something unrelated, but everything seems
// to work if I put fullscreen on the first frame of display.
if (windowMode != OF_GAME_MODE){
if ( bNewScreenMode ){
if( windowMode == OF_FULLSCREEN){
//----------------------------------------------------
// before we go fullscreen, take a snapshot of where we are:
nonFullScreenX = glutGet(GLUT_WINDOW_X);
nonFullScreenY = glutGet(GLUT_WINDOW_Y);
//----------------------------------------------------
glutFullScreen();
#ifdef TARGET_OSX
SetSystemUIMode(kUIModeAllHidden,NULL);
#endif
}else if( windowMode == OF_WINDOW ){
glutReshapeWindow(requestedWidth, requestedHeight);
//----------------------------------------------------
// if we have recorded the screen posion, put it there
// if not, better to let the system do it (and put it where it wants)
if (nFrameCount > 0){
glutPositionWindow(nonFullScreenX,nonFullScreenY);
}
//----------------------------------------------------
#ifdef TARGET_OSX
SetSystemUIMode(kUIModeNormal,NULL);
#endif
}
bNewScreenMode = false;
}
}
int width, height;
width = ofGetWidth();
height = ofGetHeight();
height = height > 0 ? height : 1;
// set viewport, clear the screen
glViewport( 0, 0, width, height );
float * bgPtr = ofBgColorPtr();
bool bClearAuto = ofbClearBg();
// I don't know why, I need more than one frame at the start in fullscreen mode
// also, in non-fullscreen mode, windows/intel graphics, this bClearAuto just fails.
// I seem to have 2 buffers, alot of flickering
// and don't accumulate the way I expect.
// with this line: if ((bClearAuto == true) || nFrameCount < 3){
// we do nFrameCount < 3, so that the buffers are cleared at the start of the app
// or else we have video memory garbage to draw on to...
#ifdef TARGET_WIN32
//windows doesn't get accumulation in window mode
if ((bClearAuto == true || windowMode == OF_WINDOW) || nFrameCount < 3){
#else
//mac and linux does :)
if ( bClearAuto == true || nFrameCount < 3){
#endif
glClearColor(bgPtr[0],bgPtr[1],bgPtr[2], bgPtr[3]);
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
if( bEnableSetupScreen )ofSetupScreen();
if(ofAppPtr)
ofAppPtr->draw();
#ifdef OF_USING_POCO
ofNotifyEvent( ofEvents.draw, voidEventArgs );
#endif
glutSwapBuffers();
// -------------- fps calculation:
timeNow = ofGetElapsedTimef();
if( (timeNow-timeThen) > 0.05f || nFramesForFPS == 0 ) {
fps = (double)nFramesForFPS / (timeNow-timeThen);
timeThen = timeNow;
nFramesForFPS = 0;
//hack for windows - was getting NAN - maybe unitialized vars???
if( nFrameCount < 5) frameRate = fps;
else frameRate = 0.9f * frameRate + 0.1f * fps;
}
nFramesForFPS++;
// --------------
nFrameCount++; // increase the overall frame count
//setFrameNum(nFrameCount); // get this info to ofUtils for people to access
}
//------------------------------------------------------------
void ofAppGlutWindow::mouse_cb(int button, int state, int x, int y) {
static ofMouseEventArgs mouseEventArgs;
if (nFrameCount > 0){
if(ofAppPtr){
ofAppPtr->mouseX = x;
ofAppPtr->mouseY = y;
}
if (state == GLUT_DOWN) {
if(ofAppPtr)
ofAppPtr->mousePressed(x,y,button);
#ifdef OF_USING_POCO
mouseEventArgs.x = x;
mouseEventArgs.y = y;
mouseEventArgs.button = button;
ofNotifyEvent( ofEvents.mousePressed, mouseEventArgs );
#endif
} else if (state == GLUT_UP) {
if(ofAppPtr){
ofAppPtr->mouseReleased(x,y,button);
ofAppPtr->mouseReleased();
}
#ifdef OF_USING_POCO
mouseEventArgs.x = x;
mouseEventArgs.y = y;
mouseEventArgs.button = button;
ofNotifyEvent( ofEvents.mouseReleased, mouseEventArgs );
#endif
}
buttonInUse = button;
}
}
//------------------------------------------------------------
void ofAppGlutWindow::motion_cb(int x, int y) {
static ofMouseEventArgs mouseEventArgs;
if (nFrameCount > 0){
if(ofAppPtr){
ofAppPtr->mouseX = x;
ofAppPtr->mouseY = y;
ofAppPtr->mouseDragged(x,y,buttonInUse);
}
#ifdef OF_USING_POCO
mouseEventArgs.x = x;
mouseEventArgs.y = y;
mouseEventArgs.button = buttonInUse;
ofNotifyEvent( ofEvents.mouseDragged, mouseEventArgs );
#endif
}
}
//------------------------------------------------------------
void ofAppGlutWindow::passive_motion_cb(int x, int y) {
static ofMouseEventArgs mouseEventArgs;
if (nFrameCount > 0){
if(ofAppPtr){
ofAppPtr->mouseX = x;
ofAppPtr->mouseY = y;
ofAppPtr->mouseMoved(x,y);
}
#ifdef OF_USING_POCO
mouseEventArgs.x = x;
mouseEventArgs.y = y;
ofNotifyEvent( ofEvents.mouseMoved, mouseEventArgs );
#endif
}
}
//------------------------------------------------------------
void ofAppGlutWindow::idle_cb(void) {
static ofEventArgs voidEventArgs;
// thanks to jorge for the fix:
// http://www.openframeworks.cc/forum/viewtopic.php?t=515&highlight=frame+rate
if (nFrameCount != 0 && bFrameRateSet == true){
diffMillis = ofGetElapsedTimeMillis() - prevMillis;
if (diffMillis > millisForFrame){
; // we do nothing, we are already slower than target frame
} else {
int waitMillis = millisForFrame - diffMillis;
#ifdef TARGET_WIN32
Sleep(waitMillis); //windows sleep in milliseconds
#else
usleep(waitMillis * 1000); //mac sleep in microseconds - cooler :)
#endif
}
}
prevMillis = ofGetElapsedTimeMillis(); // you have to measure here
if(ofAppPtr)
ofAppPtr->update();
#ifdef OF_USING_POCO
ofNotifyEvent( ofEvents.update, voidEventArgs);
#endif
glutPostRedisplay();
}
//------------------------------------------------------------
void ofAppGlutWindow::keyboard_cb(unsigned char key, int x, int y) {
static ofKeyEventArgs keyEventArgs;
if(ofAppPtr)
ofAppPtr->keyPressed(key);
#ifdef OF_USING_POCO
keyEventArgs.key = key;
ofNotifyEvent( ofEvents.keyPressed, keyEventArgs );
#endif
if (key == OF_KEY_ESC){ // "escape"
exitApp();
}
}
//------------------------------------------------------------
void ofAppGlutWindow::keyboard_up_cb(unsigned char key, int x, int y) {
static ofKeyEventArgs keyEventArgs;
if(ofAppPtr)
ofAppPtr->keyReleased(key);
#ifdef OF_USING_POCO
keyEventArgs.key = key;
ofNotifyEvent( ofEvents.keyReleased, keyEventArgs );
#endif
}
//------------------------------------------------------
void ofAppGlutWindow::special_key_cb(int key, int x, int y) {
static ofKeyEventArgs keyEventArgs;
if(ofAppPtr)
ofAppPtr->keyPressed(key | OF_KEY_MODIFIER);
#ifdef OF_USING_POCO
keyEventArgs.key = (key | OF_KEY_MODIFIER);
ofNotifyEvent( ofEvents.keyPressed, keyEventArgs );
#endif
}
//------------------------------------------------------------
void ofAppGlutWindow::special_key_up_cb(int key, int x, int y) {
static ofKeyEventArgs keyEventArgs;
if(ofAppPtr)
ofAppPtr->keyReleased(key | OF_KEY_MODIFIER);
#ifdef OF_USING_POCO
keyEventArgs.key = (key | OF_KEY_MODIFIER);
ofNotifyEvent( ofEvents.keyReleased, keyEventArgs );
#endif
}
//------------------------------------------------------------
void ofAppGlutWindow::resize_cb(int w, int h) {
static ofResizeEventArgs resizeEventArgs;
if(ofAppPtr)
ofAppPtr->windowResized(w,h);
#ifdef OF_USING_POCO
resizeEventArgs.width = w;
resizeEventArgs.height = h;
ofNotifyEvent( ofEvents.windowResized, resizeEventArgs );
#endif
}
bool gl_initialize(int screen_wid,int screen_high,bool lock_fps_refresh,int fsaa_mode,bool reset,char *err_str)
{
GLint ntxtunit,ntxtsize;
#ifdef D3_OS_MAC
long swapint,rect[4];
CGLContextObj current_ctx;
CFDictionaryRef mode_info;
CFNumberRef cf_rate;
#else
GLenum glew_error;
#endif
// setup rendering sizes
setup.screen.x_sz=screen_wid;
setup.screen.y_sz=screen_high;
// normal attributes
SDL_GL_SetAttribute(SDL_GL_RED_SIZE,8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE,8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE,8);
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE,8);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE,16);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE,8);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER,1);
// full screen anti-aliasing attributes
switch (fsaa_mode) {
case fsaa_mode_low:
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS,1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES,2);
break;
case fsaa_mode_medium:
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS,1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES,4);
break;
case fsaa_mode_high:
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS,1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES,6);
break;
}
// start window or full screen
if (gl_in_window_mode()) {
surface=SDL_SetVideoMode(setup.screen.x_sz,setup.screen.y_sz,32,SDL_OPENGL|SDL_HWSURFACE);
SDL_WM_SetCaption("dim3",NULL);
}
else {
surface=SDL_SetVideoMode(setup.screen.x_sz,setup.screen.y_sz,32,SDL_OPENGL|SDL_FULLSCREEN);
}
if (surface==NULL) {
sprintf(err_str,"SDL: Could not set video mode (Error: %s)",SDL_GetError());
return(FALSE);
}
// work around the dock losing minimize buttons because
// of SDL luncancy
#ifdef D3_OS_MAC
if (!gl_in_window_mode()) SetSystemUIMode(kUIModeContentSuppressed,0);
#endif
// use glew on linux and windows
#ifndef D3_OS_MAC
glew_error=glewInit();
if (glew_error!=GL_NO_ERROR) {
strcpy(err_str,glewGetErrorString(glew_error));
return(FALSE);
}
#endif
// grab openGL attributes
strncpy(render_info.name,(char*)glGetString(GL_RENDERER),64);
render_info.name[63]=0x0;
strncpy(render_info.ext_string,(char*)glGetString(GL_EXTENSIONS),8192);
render_info.ext_string[8191]=0x0;
glGetIntegerv(GL_MAX_TEXTURE_UNITS,&ntxtunit);
render_info.texture_unit_count=(int)ntxtunit;
glGetIntegerv(GL_MAX_TEXTURE_SIZE,&ntxtsize);
render_info.texture_max_size=(int)ntxtsize;
// in case screen is bigger than desired drawing surface
render_info.monitor_x_sz=surface->w;
render_info.monitor_y_sz=surface->h;
render_info.view_x=(render_info.monitor_x_sz-setup.screen.x_sz)>>1;
render_info.view_y=(render_info.monitor_y_sz-setup.screen.y_sz)>>1;
// determine the referesh rate
render_info.monitor_refresh_rate=60; // windows XP has a stuck refresh rate of 60
#ifdef D3_OS_MAC
mode_info=CGDisplayCurrentMode(CGMainDisplayID());
if (mode_info!=NULL) {
cf_rate=(CFNumberRef)CFDictionaryGetValue(mode_info,kCGDisplayRefreshRate);
if (cf_rate) {
CFNumberGetValue(cf_rate,kCFNumberIntType,&render_info.monitor_refresh_rate);
if (render_info.monitor_refresh_rate==0) render_info.monitor_refresh_rate=60;
}
}
#endif
// clear the entire window so it doesn't flash
glClearColor(0,0,0,0);
glClear(GL_COLOR_BUFFER_BIT);
SDL_GL_SwapBuffers();
// setup renderer
#ifdef D3_OS_MAC
current_ctx=CGLGetCurrentContext();
rect[0]=render_info.view_x;
rect[1]=render_info.view_y;
rect[2]=setup.screen.x_sz;
rect[3]=setup.screen.y_sz;
CGLSetParameter(current_ctx,kCGLCPSwapRectangle,rect);
CGLEnable(current_ctx,kCGLCESwapRectangle);
if (lock_fps_refresh) {
swapint=1;
CGLSetParameter(current_ctx,kCGLCPSwapInterval,&swapint);
}
#endif
glViewport(render_info.view_x,render_info.view_y,setup.screen.x_sz,setup.screen.y_sz);
// perspective correction
glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);
// smoothing and anti-aliasing
glDisable(GL_DITHER);
glEnable(GL_LINE_SMOOTH);
glHint(GL_LINE_SMOOTH_HINT,GL_NICEST);
if (fsaa_mode!=fsaa_mode_none) glEnable(GL_MULTISAMPLE);
// texture compression
glHint(GL_TEXTURE_COMPRESSION_HINT,GL_NICEST);
glHint(GL_GENERATE_MIPMAP_HINT,GL_NICEST);
// all alphas by 8 bit component
glDisable(GL_ALPHA_TEST);
// texture utility initialize
gl_texture_initialize();
// do an initial draw
if (!reset) {
glClearColor(0,0,0,0);
glClear(GL_COLOR_BUFFER_BIT);
SDL_GL_SwapBuffers();
}
return(TRUE);
}
//------------------------------------------------------------
void ofAppGlutWindow::display(void){
static ofEventArgs voidEventArgs;
//--------------------------------
// when I had "glutFullScreen()"
// in the initOpenGl, I was gettings a "heap" allocation error
// when debugging via visual studio. putting it here, changes that.
// maybe it's voodoo, or I am getting rid of the problem
// by removing something unrelated, but everything seems
// to work if I put fullscreen on the first frame of display.
if (windowMode != OF_GAME_MODE){
if ( bNewScreenMode ){
if( windowMode == OF_FULLSCREEN){
//----------------------------------------------------
// before we go fullscreen, take a snapshot of where we are:
nonFullScreenX = glutGet(GLUT_WINDOW_X);
nonFullScreenY = glutGet(GLUT_WINDOW_Y);
//----------------------------------------------------
glutFullScreen();
#ifdef TARGET_OSX
SetSystemUIMode(kUIModeAllHidden,NULL);
#endif
}else if( windowMode == OF_WINDOW ){
glutReshapeWindow(requestedWidth, requestedHeight);
//----------------------------------------------------
// if we have recorded the screen posion, put it there
// if not, better to let the system do it (and put it where it wants)
if (nFrameCount > 0){
glutPositionWindow(nonFullScreenX,nonFullScreenY);
}
//----------------------------------------------------
#ifdef TARGET_OSX
SetSystemUIMode(kUIModeNormal,NULL);
#endif
}
bNewScreenMode = false;
}
}
int width, height;
width = ofGetWidth();
height = ofGetHeight();
height = height > 0 ? height : 1;
// set viewport, clear the screen
glViewport( 0, 0, width, height );
float * bgPtr = ofBgColorPtr();
bool bClearAuto = ofbClearBg();
// to do non auto clear on PC for now - we do something like "single" buffering --
// it's not that pretty but it work for the most part
#ifdef TARGET_WIN32
if (bClearAuto == false){
glDrawBuffer (GL_FRONT);
}
#endif
if ( bClearAuto == true || nFrameCount < 3){
glClearColor(bgPtr[0],bgPtr[1],bgPtr[2], bgPtr[3]);
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
if( bEnableSetupScreen )ofSetupScreen();
if(ofAppPtr)
ofAppPtr->draw();
#ifdef OF_USING_POCO
ofNotifyEvent( ofEvents.draw, voidEventArgs );
#endif
#ifdef TARGET_WIN32
if (bClearAuto == false){
// on a PC resizing a window with this method of accumulation (essentially single buffering)
// is BAD, so we clear on resize events.
if (nFramesSinceWindowResized < 3){
glClearColor(bgPtr[0],bgPtr[1],bgPtr[2], bgPtr[3]);
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
} else {
if (nFrameCount < 3 || nFramesSinceWindowResized < 3) glutSwapBuffers();
else glFlush();
}
} else {
glutSwapBuffers();
}
#else
if (bClearAuto == false){
// in accum mode resizing a window is BAD, so we clear on resize events.
if (nFramesSinceWindowResized < 3){
glClearColor(bgPtr[0],bgPtr[1],bgPtr[2], bgPtr[3]);
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
}
glutSwapBuffers();
#endif
nFramesSinceWindowResized++;
nFrameCount++; // increase the overall frame count
//setFrameNum(nFrameCount); // get this info to ofUtils for people to access
}
void MCStack::realize()
{ //create window
if (!MCnoui && MCModeMakeLocalWindows())
{
if ( getextendedstate(ECS_FULLSCREEN) )
{
//TS-2008-08-01 : [[Bug 5703 - fullscreen stack prop interacts badly with HideMenuBar]]
if (!((MCScreenDC*)MCscreen)->getmenubarhidden())
SetSystemUIMode(kUIModeAllHidden, kUIOptionAutoShowMenuBar);
const MCDisplay *t_display;
t_display = MCscreen -> getnearestdisplay(rect);
MCRectangle t_workarea, t_viewport;
t_workarea = t_display -> workarea;
t_viewport = t_display -> viewport ;
setrect(t_viewport);
}
else
{
if (!((MCScreenDC*)MCscreen)->getmenubarhidden())
SetSystemUIMode(kUIModeNormal, NULL);
}
Rect wrect;
MCScreenDC *psdc = (MCScreenDC *)MCscreen;
psdc->MCRect2MacRect(rect, wrect);
window = new _Drawable;
window->type = DC_WINDOW;
window->handle.window = 0;
char *tmpname = NULL;
const unsigned char *namePascal;
if (!isunnamed())
{ //set window title to name of stack temporarily.
tmpname = strclone(getname_cstring()); //it will be changed by setname() later.
namePascal = c2pstr(tmpname);
}
else
namePascal = (unsigned char*)"\p";
loadwindowshape();
window->handle.window = NULL;
uint32_t wclass;
uint32_t wattributes;
getWinstyle(wattributes,wclass);
wattributes |= kWindowCompositingAttribute;
long testdecorations = WD_TITLE | WD_MENU | WD_CLOSE | WD_MINIMIZE | WD_MAXIMIZE;
if (m_window_shape != NULL)
{
static WindowDefUPP s_window_mask_proc = NULL;
if (s_window_mask_proc == NULL)
s_window_mask_proc = NewWindowDefUPP(WindowMaskProc);
WindowDefSpec t_spec;
t_spec . defType = kWindowDefProcPtr;
t_spec . u . defProc = s_window_mask_proc;
CreateCustomWindow(&t_spec, wclass, wattributes, &wrect, (WindowPtr *)&window -> handle . window);
HIWindowChangeFeatures((WindowPtr)window -> handle . window, 0, kWindowIsOpaque);
}
else if (((flags & F_DECORATIONS && !(decorations & testdecorations))
|| wclass == kPlainWindowClass))
{
static WindowDefUPP s_borderless_proc = NULL;
if (s_borderless_proc == NULL)
s_borderless_proc = NewWindowDefUPP(BorderlessWindowProc);
WindowDefSpec t_spec;
t_spec . defType = kWindowDefProcPtr;
t_spec . u . defProc = s_borderless_proc;
if (wclass == kPlainWindowClass)
wclass = kUtilityWindowClass;
CreateCustomWindow(&t_spec, wclass, wattributes, &wrect, (WindowPtr *)&window->handle.window);
}
else
CreateNewWindow(wclass, wattributes,&wrect, (WindowPtr *)&window->handle.window);
if (wclass == kFloatingWindowClass)
ChangeWindowAttributes((WindowPtr)window -> handle . window, kWindowNoAttributes, kWindowHideOnSuspendAttribute);
// MW-2009-10-31: Make sure we can collapse any rev window
HIWindowChangeFeatures((WindowPtr)window -> handle . window, kWindowCanCollapse, 0);
if (window->handle.window == NULL)
SetWTitle((WindowPtr)window->handle.window, namePascal);
SetWTitle((WindowPtr)window->handle.window, namePascal);
setopacity(blendlevel * 255 / 100);
SetWRefCon((WindowPtr)window->handle.window, mode);
ControlRef t_control;
MCRevolutionStackViewCreate(this, &t_control);
ControlRef t_root_control;
GetRootControl((WindowPtr)window -> handle . window, &t_root_control);
HIViewAddSubview(t_root_control, t_control);
ShowControl(t_control);
if (wclass == kDrawerWindowClass)
{
Window pwindow = NULL;
if (parentwindow != DNULL)
pwindow = parentwindow;
else
if (MCdefaultstackptr && MCdefaultstackptr->getw() != DNULL )
pwindow = MCdefaultstackptr->getw();
if (pwindow && GetWRefCon((WindowPtr)pwindow->handle.window) != WM_DRAWER)
{
SetDrawerParent((WindowPtr)window->handle.window, (WindowPtr)pwindow->handle.window);
WindowAttributes watt;
GetWindowAttributes((WindowPtr)pwindow->handle.window,&watt);
if (wattributes & kWindowResizableAttribute)
ChangeWindowAttributes((WindowPtr)pwindow->handle.window, kWindowLiveResizeAttribute, 0);
OptionBits draweredge;
switch (wposition)
{
case WP_PARENTTOP:
draweredge = kWindowEdgeTop;
break;
case WP_PARENTRIGHT:
draweredge = kWindowEdgeRight;
break;
case WP_PARENTBOTTOM:
draweredge = kWindowEdgeBottom;
break;
case WP_PARENTLEFT:
draweredge = kWindowEdgeLeft;
break;
default:
draweredge = kWindowEdgeDefault;
break;
}
SetDrawerPreferredEdge((WindowPtr)window->handle.window, draweredge);
if (walignment)
{
MCRectangle parentwindowrect;
MCscreen->getwindowgeometry(pwindow, parentwindowrect);
int2 wspace = 0;
RgnHandle r = NewRgn();
GetWindowRegion((WindowPtr)window->handle.window, kWindowStructureRgn, r);
Rect tRect;
GetRegionBounds(r, &tRect);
DisposeRgn(r);
MCRectangle drawerwindowrect;
psdc->MacRect2MCRect(tRect, drawerwindowrect);
if (wposition == WP_PARENTTOP || wposition == WP_PARENTBOTTOM)
{
wspace = parentwindowrect.width - drawerwindowrect.width;
if (watt & kWindowMetalAttribute)
if (wspace)
wspace += 10; //for metal
}
else
{
wspace = parentwindowrect.height - drawerwindowrect.height;
if (watt & kWindowMetalAttribute)
if (wspace)
wspace += 5; //for metal
}
if (wspace > 0)
switch (walignment)
{
case OP_CENTER:
SetDrawerOffsets ((WindowPtr)window->handle.window,ceil(wspace/2) -1,floor(wspace/2) + 1);
break;
case OP_RIGHT:
case OP_BOTTOM:
SetDrawerOffsets ((WindowPtr)window->handle.window,wspace,0);
break;
case OP_TOP:
case OP_LEFT:
SetDrawerOffsets ((WindowPtr)window->handle.window,0,wspace);
break;
}
}
}
}
delete tmpname;
// MW-2005-11-06: We also need to catch window constraining events so we can flush
// the screen geometry cache.
EventTypeSpec list[] =
{
{kEventClassWindow, kEventWindowCollapsed},
{kEventClassWindow, kEventWindowExpanded},
{kEventClassMouse, kEventMouseWheelMoved},
{kEventClassWindow, kEventWindowBoundsChanging},
{kEventClassWindow, kEventWindowBoundsChanged},
{kEventClassWindow, kEventWindowConstrain},
{kEventClassWindow, kEventWindowFocusAcquired},
{kEventClassWindow, kEventWindowFocusRelinquish},
{kEventClassWindow, kEventWindowActivated},
{kEventClassWindow, kEventWindowDeactivated},
{kEventClassWindow, kEventWindowClose},
};
EventHandlerRef ref;
// MW-2005-09-07: Pass the window handle as user data, otherwise 'takewindow' causes problems
InstallWindowEventHandler((WindowPtr)window->handle.window, MCS_weh, sizeof(list) / sizeof(EventTypeSpec), list, (WindowPtr)window -> handle . window, &ref);
ChangeWindowAttributes((WindowPtr)window->handle.window, 0, kWindowHideOnFullScreenAttribute);
updatemodifiedmark();
}
start_externals();
}
