toolkit/source/layout/core/timer.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile$
  10  *
  11  * $Revision$
  12  *
  13  * This file is part of OpenOffice.org.
  14  *
  15  * OpenOffice.org is free software: you can redistribute it and/or modify
  16  * it under the terms of the GNU Lesser General Public License version 3
  17  * only, as published by the Free Software Foundation.
  18  *
  19  * OpenOffice.org is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU Lesser General Public License version 3 for more details
  23  * (a copy is included in the LICENSE file that accompanied this code).
  24  *
  25  * You should have received a copy of the GNU Lesser General Public License
  26  * version 3 along with OpenOffice.org.  If not, see
  27  * <http://www.openoffice.org/license.html>
  28  * for a copy of the LGPLv3 License.
  29  *
  30  ************************************************************************/
  31
  32 #include "timer.hxx"
  33
  34 #include <vector>
  35 #include <list>
  36 #include <vcl/timer.hxx>
  37 #include <com/sun/star/awt/XLayoutContainer.hpp>
  38
  39 namespace layoutimpl
  40 {
  41 using namespace ::com::sun::star;
  42
  43 class AllocateTimer : public Timer
  44 {
  45     typedef std::list< uno::Reference< awt::XLayoutContainer > > ContainerList;
  46     ContainerList mxContainers;
  47     uno::Reference< awt::XLayoutContainer > mxLastAdded;
  48
  49 public:
  50     AllocateTimer()
  51     {
  52         // timer set to 0 -- just process it as soon as it gets idle
  53         SetTimeout( 0 );
  54     }
  55
  56     static inline bool isParentOf( uno::Reference< awt::XLayoutContainer > xParent,
  57                                    uno::Reference< awt::XLayoutContainer > xWidget )
  58     {
  59         while ( xWidget.is() )
  60         {
  61             if ( xWidget == xParent )
  62                 return true;
  63             xWidget = uno::Reference< awt::XLayoutContainer >( xWidget->getParent(), uno::UNO_QUERY );
  64         }
  65         return false;
  66     }
  67
  68     static inline void eraseChildren( ContainerList::iterator &it, ContainerList &list )
  69     {
  70         ContainerList::iterator jt = list.begin();
  71         while ( jt != list.end() )
  72         {
  73             if ( it != jt && isParentOf( *it, *jt ) )
  74                 jt = list.erase( jt );
  75             else
  76                 jt++;
  77         }
  78     }
  79
  80     static inline bool isContainerDamaged( uno::Reference< awt::XLayoutContainer > xContainer )
  81     {
  82         uno::Reference< awt::XLayoutConstrains > xConstrains( xContainer, uno::UNO_QUERY );
  83         awt::Size lastReq( xContainer->getRequestedSize() );
  84         awt::Size curReq( xConstrains->getMinimumSize() );
  85         return lastReq.Width != curReq.Width || lastReq.Height != curReq.Height;
  86     }
  87
  88     void add( const uno::Reference< awt::XLayoutContainer > &xContainer )
  89     {
  90         // small optimization
  91         if ( mxLastAdded == xContainer )
  92             return;
  93         mxLastAdded = xContainer;
  94
  95         mxContainers.push_back( xContainer );
  96     }
  97
  98     virtual void Timeout()
  99     {
 100         mxLastAdded = uno::Reference< awt::XLayoutContainer >();
 101
 102         // 1. remove duplications and children
 103         for ( ContainerList::iterator it = mxContainers.begin();
 104              it != mxContainers.end(); it++ )
 105             eraseChildren( it, mxContainers );
 106
 107         // 2. check damage extent
 108         for ( ContainerList::iterator it = mxContainers.begin();
 109              it != mxContainers.end(); it++ )
 110         {
 111             uno::Reference< awt::XLayoutContainer > xContainer = *it;
 112             while ( xContainer->getParent().is() && isContainerDamaged( xContainer ) )
 113             {
 114                 xContainer = uno::Reference< awt::XLayoutContainer >(
 115                     xContainer->getParent(), uno::UNO_QUERY );
 116             }
 117
 118             if ( *it != xContainer )
 119             {
 120                 // 2.2 replace it with parent
 121                 *it = xContainer;
 122
 123                 // 2.3 remove children of new parent
 124                 eraseChildren( it, mxContainers );
 125             }
 126         }
 127
 128         // 3. force re-calculations
 129         for ( ContainerList::iterator it = mxContainers.begin();
 130              it != mxContainers.end(); it++ )
 131             (*it)->allocateArea( (*it)->getAllocatedArea() );
 132     }
 133 };
 134
 135 static void AddResizeTimeout( const uno::Reference< awt::XLayoutContainer > &xCont )
 136 {
 137     static AllocateTimer timer;
 138     timer.add( xCont );
 139     timer.Start();
 140 }
 141
 142 LayoutUnit::LayoutUnit() : LayoutUnit_Base()
 143 {
 144 }
 145
 146 void SAL_CALL LayoutUnit::queueResize( const uno::Reference< awt::XLayoutContainer > &xContainer )
 147     throw( uno::RuntimeException )
 148 {
 149     AddResizeTimeout( xContainer );
 150 }
 151
 152 }