scrollarea.cpp

Linux系统下的《红色警戒》游戏

            if (getParent())
            {
                getParent()->moveToTop(this);
            }
        }
        else
        {
            throw GCN_EXCEPTION("Only a ScrollArea's content may be moved to top.");
        }
    }

    void ScrollArea::moveToBottom(Widget* widget)
    {
        if (widget == mContent)
        {
            if (getParent())
            {
                getParent()->moveToBottom(this);
            }
        }
        else
        {
            throw GCN_EXCEPTION("Only a ScrollArea's content may be moved to bottom.");
        }
    }

    void ScrollArea::_announceDeath(Widget *widget)
    {
        if (widget == mContent)
        {
            mContent = NULL;
            checkPolicies();
        }
        else
        {
            throw GCN_EXCEPTION("Called by not-child.");
        }
    }

    void ScrollArea::getDrawSize(int& width, int& height, Widget* widget)
    {
        if (mContent == widget)
        {
            width = getContentDimension().width;
            height = getContentDimension().height;
        }
        else
        {
            throw GCN_EXCEPTION("Widget not in scrollarea.");
        }    
    }
  
    void ScrollArea::drawContent(Graphics* graphics)
    {
        if (mContent)
        {
            mContent->draw(graphics);
        }
    }
  
    void ScrollArea::checkPolicies()
    {
        int w = getWidth();
        int h = getHeight();
    
        mHBarVisible = false;
        mVBarVisible = false;
    
    
        if (!mContent)
        {
            mHBarVisible = (mHPolicy == SHOW_ALWAYS);
            mVBarVisible = (mVPolicy == SHOW_ALWAYS);
            return;
        }
    
        if (mHPolicy == SHOW_AUTO &&
            mVPolicy == SHOW_AUTO)
        {
            if (mContent->getWidth() <= w
                && mContent->getHeight() <= h)
            {
                mHBarVisible = false;
                mVBarVisible = false;
            }

            if (mContent->getWidth() > w)
            {
                mHBarVisible = true;
            }

            if ((mContent->getHeight() > h)
                || (mHBarVisible && mContent->getHeight() > h - mScrollbarWidth))
            {
                mVBarVisible = true;
            }

            if (mVBarVisible && mContent->getWidth() > w - mScrollbarWidth)
            {
                mHBarVisible = true;
            }
      
            return;
        }
    
        switch (mHPolicy)
        {
          case SHOW_NEVER:
              mHBarVisible = false;
              break;

          case SHOW_ALWAYS:
              mHBarVisible = true;
              break;

          case SHOW_AUTO:
              if (mVPolicy == SHOW_NEVER)
              {
                  mHBarVisible = mContent->getWidth() > w;
              }
              else // (mVPolicy == SHOW_ALWAYS)
              {
                  mHBarVisible = mContent->getWidth() > w - mScrollbarWidth;
              }
              break;

          default:
              throw GCN_EXCEPTION("Horizontal scroll policy invalid.");
        }

        switch (mVPolicy)
        {
          case SHOW_NEVER:
              mVBarVisible = false;
              break;

          case SHOW_ALWAYS:
              mVBarVisible = true;
              break;

          case SHOW_AUTO:
              if (mHPolicy == SHOW_NEVER)
              {
                  mVBarVisible = mContent->getHeight() > h;
              }
              else // (mHPolicy == SHOW_ALWAYS)
              {
                  mVBarVisible = mContent->getHeight() > h - mScrollbarWidth;
              }
              break;
          default:
              throw GCN_EXCEPTION("Vertical scroll policy invalid.");
        }
    }

    Rectangle ScrollArea::getUpButtonDimension()
    {
        if (!mVBarVisible)
        {
            return Rectangle(0, 0, 0, 0);
        }
    
        return Rectangle(getWidth() - mScrollbarWidth,
                         0,
                         mScrollbarWidth,
                         mScrollbarWidth);
    }

    Rectangle ScrollArea::getDownButtonDimension()
    {
        if (!mVBarVisible)
        {
            return Rectangle(0, 0, 0, 0);
        }

        if (mVBarVisible && mHBarVisible)
        {
            return Rectangle(getWidth() - mScrollbarWidth,
                             getHeight() - mScrollbarWidth*2,
                             mScrollbarWidth,
                             mScrollbarWidth);
        }
    
        return Rectangle(getWidth() - mScrollbarWidth,
                         getHeight() - mScrollbarWidth,
                         mScrollbarWidth,
                         mScrollbarWidth);          
    }

    Rectangle ScrollArea::getLeftButtonDimension()
    {
        if (!mHBarVisible)
        {
            return Rectangle(0, 0, 0, 0);
        }
    
        return Rectangle(0,
                         getHeight() - mScrollbarWidth,
                         mScrollbarWidth,
                         mScrollbarWidth);    
    }

    Rectangle ScrollArea::getRightButtonDimension()
    {
        if (!mHBarVisible)
        {
            return Rectangle(0, 0, 0, 0);
        }

        if (mVBarVisible && mHBarVisible)
        {
            return Rectangle(getWidth() - mScrollbarWidth*2,
                             getHeight() - mScrollbarWidth,
                             mScrollbarWidth,
                             mScrollbarWidth);
        }

        return Rectangle(getWidth() - mScrollbarWidth,
                         getHeight() - mScrollbarWidth,
                         mScrollbarWidth,
                         mScrollbarWidth);          
    }

    Rectangle ScrollArea::getContentDimension()
    {
        if (mVBarVisible && mHBarVisible)
        {
            return Rectangle(0, 0, getWidth() - mScrollbarWidth, 
                             getHeight() - mScrollbarWidth);
        }

        if (mVBarVisible)
        {
            return Rectangle(0, 0, getWidth() - mScrollbarWidth, getHeight());
        }

        if (mHBarVisible)
        {
            return Rectangle(0, 0, getWidth(), getHeight() - mScrollbarWidth);
        }
    
        return Rectangle(0, 0, getWidth(), getHeight());
    }

    Rectangle ScrollArea::getVerticalBarDimension()
    {
        if (!mVBarVisible)
        {
            return Rectangle(0, 0, 0, 0);
        }

        if (mHBarVisible)
        {
            return Rectangle(getWidth() - mScrollbarWidth,
                             getUpButtonDimension().height,
                             mScrollbarWidth,
                             getHeight() 
                             - getUpButtonDimension().height
                             - getDownButtonDimension().height
                             - mScrollbarWidth);
        }
    
        return Rectangle(getWidth() - mScrollbarWidth,
                         getUpButtonDimension().height,
                         mScrollbarWidth,
                         getHeight() 
                         - getUpButtonDimension().height
                         - getDownButtonDimension().height);
    } 

    Rectangle ScrollArea::getHorizontalBarDimension()
    {
        if (!mHBarVisible)
        {
            return Rectangle(0, 0, 0, 0);
        }

        if (mVBarVisible)
        {
            return Rectangle(getLeftButtonDimension().width,
                             getHeight() - mScrollbarWidth,
                             getWidth() 
                             - getLeftButtonDimension().width
                             - getRightButtonDimension().width
                             - mScrollbarWidth, 
                             mScrollbarWidth);
        }

        return Rectangle(getLeftButtonDimension().width,
                         getHeight() - mScrollbarWidth,
                         getWidth() 
                         - getLeftButtonDimension().width
                         - getRightButtonDimension().width,
                         mScrollbarWidth);
    }

    Rectangle ScrollArea::getVerticalMarkerDimension()
    {
        if (!mVBarVisible)
        {
            return Rectangle(0, 0, 0, 0);
        }

        int length, pos;
        Rectangle barDim = getVerticalBarDimension();

        if (mContent && mContent->getHeight() != 0)
        {      
            length = (barDim.height * getContentDimension().height) 
                / mContent->getHeight();
        }
        else
        {
            length = barDim.height;
        }

        if (length < mScrollbarWidth)
        {
            length = mScrollbarWidth;
        }

        if (length > barDim.height)
        {
            length = barDim.height;
        }

        if (getVerticalMaxScroll() != 0)
        {
            pos = ((barDim.height - length) * getVerticalScrollAmount())
                / getVerticalMaxScroll();
        }
        else
        {
            pos = 0;
        }
    
        return Rectangle(barDim.x, barDim.y + pos, mScrollbarWidth, length);
    }

    Rectangle ScrollArea::getHorizontalMarkerDimension()
    {
        if (!mHBarVisible)
        {
            return Rectangle(0, 0, 0, 0);
        }

        int length, pos;
        Rectangle barDim = getHorizontalBarDimension();

        if (mContent && mContent->getWidth() != 0)
        {      
            length = (barDim.width * getContentDimension().width) 
                / mContent->getWidth();
        }
        else
        {
            length = barDim.width;
        }

        if (length < mScrollbarWidth)
        {
            length = mScrollbarWidth;
        }

        if (length > barDim.width)
        {
            length = barDim.width;
        }
    
        if (getHorizontalMaxScroll() != 0)
        {
            pos = ((barDim.width - length) * getHorizontalScrollAmount())
                / getHorizontalMaxScroll();
        }
        else
        {
            pos = 0;
        }

        return Rectangle(barDim.x + pos, barDim.y, length, mScrollbarWidth);
    }

    void ScrollArea::scrollToRectangle(const Rectangle& rectangle)
    {
        Rectangle contentDim = getContentDimension();
    
        if (rectangle.x + rectangle.width
            > getHorizontalScrollAmount() + contentDim.width)
        {
            setHorizontalScrollAmount(rectangle.x + rectangle.width - contentDim.width);
        }
    
        if (rectangle.y + rectangle.height
            > getVerticalScrollAmount() + contentDim.height)
        {
            setVerticalScrollAmount(rectangle.y + rectangle.height - contentDim.height);
        }

        if (rectangle.x < getHorizontalScrollAmount())
        {
            setHorizontalScrollAmount(rectangle.x);
        }
    
        if (rectangle.y < getVerticalScrollAmount())
        {
            setVerticalScrollAmount(rectangle.y);
        }
    }

    void ScrollArea::mouseWheelUp(int x, int y)
    {    
        if (hasMouse())
        {
            setVerticalScrollAmount(getVerticalScrollAmount() - getContentDimension().height / 8);
        }    
    }

    void ScrollArea::mouseWheelDown(int x, int y)
    {    
        if (hasMouse())
        {
            setVerticalScrollAmount(getVerticalScrollAmount() + getContentDimension().height / 8);
        }    
    }
}

/*
 * Wow! This is a looooong source file. 1291 lines!
 */