LCOV - app.info - layout/xul/base/src/nsScrollBoxObject.cpp

LCOV - code coverage report
| Current view: | directory - layout/xul/base/src - nsScrollBoxObject.cpp (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 149 | 0 | 0.0 %
| Date: | 2012-04-21 | Functions: | 21 | 0 | 0.0 %

           1                 : /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
           2                 : /* ***** BEGIN LICENSE BLOCK *****
           3                 :  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
           4                 :  *
           5                 :  * The contents of this file are subject to the Mozilla Public License Version
           6                 :  * 1.1 (the "License"); you may not use this file except in compliance with
           7                 :  * the License. You may obtain a copy of the License at
           8                 :  * http://www.mozilla.org/MPL/
           9                 :  *
          10                 :  * Software distributed under the License is distributed on an "AS IS" basis,
          11                 :  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
          12                 :  * for the specific language governing rights and limitations under the
          13                 :  * License.
          14                 :  *
          15                 :  * The Original Code is Mozilla Communicator client code.
          16                 :  *
          17                 :  * The Initial Developer of the Original Code is
          18                 :  * Netscape Communications Corporation.
          19                 :  * Portions created by the Initial Developer are Copyright (C) 1998
          20                 :  * the Initial Developer. All Rights Reserved.
          21                 :  *
          22                 :  * Contributor(s):
          23                 :  *   Original Author: David W. Hyatt (hyatt@netscape.com)
          24                 :  *   Mihai Șucan <mihai.sucan@gmail.com>
          25                 :  *
          26                 :  * Alternatively, the contents of this file may be used under the terms of
          27                 :  * either of the GNU General Public License Version 2 or later (the "GPL"),
          28                 :  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
          29                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
          30                 :  * of those above. If you wish to allow use of your version of this file only
          31                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
          32                 :  * use your version of this file under the terms of the MPL, indicate your
          33                 :  * decision by deleting the provisions above and replace them with the notice
          34                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
          35                 :  * the provisions above, a recipient may use your version of this file under
          36                 :  * the terms of any one of the MPL, the GPL or the LGPL.
          37                 :  *
          38                 :  * ***** END LICENSE BLOCK ***** */
          39                 :
          40                 : #include "nsCOMPtr.h"
          41                 : #include "nsIScrollBoxObject.h"
          42                 : #include "nsBoxObject.h"
          43                 : #include "nsIPresShell.h"
          44                 : #include "nsIContent.h"
          45                 : #include "nsIDocument.h"
          46                 : #include "nsIDOMDocument.h"
          47                 : #include "nsIDOMElement.h"
          48                 : #include "nsPresContext.h"
          49                 : #include "nsIFrame.h"
          50                 : #include "nsIScrollableFrame.h"
          51                 :
          52                 : class nsScrollBoxObject : public nsIScrollBoxObject, public nsBoxObject
          53                 : {
          54                 : public:
          55                 :   NS_DECL_ISUPPORTS_INHERITED
          56                 :   NS_DECL_NSISCROLLBOXOBJECT
          57                 :
          58                 :   nsScrollBoxObject();
          59                 :   virtual ~nsScrollBoxObject();
          60                 :
          61               0 :   virtual nsIScrollableFrame* GetScrollFrame() {
          62               0 :     return do_QueryFrame(GetFrame(false));
          63                 :   }
          64                 :
          65                 :   /* additional members */
          66                 : };
          67                 :
          68                 : /* Implementation file */
          69                 :
          70               0 : NS_INTERFACE_MAP_BEGIN(nsScrollBoxObject)
          71               0 :   NS_INTERFACE_MAP_ENTRY(nsIScrollBoxObject)
          72               0 : NS_INTERFACE_MAP_END_INHERITING(nsBoxObject)
          73                 :
          74               0 : NS_IMPL_ADDREF_INHERITED(nsScrollBoxObject, nsBoxObject)
          75               0 : NS_IMPL_RELEASE_INHERITED(nsScrollBoxObject, nsBoxObject)
          76                 :
          77               0 : nsScrollBoxObject::nsScrollBoxObject()
          78                 : {
          79                 :   /* member initializers and constructor code */
          80               0 : }
          81                 :
          82               0 : nsScrollBoxObject::~nsScrollBoxObject()
          83                 : {
          84                 :   /* destructor code */
          85               0 : }
          86                 :
          87                 : /* void scrollTo (in long x, in long y); */
          88               0 : NS_IMETHODIMP nsScrollBoxObject::ScrollTo(PRInt32 x, PRInt32 y)
          89                 : {
          90               0 :   nsIScrollableFrame* sf = GetScrollFrame();
          91               0 :   if (!sf)
          92               0 :     return NS_ERROR_FAILURE;
          93                 :
          94                 :   sf->ScrollTo(nsPoint(nsPresContext::CSSPixelsToAppUnits(x),
          95                 :                        nsPresContext::CSSPixelsToAppUnits(y)),
          96               0 :                nsIScrollableFrame::INSTANT);
          97               0 :   return NS_OK;
          98                 : }
          99                 :
         100                 : /* void scrollBy (in long dx, in long dy); */
         101               0 : NS_IMETHODIMP nsScrollBoxObject::ScrollBy(PRInt32 dx, PRInt32 dy)
         102                 : {
         103                 :   PRInt32 x, y;
         104               0 :   nsresult rv = GetPosition(&x, &y);
         105               0 :   if (NS_FAILED(rv))
         106               0 :     return rv;
         107                 :
         108               0 :   return ScrollTo(x + dx, y + dy);
         109                 : }
         110                 :
         111                 : /* void scrollByLine (in long dlines); */
         112               0 : NS_IMETHODIMP nsScrollBoxObject::ScrollByLine(PRInt32 dlines)
         113                 : {
         114               0 :   nsIScrollableFrame* sf = GetScrollFrame();
         115               0 :   if (!sf)
         116               0 :     return NS_ERROR_FAILURE;
         117                 :
         118                 :   sf->ScrollBy(nsIntPoint(0, dlines), nsIScrollableFrame::LINES,
         119               0 :                nsIScrollableFrame::SMOOTH);
         120               0 :   return NS_OK;
         121                 : }
         122                 :
         123                 : // XUL <scrollbox> elements have a single box child element.
         124                 : // Get a pointer to that box.
         125                 : // Note that now that the <scrollbox> is just a regular box
         126                 : // with 'overflow:hidden', the boxobject's frame is an nsXULScrollFrame,
         127                 : // the <scrollbox>'s box frame is the scrollframe's "scrolled frame", and
         128                 : // the <scrollbox>'s child box is a child of that.
         129               0 : static nsIFrame* GetScrolledBox(nsBoxObject* aScrollBox) {
         130               0 :   nsIFrame* frame = aScrollBox->GetFrame(false);
         131               0 :   if (!frame)
         132               0 :     return nsnull;
         133               0 :   nsIScrollableFrame* scrollFrame = do_QueryFrame(frame);
         134               0 :   if (!scrollFrame) {
         135               0 :     NS_WARNING("nsIScrollBoxObject attached to something that's not a scroll frame!");
         136               0 :     return nsnull;
         137                 :   }
         138               0 :   nsIFrame* scrolledFrame = scrollFrame->GetScrolledFrame();
         139               0 :   if (!scrolledFrame)
         140               0 :     return nsnull;
         141               0 :   return scrolledFrame->GetChildBox();
         142                 : }
         143                 :
         144                 : /* void scrollByIndex (in long dindexes); */
         145               0 : NS_IMETHODIMP nsScrollBoxObject::ScrollByIndex(PRInt32 dindexes)
         146                 : {
         147               0 :     nsIScrollableFrame* sf = GetScrollFrame();
         148               0 :     if (!sf)
         149               0 :        return NS_ERROR_FAILURE;
         150               0 :     nsIFrame* scrolledBox = GetScrolledBox(this);
         151               0 :     if (!scrolledBox)
         152               0 :        return NS_ERROR_FAILURE;
         153                 :
         154               0 :     nsRect rect;
         155                 :
         156                 :     // now get the scrolled boxes first child.
         157               0 :     nsIFrame* child = scrolledBox->GetChildBox();
         158                 :
         159               0 :     bool horiz = scrolledBox->IsHorizontal();
         160               0 :     nsPoint cp = sf->GetScrollPosition();
         161               0 :     nscoord diff = 0;
         162               0 :     PRInt32 curIndex = 0;
         163               0 :     bool isLTR = scrolledBox->IsNormalDirection();
         164                 :
         165               0 :     PRInt32 frameWidth = 0;
         166               0 :     if (!isLTR && horiz) {
         167               0 :       GetWidth(&frameWidth);
         168               0 :       nsCOMPtr<nsIPresShell> shell = GetPresShell(false);
         169               0 :       if (!shell) {
         170               0 :         return NS_ERROR_UNEXPECTED;
         171                 :       }
         172               0 :       frameWidth = nsPresContext::CSSPixelsToAppUnits(frameWidth);
         173                 :     }
         174                 :
         175                 :     // first find out what index we are currently at
         176               0 :     while(child) {
         177               0 :       rect = child->GetRect();
         178               0 :       if (horiz) {
         179                 :         // In the left-to-right case we break from the loop when the center of
         180                 :         // the current child rect is greater than the scrolled position of
         181                 :         // the left edge of the scrollbox
         182                 :         // In the right-to-left case we break when the center of the current
         183                 :         // child rect is less than the scrolled position of the right edge of
         184                 :         // the scrollbox.
         185               0 :         diff = rect.x + rect.width/2; // use the center, to avoid rounding errors
         186               0 :         if ((isLTR && diff > cp.x) ||
         187               0 :             (!isLTR && diff < cp.x + frameWidth)) {
         188               0 :           break;
         189                 :         }
         190                 :       } else {
         191               0 :         diff = rect.y + rect.height/2;// use the center, to avoid rounding errors
         192               0 :         if (diff > cp.y) {
         193               0 :           break;
         194                 :         }
         195                 :       }
         196               0 :       child = child->GetNextBox();
         197               0 :       curIndex++;
         198                 :     }
         199                 :
         200               0 :     PRInt32 count = 0;
         201                 :
         202               0 :     if (dindexes == 0)
         203               0 :        return NS_OK;
         204                 :
         205               0 :     if (dindexes > 0) {
         206               0 :       while(child) {
         207               0 :         child = child->GetNextBox();
         208               0 :         if (child)
         209               0 :           rect = child->GetRect();
         210               0 :         count++;
         211               0 :         if (count >= dindexes)
         212               0 :           break;
         213                 :       }
         214                 :
         215               0 :    } else if (dindexes < 0) {
         216               0 :       child = scrolledBox->GetChildBox();
         217               0 :       while(child) {
         218               0 :         rect = child->GetRect();
         219               0 :         if (count >= curIndex + dindexes)
         220               0 :           break;
         221                 :
         222               0 :         count++;
         223               0 :         child = child->GetNextBox();
         224                 :
         225                 :       }
         226                 :    }
         227                 :
         228               0 :    if (horiz)
         229                 :        // In the left-to-right case we scroll so that the left edge of the
         230                 :        // selected child is scrolled to the left edge of the scrollbox.
         231                 :        // In the right-to-left case we scroll so that the right edge of the
         232                 :        // selected child is scrolled to the right edge of the scrollbox.
         233                 :        sf->ScrollTo(nsPoint(isLTR ? rect.x : rect.x + rect.width - frameWidth,
         234                 :                             cp.y),
         235               0 :                     nsIScrollableFrame::INSTANT);
         236                 :    else
         237               0 :        sf->ScrollTo(nsPoint(cp.x, rect.y), nsIScrollableFrame::INSTANT);
         238                 :
         239               0 :    return NS_OK;
         240                 : }
         241                 :
         242                 : /* void scrollToLine (in long line); */
         243               0 : NS_IMETHODIMP nsScrollBoxObject::ScrollToLine(PRInt32 line)
         244                 : {
         245               0 :   nsIScrollableFrame* sf = GetScrollFrame();
         246               0 :   if (!sf)
         247               0 :      return NS_ERROR_FAILURE;
         248                 :
         249               0 :   nscoord y = sf->GetLineScrollAmount().height * line;
         250               0 :   sf->ScrollTo(nsPoint(0, y), nsIScrollableFrame::INSTANT);
         251               0 :   return NS_OK;
         252                 : }
         253                 :
         254                 : /* void scrollToElement (in nsIDOMElement child); */
         255               0 : NS_IMETHODIMP nsScrollBoxObject::ScrollToElement(nsIDOMElement *child)
         256                 : {
         257               0 :     NS_ENSURE_ARG_POINTER(child);
         258                 :
         259               0 :     nsCOMPtr<nsIPresShell> shell = GetPresShell(false);
         260               0 :     if (!shell) {
         261               0 :       return NS_ERROR_UNEXPECTED;
         262                 :     }
         263                 :
         264               0 :     nsCOMPtr<nsIContent> content = do_QueryInterface(child);
         265               0 :     shell->ScrollContentIntoView(content,
         266                 :                                  NS_PRESSHELL_SCROLL_TOP,
         267                 :                                  NS_PRESSHELL_SCROLL_LEFT,
         268                 :                                  nsIPresShell::SCROLL_FIRST_ANCESTOR_ONLY |
         269               0 :                                  nsIPresShell::SCROLL_OVERFLOW_HIDDEN);
         270               0 :     return NS_OK;
         271                 : }
         272                 :
         273                 : /* void scrollToIndex (in long index); */
         274               0 : NS_IMETHODIMP nsScrollBoxObject::ScrollToIndex(PRInt32 index)
         275                 : {
         276               0 :     return NS_ERROR_NOT_IMPLEMENTED;
         277                 : }
         278                 :
         279                 : /* void getPosition (out long x, out long y); */
         280               0 : NS_IMETHODIMP nsScrollBoxObject::GetPosition(PRInt32 *x, PRInt32 *y)
         281                 : {
         282               0 :   nsIScrollableFrame* sf = GetScrollFrame();
         283               0 :   if (!sf)
         284               0 :      return NS_ERROR_FAILURE;
         285                 :
         286               0 :   nsPoint pt = sf->GetScrollPosition();
         287               0 :   *x = nsPresContext::AppUnitsToIntCSSPixels(pt.x);
         288               0 :   *y = nsPresContext::AppUnitsToIntCSSPixels(pt.y);
         289                 :
         290               0 :   return NS_OK;
         291                 : }
         292                 :
         293                 : /* void getScrolledSize (out long width, out long height); */
         294               0 : NS_IMETHODIMP nsScrollBoxObject::GetScrolledSize(PRInt32 *width, PRInt32 *height)
         295                 : {
         296               0 :     nsIFrame* scrolledBox = GetScrolledBox(this);
         297               0 :     if (!scrolledBox)
         298               0 :         return NS_ERROR_FAILURE;
         299                 :
         300               0 :     nsRect scrollRect = scrolledBox->GetRect();
         301                 :
         302               0 :     *width  = nsPresContext::AppUnitsToIntCSSPixels(scrollRect.width);
         303               0 :     *height = nsPresContext::AppUnitsToIntCSSPixels(scrollRect.height);
         304                 :
         305               0 :     return NS_OK;
         306                 : }
         307                 :
         308                 : /* void ensureElementIsVisible (in nsIDOMElement child); */
         309               0 : NS_IMETHODIMP nsScrollBoxObject::EnsureElementIsVisible(nsIDOMElement *child)
         310                 : {
         311               0 :     NS_ENSURE_ARG_POINTER(child);
         312                 :
         313               0 :     nsCOMPtr<nsIPresShell> shell = GetPresShell(false);
         314               0 :     if (!shell) {
         315               0 :       return NS_ERROR_UNEXPECTED;
         316                 :     }
         317                 :
         318               0 :     nsCOMPtr<nsIContent> content = do_QueryInterface(child);
         319               0 :     shell->ScrollContentIntoView(content,
         320                 :                                  NS_PRESSHELL_SCROLL_ANYWHERE,
         321                 :                                  NS_PRESSHELL_SCROLL_ANYWHERE,
         322                 :                                  nsIPresShell::SCROLL_FIRST_ANCESTOR_ONLY |
         323               0 :                                  nsIPresShell::SCROLL_OVERFLOW_HIDDEN);
         324               0 :     return NS_OK;
         325                 : }
         326                 :
         327                 : /* void ensureIndexIsVisible (in long index); */
         328               0 : NS_IMETHODIMP nsScrollBoxObject::EnsureIndexIsVisible(PRInt32 index)
         329                 : {
         330               0 :     return NS_ERROR_NOT_IMPLEMENTED;
         331                 : }
         332                 :
         333                 : /* void ensureLineIsVisible (in long line); */
         334               0 : NS_IMETHODIMP nsScrollBoxObject::EnsureLineIsVisible(PRInt32 line)
         335                 : {
         336               0 :     return NS_ERROR_NOT_IMPLEMENTED;
         337                 : }
         338                 :
         339                 : nsresult
         340               0 : NS_NewScrollBoxObject(nsIBoxObject** aResult)
         341                 : {
         342               0 :   *aResult = new nsScrollBoxObject;
         343               0 :   if (!*aResult)
         344               0 :     return NS_ERROR_OUT_OF_MEMORY;
         345               0 :   NS_ADDREF(*aResult);
         346               0 :   return NS_OK;
         347                 : }
         348                 :

Generated by: LCOV version 1.7