source/awt/vclxtabcontrol.cxx

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/


#include "vclxtabcontrol.hxx"

#include <com/sun/star/awt/PosSize.hpp>
#include <sal/macros.h>
#include <toolkit/helper/property.hxx>
#include <toolkit/helper/vclunohelper.hxx>
#include <vcl/tabctrl.hxx>
#include <vcl/tabpage.hxx>

#include "forward.hxx"

namespace layoutimpl
{

using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::beans;
using namespace ::com::sun::star;

VCLXTabControl::ChildProps::ChildProps( VCLXTabControl::ChildData *pData )
{
    addProp( RTL_CONSTASCII_USTRINGPARAM( "Title" ),
             ::getCppuType( static_cast< const rtl::OUString* >( NULL ) ),
             &(pData->maTitle) );
}

VCLXTabControl::ChildData::ChildData( uno::Reference< awt::XLayoutConstrains > const& xChild )
    : Box_Base::ChildData( xChild )
    , maTitle()
{
}

VCLXTabControl::ChildData*
VCLXTabControl::createChild( uno::Reference< awt::XLayoutConstrains > const& xChild )
{
    return new ChildData( xChild );
}

VCLXTabControl::ChildProps*
VCLXTabControl::createChildProps( Box_Base::ChildData *pData )
{
    return new ChildProps( static_cast<VCLXTabControl::ChildData*> ( pData ) );
}

DBG_NAME( VCLXTabControl );

#if !defined (__GNUC__)
#define __PRETTY_FUNCTION__ __FUNCTION__
#endif /* !__GNUC__ */

VCLXTabControl::VCLXTabControl()
  : VCLXWindow()
  , VCLXTabControl_Base()
  , Box_Base()
  , mTabId (1)
  , bRealized (false)
{
#ifndef __SUNPRO_CC
    OSL_TRACE ("\n********%s:%x", __PRETTY_FUNCTION__, this);
#endif
    DBG_CTOR( VCLXTabControl, NULL );
}

VCLXTabControl::~VCLXTabControl()
{
    DBG_DTOR( VCLXTabControl, NULL );
}

IMPLEMENT_2_FORWARD_XINTERFACE2( VCLXTabControl, VCLXWindow, Container, VCLXTabControl_Base );

IMPLEMENT_FORWARD_XTYPEPROVIDER2( VCLXTabControl, VCLXWindow, VCLXTabControl_Base );

void SAL_CALL VCLXTabControl::dispose( )
{
    {
        ::vos::OGuard aGuard( GetMutex() );

        EventObject aDisposeEvent;
        aDisposeEvent.Source = W3K_EXPLICIT_CAST (*this);
//            maTabListeners.disposeAndClear( aDisposeEvent );
    }

    VCLXWindow::dispose();
}

#if 0
void SAL_CALL VCLXTabControl::addTabListener( const Reference< XTabListener >& listener )
{
    if ( listener.is() )
        maTabListeners.addInterface( listener );
}

void SAL_CALL VCLXTabControl::removeTabListener( const Reference< XTabListener >& listener )
{
    if ( listener.is() )
        maTabListeners.removeInterface( listener );
}
#endif

TabControl *VCLXTabControl::getTabControl() const
{
    TabControl *pTabControl = static_cast< TabControl* >( GetWindow() );
    if ( pTabControl )
        return pTabControl;
    throw uno::RuntimeException();
}

sal_Int32 SAL_CALL VCLXTabControl::insertTab()
{
    TabControl *pTabControl = getTabControl();
    sal_uInt16 id = sal::static_int_cast< sal_uInt16 >( mTabId++ );
    rtl::OUString title (RTL_CONSTASCII_USTRINGPARAM( "" ) );
    pTabControl->InsertPage( id, title.getStr(), TAB_APPEND );
    pTabControl->SetTabPage( id, new TabPage( pTabControl ) );
    return id;
}

void SAL_CALL VCLXTabControl::removeTab( sal_Int32 ID )
{
    TabControl *pTabControl = getTabControl();
    if ( pTabControl->GetTabPage( sal::static_int_cast< sal_uInt16 >( ID ) ) == NULL )
        throw IndexOutOfBoundsException();
    pTabControl->RemovePage( sal::static_int_cast< sal_uInt16 >( ID ) );
}

void SAL_CALL VCLXTabControl::activateTab( sal_Int32 ID )
{
    TabControl *pTabControl = getTabControl();
    if ( pTabControl->GetTabPage( sal::static_int_cast< sal_uInt16 >( ID ) ) == NULL )
        throw IndexOutOfBoundsException();
    pTabControl->SelectTabPage( sal::static_int_cast< sal_uInt16 >( ID ) );
}

sal_Int32 SAL_CALL VCLXTabControl::getActiveTabID()
{
    return getTabControl()->GetCurPageId( );
}

void SAL_CALL VCLXTabControl::addTabListener( const uno::Reference< awt::XTabListener >& xListener )
{
    for ( std::list< uno::Reference
              < awt::XTabListener > >::const_iterator it
              = mxTabListeners.begin(); it != mxTabListeners.end(); it++ )
    {
        if ( *it == xListener )
            // already added
            return;
    }
    mxTabListeners.push_back( xListener );
}

void SAL_CALL VCLXTabControl::removeTabListener( const uno::Reference< awt::XTabListener >& xListener )
{
    for ( std::list< uno::Reference
              < awt::XTabListener > >::iterator it
              = mxTabListeners.begin(); it != mxTabListeners.end(); it++ )
    {
        if ( *it == xListener )
        {
            mxTabListeners.erase( it );
            break;
        }
    }
}

void SAL_CALL VCLXTabControl::setTabProps( sal_Int32 ID, const uno::Sequence< NamedValue >& Properties )
{
    TabControl *pTabControl = getTabControl();
    if ( pTabControl->GetTabPage( sal::static_int_cast< sal_uInt16 >( ID ) ) == NULL )
        throw IndexOutOfBoundsException();

    for ( int i = 0; i < Properties.getLength(); i++ )
    {
        const rtl::OUString &name = Properties[i].Name;
        const uno::Any &value = Properties[i].Value;

        if ( name  == rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Title" ) ) )
        {
            rtl::OUString title = value.get<rtl::OUString>();
            pTabControl->SetPageText( sal::static_int_cast< sal_uInt16 >( ID ), title.getStr() );
        }
    }
}

uno::Sequence< NamedValue > SAL_CALL VCLXTabControl::getTabProps( sal_Int32 ID )
{
    TabControl *pTabControl = getTabControl();
    if ( pTabControl->GetTabPage( sal::static_int_cast< sal_uInt16 >( ID ) ) == NULL )
        throw IndexOutOfBoundsException();

#define ADD_PROP( seq, i, name, val ) {                                \
        NamedValue value;                                                  \
        value.Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( name ) ); \
        value.Value = uno::makeAny( val );                                      \
        seq[i] = value;                                                    \
    }

