// Called whenever the in-browser window changes size. virtual void DidChangeView(const pp::Rect& position, const pp::Rect& clip) { if (position.size().width() == width && position.size().height() == height) return; // Size didn't change, no need to update anything. if (opengl_context_ == NULL) { opengl_context_.reset(new OpenGLContext(this)); }; opengl_context_->InvalidateContext(this); opengl_context_->ResizeContext(position.size()); if (!opengl_context_->MakeContextCurrent(this)) return; width = position.size().width(); height = position.size().height(); // init gl here? OS::VideoMode vm; vm.width = width; vm.height = height; vm.resizable = false; vm.fullscreen = true; OS::get_singleton()->set_video_mode(vm, 0); DrawSelf(); };
void GuiElement::Draw() { DrawSelf(); for (ChildList::iterator it = children.begin(); it != children.end(); ++it) { (*it)->Draw(); } }
void LGAMiniArrowPopup::DeactivateSelf () { if ( FocusDraw ()) DrawSelf (); } // LGAMiniArrowPopup::DeactivateSelf
/** Draw this UI element. In practice this means recursively drawing all its child items too.*/ void CGUIbase::Draw() { if (!visible) return; if (needsUpdate) updateAppearance(); UIrect* parentClipbox = &parent->Clipbox; pDrawFuncs->setClip(Clipbox); DrawSelf(); //then draw each subcontrol for (size_t i=0;i<Control.size();i++) Control[i]->Draw(); }
void AwtMenuItem::DrawItem(DRAWITEMSTRUCT& drawInfo) { DASSERT(drawInfo.CtlType == ODT_MENU); if (drawInfo.itemID != m_Id) return; /* Fixed bug 4349969. Since the problem occurs on Windows 98 and not on Windows NT, the fix is to check for Windows 95/98 and to check if the handle to the menu of the item to be drawn is the same as the handle to the menu of the menu object. If they're not the same, just return and don't do the drawing. */ if ( IS_WIN95 && drawInfo.hwndItem != (HWND)this->m_menuContainer->GetHMenu()) { return; } else DrawSelf(drawInfo); }
void CUIContainer::Draw( CGraphics* pGraphic ) { DrawSelf(pGraphic); CBound clip = pGraphic->GetClipBound(); for (unsigned int i = mChilds.size(); i ; i--) { if(mChilds[i-1]->Visible()) { CBound bdchild = mChilds[i-1]->Bound(); Absolute(bdchild); if(CBound::Intersect(clip,bdchild,bdchild)) { pGraphic->SetClipBound(bdchild); mChilds[i-1]->Draw(pGraphic); } } } pGraphic->SetClipBound(clip); }
void MythUIType::Draw(MythPainter *p, int xoffset, int yoffset, int alphaMod, QRect clipRect) { m_DirtyRegion = QRegion(QRect(0, 0, 0, 0)); if (!m_Visible || m_Vanished) return; QRect realArea = m_Area.toQRect(); realArea.translate(xoffset, yoffset); if (!realArea.intersects(clipRect)) return; DrawSelf(p, xoffset, yoffset, alphaMod, clipRect); QList<MythUIType *>::Iterator it; for (it = m_ChildrenList.begin(); it != m_ChildrenList.end(); ++it) { (*it)->Draw(p, xoffset + m_Area.x(), yoffset + m_Area.y(), CalcAlpha(alphaMod), clipRect); } if (p->ShowBorders()) { static const QBrush nullbrush(Qt::NoBrush); p->DrawRect(realArea, nullbrush, QPen(m_BorderColor), 255); if (p->ShowTypeNames()) { MythFontProperties font; font.SetFace(QFont("Droid Sans")); font.SetColor(m_BorderColor); font.SetPointSize(8); p->DrawText(realArea, objectName(), 0, font, 255, realArea); } } }
void MythUIType::Draw(MythPainter *p, int xoffset, int yoffset, int alphaMod, QRect clipRect) { m_DirtyRegion = QRegion(QRect(0,0,0,0)); if (!m_Visible) return; QRect realArea = m_Area.toQRect(); realArea.translate(xoffset, yoffset); if (!realArea.intersects(clipRect)) return; DrawSelf(p, xoffset, yoffset, alphaMod, clipRect); QList<MythUIType *>::Iterator it; for (it = m_ChildrenList.begin(); it != m_ChildrenList.end(); ++it) { (*it)->Draw(p, xoffset + m_Area.x(), yoffset + m_Area.y(), CalcAlpha(alphaMod), clipRect); } }
void RSSourceStatusButton::StatusBlink() { // Validate pointers. ValidateThis_(); // Force redraw first. Draw(nil); // Now blink the framerect three times. Rect frame; CalcLocalFrameRect(frame); ::InsetRect(&frame, 1, 1); #if PP_Target_Carbon SInt16 menuFlash = 3 << 1; #else SInt16 menuFlash = LMGetMenuFlash() << 1; //* 2.2d9: BUG FIX #592: flash to match menu blink #endif if (menuFlash < 2) menuFlash = 2; for (SInt16 i = 0; i < menuFlash; i++) { UInt32 junk; ::InvertRect(&frame); ::Delay(3, &junk); } // Make sure it looks right again. DrawSelf(); }
void CHudTexture::DrawSelf(int x, int y, const Color& clr) const { DrawSelf(x, y, Width(), Height(), clr); }
//+--------------------------------------------------------------------------- // // Member: CDispRoot::DrawRoot // // Synopsis: Draw this display tree. // // Arguments: pContext draw context // pClientData client data used by clients in DrawClient // hrgnDraw region to draw in destination coordinates // prcDraw rect to draw in destination coordinates // // Notes: if hrgnDraw and prcDraw are both NULL, the bounding rect of // this root node is used // //---------------------------------------------------------------------------- void CDispRoot::DrawRoot( CDispDrawContext* pContext, void* pClientData, HRGN hrgnDraw, const RECT* prcDraw) { // BUGBUG (donmarsh) - for now we must use this root's own context, due // to the context stack used for drawing. Eventually, we should eliminate // the context pointer argument to DrawRoot. Assert(pContext == &_drawContext); AssertSz(!_fDrawLock, "Illegal call to DrawRoot inside Draw()"); AssertSz(_cOpen==0, "DrawRoot called while Display Tree is open"); Assert(_pRenderSurface != NULL); Assert(!IsSet(CDispFlags::s_interiorFlagsNotSetInDraw)); // set redraw region (will become a rect if possible) CRegion rgnRedraw; if(hrgnDraw != NULL) { rgnRedraw = hrgnDraw; } else if(prcDraw != NULL) { rgnRedraw = *prcDraw; } else { rgnRedraw = _rcContainer; } // check for early exit conditions if(!rgnRedraw.Intersects(_rcContainer)) { return; } // set initial context values pContext->SetClientData(pClientData); pContext->SetNoClip(); pContext->_offset = _rcContainer.TopLeft().AsSize(); pContext->_pFirstDrawNode = NULL; pContext->SetRedrawRegion(&rgnRedraw); // BUGBUG (donmarsh) -- this is a little ugly, but our the _rcVisBounds // for CDispRoot must be zero-based, because it is transformed by the // offset in CDispNode::Draw, and if _rcVisBounds == _rcContainer like // one would expect, _rcVisBounds gets transformed twice. _rcVisBounds.MoveToOrigin(); if(_pFirstChildNode == NULL) { pContext->SetDispSurface(_pRenderSurface); _pRenderSurface->SetBandOffset(_afxGlobalData._Zero.size); CRect rcClip; rgnRedraw.GetBounds(&rcClip); CRegion rgnClip(rcClip); _pRenderSurface->SetClipRgn(&rgnClip); DrawSelf(pContext, NULL); _pRenderSurface->SetClipRgn(NULL); ::SelectClipRgn(_pRenderSurface->GetRawDC(), NULL); goto Cleanup; } // DrawRoot does not allow recursion _fDrawLock = TRUE; // speed optimization: draw border and scroll bars for first node // without buffering or banding, then subtract them from the redraw // region. if(_pFirstChildNode==_pLastChildNode && _pFirstChildNode->IsContainer() && _pFirstChildNode->IsVisible()) { CDispContainer* pContainer = DYNCAST(CDispContainer, _pFirstChildNode); pContext->SetDispSurface(_pRenderSurface); _pRenderSurface->SetBandOffset(_afxGlobalData._Zero.size); CRect rcClip; rgnRedraw.GetBounds(&rcClip); CRegion rgnClip(rcClip); _pRenderSurface->SetClipRgn(&rgnClip); pContainer->DrawBorderAndScrollbars(pContext, &_rcContent); _rcContent.OffsetRect(_rcContainer.TopLeft().AsSize()); _pRenderSurface->SetClipRgn(NULL); // restore clipping on destination surface to redraw region // (this is important when we're using filters and we have a // direct draw surface) if(rgnRedraw.IsComplex()) { ::SelectClipRgn(_pRenderSurface->GetRawDC(), rgnRedraw.GetRegionAlias()); } else { HRGN hrgnClip = ::CreateRectRgnIndirect(&rgnRedraw.AsRect()); ::SelectClipRgn(_pRenderSurface->GetRawDC(), hrgnClip); ::DeleteObject(hrgnClip); } rgnRedraw.Intersect(_rcContent); // early exit if all we needed to draw was the border and scroll bars if(rgnRedraw.IsEmpty()) { goto Cleanup; } } else { _rcContent = _rcContainer; } // early exit if all we needed to draw was the border and scroll bars if(!_rcContent.IsEmpty()) { // try to allocate offscreen buffer BOOL fOffscreen = SetupOffscreenBuffer(pContext); Assert(!fOffscreen || _pOffscreenBuffer); // allocate stacks for redraw regions and context values CRegionStack redrawRegionStack; pContext->SetRedrawRegionStack(&redrawRegionStack); CDispContextStack contextStack; pContext->SetContextStack(&contextStack); // PreDraw pass processes the tree from highest layer to lowest, // culling layers beneath opaque layers, and identifying the lowest // opaque layer which needs to be rendered during the Draw pass PreDraw(pContext); // if we didn't consume the redraw region, we'll have to start rendering // from the root if(!pContext->GetRedrawRegion()->IsEmpty()) { pContext->_pFirstDrawNode = this; redrawRegionStack.PushRegionForRoot(pContext->GetRedrawRegion(), this, _rcContainer); contextStack.Init(); } else { Assert(pContext->_pFirstDrawNode != NULL); AssertSz(redrawRegionStack.MoreToPop(), "Mysterious redraw region stack bug!"); delete pContext->GetRedrawRegion(); contextStack.Restore(); } if(!fOffscreen) { _pRenderSurface->SetBandOffset(_afxGlobalData._Zero.size); DrawEntire(pContext); } else if(_pOffscreenBuffer->Height() >= _rcContent.Height()) { _pOffscreenBuffer->SetBandOffset(_rcContent.TopLeft().AsSize()); DrawEntire(pContext); _pOffscreenBuffer->Draw(_pRenderSurface, _rcContent); } else { DrawBands(pContext, &rgnRedraw, redrawRegionStack); } pContext->SetClientData(NULL); // clear redraw region trails redrawRegionStack.Restore(); for(;;) { CDispNode* pOpaqueNode = (CDispNode*)redrawRegionStack.PopKey(); if(pOpaqueNode == NULL) { break; } pOpaqueNode->ClearFlagToRoot(CDispFlags::s_savedRedrawRegion); } // delete all regions except the first redrawRegionStack.DeleteStack(&rgnRedraw); } Cleanup: // BUGBUG (donmarsh) -- restore _rcVisBounds to coincide with _rcContainer _rcVisBounds = _rcContainer; _fDrawLock = FALSE; }
//+--------------------------------------------------------------------------- // // Member: CDispRoot::EraseBackground // // Synopsis: Quickly draw border and background. // // Arguments: pContext draw context // pClientData client data used by clients in DrawClient // hrgnDraw region to draw in destination coordinates // prcDraw rect to draw in destination coordinates // // Notes: if hrgnDraw and prcDraw are both NULL, the bounding rect of // this root node is used // //---------------------------------------------------------------------------- void CDispRoot::EraseBackground( CDispDrawContext* pContext, void* pClientData, HRGN hrgnDraw, const RECT* prcDraw) { // BUGBUG (donmarsh) - EraseBackground can be called while we are recalcing // the display tree! For example, CSelectLayout::HandleViewChange changes // the clip region of child windows, which causes an immediate // call to EraseBackground. This is messy, because we could stomp on // values in pContext that are in use by the recalc code. Therefore, we // ignore these calls. If the following Assert fires, you should look // at the stack and protect the operation that called it with // CServer::CLock lock(Doc(), SERVERLOCK_IGNOREERASEBKGND); AssertSz(!_fDrawLock, "EraseBackground called during drawing"); // BUGBUG (donmarsh) -- temporarily disable this assert to help 5.0 stress numbers // AssertSz(!_fRecalcLock, "EraseBackground called during recalc"); if(_fDrawLock || _fRecalcLock) { return; } // BUGBUG (donmarsh) - for now we must use this root's own context, due // to the context stack used for drawing. Eventually, we should eliminate // the context pointer argument to DrawRoot. Assert(pContext == &_drawContext); AssertSz(!_fDrawLock, "Illegal call to EraseBackground inside Draw()"); Assert(_pRenderSurface != NULL); // set redraw region (will become a rect if possible) CRegion rgnRedraw; if(hrgnDraw != NULL) { rgnRedraw = hrgnDraw; } else if(prcDraw != NULL) { rgnRedraw = *prcDraw; } else { rgnRedraw = _rcContainer; } // check for early exit conditions if(!rgnRedraw.Intersects(_rcContainer)) { return; } // set initial context values pContext->SetClientData(pClientData); pContext->_offset = _rcContainer.TopLeft().AsSize(); pContext->_pFirstDrawNode = NULL; pContext->SetRedrawRegion(&rgnRedraw); pContext->SetDispSurface(_pRenderSurface); _pRenderSurface->SetBandOffset(_afxGlobalData._Zero.size); // BUGBUG (donmarsh) - To address bug 62008 (erase background for HTML Help // control), we need to disable clipping in CDispSurface::GetDC. Ideally, // CDispSurface should allow us to have a NULL _prgnClip, but that is // currently not the case. CRegion rgnClip(-15000, -15000, 15000, 15000); _pRenderSurface->SetClipRgn(&rgnClip); if(_pFirstChildNode == NULL) { DrawSelf(pContext, NULL); } else if(_pFirstChildNode->IsScroller()) { CDispScroller* pScroller = DYNCAST(CDispScroller, _pFirstChildNode); CDispExtras* pExtras = pScroller->GetExtras(); CDispInfo di(pExtras); pScroller->CalcDispInfo(_rcContainer, &di); // draw root background if scroller isn't opaque or doesn't have a background if(!pScroller->IsOpaque() || !pScroller->HasBackground()) { Assert(HasBackground()); CRect rcBackground(_rcContainer.Size()); CRect rcBackgroundClip(rcBackground); pContext->IntersectRedrawRegion(&rcBackgroundClip); if(!rcBackgroundClip.IsEmpty()) { _pDispClient->DrawClientBackground( &rcBackground, &rcBackgroundClip, pContext->GetDispSurface(), this, pContext->GetClientData(), 0); } } else { pScroller->DrawBackground(pContext, &di); } // draw scroller's border if it has one if(pScroller->HasBorder(pExtras)) { pScroller->DrawBorder(pContext, &di); } } _pRenderSurface->SetClipRgn(NULL); ::SelectClipRgn(_pRenderSurface->GetRawDC(), NULL); }