Пример #1
0
void Base::RenderRecursive(Gwen::Skin::Base* skin, const Gwen::Rect& cliprect)
{
    Gwen::Renderer::Base* render = skin->GetRender();
    Gwen::Point pOldRenderOffset = render->GetRenderOffset();
    render->AddRenderOffset(cliprect);
    RenderUnder(skin);
    Gwen::Rect rOldRegion = render->ClipRegion();

    //
    // If this control is clipping, change the clip rect to ourselves
    // ( if not then we still clip using our parents clip rect )
    //
    if (ShouldClip())
    {
        render->AddClipRegion(cliprect);

        if (!render->ClipRegionVisible())
        {
            render->SetRenderOffset(pOldRenderOffset);
            render->SetClipRegion(rOldRegion);
            return;
        }
    }

    //
    // Render this control and children controls
    //
    render->StartClip();
    {
        Render(skin);

        if (!Children.empty())
        {
            // Now render my kids
            for (Base::List::iterator iter = Children.begin(); iter != Children.end(); ++iter)
            {
                Base* pChild = *iter;

                if (pChild->Hidden())
                    continue;

                pChild->DoRender(skin);
            }
        }
    }
    render->EndClip();
    //
    // Render overlay/focus
    //
    {
        render->SetClipRegion(rOldRegion);
        render->StartClip();
        {
            RenderOver(skin);
            RenderFocus(skin);
        }
        render->EndClip();
        render->SetRenderOffset(pOldRenderOffset);
    }
}
Пример #2
0
void Canvas::RenderCanvas()
{
	DoThink();

	Gwen::Renderer::Base* render = m_Skin->GetRender();
	render->Begin();

	
		RecurseLayout( m_Skin );

		render->SetClipRegion( GetBounds() );
		render->SetRenderOffset( Gwen::Point( 0, 0 ) );
		render->SetScale( Scale() );

		if ( m_bDrawBackground )
		{
			render->SetDrawColor( m_BackgroundColor );
			render->DrawFilledRect( GetRenderBounds() );
		}

		DoRender( m_Skin );

		DragAndDrop::RenderOverlay( this, m_Skin );

		ToolTip::RenderToolTip( m_Skin );

		render->EndClip();

	render->End();
	ProcessDelayedDeletes();

}
Пример #3
0
	void RenderToolTip( Skin::Base* skin )
	{
		if ( !g_ToolTip ) { return; }

		Gwen::Renderer::Base* render = skin->GetRender();
		Gwen::Point pOldRenderOffset = render->GetRenderOffset();
		Gwen::Point MousePos = Input::GetMousePosition();
		Gwen::Rect Bounds = g_ToolTip->GetToolTip()->GetBounds();
		Gwen::Rect rOffset = Gwen::Rect( MousePos.x - Bounds.w * 0.5f, MousePos.y - Bounds.h - 10, Bounds.w, Bounds.h );
		rOffset = Utility::ClampRectToRect( rOffset, g_ToolTip->GetCanvas()->GetBounds() );
		//Calculate offset on screen bounds
		render->AddRenderOffset( rOffset );
		render->EndClip();
		skin->DrawToolTip( g_ToolTip->GetToolTip() );
		g_ToolTip->GetToolTip()->DoRender( skin );
		render->SetRenderOffset( pOldRenderOffset );
	}
Пример #4
0
void Base::DoCacheRender( Gwen::Skin::Base* skin, Gwen::Controls::Base* pMaster )
{
	Gwen::Renderer::Base* render = skin->GetRender();
	Gwen::Renderer::ICacheToTexture* cache = render->GetCTT();

	if ( !cache ) { return; }

	Gwen::Point pOldRenderOffset = render->GetRenderOffset();
	Gwen::Rect rOldRegion = render->ClipRegion();

	if ( this != pMaster )
	{
		render->AddRenderOffset( GetBounds() );
		render->AddClipRegion( GetBounds() );
	}
	else
	{
		render->SetRenderOffset( Gwen::Point( 0, 0 ) );
		render->SetClipRegion( GetBounds() );
	}

	if ( m_bCacheTextureDirty && render->ClipRegionVisible() )
	{
		render->StartClip();
		{
			if ( ShouldCacheToTexture() )
			{ cache->SetupCacheTexture( this ); }

			//Render myself first
			Render( skin );

			if ( !Children.empty() )
			{
				//Now render my kids
				for ( Base::List::iterator iter = Children.begin(); iter != Children.end(); ++iter )
				{
					Base* pChild = *iter;

					if ( pChild->Hidden() ) { continue; }

					pChild->DoCacheRender( skin, pMaster );
				}
			}

			if ( ShouldCacheToTexture() )
			{
				cache->FinishCacheTexture( this );
				m_bCacheTextureDirty = false;
			}
		}
		render->EndClip();
	}

	render->SetClipRegion( rOldRegion );
	render->StartClip();
	{
		render->SetRenderOffset( pOldRenderOffset );
		cache->DrawCachedControlTexture( this );
	}
	render->EndClip();
}
Пример #5
0
void Base::DoCacheRender(Gwen::Skin::Base* skin, Gwen::Controls::Base* pMaster)
{
    Gwen::Renderer::Base* render = skin->GetRender();
    Gwen::Renderer::ICacheToTexture* cache = render->GetCTT();

    if (!cache)
        return;

    Gwen::Point pOldRenderOffset = render->GetRenderOffset();
    Gwen::Rect rOldRegion = render->ClipRegion();

    if (this != pMaster)
    {
        render->AddRenderOffset(GetBounds());
        render->AddClipRegion(GetBounds());
    }
    else
    {
        render->SetRenderOffset(Gwen::Point(0, 0));
        render->SetClipRegion(GetBounds());
    }

    // See if we need to update the cached texture. Dirty?
    if (m_bCacheTextureDirty && render->ClipRegionVisible())
    {
        render->StartClip();
        {
            if (IsCachedToTexture())
                cache->SetupCacheTexture(this);

            // Render myself first
            Render(skin);

            if (!Children.empty())
            {
                // Now render my kids
                for (Base::List::iterator iter = Children.begin(); iter != Children.end(); ++iter)
                {
                    Base* pChild = *iter;

                    if (!pChild->Hidden())
                    {
                        // Draw child control using normal render. If it is cached it will
                        // be handled in the same way as this one.
                        pChild->DoRender(skin);
                    }
                }
            }

            if (IsCachedToTexture())
            {
                cache->FinishCacheTexture(this);
                m_bCacheTextureDirty = false;
            }
        }
        render->EndClip();
    }

    // Draw the cached texture.
    render->SetClipRegion(rOldRegion);
    render->StartClip();
    {
        render->SetRenderOffset(pOldRenderOffset);
        cache->DrawCachedControlTexture(this);
    }
    render->EndClip();
}