    uno::Sequence< NamedValue > props( 2 );
    ADD_PROP( props, 0, "Title", rtl::OUString( pTabControl->GetPageText( sal::static_int_cast< sal_uInt16 >( ID ) ) ) );
    ADD_PROP( props, 1, "Position", pTabControl->GetPagePos( sal::static_int_cast< sal_uInt16 >( ID ) ) );
#undef ADD_PROP
    return props;
}

// TODO: draw tab border here
void SAL_CALL VCLXTabControl::draw( sal_Int32 nX, sal_Int32 nY )
{
    ::vos::OGuard aGuard( GetMutex() );

    TabControl *pTabControl = getTabControl();
    TabPage *pTabPage = pTabControl->GetTabPage( sal::static_int_cast< sal_uInt16 >(  getActiveTabID() ) );
    if ( pTabPage )
    {
        ::Point aPos( nX, nY );
        ::Size  aSize = pTabPage->GetSizePixel();

        OutputDevice* pDev = VCLUnoHelper::GetOutputDevice( getGraphics() );
        aPos  = pDev->PixelToLogic( aPos );
        aSize = pDev->PixelToLogic( aSize );

        pTabPage->Draw( pDev, aPos, aSize, 0 );
    }

    VCLXWindow::draw( nX, nY );
}

