void ofxFenster::move(int x, int y) { ofPoint p = getWindowPosition(); int nx, ny; //win->screenToClient(p.x+x, p.y+y, nx, ny); nx = p.x + x; ny = p.y + y; setWindowPosition(nx, ny); }
void NativeWindow::setPosition(int x, int y) { _x = x; _y = y; int returnCode = setWindowPosition(_x, _y); if (returnCode) { perror("window position"); } }
void Waveform::audioPositionChanged(qint64 position) { WAVEFORM_DEBUG << "Waveform::audioPositionChanged" << "audioPosition" << position << "bufferPosition" << m_bufferPosition << "bufferLength" << m_bufferLength; if (position >= m_bufferPosition) { if (position + m_windowLength > m_bufferPosition + m_bufferLength) position = qMax(qint64(0), m_bufferPosition + m_bufferLength - m_windowLength); m_audioPosition = position; setWindowPosition(position); } }
BOOL CDirectionDlg::OnInitDialog() { __super::OnInitDialog(); int selectedButton = IDCANCEL; switch(m_dir) { case S : selectedButton = IDC_BUTTONS ; break; case E : selectedButton = IDC_BUTTONE ; break; case N : selectedButton = IDC_BUTTONN ; break; case W : selectedButton = IDC_BUTTONW ; break; } GetDlgItem(selectedButton)->SetFocus(); setWindowText(this, IDC_STATICMSG, format(_T("Is start direction %s Ok?"), directionName[m_dir])); setWindowPosition(this, CPoint(700,100)); return FALSE; }
/** * Constructor */ SelectFileScreen::SelectFileScreen() { state = ENTERING_SCREEN; deletePromptActive = false; selectedFile = 0; yesDeleteBox = new hgeRect(); noDeleteBox = new hgeRect(); difficultyPrompt = new DifficultyPrompt(); //Buttons buttons[SFS_BACK_BUTTON] = new Button(0, 0, "Back"); buttons[SFS_DELETE_BUTTON] = new Button(0, 0, "Delete"); buttons[SFS_START_BUTTON] = new Button(0, 0, "Start"); for (int i = 0; i < 4; i++) { saveBoxes[i].collisionBox = new hgeRect(); } setWindowPosition(182.0, -512.0); }
/** * Updates the load screen */ bool SelectFileScreen::update(float dt, float mouseX, float mouseY) { if (difficultyPrompt->visible) { int result = difficultyPrompt->update(dt); if (result == -1) { return false; } else { smh->saveManager->difficulty = result; } } if (state == ENTERING_SCREEN) { setWindowPosition(windowX, windowY + 1800.0 * dt); if (windowY >= 138.0) { state = IN_SCREEN; windowY = 138.0; setWindowPosition(windowX, windowY); } } else if (state == EXITING_SCREEN) { setWindowPosition(windowX, windowY - 1800.0 * dt); if (windowY <= -512.0) { //Done exiting screen - perform action based on what button was clicked switch (clickedButton) { case SFS_BACK_BUTTON: smh->menu->setScreen(MenuScreens::TITLE_SCREEN); return false; case SFS_START_BUTTON: smh->menu->openLoadScreen(selectedFile, true); return false; } } } //Set "start" button text based on whether or not an empty file is selected buttons[SFS_START_BUTTON]->setText(smh->saveManager->isFileEmpty(selectedFile) ? "Start" : "Continue"); //Update buttons for (int i = 0; i < SFS_NUM_BUTTONS; i++) { buttons[i]->update(dt); if (buttons[i]->isClicked() && i != SFS_DELETE_BUTTON) { clickedButton = i; state = EXITING_SCREEN; if (i == SFS_START_BUTTON && smh->saveManager->isFileEmpty(selectedFile)) { difficultyPrompt->visible = true; } } } //Click delete button if (buttons[SFS_DELETE_BUTTON]->isClicked()) { if (!smh->saveManager->isFileEmpty(selectedFile)) { deletePromptActive = true; } } //Update save box selection if (!deletePromptActive) { for (int i = 0; i < 4; i++) { if ((smh->hge->Input_KeyDown(HGEK_LBUTTON) || smh->input->keyPressed(INPUT_ATTACK)) && saveBoxes[i].collisionBox->TestPoint(mouseX, mouseY)) { selectedFile = i; } } } //Listen for response to delete prompt if (deletePromptActive) { yesDeleteBox->Set(saveBoxes[selectedFile].x + 100.0, saveBoxes[selectedFile].y + 60.0, saveBoxes[selectedFile].x + 100.0 + 50.0, saveBoxes[selectedFile].y + 60.0 + 35.0); noDeleteBox->Set( saveBoxes[selectedFile].x + 180.0, saveBoxes[selectedFile].y + 60.0, saveBoxes[selectedFile].x + 180.0 + 50.0, saveBoxes[selectedFile].y + 60.0 + 35.0); mouseOverYes = yesDeleteBox->TestPoint(smh->input->getMouseX(), smh->input->getMouseY()); mouseOverNo = noDeleteBox->TestPoint(smh->input->getMouseX(), smh->input->getMouseY()); if (mouseOverYes && smh->hge->Input_KeyDown(HGEK_LBUTTON)) { smh->saveManager->deleteFile(selectedFile); deletePromptActive = false; } if (mouseOverNo && smh->hge->Input_KeyDown(HGEK_LBUTTON)) { deletePromptActive = false; } } //Move the Smiley selector towards the selected file if (smileyY > saveBoxes[selectedFile].y + 45.0) { smileyY -= 750.0 * dt; if (smileyY < saveBoxes[selectedFile].y + 45.0) { smileyY = saveBoxes[selectedFile].y + 45.0; } } else if (smileyY < saveBoxes[selectedFile].y + 45.0) { smileyY += 750.0 * dt; if (smileyY > saveBoxes[selectedFile].y + 45.0) { smileyY = saveBoxes[selectedFile].y + 45.0; } } return false; }
int OpenGLView::regenerate() { int returnCode; EGLBoolean status; EGLint interval = 1; OpenGLView::m_renderMutex.lock(); status = eglQuerySurface(m_egl_disp, m_egl_surf, EGL_WIDTH, &m_surface_width); if (status != EGL_TRUE) { perror("query surface width"); return EXIT_FAILURE; } status = eglQuerySurface(m_egl_disp, m_egl_surf, EGL_HEIGHT, &m_surface_height); if (status != EGL_TRUE) { perror("query surface height"); return EXIT_FAILURE; } /* rc = screen_get_window_property_iv(m_screen_win, SCREEN_PROPERTY_ROTATION, &rotation); if (rc) { perror("screen_set_window_property_iv"); return EXIT_FAILURE; } rc = screen_get_window_property_iv(m_screen_win, SCREEN_PROPERTY_BUFFER_SIZE, size); if (rc) { perror("screen_set_window_property_iv"); return EXIT_FAILURE; } switch (angle - rotation) { case -270: case -90: case 90: case 270: temp = size[0]; size[0] = size[1]; size[1] = temp; skip = 0; break; } */ status = eglMakeCurrent(m_egl_disp, NULL, NULL, NULL); if (status != EGL_TRUE) { OpenGLThread::eglPrintError("eglMakeCurrent"); return EXIT_FAILURE; } status = eglDestroySurface(m_egl_disp, m_egl_surf); if (status != EGL_TRUE) { OpenGLThread::eglPrintError("eglMakeCurrent"); return EXIT_FAILURE; } returnCode = setWindowPosition(m_x, m_y); if (returnCode) { perror("window position"); return EXIT_FAILURE; } returnCode = setWindowSize(m_width, m_height); if (returnCode) { perror("window size"); return EXIT_FAILURE; } /* setWindowAngle(m_angle); if (returnCode) { perror("window angle"); return EXIT_FAILURE; } */ returnCode = setWindowSourceSize(m_width, m_height); if (returnCode) { perror("unable to set window source size"); return EXIT_FAILURE; } returnCode = setWindowBufferSize(m_width, m_height); if (returnCode) { perror("buffer size"); return EXIT_FAILURE; } m_egl_surf = eglCreateWindowSurface(m_egl_disp, m_egl_conf, m_screen_win, NULL); if (m_egl_surf == EGL_NO_SURFACE) { OpenGLThread::eglPrintError("eglCreateWindowSurface"); return EXIT_FAILURE; } getGLContext(); status = eglSwapInterval(m_egl_disp, interval); if (status != EGL_TRUE) { OpenGLThread::eglPrintError("eglSwapInterval"); return EXIT_FAILURE; } OpenGLView::m_renderMutex.unlock(); setAltered(false); setStale(true); return EXIT_SUCCESS; }
int OpenGLView::initGL() { int numberDisplays; int numberModes; int returnCode; EGLBoolean status; int type; EGLint attributes[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE }; EGLint attrib_list[]= { EGL_RED_SIZE, 8, EGL_GREEN_SIZE, 8, EGL_BLUE_SIZE, 8, EGL_SURFACE_TYPE, EGL_WINDOW_BIT, EGL_RENDERABLE_TYPE, EGL_OPENGL_ES_BIT, EGL_NONE}; // try this first as it will fail if an HDMI display is not attached if (m_api == GL_ES_2) { m_egl_ctx = eglCreateContext(m_egl_disp, m_egl_conf, EGL_NO_CONTEXT, attributes); } else { m_egl_ctx = eglCreateContext(m_egl_disp, m_egl_conf, EGL_NO_CONTEXT, NULL); } if (m_egl_ctx == EGL_NO_CONTEXT) { perror("eglCreateContext"); return EXIT_FAILURE; } screen_get_context_property_iv(m_screen_ctx, SCREEN_PROPERTY_DISPLAY_COUNT, &numberDisplays); m_screen_dpy = (screen_display_t *)calloc(numberDisplays, sizeof(screen_display_t)); screen_get_context_property_pv(m_screen_ctx, SCREEN_PROPERTY_DISPLAYS, (void **)m_screen_dpy); for (int index = 0; index < numberDisplays; index++) { int displayID; returnCode = screen_get_display_property_iv(m_screen_dpy[index], SCREEN_PROPERTY_ID, (int *)&displayID); if (returnCode) { perror("display ID"); return EXIT_FAILURE; } else { if (displayID == m_display) { screen_get_display_property_iv(m_screen_dpy[index], SCREEN_PROPERTY_TYPE, &type); if (type == SCREEN_DISPLAY_TYPE_HDMI) { returnCode = screen_create_window(&m_screen_win, m_screen_ctx); if (returnCode) { perror("screen_create_window"); return EXIT_FAILURE; } } else { returnCode = screen_create_window_type(&m_screen_win, m_screen_ctx, SCREEN_CHILD_WINDOW); if (returnCode) { perror("screen_create_window (child window)"); return EXIT_FAILURE; } } if (type == SCREEN_DISPLAY_TYPE_HDMI) { returnCode = screen_set_window_property_pv(m_screen_win, SCREEN_PROPERTY_DISPLAY, (void **)&(m_screen_dpy[index])); if (returnCode) { perror("window display"); return EXIT_FAILURE; } } } } } qDebug() << "OpenGLView::initialize: "<< m_screen_ctx << ":" << m_egl_disp << ":" << m_egl_conf << ":" << m_egl_ctx << ":" << m_screen_win; int format = SCREEN_FORMAT_RGBA8888; returnCode = screen_set_window_property_iv(m_screen_win, SCREEN_PROPERTY_FORMAT, &format); if (returnCode) { perror("screen_set_window_property_iv(SCREEN_PROPERTY_FORMAT)"); return EXIT_FAILURE; } if (m_transparency > 0) { returnCode = setWindowTransparency(m_transparency); if (returnCode) { perror("transparency"); return EXIT_FAILURE; } } returnCode = screen_get_window_property_pv(m_screen_win, SCREEN_PROPERTY_DISPLAY, (void **)&m_screen_disp); if (returnCode) { perror("screen_get_window_property_pv"); return EXIT_FAILURE; } int angle = atoi(getenv("ORIENTATION")); screen_get_display_property_iv(m_screen_disp, SCREEN_PROPERTY_MODE_COUNT, &numberModes); m_screen_modes = (screen_display_mode_t *)calloc(numberModes, sizeof(screen_display_mode_t)); returnCode = screen_get_display_property_pv(m_screen_disp, SCREEN_PROPERTY_MODE, (void**)m_screen_modes); if (returnCode) { perror("screen modes"); return EXIT_FAILURE; } int dpi = calculateDPI(); if (dpi == EXIT_FAILURE) { fprintf(stderr, "Unable to calculate dpi\n"); return EXIT_FAILURE; } returnCode = setWindowPosition(m_x, m_y); if (returnCode) { perror("window position"); return EXIT_FAILURE; } returnCode = setWindowSize(m_width, m_height); if (returnCode) { perror("window size"); return EXIT_FAILURE; } returnCode = setWindowZ(m_z); if (returnCode) { perror("z order"); return EXIT_FAILURE; } returnCode = setWindowBufferSize(m_width, m_height); if (returnCode) { perror("buffer size"); return EXIT_FAILURE; } returnCode = setWindowAngle(m_angle); if (returnCode) { perror("angle"); return EXIT_FAILURE; } returnCode = screen_create_window_buffers(m_screen_win, m_nbuffers); if (returnCode) { perror("screen_create_window_buffers"); return EXIT_FAILURE; } if (m_api == GL_ES_1) { m_usage = SCREEN_USAGE_OPENGL_ES1 | SCREEN_USAGE_ROTATION; } else if (m_api == GL_ES_2) { attrib_list[9] = EGL_OPENGL_ES2_BIT; m_usage = SCREEN_USAGE_OPENGL_ES2 | SCREEN_USAGE_ROTATION; } else if (m_api == VG) { attrib_list[9] = EGL_OPENVG_BIT; m_usage = SCREEN_USAGE_OPENVG | SCREEN_USAGE_ROTATION; } else { fprintf(stderr, "invalid api setting\n"); return EXIT_FAILURE; } returnCode = setWindowUsage(m_usage); if (returnCode) { perror("screen_set_window_property_iv(window usage)"); return EXIT_FAILURE; } qDebug() << "OpenGLView::initGL:eglCreateContext "<< m_egl_ctx; m_egl_surf = eglCreateWindowSurface(m_egl_disp, m_egl_conf, m_screen_win, NULL); if (m_egl_surf == EGL_NO_SURFACE) { OpenGLThread::eglPrintError("eglCreateWindowSurface"); return EXIT_FAILURE; } getGLContext(); EGLint interval = 1; status = eglSwapInterval(m_egl_disp, interval); if (status != EGL_TRUE) { OpenGLThread::eglPrintError("eglSwapInterval"); return EXIT_FAILURE; } status = eglQuerySurface(m_egl_disp, m_egl_surf, EGL_WIDTH, &m_surface_width); if (status != EGL_TRUE) { perror("query surface width"); return EXIT_FAILURE; } status = eglQuerySurface(m_egl_disp, m_egl_surf, EGL_HEIGHT, &m_surface_height); if (status != EGL_TRUE) { perror("query surface height"); return EXIT_FAILURE; } returnCode = joinWindowGroup(m_group); if (returnCode) { perror("window group"); return EXIT_FAILURE; } returnCode = setScreenWindowID(m_id); if (returnCode) { perror("window ID"); return EXIT_FAILURE; } qDebug() << "OpenGLView::initGL: "<< angle << ":" << numberModes << ":" << m_screen_modes[0].width << ":" << m_screen_modes[0].height << ":" << m_egl_disp << ":" << dpi; setInitialized(true); return EXIT_SUCCESS; }
// Actually put us in windowed or full screen mode. Pass true the first time this is used, false subsequently. // This has the unfortunate side-effect of triggering a mouse move event. void VideoSystem::actualizeScreenMode(GameSettings *settings, bool changingInterfaces, bool currentUIUsesEditorScreenMode) { DisplayMode displayMode = settings->getSetting<DisplayMode>(IniKey::WindowMode); DisplayManager::getScreenInfo()->resetGameCanvasSize(); // Set GameCanvasSize vars back to their default values DisplayManager::getScreenInfo()->setActualized(); // If old display mode is windowed or current is windowed but we change interfaces, // save the window position if(settings->getIniSettings()->oldDisplayMode == DISPLAY_MODE_WINDOWED || (changingInterfaces && displayMode == DISPLAY_MODE_WINDOWED)) { settings->setWindowPosition(VideoSystem::getWindowPositionX(), VideoSystem::getWindowPositionY()); } // When we're in the editor, let's take advantage of the entire screen unstretched // We might want to disallow this when we're in split screen mode? if(currentUIUsesEditorScreenMode && (displayMode == DISPLAY_MODE_FULL_SCREEN_STRETCHED || displayMode == DISPLAY_MODE_FULL_SCREEN_UNSTRETCHED)) { // Smaller values give bigger magnification; makes small things easier to see on full screen F32 magFactor = 0.85f; // For screens smaller than normal, we need to readjust magFactor to make sure we get the full canvas height crammed onto // the screen; otherwise our dock will break. Since this mode is only used in the editor, we don't really care about // screen width; tall skinny screens will work just fine. magFactor = max(magFactor, (F32)DisplayManager::getScreenInfo()->getGameCanvasHeight() / (F32)DisplayManager::getScreenInfo()->getPhysicalScreenHeight()); DisplayManager::getScreenInfo()->setGameCanvasSize(S32(DisplayManager::getScreenInfo()->getPhysicalScreenWidth() * magFactor), S32(DisplayManager::getScreenInfo()->getPhysicalScreenHeight() * magFactor)); displayMode = DISPLAY_MODE_FULL_SCREEN_STRETCHED; } // Set up video/window flags amd parameters and get ready to change the window S32 sdlWindowWidth, sdlWindowHeight; F64 orthoLeft, orthoRight, orthoTop, orthoBottom; getWindowParameters(settings, displayMode, sdlWindowWidth, sdlWindowHeight, orthoLeft, orthoRight, orthoTop, orthoBottom); // Change video modes based on selected display mode // Note: going into fullscreen you have to do in order: // - SDL_SetWindowSize() // - SDL_SetWindowFullscreen() // // However, coming out of fullscreen mode you must do the reverse switch (displayMode) { case DISPLAY_MODE_FULL_SCREEN_STRETCHED: SDL_SetWindowSize(DisplayManager::getScreenInfo()->sdlWindow, sdlWindowWidth, sdlWindowHeight); SDL_SetWindowFullscreen(DisplayManager::getScreenInfo()->sdlWindow, SDL_WINDOW_FULLSCREEN_DESKTOP); break; case DISPLAY_MODE_FULL_SCREEN_UNSTRETCHED: SDL_SetWindowSize(DisplayManager::getScreenInfo()->sdlWindow, sdlWindowWidth, sdlWindowHeight); SDL_SetWindowFullscreen(DisplayManager::getScreenInfo()->sdlWindow, SDL_WINDOW_FULLSCREEN_DESKTOP); break; case DISPLAY_MODE_WINDOWED: default: // Reverse order, leave fullscreen before setting size SDL_SetWindowFullscreen(DisplayManager::getScreenInfo()->sdlWindow, 0); SDL_SetWindowSize(DisplayManager::getScreenInfo()->sdlWindow, sdlWindowWidth, sdlWindowHeight); break; } if(settings->getSetting<YesNo>(IniKey::DisableScreenSaver)) SDL_DisableScreenSaver(); else SDL_EnableScreenSaver(); // Flush window events because SDL_SetWindowSize triggers a SDL_WINDOWEVENT_RESIZED // event (which in turn triggers another SDL_SetWindowSize) SDL_FlushEvent(SDL_WINDOWEVENT); SDL_GL_SetSwapInterval(settings->getSetting<YesNo>(IniKey::Vsync) ? 1 : 0); // Now save the new window dimensions in ScreenInfo DisplayManager::getScreenInfo()->setWindowSize(sdlWindowWidth, sdlWindowHeight); mGL->glClearColor(0, 0, 0, 0); mGL->glViewport(0, 0, sdlWindowWidth, sdlWindowHeight); mGL->glMatrixMode(GLOPT::Projection); mGL->glLoadIdentity(); // The best understanding I can get for glOrtho is that these are the coordinates you want to appear at the four corners of the // physical screen. If you want a "black border" down one side of the screen, you need to make left negative, so that 0 would // appear some distance in from the left edge of the physical screen. The same applies to the other coordinates as well. mGL->glOrtho(orthoLeft, orthoRight, orthoBottom, orthoTop, 0, 1); mGL->glMatrixMode(GLOPT::Modelview); mGL->glLoadIdentity(); // Do the scissoring if(displayMode == DISPLAY_MODE_FULL_SCREEN_UNSTRETCHED) { mGL->glScissor(DisplayManager::getScreenInfo()->getHorizPhysicalMargin(), // x DisplayManager::getScreenInfo()->getVertPhysicalMargin(), // y DisplayManager::getScreenInfo()->getDrawAreaWidth(), // width DisplayManager::getScreenInfo()->getDrawAreaHeight()); // height } else { // Enabling scissor appears to fix crashing problem switching screen mode // in linux and "Mobile 945GME Express Integrated Graphics Controller", // probably due to lines and points was not being clipped, // causing some lines to wrap around the screen, or by writing other // parts of RAM that can crash Bitfighter, graphics driver, or the entire computer. // This is probably a bug in the Linux Intel graphics driver. mGL->glScissor(0, 0, DisplayManager::getScreenInfo()->getWindowWidth(), DisplayManager::getScreenInfo()->getWindowHeight()); } mGL->glEnable(GLOPT::ScissorTest); // Turn on clipping mGL->setDefaultBlendFunction(); mGL->glLineWidth(RenderUtils::DEFAULT_LINE_WIDTH); // Enable Line smoothing everywhere! Make sure to disable temporarily for filled polygons and such if(settings->getSetting<YesNo>(IniKey::LineSmoothing)) { mGL->glEnable(GLOPT::LineSmooth); //glHint(GL_LINE_SMOOTH_HINT, GL_NICEST); } mGL->glEnable(GLOPT::Blend); // Now set the window position if(displayMode == DISPLAY_MODE_WINDOWED) { // Sometimes it happens to be (0,0) hiding the top title bar preventing ability to // move the window, in this case we are not moving it unless it is not (0,0). // Note that ini config file will default to (0,0). if(settings->getWindowPositionX() != 0 || settings->getWindowPositionY() != 0) setWindowPosition(settings->getWindowPositionX(), settings->getWindowPositionY()); } else setWindowPosition(0, 0); // Notify all active UIs that the screen has changed mode. This will likely need some work to not do something // horrible in split-screen mode. const Vector<ClientGame *> *clientGames = GameManager::getClientGames(); for(S32 i = 0; i < clientGames->size(); i++) if(clientGames->get(i)->getUIManager()->getCurrentUI()) clientGames->get(i)->getUIManager()->getCurrentUI()->onDisplayModeChange(); // Re-initialize our fonts because OpenGL textures can be lost upon screen change FontManager::reinitialize(settings); // This needs to happen after font re-initialization because I think fontstash interferes // with the oglconsole font somehow... GameManager::gameConsole->onScreenModeChanged(); }
void ofAppGLFWWindow::setupOpenGL(int w, int h, int screenMode){ requestedWidth = w; requestedHeight = h; if(!glfwInit( )){ ofLog(OF_LOG_ERROR,"cannot init GLFW"); return; } printf("WINDOW MODE IS %i", screenMode); windowMode = screenMode; glfwOpenWindowHint( GLFW_FSAA_SAMPLES, samples ); // targets default // GLFW_REFRESH_RATE 0 // GLFW_ACCUM_RED_BITS; 0 // GLFW_ACCUM_GREEN_BITS; 0 // GLFW_ACCUM_BLUE_BITS; 0 // GLFW_ACCUM_ALPHA_BITS; 0 // GLFW_AUX_BUFFERS; 0 // GLFW_STEREO; 0 // GLFW_WINDOW_NO_RESIZE; 0 // GLFW_FSAA_SAMPLES; 0 int result; if (windowMode == OF_WINDOW){ result = glfwOpenWindow( w, h, // Width and height of window 8, 8, 8, // Number of red, green, and blue bits for color buffer 8, // Number of bits for alpha buffer 32, // Number of bits for depth buffer (Z-buffer) 0, // Number of bits for stencil buffer GLFW_WINDOW // We want a desktop window (could be GLFW_FULLSCREEN) ); }else if(windowMode == OF_FULLSCREEN){ result = glfwOpenWindow( getScreenSize().x, getScreenSize().y, // Width and height of window 8, 8, 8, // Number of red, green, and blue bits for color buffer 8, // Number of bits for alpha buffer 32, // Number of bits for depth buffer (Z-buffer) 0, // Number of bits for stencil buffer GLFW_FULLSCREEN // We want a desktop window (could be GLFW_FULLSCREEN) ); showCursor(); }else if(windowMode == OF_GAME_MODE){ result = glfwOpenWindow( w, h, // Width and height of window 8, 8, 8, // Number of red, green, and blue bits for color buffer 8, // Number of bits for alpha buffer 32, // Number of bits for depth buffer (Z-buffer) 0, // Number of bits for stencil buffer GLFW_FULLSCREEN // We want a desktop window (could be GLFW_FULLSCREEN) ); showCursor(); } else { printf("**** invalid windowMode\n"); } if ( result != GL_TRUE ) { printf("**** failed to open glfw window\n"); } else printf("*--- opened glfw window\n"); setVerticalSync(false); // Set window title glfwSetWindowTitle( " " ); glfwEnable( GLFW_KEY_REPEAT ); // ofBackground(200,200,200); // default bg color // ofSetColor(0xFFFFFF); // default draw color // used to be black, but // black + texture = black // so maybe grey bg // and "white" fg color // as default works the best... requestedHeight = requestedHeight < 1 ? 1 : requestedHeight; glfwGetWindowSize( &requestedWidth, &requestedHeight ); nonFullScreenW = ofGetWidth(); nonFullScreenH = ofGetHeight(); glfwGetWindowSize( &windowW, &windowH ); setWindowPosition(50, 50); }
/*! \brief parse the parameters received from the main container in QstringList form \param params the parameter list */ bool QtYARPScope::parseParameters(QStringList params) { //YARP network initialization if (!yarp.checkNetwork()) { qCritical("Cannot connect to yarp network"); return false; } else { connect(plotManager,SIGNAL(requestRepaint()),this,SLOT(onRepaint()),Qt::QueuedConnection); } // Setup resource finder yarp::os::ResourceFinder rf; rf.setVerbose(); // TODO Read default values from yarpscope.ini rf.setDefaultConfigFile("yarpscope.ini"); rf.setDefaultContext("yarpscope"); // Transform Qt Params array in standard argc & argv int c = params.count(); char **v; v = (char**)malloc(sizeof(char*) * c); for(int i=0;i<params.count();i++){ v[i] = strdup(params.at(i).toLatin1().data()); } if(!rf.configure(c, v)){ usage(); for(int i=0;i<params.count();i++) { free(v[i]); } free(v); return false; } qDebug("%s",rf.toString().data()); if (rf.check("help")) { usage(); for(int i=0;i<params.count();i++) { free(v[i]); } free(v); return false; } for(int i=0;i<params.count();i++) { free(v[i]); } free(v); //********************** Deprecated options // local if (rf.check("local")) { qWarning() << "--local option is deprecated. YARPScope now uses \"${YARP_PORT_PREFIX}/YARPScope/${REMOTE_PORT_NAME}\""; } // rows if (rf.check("rows")) { qWarning() << "--rows option is deprecated. Use XML mode if you need more than one plot in a single window\""; } // cols if (rf.check("cols")) { qWarning() << "--cols option is deprecated. Use XML mode if you need more than one plot in a single window\""; } //******************************************** //************************* Generic options int interval; // title if (rf.find("title").isString()) { emit setWindowTitle(QString("%1").arg(rf.find("title").asString().data())); } // position if (rf.find("x").isInt32() && rf.find("y").isInt32()) { emit setWindowPosition(rf.find("x").asInt32(), rf.find("y").asInt32()); } // size if (rf.find("dx").isInt32() && rf.find("dy").isInt32()) { emit setWindowSize(rf.find("dx").asInt32(), rf.find("dy").asInt32()); } // interval if (rf.find("interval").isInt32()) { interval = rf.find("interval").asInt32(); }else{ interval = 50; } //******************************************* bool ok; if (rf.check("xml")) { // XML Mode Options const std::string &filename = rf.findFile("xml"); QString f = QString("%1").arg(filename.data()); loader = new XmlLoader(f,plotManager,this); qDebug("Loading file %s",filename.c_str()); } else { // Command Line Mode Options qDebug("Loading from command line"); loader = new SimpleLoader(&rf,plotManager, &ok,this); if (!ok) { usage(); exit(1); } } plotManager->setInterval(interval); emit intervalLoaded(interval); updateCustomPlotSize(); return true; }
int NativeWindow::initialize(bool _createFullWindow) { int returnCode; int numberModes; screen_display_mode_t* screenModes; int type; if (_createFullWindow) { returnCode = screen_create_window(&_screenWindow, _screenContext); qDebug() << "NativeWindow::initialize: _screenWindow (full window): " << ":" << _screenWindow << ":" << _screenContext << ":" << returnCode; if (returnCode) { perror("screen_create_window"); return EXIT_FAILURE; } } else { returnCode = screen_create_window_type(&_screenWindow, _screenContext, SCREEN_CHILD_WINDOW); qDebug() << "NativeWindow::initialize: _screenWindow (child window): " << _screenWindow << ":" << returnCode; if (returnCode) { perror("screen_create_window (child window)"); return EXIT_FAILURE; } } _displaysMutex.lock(); if (_screenDisplays) { free (_screenDisplays); } // try this first as it will fail if an HDMI display is not attached screen_get_context_property_iv(_screenContext, SCREEN_PROPERTY_DISPLAY_COUNT, &_numberDisplays); _screenDisplays = (screen_display_t *)calloc(_numberDisplays, sizeof(screen_display_t)); screen_get_context_property_pv(_screenContext, SCREEN_PROPERTY_DISPLAYS, (void **)_screenDisplays); for (int index = 0; index < _numberDisplays; index++) { int displayID; returnCode = screen_get_display_property_iv(_screenDisplays[index], SCREEN_PROPERTY_ID, (int *)&displayID); qDebug() << "NativeWindow::initialize: display: " << ":" << index << ":" << displayID << ":" << _display << ":" << _screenDisplays[index]; if (returnCode) { perror("display ID"); return EXIT_FAILURE; } else { if (displayID == _display) { screen_get_display_property_iv(_screenDisplays[index], SCREEN_PROPERTY_TYPE, &type); if (type == SCREEN_DISPLAY_TYPE_HDMI) { returnCode = screen_set_window_property_pv(_screenWindow, SCREEN_PROPERTY_DISPLAY, (void **)&(_screenDisplays[index])); if (returnCode) { perror("window display"); return EXIT_FAILURE; } } } } } _displaysMutex.unlock(); qDebug() << "NativeWindow::initialize: "<< _screenContext << ":" << _screenWindow; returnCode = setWindowFormat(_format); if (returnCode) { perror("screen_set_window_property_iv(SCREEN_PROPERTY_FORMAT)"); return EXIT_FAILURE; } returnCode = setWindowTransparency(_transparency); if (returnCode) { perror("transparency"); return EXIT_FAILURE; } returnCode = screen_get_window_property_pv(_screenWindow, SCREEN_PROPERTY_DISPLAY, (void **)&_screenDisplay); if (returnCode) { perror("screenDisplay"); return EXIT_FAILURE; } int angle = atoi(getenv("ORIENTATION")); screen_get_display_property_iv(_screenDisplay, SCREEN_PROPERTY_MODE_COUNT, &numberModes); screenModes = (screen_display_mode_t *)calloc(numberModes, sizeof(screen_display_mode_t)); returnCode = screen_get_display_property_pv(_screenDisplay, SCREEN_PROPERTY_MODE, (void**)screenModes); if (returnCode) { perror("screen modes"); return EXIT_FAILURE; } int dpi = calculateDPI(); if (dpi == EXIT_FAILURE) { fprintf(stderr, "Unable to calculate dpi\n"); return EXIT_FAILURE; } returnCode = setWindowPosition(_x, _y); if (returnCode) { perror("window position"); return EXIT_FAILURE; } returnCode = setWindowSize(_width, _height); if (returnCode) { perror("window size"); return EXIT_FAILURE; } returnCode = setWindowZ(_z); if (returnCode) { perror("z order"); return EXIT_FAILURE; } if (_sourceWidth > 0) { returnCode = setWindowSourcePosition(_sourceX, _sourceY); if (returnCode) { perror("source size"); return EXIT_FAILURE; } returnCode = setWindowSourceSize(_sourceWidth, _sourceHeight); if (returnCode) { perror("source size"); return EXIT_FAILURE; } } if (_bufferWidth > 0) { returnCode = setWindowBufferSize(_bufferWidth, _bufferHeight); if (returnCode) { perror("buffer size"); return EXIT_FAILURE; } } returnCode = setWindowAngle(_angle); if (returnCode) { perror("angle"); return EXIT_FAILURE; } returnCode = screen_create_window_buffers(_screenWindow, _nbuffers); if (returnCode) { perror("screen_create_window_buffers"); return EXIT_FAILURE; } _usage = Graphics::getNativeWindowUsage(); // enable this in case we need any native API access to this window _usage |= SCREEN_USAGE_NATIVE; returnCode = setWindowUsage(_usage); if (returnCode) { perror("screen_set_window_property_iv(window usage)"); return EXIT_FAILURE; } returnCode = joinWindowGroup(_group); if (returnCode) { perror("window group"); return EXIT_FAILURE; } returnCode = setScreenWindowID(_id); if (returnCode) { perror("window ID"); return EXIT_FAILURE; } qDebug() << "NativeWindow::initialize: "<< angle << ":" << numberModes << ":" << screenModes[0].width << ":" << screenModes[0].height << ":" << dpi; if (screenModes != NULL) { free(screenModes); } return EXIT_SUCCESS; }