unsigned Screen::width() const { if (!m_frame) return 0; FrameHost* host = m_frame->host(); if (host && host->settings().reportScreenSizeInPhysicalPixelsQuirk()) return lroundf(screenRect(m_frame->view()).width() * host->deviceScaleFactor()); return static_cast<unsigned>(screenRect(m_frame->view()).width()); }
QVNCIntegration::QVNCIntegration(const QStringList& paramList) : virtualDesktop(false), fontDb(new QGenericUnixFontDatabase()) { int sizeX = defaultWidth(); int sizeY = defaultHeight(); int offsetX = 0; int offsetY = 0; int display = defaultDisplay(); bool showUsage = false; foreach(QString confString, paramList) { if (confString.startsWith(QLatin1String("size="))) { QString val = confString.section(QLatin1Char('='), 1, 1); sizeX = val.section(QLatin1Char('x'), 0, 0).toInt(); sizeY = val.section(QLatin1Char('x'), 1, 1).toInt(); } else if (confString.startsWith(QLatin1String("display="))) { display = confString.section(QLatin1Char('='), 1, 1).toInt(); } else if (confString.startsWith(QLatin1String("offset="))) { QString val = confString.section(QLatin1Char('='), 1, 1); offsetX = val.section(QLatin1Char('x'), 0, 0).toInt(); offsetY = val.section(QLatin1Char('x'), 1, 1).toInt(); } else if (confString == QLatin1String("vnc")) { QRect screenRect(offsetX, offsetY, sizeX, sizeY); QVNCScreen *screen = new QVNCScreen(screenRect, display); mScreens.append(screen); screen->setObjectName(QString("screen %1").arg(display)); screen->setDirty(screenRect); ++display; } else if (confString == QLatin1String("virtual")) { virtualDesktop = true; } else { qWarning() << "Unknown VNC option:" << confString; showUsage = true; } } if (showUsage) usage(); QRect screenRect(offsetX, offsetY, sizeX, sizeY); QVNCScreen *screen = new QVNCScreen(screenRect, display); mScreens.append(screen); mPrimaryScreen = qobject_cast<QVNCScreen *>(mScreens.first()); screen->setObjectName(QString("screen %1").arg(display)); screen->setDirty(screenRect); }
void qtauMeterBar::paintEvent(QPaintEvent *event) { // draw bg int hSt = event->rect().x() + _offset; int barWidth = _ns.note.width() * _ns.notesInBar; int firstBar = hSt / barWidth; int cacheOffset = hSt - firstBar * barWidth; QRect screenRect(event->rect()); QRect cacheRect(screenRect); cacheRect.moveLeft(cacheRect.x() + cacheOffset); QPainter p(this); p.drawPixmap(screenRect, *_bgCache, cacheRect); // draw bar numbers if (cacheOffset != 0) firstBar++; // now it's first visible bar line int lastBar = (hSt + event->rect().width()) / barWidth; QVector<QPainter::PixmapFragment> cachedLabels; int barScreenOffset = firstBar * barWidth - _offset; for (int i = firstBar; i <= lastBar; ++i, barScreenOffset += barWidth) cachedLabels.append(QPainter::PixmapFragment::create( QPointF(barScreenOffset + c_lblcache_hoff, c_lblcache_voff), QRectF(0, i * c_lblcache_line_height, c_lblcache_line_width, c_lblcache_line_height))); if (!cachedLabels.isEmpty()) p.drawPixmapFragments(cachedLabels.data(), cachedLabels.size(), *_labelCache); }
Space::Space (sf::RenderWindow &window) : window (window) , view (window.getDefaultView()) , screenRect () , spaceBounds (0.f, 0.f, view.getSize().x, view.getSize().y) , shape () // testing { // load textures // init scene // build scene // Set view based on window size view.setCenter (sf::Vector2f (window.getSize().x/2, window.getSize().y/2)); view.setSize (sf::Vector2f (window.getSize().x, window.getSize().y)); view.setViewport (sf::FloatRect (0.f, 0.f, 1.f, 1.f)); // One view for entire window sf::FloatRect screenRect (sf::Vector2f (view.getCenter().x - (view.getSize().x)/2, view.getCenter().y - (view.getSize().y)/2) , view.getSize()); //window.setView (view); // ScreenRect Tests // std::cout << screenRect.top << std::endl; // std::cout << screenRect.left << std::endl; // std::cout << screenRect.height << std::endl; // std::cout << screenRect.width << std::endl; // shape.setFillColor (sf::Color::Blue); // shape.setPosition (sf::Vector2f (100, 100)); // shape.setSize (sf::Vector2f (100, 100)); } // Space:Space
void FWRenderer::drawTransparentBox(int x, int y, int width, int height) { // Handle horizontally flipped boxes if (width < 0) { width = ABS(width); x -= width; } // Handle vertically flipped boxes if (height < 0) { height = ABS(height); y -= height; } // Clip the rectangle to screen dimensions Common::Rect boxRect(x, y, x + width, y + height); Common::Rect screenRect(320, 200); boxRect.clip(screenRect); byte *dest = _backBuffer + boxRect.top * 320 + boxRect.left; const int lineAdd = 320 - boxRect.width(); for (int i = 0; i < boxRect.height(); ++i) { for (int j = 0; j < boxRect.width(); ++j, ++dest) { if (*dest < 16) *dest += 16; } dest += lineAdd; } }
unsigned Screen::width() const { if (!m_frame) return 0; long width = static_cast<long>(screenRect(m_frame->view()).width()); return static_cast<unsigned>(width); }
void Graphics::resizeScreen(int width, int height) { width = clamp(width, 1, 640); height = clamp(height, 1, 480); Vec2i size(width, height); if (p->scRes == size) return; p->scRes = size; p->screen.setResolution(width, height); TEX::bind(p->frozenScene.tex); TEX::allocEmpty(width, height); TEX::bind(p->currentScene.tex); TEX::allocEmpty(width, height); FloatRect screenRect(0, 0, width, height); p->screenQuad.setTexPosRect(screenRect, screenRect); TEX::bind(p->transBuffer.tex); TEX::allocEmpty(width, height); shState->eThread().requestWindowResize(width, height); }
unsigned Screen::height() const { if (!m_frame) return 0; long height = static_cast<long>(screenRect(m_frame->view()).height()); return static_cast<unsigned>(height); }
// Compute the screen orientation using the orientation angle and the screen width / height. WebScreenOrientationType ScreenOrientationController::computeOrientation(FrameView* view) { // Bypass orientation detection in layout tests to get consistent results. // FIXME: The screen dimension should be fixed when running the layout tests to avoid such // issues. if (LayoutTestSupport::isRunningLayoutTest()) return WebScreenOrientationPortraitPrimary; FloatRect rect = screenRect(view); uint16_t rotation = screenOrientationAngle(view); bool isTallDisplay = rotation % 180 ? rect.height() < rect.width() : rect.height() > rect.width(); switch (rotation) { case 0: return isTallDisplay ? WebScreenOrientationPortraitPrimary : WebScreenOrientationLandscapePrimary; case 90: return isTallDisplay ? WebScreenOrientationLandscapePrimary : WebScreenOrientationPortraitSecondary; case 180: return isTallDisplay ? WebScreenOrientationPortraitSecondary : WebScreenOrientationLandscapeSecondary; case 270: return isTallDisplay ? WebScreenOrientationLandscapeSecondary : WebScreenOrientationPortraitPrimary; default: ASSERT_NOT_REACHED(); return WebScreenOrientationPortraitPrimary; } }
void LightSystem::debugRender(const sf::View& screenView, sf::RenderTarget& target, int flags) { sf::IntRect screen = DMUtils::sfml::getViewInWorldAABB(screenView); _sprite.setPosition(screen.left,screen.top); _renderTexture.clear(_ambiant); sf::RenderStates stAdd(_addState); sf::RenderStates stRm(_subtractState); sf::RenderStates stMp(_multiplyState); sf::Transform t; t.translate(-_sprite.getPosition()); stAdd.transform.combine(t); stRm.transform.combine(t); stMp.transform.combine(t); sf::FloatRect screenRect(screen); for(Light* l : _lights) { if(l->getAABB().intersects(screen)) { if(flags & DebugFlags::SHADER_OFF) l->debugRender(_renderTexture,stAdd); else { _buffer.clear(sf::Color::Black); //sf::FloatRect rect(l->getAABB().left,l->getAABB().top,l->getAABB().width,l->getAABB().height); l->calcShadow(_shadowSystem->getWalls()); //l->render(screen,_renderTexture,&_lightAttenuationShader,stAdd); l->render(screen,_buffer,&_lightAttenuationShader,stMp); _buffer.display(); _renderTexture.draw(_bufferSprite,_addState); } } } for(Light* l : _negativeLights) { if(l->getAABB().intersects(screen)) { if(flags & DebugFlags::SHADER_OFF) l->debugRender(_renderTexture,stRm); else { _buffer.clear(sf::Color::Black); //sf::FloatRect rect(l->getAABB().left,l->getAABB().top,l->getAABB().width,l->getAABB().height); l->calcShadow(_shadowSystem->getWalls()); //l->render(screen,_renderTexture,&_lightAttenuationShader,stAdd); l->render(screen,_buffer,&_lightAttenuationShader,stMp); _buffer.display(); _renderTexture.draw(_bufferSprite,_subtractState); } } } _renderTexture.display(); _updateLightMapImage = true; if(flags & DebugFlags::LIGHTMAP_ONLY) target.clear(sf::Color::White); }
unsigned Screen::height() const { if (!m_frame) return 0; long height = static_cast<long>(screenRect(m_frame->view()).height()); InspectorInstrumentation::applyScreenHeightOverride(m_frame, &height); return static_cast<unsigned>(height); }
int MediaValues::calculateDeviceWidth(LocalFrame* frame) const { ASSERT(frame && frame->view() && frame->settings() && frame->host()); int deviceWidth = static_cast<int>(screenRect(frame->view()).width()); if (frame->settings()->reportScreenSizeInPhysicalPixelsQuirk()) deviceWidth = lroundf(deviceWidth * frame->host()->deviceScaleFactor()); return deviceWidth; }
static int calculateDeviceHeight(LocalFrame* frame) { ASSERT(frame && frame->view() && frame->settings() && frame->host()); int deviceHeight = static_cast<int>(screenRect(frame->view()).height()); if (frame->settings()->reportScreenSizeInPhysicalPixelsQuirk()) deviceHeight = lroundf(deviceHeight * frame->host()->deviceScaleFactor()); return deviceHeight; }
unsigned Screen::width() const { if (!m_frame) return 0; long width = static_cast<long>(screenRect(m_frame->view()).width()); InspectorInstrumentation::applyScreenWidthOverride(m_frame, &width); return static_cast<unsigned>(width); }
void CutsceneState::updateSize(sf::RenderWindow& window) { sf::View view = window.getView(); sf::Vector2f center = view.getCenter(); sf::Vector2f size = view.getSize(); sf::FloatRect screenRect(center.x - size.x/2, center.y - size.y/2, size.x, size.y); video.resizeToFrame(static_cast<sf::IntRect>(screenRect), true); }
unsigned Screen::height() const { if (!m_frame) return 0; #ifdef LOG_MODS_FP logFPCalls(m_frame, "Screen::height"); #endif return static_cast<unsigned>(screenRect(m_frame->view()).height()); }
void KDialog::centerOnScreen( QWidget *w, int screen ) { if ( !w ) return; QRect r = screenRect( w, screen ); w->move( r.center().x() - w->width()/2, r.center().y() - w->height()/2 ); }
GraphicsPrivate(RGSSThreadData *rtData) : scRes(DEF_SCREEN_W, DEF_SCREEN_H), scSize(scRes), winSize(rtData->config.defScreenW, rtData->config.defScreenH), screen(scRes.x, scRes.y), threadData(rtData), glCtx(SDL_GL_GetCurrentContext()), frameRate(DEF_FRAMERATE), frameCount(0), brightness(255), fpsLimiter(frameRate), frozen(false) { recalculateScreenSize(rtData); updateScreenResoRatio(rtData); TEXFBO::init(frozenScene); TEXFBO::allocEmpty(frozenScene, scRes.x, scRes.y); TEXFBO::linkFBO(frozenScene); TEXFBO::init(currentScene); TEXFBO::allocEmpty(currentScene, scRes.x, scRes.y); TEXFBO::linkFBO(currentScene); FloatRect screenRect(0, 0, scRes.x, scRes.y); screenQuad.setTexPosRect(screenRect, screenRect); TEXFBO::init(transBuffer); TEXFBO::allocEmpty(transBuffer, scRes.x, scRes.y); TEXFBO::linkFBO(transBuffer); fpsLimiter.resetFrameAdjust(); const std::string &olImage = rtData->config.touchOverlay.image; if (!olImage.empty()) { SDL_RWops *ops = SDL_RWFromFile(olImage.c_str(), "rb"); SDL_Surface *surf = IMG_Load_RW(ops, 1); if (surf) { overlayTex = TEX::gen(); TEX::bind(overlayTex); TEX::setRepeat(false); TEX::setSmooth(true); TEX::uploadImage(surf->w, surf->h, surf->pixels, GL_RGBA); overlayTexSize = Vec2i(surf->w, surf->h); } else { Debug() << "failed to load overlay image:" << SDL_GetError(); } } }
FloatRect screenAvailableRect(Widget* widget) { if (!widget) return FloatRect(); #if PLATFORM(X11) GtkWidget* container = GTK_WIDGET(widget->root()->hostWindow()->platformPageClient()); if (!container) return FloatRect(); if (!gtk_widget_get_realized(container)) return screenRect(widget); GdkDrawable* rootWindow = GDK_DRAWABLE(gtk_widget_get_root_window(container)); GdkDisplay* display = gdk_drawable_get_display(rootWindow); Atom xproperty = gdk_x11_get_xatom_by_name_for_display(display, "_NET_WORKAREA"); Atom retType; int retFormat; long *workAreaPos = NULL; unsigned long retNItems; unsigned long retAfter; int xRes = XGetWindowProperty(GDK_DISPLAY_XDISPLAY(display), GDK_WINDOW_XWINDOW(rootWindow), xproperty, 0, 4, FALSE, XA_CARDINAL, &retType, &retFormat, &retNItems, &retAfter, (guchar**)&workAreaPos); FloatRect rect; if (xRes == Success && workAreaPos != NULL && retType == XA_CARDINAL && retNItems == 4 && retFormat == 32) { rect = FloatRect(workAreaPos[0], workAreaPos[1], workAreaPos[2], workAreaPos[3]); // rect contains the available space in the whole screen not just in the monitor // containing the widget, so we intersect it with the monitor rectangle. rect.intersect(screenRect(widget)); } else rect = screenRect(widget); if (workAreaPos) XFree(workAreaPos); return rect; #else return screenRect(widget); #endif }
IntRect ChromeClientImpl::rootViewToScreen(const IntRect& rect) const { IntRect screenRect(rect); if (m_webView->client()) { WebRect windowRect = m_webView->client()->windowRect(); screenRect.move(windowRect.x, windowRect.y); } return screenRect; }
void SpriteCardItem::init(Container* parent, rapidxml::xml_node<>* xml_item) { MapItem::init(parent, xml_item); rapidxml::xml_node<>* xml_info = xml_item->first_node("info"); IPoint offset(xml_info); Render::Texture *texture = Core::resourceManager.Get<Render::Texture>(Xml::GetStringAttribute(xml_info, "id")); rapidxml::xml_node<>* xml_rect = xml_info->first_node("rect"); IRect screenRect(offset + IPoint(xml_rect), Xml::GetIntAttribute(xml_rect, "w"), Xml::GetIntAttribute(xml_rect, "h")); part = PartSheet(texture, screenRect, FRect(0.f, 1.f, 0.f, 1.f)); }
bool GLWindow::isRectangleVisible(double x, double y, double w, double h) { // get four corners in object space double xObj[4][3]; xObj[0][0] = x; xObj[0][1] = y; xObj[0][2] = 0.; xObj[1][0] = x+w; xObj[1][1] = y; xObj[1][2] = 0.; xObj[2][0] = x+w; xObj[2][1] = y+h; xObj[2][2] = 0.; xObj[3][0] = x; xObj[3][1] = y+h; xObj[3][2] = 0.; // get four corners in screen space GLdouble modelview[16]; glGetDoublev(GL_MODELVIEW_MATRIX, modelview); GLdouble projection[16]; glGetDoublev(GL_PROJECTION_MATRIX, projection); GLint viewport[4]; glGetIntegerv(GL_VIEWPORT, viewport); GLdouble xWin[4][3]; for(int i=0; i<4; i++) { gluProject(xObj[i][0], xObj[i][1], xObj[i][2], modelview, projection, viewport, &xWin[i][0], &xWin[i][1], &xWin[i][2]); } // screen rectangle QRectF screenRect(0.,0., (double)g_mainWindow->getGLWindow()->width(), (double)g_mainWindow->getGLWindow()->height()); // the given rectangle QRectF rect(xWin[0][0], xWin[0][1], xWin[2][0]-xWin[0][0], xWin[2][1]-xWin[0][1]); if(screenRect.intersects(rect) == true) { return true; } else { return false; } }
IntRect ChromeClientImpl::viewportToScreen(const IntRect& rectInViewport) const { WebRect screenRect(rectInViewport); if (m_webView->client()) { m_webView->client()->convertViewportToWindow(&screenRect); WebRect windowRect = m_webView->client()->windowRect(); screenRect.x += windowRect.x; screenRect.y += windowRect.y; } return screenRect; }
bool KDialog::avoidArea( QWidget *w, const QRect& area, int screen ) { if ( !w ) return false; QRect fg = w->frameGeometry(); if ( !fg.intersects( area ) ) return true; // nothing to do. QRect scr = screenRect( w, screen ); QRect avoid( area ); // let's add some margin avoid.moveBy( -5, -5 ); avoid.rRight() += 10; avoid.rBottom() += 10; if ( QMAX( fg.top(), avoid.top() ) <= QMIN( fg.bottom(), avoid.bottom() ) ) { // We need to move the widget up or down int spaceAbove = QMAX(0, avoid.top() - scr.top()); int spaceBelow = QMAX(0, scr.bottom() - avoid.bottom()); if ( spaceAbove > spaceBelow ) // where's the biggest side? if ( fg.height() <= spaceAbove ) // big enough? fg.setY( avoid.top() - fg.height() ); else return false; else if ( fg.height() <= spaceBelow ) // big enough? fg.setY( avoid.bottom() ); else return false; } if ( QMAX( fg.left(), avoid.left() ) <= QMIN( fg.right(), avoid.right() ) ) { // We need to move the widget left or right int spaceLeft = QMAX(0, avoid.left() - scr.left()); int spaceRight = QMAX(0, scr.right() - avoid.right()); if ( spaceLeft > spaceRight ) // where's the biggest side? if ( fg.width() <= spaceLeft ) // big enough? fg.setX( avoid.left() - fg.width() ); else return false; else if ( fg.width() <= spaceRight ) // big enough? fg.setX( avoid.right() ); else return false; } //kdDebug() << "Moving window to " << fg.x() << "," << fg.y() << endl; w->move(fg.x(), fg.y()); return true; }
/** * _cairo_beos_view_to_bitmap: * @bitmap: [out] The resulting bitmap. * @rect: [out] The rectangle that was copied, in the view's coordinate system * @interestRect: If non-null, only this part of the view will be copied (view's coord system). * * Gets the contents of the view as a BBitmap*. Caller must delete the bitmap. **/ static ViewCopyStatus _cairo_beos_view_to_bitmap (BView* view, BBitmap** bitmap, BRect* rect = NULL, const BRect* interestRect = NULL) { *bitmap = NULL; BWindow* wnd = view->Window(); // If we have no window, can't do anything if (!wnd) return NOT_VISIBLE; view->Sync(); wnd->Sync(); #if 0 // Is it a direct window? BDirectWindow* directWnd = dynamic_cast<BDirectWindow*>(wnd); if (directWnd) { // WRITEME } #endif // Is it visible? If so, we can copy the content off the screen if (wnd->IsHidden()) return NOT_VISIBLE; BRect rectToCopy(view->Bounds()); if (interestRect) rectToCopy = rectToCopy & *interestRect; if (!rectToCopy.IsValid()) return NOT_VISIBLE; BScreen screen(wnd); BRect screenRect(view->ConvertToScreen(rectToCopy)); screenRect = screenRect & screen.Frame(); if (!screen.IsValid()) return NOT_VISIBLE; if (rect) *rect = view->ConvertFromScreen(screenRect); if (screen.GetBitmap(bitmap, false, &screenRect) == B_OK) return OK; return ERROR; }
IntRect ChromeClientQt::rootViewToScreen(const IntRect& rect) const { QWebPageClient* pageClient = platformPageClient(); if (!pageClient) return rect; QWidget* ownerWidget = pageClient->ownerWidget(); if (!ownerWidget) return rect; QRect screenRect(rect); screenRect.translate(ownerWidget->mapToGlobal(QPoint(0, 0))); return screenRect; }
void ofApp::initSound(string path) { killSound(); bool bLoaded = soundPlayer.load(path); if(bLoaded == false) { return; } sessionDir = ofGetTimestampString("%Y%m%d%H%M%S"); bool bCreatedDir = ofDirectory::createDirectory(sessionDir); if(bCreatedDir == false) { return; } ofFile file(path); soundBaseName = file.getBaseName(); soundFileName = file.getFileName(); file.copyTo(sessionDir + "/" + soundFileName); fft.startFrameSync(&soundPlayer, numOfSoundFramesPerSecond); int numOfSoundPixelsTotal = numOfPixelsPerSoundFrame * fft.frameSyncTotal; int soundImageSize = sqrt(numOfSoundPixelsTotal); soundImageSize = ofNextPow2(soundImageSize); soundImage.allocate(soundImageSize, soundImageSize, OF_IMAGE_GRAYSCALE); soundImage.setColor(ofColor(0, 255)); soundImage.update(); ofRectangle screenRect(0, 0, ofGetWidth(), ofGetHeight()); ofRectangle soundImageRect(0, 0, soundImageSize, soundImageSize); soundImageRect.scaleTo(screenRect, OF_ASPECT_RATIO_KEEP); soundImageRect.x = (int)soundImageRect.x; soundImageRect.y = (int)soundImageRect.y; soundImageRect.width = (int)soundImageRect.width; soundImageRect.height = (int)soundImageRect.height; float soundImageScale = soundImageRect.width / (float)soundImageSize; soundImageMat.makeIdentityMatrix(); soundImageMat.preMultTranslate(ofVec3f(soundImageRect.x, soundImageRect.y)); soundImageMat.preMultScale(ofVec3f(soundImageScale, soundImageScale, 1)); ofSetFrameRate(10000); ofSetVerticalSync(false); }
void ThingType::draw(const Point& dest, float scaleFactor, int layer, int xPattern, int yPattern, int zPattern, int animationPhase, LightView *lightView) { if(m_null) return; if(animationPhase >= m_animationPhases) return; const TexturePtr& texture = getTexture(animationPhase); // texture might not exists, neither its rects. if(!texture) return; uint frameIndex = getTextureIndex(layer, xPattern, yPattern, zPattern); if(frameIndex >= m_texturesFramesRects[animationPhase].size()) return; Point textureOffset; Rect textureRect; if(scaleFactor != 1.0f) { textureRect = m_texturesFramesOriginRects[animationPhase][frameIndex]; } else { textureOffset = m_texturesFramesOffsets[animationPhase][frameIndex]; textureRect = m_texturesFramesRects[animationPhase][frameIndex]; } Rect screenRect(dest + (textureOffset - m_displacement - (m_size.toPoint() - Point(1, 1)) * 32) * scaleFactor, textureRect.size() * scaleFactor); bool useOpacity = m_opacity < 1.0f; if(useOpacity) g_painter->setColor(Color(1.0f,1.0f,1.0f,m_opacity)); g_painter->drawTexturedRect(screenRect, texture, textureRect); if(useOpacity) g_painter->setColor(Color::white); if(lightView && hasLight()) { Light light = getLight(); if(light.intensity > 0) lightView->addLightSource(screenRect.center(), scaleFactor, light); } }
QPoint YaChatToolTipPosition::calculateTipPosition(const QWidget* _label, const QSize& size) const { Q_UNUSED(size); const YaChatTipLabel* label = dynamic_cast<const YaChatTipLabel*>(_label); QRect screen = screenRect(); QPoint p = globalRect.topLeft(); if (p.x() + label->width() > screen.x() + screen.width()) p.rx() = screen.right() - label->width(); if (p.x() < screen.x()) p.rx() = screen.x(); if (p.y() + label->height() > screen.y() + screen.height()) p.ry() = screen.bottom() - label->height(); if (p.y() < screen.y()) p.ry() = screen.y(); return p; }
FloatRect screenAvailableRect(Widget* widget) { GtkWidget* container = widget ? GTK_WIDGET(widget->root()->hostWindow()->platformPageClient()) : 0; if (container && !gtk_widget_get_realized(container)) return screenRect(widget); GdkScreen* screen = container ? getScreen(container) : gdk_screen_get_default(); if (!screen) return FloatRect(); gint monitor = container ? gdk_screen_get_monitor_at_window(screen, gtk_widget_get_window(container)) : 0; GdkRectangle workArea; gdk_screen_get_monitor_workarea(screen, monitor, &workArea); return FloatRect(workArea.x, workArea.y, workArea.width, workArea.height); }