void VCLXTabControl::AddChild (uno::Reference< awt::XLayoutConstrains > const& xChild)

{
#ifndef __SUNPRO_CC
    OSL_TRACE ("%s: children: %d", __PRETTY_FUNCTION__, maChildren.size ());
#endif
    mIdMap[ xChild ] = mTabId++;
    Box_Base::AddChild( xChild );
#ifndef __SUNPRO_CC
    OSL_TRACE ("%s: children: %d", __PRETTY_FUNCTION__, maChildren.size ());
#endif
}

void SAL_CALL VCLXTabControl::addChild(
    const uno::Reference< awt::XLayoutConstrains > &xChild )
{
    mIdMap[ xChild ] = insertTab();
    Box_Base::addChild( xChild );
}

void SAL_CALL VCLXTabControl::removeChild( const uno::Reference< awt::XLayoutConstrains > &xChild )
{
    removeTab( mIdMap[xChild] );
    mIdMap[ xChild ] = -1;
    Box_Base::removeChild( xChild );
}

static void setChildrenVisible( uno::Reference < awt::XLayoutConstrains > xChild, bool visible )
{
    uno::Reference< awt::XWindow > xWin( xChild, uno::UNO_QUERY);
    if ( xWin.is() )
    {
        xWin->setVisible( visible );
    }

    uno::Reference < awt::XLayoutContainer > xCont( xChild, uno::UNO_QUERY );
    if ( xCont.is())
    {
        uno::Sequence< uno::Reference < awt::XLayoutConstrains > > children = xCont->getChildren();
        for ( int i = 0; i < children.getLength(); i++ )
        {
            setChildrenVisible( children[i], visible );
        }
    }
}

