C++ View::IsVisible方法代码示例

    void SingleSplitView::Layout()
    {
        if(GetChildViewCount() != 2)
        {
            return;
        }

        View* leading = GetChildViewAt(0);
        View* trailing = GetChildViewAt(1);

        if(!leading->IsVisible() && !trailing->IsVisible())
        {
            return;
        }

        if(width()==0 || height()==0)
        {
            // We are most likely minimized - do not touch divider offset.
            return;
        }
        else if(!trailing->IsVisible())
        {
            leading->SetBounds(0, 0, width(), height());
        }
        else if(!leading->IsVisible())
        {
            trailing->SetBounds(0, 0, width(), height());
        }
        else
        {
            if(divider_offset_ < 0)
            {
                divider_offset_ = (GetPrimaryAxisSize() - kDividerSize) / 2;
            }
            else
            {
                divider_offset_ = std::min(divider_offset_,
                    GetPrimaryAxisSize()-kDividerSize);
            }

            if(is_horizontal_)
            {
                leading->SetBounds(0, 0, divider_offset_, height());
                trailing->SetBounds(divider_offset_+kDividerSize, 0,
                    width()-divider_offset_-kDividerSize, height());
            }
            else
            {
                leading->SetBounds(0, 0, width(), divider_offset_);
                trailing->SetBounds(0, divider_offset_+kDividerSize,
                    width(), height()-divider_offset_-kDividerSize);
            }
        }

        SchedulePaint();

        // Invoke super's implementation so that the children are layed out.
        View::Layout();
    }

 gfx::Size BoxLayout::GetPreferredSize(View* host)
 {
     gfx::Rect bounds;
     int position = 0;
     for(int i=0; i<host->GetChildViewCount(); ++i)
     {
         View* child = host->GetChildViewAt(i);
         if(child->IsVisible())
         {
             gfx::Size size(child->GetPreferredSize());
             if(orientation_ == kHorizontal)
             {
                 gfx::Rect child_bounds(position, 0, size.width(), size.height());
                 bounds = bounds.Union(child_bounds);
                 position += size.width();
             }
             else
             {
                 gfx::Rect child_bounds(0, position, size.width(), size.height());
                 bounds = bounds.Union(child_bounds);
                 position += size.height();
             }
             position += between_child_spacing_;
         }
     }
     gfx::Insets insets(host->GetInsets());
     return gfx::Size(
         bounds.width()+insets.width()+2*inside_border_horizontal_spacing_,
         bounds.height()+insets.height()+2*inside_border_vertical_spacing_);
 }

 void BoxLayout::Layout(View* host)
 {
     gfx::Rect childArea(gfx::Rect(host->size()));
     childArea.Inset(host->GetInsets());
     childArea.Inset(inside_border_horizontal_spacing_,
         inside_border_vertical_spacing_);
     int x = childArea.x();
     int y = childArea.y();
     for(int i=0; i<host->GetChildViewCount(); ++i)
     {
         View* child = host->GetChildViewAt(i);
         if(child->IsVisible())
         {
             gfx::Rect bounds(x, y, childArea.width(), childArea.height());
             gfx::Size size(child->GetPreferredSize());
             if(orientation_ == kHorizontal)
             {
                 bounds.set_width(size.width());
                 x += size.width() + between_child_spacing_;
             }
             else
             {
                 bounds.set_height(size.height());
                 y += size.height() + between_child_spacing_;
             }
             // Clamp child view bounds to |childArea|.
             child->SetBounds(bounds.Intersect(childArea));
         }
     }
 }

void ViewOwner::RenderViews()
{
	for (auto i = _views.rbegin(); i != _views.rend(); ++i)
	{
		View* view = *i;
		if (view->IsVisible())
			view->Render();
	}
}

 // LayoutManager overrides:
 virtual void Layout(View* host)
 {
     gfx::Rect bounds(host->GetContentsBounds());
     for(int i=0; i<host->child_count(); ++i)
     {
         View* child = host->child_at(i);
         // We only layout visible children, since it may be expensive.
         if(child->IsVisible() && child->bounds()!=bounds)
         {
             child->SetBoundsRect(bounds);
         }
     }
 }

void
View::ResizeBy(int32 x, int32 y, BRegion* dirtyRegion)
{
    if (x == 0 && y == 0)
        return;

    fFrame.right += x;
    fFrame.bottom += y;

    if (fVisible && dirtyRegion) {
        IntRect oldBounds(Bounds());
        oldBounds.right -= x;
        oldBounds.bottom -= y;

        BRegion* dirty = fWindow->GetRegion();
        if (!dirty)
            return;

        dirty->Set((clipping_rect)Bounds());
        dirty->Include((clipping_rect)oldBounds);

        if (!(fFlags & B_FULL_UPDATE_ON_RESIZE)) {
            // the dirty region is just the difference of
            // old and new bounds
            dirty->Exclude((clipping_rect)(oldBounds & Bounds()));
        }

        InvalidateScreenClipping();

        if (dirty->CountRects() > 0) {
            if ((fFlags & B_DRAW_ON_CHILDREN) == 0) {
                // exclude children, they are expected to
                // include their own dirty regions in ParentResized()
                for (View* child = FirstChild(); child;
                        child = child->NextSibling()) {
                    if (!child->IsVisible())
                        continue;
                    IntRect previousChildVisible(
                        child->Frame() & oldBounds & Bounds());
                    if (dirty->Frame().Intersects(previousChildVisible)) {
                        dirty->Exclude((clipping_rect)previousChildVisible);
                    }
                }
            }

            ConvertToScreen(dirty);
            dirtyRegion->Include(dirty);
        }
        fWindow->RecycleRegion(dirty);
    }

    // layout the children
    for (View* child = FirstChild(); child; child = child->NextSibling())
        child->ParentResized(x, y, dirtyRegion);

    // view bitmap

    resize_frame(fBitmapDestination, fBitmapResizingMode, x, y);

    // at this point, children are at their new locations,
    // so we can rebuild the clipping
    // TODO: when the implementation of Hide() and Show() is
    // complete, see if this should be avoided
    RebuildClipping(false);
}