void SAL_CALL VCLXTabControl::allocateArea (awt::Rectangle const &area)
{
#ifndef __SUNPRO_CC
    OSL_TRACE ("\n%s", __PRETTY_FUNCTION__);
#endif
    maAllocation = area;

    TabControl *pTabControl = getTabControl();

// FIXME: this is wrong. We just want to set tab controls pos/size for
// the tabs menu, otherwise, it gets events that should go to children
// (I guess we could solve this by making the tabcontrol as the actual
// XWindow parent of its children, when importing...)  Not sure about
// TabPage drawing... That doesn't work on gtk+; just ignoring that.
// LATER: Nah, the proper fix is to get the XWindow hierarchy
// straight.

#if 0
    setPosSize( area.X, area.Y, area.Width, area.Height, awt::PosSize::POSSIZE );
#else
    awt::Size currentSize = getSize();
    awt::Size requestedSize (area.Width, area.Height);
//    requestedSize.Height = getHeightForWidth( area.Width );

    awt::Size minimumSize = getMinimumSize();
    if (requestedSize.Width < minimumSize.Width)
        requestedSize.Width = minimumSize.Width;
    if (requestedSize.Height < minimumSize.Height)
        requestedSize.Height = minimumSize.Height;

    Size pageSize = static_cast<TabControl*> (GetWindow ())->GetTabPageSizePixel ();
    awt::Size pageBasedSize (0, 0);
    pageBasedSize.Width = pageSize.Width ();
    pageBasedSize.Height = pageSize.Height ();

    const int wc = 0;
    const int hc = 20;
    static int pwc = 0;
    static int phc = 40;

    if (requestedSize.Width < pageBasedSize.Width)
        requestedSize.Width = pageBasedSize.Width + wc;
    if (requestedSize.Height < pageBasedSize.Height)
        requestedSize.Height = pageBasedSize.Height + hc;

    Size windowSize = GetWindow()->GetSizePixel();
    Window *parent = GetWindow()->GetParent();
    Size parentSize = parent->GetSizePixel();

#ifndef __SUNPRO_CC
#ifdef GCC_MAJOR
    OSL_TRACE ("\n%s", __PRETTY_FUNCTION__);
#endif /* GCC_MAJOR */
    OSL_TRACE ("%s: cursize: %d ,%d", __FUNCTION__, currentSize.Width, currentSize.Height );
    OSL_TRACE ("%s: area: %d, %d", __FUNCTION__, area.Width, area.Height );
    OSL_TRACE ("%s: minimum: %d, %d", __FUNCTION__, minimumSize.Width, minimumSize.Height );
    OSL_TRACE ("%s: requestedSize: %d, %d", __FUNCTION__, requestedSize.Width, requestedSize.Height );
    OSL_TRACE ("%s: pageBasedSize: %d, %d", __FUNCTION__, pageBasedSize.Width, pageBasedSize.Height );

    //OSL_TRACE ("%s: parent: %d, %d", __FUNCTION__, parentSize.Width(), parentSize.Height() );
    //OSL_TRACE ("%s: window: %d, %d", __FUNCTION__, windowSize.Width(), windowSize.Height() );
#endif

    //bRealized = false;
    if (!bRealized)
    {
        setPosSize( area.X, area.Y, requestedSize.Width, requestedSize.Height, awt::PosSize::POSSIZE );
        bRealized = true;
    }
    else
    {
        if ( requestedSize.Width > currentSize.Width + 10)
            setPosSize( 0, 0, requestedSize.Width, 0, awt::PosSize::WIDTH );
        if ( requestedSize.Height > currentSize.Height + 10)
            setPosSize( 0, 0, 0, requestedSize.Height, awt::PosSize::HEIGHT );
    }
#endif

    if (pageBasedSize.Width > parentSize.Width ()
        || pageBasedSize.Height > parentSize.Height ())
        //parent->SetSizePixel ( Size (pageBasedSize.Width, pageBasedSize.Height));
        //parent->SetSizePixel ( Size (pageBasedSize.Width + pwc, pageBasedSize.Height + phc));
        parent->SetSizePixel ( Size (requestedSize.Width + pwc, requestedSize.Height + phc));

    // FIXME: we can save cycles by setting visibility more sensibly. Having
    // it here does makes it easier when changing tabs (just needs a recalc())
    unsigned i = 0;
    for ( std::list<Box_Base::ChildData *>::const_iterator it
              = maChildren.begin(); it != maChildren.end(); it++, i++ )
    {
        ChildData *child = static_cast<VCLXTabControl::ChildData*> ( *it );
        uno::Reference
              < awt::XLayoutConstrains > xChild( child->mxChild );
        if ( xChild.is() )
        {
            uno::Reference< awt::XWindow > xWin( xChild, uno::UNO_QUERY );
            bool active = (i+1 == (unsigned) getActiveTabID());

            // HACK: since our layout:: container don't implement XWindow, we have no easy
            // way to set them invisible; lets just set all their children as such :P
#if 0
            if ( xWin.is() )
                xWin->setVisible( active );
#else
            setChildrenVisible( xChild, active );
#endif

            if ( active )
            {
                ::Rectangle label_rect = pTabControl->GetTabBounds( sal::static_int_cast< sal_uInt16 >( i+1 ) );
                ::Rectangle page_rect = pTabControl->GetTabPageBounds( sal::static_int_cast< sal_uInt16 >( i+1 ) );

                awt::Rectangle childRect;
                childRect.X = page_rect.Left();
                childRect.Y = SAL_MAX( label_rect.Bottom(), page_rect.Top() );
                childRect.Width = page_rect.Right() - page_rect.Left();
                childRect.Height = page_rect.Bottom() - childRect.Y;

                allocateChildAt( xChild, childRect );
            }
        }
    }
}

awt::Size SAL_CALL VCLXTabControl::getMinimumSize()
{
    awt::Size requestedSize = VCLXWindow::getMinimumSize();
    awt::Size childrenSize( 0, 0 );

    TabControl* pTabControl = static_cast< TabControl* >( GetWindow() );
    if ( !pTabControl )
        return requestedSize;

    // calculate size to accommodate all children
    unsigned i = 0;
    for ( std::list<Box_Base::ChildData *>::const_iterator it
              = maChildren.begin(); it != maChildren.end(); it++, i++ )
    {
        ChildData *child = static_cast<VCLXTabControl::ChildData*> ( *it );
        if ( child->mxChild.is() )
        {
            // set the title prop here...
            pTabControl->SetPageText( sal::static_int_cast< sal_uInt16 >( i+1 ), child->maTitle.getStr() );

            awt::Size childSize( child->mxChild->getMinimumSize() );
            childrenSize.Width = SAL_MAX( childSize.Width, childrenSize.Width );
            childrenSize.Height = SAL_MAX( childSize.Height, childrenSize.Height );
        }
    }

#ifndef __SUNPRO_CC
#ifdef GCC_MAJOR
    OSL_TRACE ("\n%s", __PRETTY_FUNCTION__);
#endif /* GCC_MAJOR */
    OSL_TRACE ("%s: children: %d", __FUNCTION__, i);
    OSL_TRACE ("%s: childrenSize: %d, %d", __FUNCTION__, childrenSize.Width, childrenSize.Height );
#endif

    requestedSize.Width += childrenSize.Width;
    requestedSize.Height += childrenSize.Height + 20;

    maRequisition = requestedSize;
    return requestedSize;
}

void VCLXTabControl::ProcessWindowEvent( const VclWindowEvent& _rVclWindowEvent )
{
    ::vos::OClearableGuard aGuard( GetMutex() );
    TabControl* pTabControl = static_cast< TabControl* >( GetWindow() );
    if ( !pTabControl )
        return;

    switch ( _rVclWindowEvent.GetId() )
    {
        case VCLEVENT_TABPAGE_ACTIVATE:
            forceRecalc();
        case VCLEVENT_TABPAGE_DEACTIVATE:
        case VCLEVENT_TABPAGE_INSERTED:
        case VCLEVENT_TABPAGE_REMOVED:
        case VCLEVENT_TABPAGE_REMOVEDALL:
        case VCLEVENT_TABPAGE_PAGETEXTCHANGED:
        {
            sal_uLong page = (sal_uLong) _rVclWindowEvent.GetData();
            for ( std::list< uno::Reference
                      < awt::XTabListener > >::iterator it
                      = mxTabListeners.begin(); it != mxTabListeners.end(); it++)
            {
                uno::Reference
                    < awt::XTabListener > listener = *it;

                switch ( _rVclWindowEvent.GetId() )
                {

                    case VCLEVENT_TABPAGE_ACTIVATE:
                        listener->activated( page );
                        break;
                    case VCLEVENT_TABPAGE_DEACTIVATE:
                        listener->deactivated( page );
                        break;
                    case VCLEVENT_TABPAGE_INSERTED:
                        listener->inserted( page );
                        break;
                    case VCLEVENT_TABPAGE_REMOVED:
                        listener->removed( page );
                        break;
                    case VCLEVENT_TABPAGE_REMOVEDALL:
                        for ( int i = 1; i < mTabId; i++)
                        {
                            if ( pTabControl->GetTabPage( sal::static_int_cast< sal_uInt16 >( i ) ) )
                                listener->removed( i );
                        }
                        break;
                    case VCLEVENT_TABPAGE_PAGETEXTCHANGED:
                        listener->changed( page, getTabProps( page ) );
                        break;
                }
            }
            break;
        }
        default:
            aGuard.clear();
            VCLXWindow::ProcessWindowEvent( _rVclWindowEvent );
            break;
    }
}

void SAL_CALL VCLXTabControl::setProperty( const ::rtl::OUString& PropertyName, const uno::Any &Value )
{
    VCLXWindow::setProperty( PropertyName, Value );
}

uno::Any SAL_CALL VCLXTabControl::getProperty( const ::rtl::OUString& PropertyName )
{
    return VCLXWindow::getProperty( PropertyName );
}

} // namespace layoutimpl