xref: /trunk/main/toolkit/source/layout/vcl/wfield.cxx (revision cf6516809c57e1bb0a940545cca99cdad54d4ce2)

/**************************************************************
 *
 * 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 "wrapper.hxx"

#include <comphelper/processfactory.hxx>
#include <com/sun/star/awt/XMetricField.hpp>
#include <com/sun/star/awt/XNumericField.hpp>
#include <com/sun/star/awt/XTextComponent.hpp>
#include <com/sun/star/awt/XListBox.hpp>
#include <com/sun/star/awt/XComboBox.hpp>
#include <cppuhelper/implbase1.hxx>
#include <com/sun/star/awt/XActionListener.hpp>
#include <com/sun/star/awt/XItemListener.hpp>
#include <com/sun/star/awt/XMouseListener.hpp>
#include <vcl/combobox.hxx>
#include <vcl/lstbox.hxx>

#include <toolkit/awt/vclxwindows.hxx>

using namespace ::com::sun::star;
using rtl::OUString;

#define LAYOUT_API_CALLS_HANDLER 0

namespace layout
{

class EditImpl : public ControlImpl
               , public ::cppu::WeakImplHelper1< awt::XTextListener >
{
public:
    Link maModifyHdl;

    uno::Reference< awt::XTextComponent > mxEdit;
    EditImpl( Context *context, const PeerHandle &peer, Window *window )
        : ControlImpl( context, peer, window )
        , mxEdit( peer, uno::UNO_QUERY )
    {
    }

    ~EditImpl ();

    virtual void SAL_CALL disposing( lang::EventObject const& e )
        throw (uno::RuntimeException);

    virtual void SetModifyHdl( Link const& link );

    void SAL_CALL textChanged( const awt::TextEvent& /* rEvent */ )
        throw (uno::RuntimeException)
    {
        maModifyHdl.Call( mpWindow );
    }
};

EditImpl::~EditImpl ()
{
}

void SAL_CALL EditImpl::disposing( lang::EventObject const& e )
    throw (uno::RuntimeException)
{
    ControlImpl::disposing (e);
    mxEdit.clear ();
}

void EditImpl::SetModifyHdl( Link const& link )
{
    if (!link && !!maModifyHdl)
        mxEdit->removeTextListener( this );
    else if (!!link && !maModifyHdl)
        mxEdit->addTextListener( this );
    maModifyHdl = link;
}

Edit::~Edit ()
{
    SetModifyHdl (Link ());
}

void Edit::SetSelection( Selection const& rSelection )
{
#if LAYOUT_API_CALLS_HANDLER
    if ( !getImpl()->mxEdit.is() )
        getImpl()->mxEdit->setSelection( awt::Selection( rSelection.Min(), rSelection.Max() ) );
#else /* !LAYOUT_API_CALLS_HANDLER */
    GetEdit ()->SetSelection (rSelection);
#endif /* !LAYOUT_API_CALLS_HANDLER */
}

void Edit::SetText( OUString const& rStr )
{
#if LAYOUT_API_CALLS_HANDLER
    if ( getImpl()->mxEdit.is() )
        /// this calls handlers; endless loop in numfmt.cxx
        getImpl()->mxEdit->setText( rStr );
#else /* !LAYOUT_API_CALLS_HANDLER */
    GetEdit ()->SetText (rStr);
#endif /* !LAYOUT_API_CALLS_HANDLER */
}

String Edit::GetText() const
{
    if ( !getImpl()->mxEdit.is() )
        return getImpl()->mxEdit->getText();
    return OUString();
}

void Edit::SetModifyHdl( const Link& link )
{
    if (getImpl() && getImpl()->mxEdit.is ())
        getImpl()->SetModifyHdl( link );
}

IMPL_CONSTRUCTORS( Edit, Control, "edit" );
IMPL_GET_IMPL( Edit );
IMPL_GET_WINDOW (Edit);

class MultiLineEditImpl : public EditImpl
{
public:
    MultiLineEditImpl( Context *context, const PeerHandle &peer, Window *window )
        : EditImpl( context, peer, window )
    {
    }
};

IMPL_CONSTRUCTORS( MultiLineEdit, Edit, "multilineedit" );
IMPL_GET_IMPL( MultiLineEdit );

class SpinFieldImpl : public EditImpl
{
  public:
    SpinFieldImpl( Context *context, const PeerHandle &peer, Window *window )
        : EditImpl( context, peer, window )
    {
    }
};

IMPL_CONSTRUCTORS( SpinField, Edit, "spinfield" );

class NumericFieldImpl : public SpinFieldImpl
{
  public:
    NumericFieldImpl( Context *context, const PeerHandle &peer, Window *window )
        : SpinFieldImpl( context, peer, window )
    {
    }
};

class MetricFieldImpl : public SpinFieldImpl
{
  public:
    MetricFieldImpl( Context *context, const PeerHandle &peer, Window *window )
        : SpinFieldImpl( context, peer, window )
    {
    }
};

IMPL_GET_IMPL( SpinField );
IMPL_GET_IMPL( NumericField );
IMPL_GET_IMPL( MetricField );

class FormatterBaseImpl
{
  protected:
    PeerHandle mpeer;
  public:
    explicit FormatterBaseImpl( const PeerHandle &peer )
        : mpeer( peer )
    {
    };
};

FormatterBase::FormatterBase( FormatterBaseImpl *pFormatImpl )
    : mpFormatImpl( pFormatImpl )
{
}

class NumericFormatterImpl : public FormatterBaseImpl
{
  public:
    uno::Reference< awt::XNumericField > mxField;
    explicit NumericFormatterImpl( const PeerHandle &peer )
        : FormatterBaseImpl( peer )
        , mxField( peer, uno::UNO_QUERY )
    {
    }

    // FIXME: burn that CPU ! cut/paste from vclxwindows.cxx
    double valueToDouble( sal_Int64 nValue )
    {
        sal_Int16 nDigits = mxField->getDecimalDigits();
        double n = (double)nValue;
        for ( sal_uInt16 d = 0; d < nDigits; d++ )
            n /= 10;
        return n;
    } // FIXME: burn that CPU ! cut/paste from vclxwindows.cxx
    sal_Int64 doubleToValue( double nValue )
    {
        sal_Int16 nDigits = mxField->getDecimalDigits();
        double n = nValue;
        for ( sal_uInt16 d = 0; d < nDigits; d++ )
            n *= 10;
        return (sal_Int64) n;
    }
};

class MetricFormatterImpl : public FormatterBaseImpl
{
  public:
    uno::Reference< awt::XMetricField > mxField;
    explicit MetricFormatterImpl( const PeerHandle &peer )
        : FormatterBaseImpl( peer )
        , mxField( peer, uno::UNO_QUERY )
    {
    }
};

NumericFormatter::NumericFormatter( FormatterBaseImpl *pImpl )
    : FormatterBase( pImpl )
{
}

NumericFormatterImpl& NumericFormatter::getFormatImpl() const
{
    return *( static_cast<NumericFormatterImpl *>( mpFormatImpl ) );
}

#define SET_IMPL(vclmethod, idlmethod) \
    void NumericFormatter::vclmethod( sal_Int64 nValue ) \
    { \
        if ( !getFormatImpl().mxField.is() ) \
            return; \
        getFormatImpl().mxField->idlmethod( getFormatImpl().valueToDouble( nValue ) ); \
    }

SET_IMPL( SetMin, setMin )
SET_IMPL( SetMax, setMax )
SET_IMPL( SetLast, setLast )
SET_IMPL( SetFirst, setFirst )
SET_IMPL( SetValue, setValue )
SET_IMPL( SetSpinSize, setSpinSize )

sal_Int64 NumericFormatter::GetValue() const
{
    if ( !getFormatImpl().mxField.is() )
        return 0;
    return getFormatImpl().doubleToValue( getFormatImpl().mxField->getValue() );
}

#undef SET_IMPL

IMPL_CONSTRUCTORS_2( NumericField, SpinField, NumericFormatter, "numericfield" );

MetricFormatter::MetricFormatter( FormatterBaseImpl *pImpl )
    : FormatterBase( pImpl )
{
}
MetricFormatterImpl& MetricFormatter::getFormatImpl() const
{    return *( static_cast<MetricFormatterImpl *>( mpFormatImpl ) );   }

#define MetricUnitVclToUno(a) ((sal_uInt16)(a))

#define SET_IMPL(vclmethod, idlmethod) \
    void MetricFormatter::vclmethod( sal_Int64 nValue, FieldUnit nUnit ) \
    { \
        if ( !getFormatImpl().mxField.is() ) \
            return; \
        getFormatImpl().mxField->idlmethod( nValue, MetricUnitVclToUno( nUnit ) ); \
    }

SET_IMPL( SetMin, setMin )
SET_IMPL( SetMax, setMax )
SET_IMPL( SetLast, setLast )
SET_IMPL( SetFirst, setFirst )
SET_IMPL( SetValue, setValue )

#undef SET_IMPL

void MetricFormatter::SetSpinSize( sal_Int64 nValue )
{
    if ( !getFormatImpl().mxField.is() )
        return;
    getFormatImpl().mxField->setSpinSize( nValue );
}

sal_Int64 MetricFormatter::GetValue( FieldUnit nUnit ) const
{
    if ( !getFormatImpl().mxField.is() )
        return 0;
    return getFormatImpl().mxField->getValue( MetricUnitVclToUno( nUnit ) );
}

IMPL_CONSTRUCTORS_2( MetricField, SpinField, MetricFormatter, "metricfield" );

class ComboBoxImpl : public EditImpl
                   , public ::cppu::WeakImplHelper1< awt::XActionListener >
                   , public ::cppu::WeakImplHelper1< awt::XItemListener >
{
public:
    uno::Reference< awt::XComboBox > mxComboBox;

    Link maClickHdl;
    Link maSelectHdl;

    Window *parent;

    ComboBoxImpl( Context *context, const PeerHandle &peer, Window *window )
        : EditImpl( context, peer, window )
        , mxComboBox( peer, uno::UNO_QUERY )
    {
    }

    ~ComboBoxImpl ();

    sal_uInt16 InsertEntry( OUString const& rStr, sal_uInt16 nPos )
    {
        if ( nPos == COMBOBOX_APPEND )
            nPos = GetEntryCount();
        mxComboBox->addItem( rtl::OUString( rStr ), nPos );
        return nPos;
    }

    void RemoveEntry( sal_uInt16 nPos )
    {
        mxComboBox->removeItems( nPos, 1 );
    }

    sal_uInt16 GetEntryPos( String const& rStr ) const
    {
        uno::Sequence< rtl::OUString> aItems( mxComboBox->getItems() );
        rtl::OUString rKey( rStr );
        sal_uInt16 n = sal::static_int_cast< sal_uInt16 >(aItems.getLength());
        for (sal_uInt16 i = 0; i < n; i++)
        {
            if ( aItems[ i ] == rKey )
                return i;
        }
        return COMBOBOX_ENTRY_NOTFOUND;
    }

    OUString GetEntry( sal_uInt16 nPos ) const
    {
        return OUString( mxComboBox->getItem( nPos ) );
    }

    sal_uInt16 GetEntryCount() const
    {
        return mxComboBox->getItemCount();
    }

    void SetClickHdl( Link const& link )
    {
        if (!link && !!maClickHdl)
            mxComboBox->removeActionListener( this );
        else if (!!link && !maClickHdl)
            mxComboBox->addActionListener( this );
        maClickHdl = link;
    }

    void SetSelectHdl( Link const& link )
    {
        if (!link && !!maSelectHdl)
            mxComboBox->removeItemListener( this );
        else if (!!link && !maSelectHdl)
            mxComboBox->addItemListener( this );
        maSelectHdl = link;
    }

    void SAL_CALL disposing( lang::EventObject const& e )
        throw (uno::RuntimeException);

    void SAL_CALL actionPerformed (const awt::ActionEvent&)
        throw (uno::RuntimeException)
    {
        ComboBox* pComboBox = static_cast<ComboBox*>( mpWindow );
        if ( !pComboBox )
            return;
        maClickHdl.Call( pComboBox );
    }

    void SAL_CALL itemStateChanged( awt::ItemEvent const&)
        throw (uno::RuntimeException)
    {
        ComboBox* pComboBox = static_cast<ComboBox*>( mpWindow );
        if ( !pComboBox )
            return;
        maSelectHdl.Call( pComboBox );
    }
};

ComboBox::~ComboBox ()
{
#ifndef __SUNPRO_CC
    OSL_TRACE ("%s: deleting ComboBox for window: %p", __FUNCTION__, GetWindow ());
#endif
}

ComboBoxImpl::~ComboBoxImpl ()
{
#ifndef __SUNPRO_CC
    OSL_TRACE ("%s: deleting ComboBoxImpl for window: %p", __FUNCTION__, mpWindow ? mpWindow->GetWindow () : 0);
    OSL_TRACE ("%s: deleting ComboBoxImpl for listener: %p", __FUNCTION__, static_cast<XFocusListener*> (this));
#endif
}

void ComboBoxImpl::disposing( lang::EventObject const& e )
    throw (uno::RuntimeException)
{
    EditImpl::disposing (e);
    mxComboBox.clear ();
}

sal_uInt16 ComboBox::InsertEntry( String const& rStr, sal_uInt16 nPos )
{
    return getImpl()->InsertEntry( rStr, nPos );
}

void ComboBox::RemoveEntry( String const& rStr )
{
    getImpl()->RemoveEntry( GetEntryPos( rStr ) );
}

void ComboBox::RemoveEntry( sal_uInt16 nPos )
{
    getImpl()->RemoveEntry( nPos );
}

void ComboBox::Clear()
{
    uno::Sequence< rtl::OUString> aNoItems;
    if ( getImpl() )
        getImpl()->setProperty( "StringItemList", uno::Any( aNoItems ) );
}

sal_uInt16 ComboBox::GetEntryPos( String const& rStr ) const
{
    return getImpl()->GetEntryPos( rStr );
}

String ComboBox::GetEntry( sal_uInt16 nPos ) const
{
    rtl::OUString rItem = getImpl()->mxComboBox->getItem( nPos );
    return OUString( rItem );
}

sal_uInt16 ComboBox::GetEntryCount() const
{
    return getImpl()->GetEntryCount();
}

void ComboBox::SetClickHdl( const Link& link )
{
    if (getImpl() && getImpl()->mxComboBox.is ())
        getImpl()->SetClickHdl( link );
}

void ComboBox::SetSelectHdl( const Link& link )
{
    if (getImpl() && getImpl()->mxComboBox.is ())
        getImpl()->SetSelectHdl( link );
}

void ComboBox::EnableAutocomplete (bool enable, bool matchCase)
{
    GetComboBox ()->EnableAutocomplete (enable, matchCase);
}

IMPL_CONSTRUCTORS_BODY( ComboBox, Edit, "combobox", getImpl()->parent = parent; );
IMPL_GET_WINDOW (ComboBox);
IMPL_GET_IMPL( ComboBox );

class ListBoxImpl : public ControlImpl
                  , public ::cppu::WeakImplHelper1< awt::XActionListener >
                  , public ::cppu::WeakImplHelper1< awt::XItemListener >
                  , public ::cppu::WeakImplHelper1< awt::XMouseListener >
{
    Link maClickHdl;
    Link maSelectHdl;
    Link maDoubleClickHdl;

public:
    uno::Reference< awt::XListBox > mxListBox;
    ListBoxImpl( Context *context, const PeerHandle &peer, Window *window )
        : ControlImpl( context, peer, window )
        , mxListBox( peer, uno::UNO_QUERY )
    {
        SelectEntryPos (0, true);
    }

    sal_uInt16 InsertEntry (String const& rStr, sal_uInt16 nPos)
    {
        if ( nPos == LISTBOX_APPEND )
            nPos = mxListBox->getItemCount();
        mxListBox->addItem( rtl::OUString( rStr ), nPos );
        return nPos;
    }

    void RemoveEntry( sal_uInt16 nPos )
    {
        mxListBox->removeItems( nPos, 1 );
    }

    sal_uInt16 RemoveEntry( String const& rStr, sal_uInt16 nPos)
    {
        if ( nPos == LISTBOX_APPEND )
            nPos = mxListBox->getItemCount();
        mxListBox->addItem( rtl::OUString( rStr ), nPos );
        return nPos;
    }

    sal_uInt16 GetEntryPos( String const& rStr ) const
    {
        uno::Sequence< rtl::OUString> aItems( mxListBox->getItems() );
        rtl::OUString rKey( rStr );
        sal_uInt16 n = sal::static_int_cast< sal_uInt16 >(aItems.getLength());
        for (sal_uInt16 i = 0; i < n; i++)
        {
            if ( aItems[ i ] == rKey )
                return i;
        }
        return LISTBOX_ENTRY_NOTFOUND;
    }

    OUString GetEntry( sal_uInt16 nPos ) const
    {
        return mxListBox->getItem( nPos );
    }

    sal_uInt16 GetEntryCount() const
    {
        return mxListBox->getItemCount();
    }

    void SelectEntryPos( sal_uInt16 nPos, bool bSelect )
    {
        mxListBox->selectItemPos( nPos, bSelect );
    }

    sal_uInt16 GetSelectEntryCount() const
    {
        return sal::static_int_cast< sal_uInt16 >( mxListBox->getSelectedItems().getLength() );
    }

    sal_uInt16 GetSelectEntryPos( sal_uInt16 nSelIndex ) const
    {
        sal_uInt16 nSelected = 0;
        if ( mxListBox->isMutipleMode() )
        {
            uno::Sequence< short > aItems( mxListBox->getSelectedItemsPos() );
            if ( nSelIndex < aItems.getLength() )
                nSelected = aItems[ nSelIndex ];
        }
        else
            nSelected = mxListBox->getSelectedItemPos();
        return nSelected;
    }

    virtual void SAL_CALL disposing( lang::EventObject const& e )
        throw (uno::RuntimeException)
    {
        ControlImpl::disposing (e);
        mxListBox.clear ();
    }

    Link& GetClickHdl ()
    {
        return maClickHdl;
    }

    void SetClickHdl( Link const& link )
    {
        if (!link && !!maClickHdl)
            mxListBox->removeActionListener( this );
        else if (!!link && !maClickHdl)
            mxListBox->addActionListener( this );
        maClickHdl = link;
    }

    void SAL_CALL actionPerformed( const awt::ActionEvent& /* rEvent */ )
        throw (uno::RuntimeException)
    {
        maClickHdl.Call( mpWindow );
    }

    Link& GetSelectHdl ()
    {
        return maSelectHdl;
    }

    void SetSelectHdl( Link const& link )
    {
        if (!link && !!maSelectHdl)
            mxListBox->removeItemListener( this );
        else if (!!link && !maSelectHdl)
            mxListBox->addItemListener( this );
        maSelectHdl = link;
    }

    void SAL_CALL itemStateChanged (awt::ItemEvent const&)
        throw (uno::RuntimeException)
    {
        maSelectHdl.Call (static_cast <ListBox*> (mpWindow));
    }

    Link& GetDoubleClickHdl ()
    {
        return maDoubleClickHdl;
    }

    void SetDoubleClickHdl (Link const& link)
    {
        if (!link && !!maDoubleClickHdl)
            mxWindow->removeMouseListener (this);
        else if (!!link && !maSelectHdl)
            mxWindow->addMouseListener (this);
        maDoubleClickHdl = link;
    }

    void SAL_CALL mousePressed (awt::MouseEvent const&) throw (uno::RuntimeException)
    {
    }
    void SAL_CALL mouseReleased (awt::MouseEvent const& e) throw (uno::RuntimeException)
    {
        if (e.ClickCount == 2)
            maDoubleClickHdl.Call (mpWindow);
    }
    void SAL_CALL mouseEntered (awt::MouseEvent const&) throw (uno::RuntimeException)
    {
    }
    void SAL_CALL mouseExited (awt::MouseEvent const&) throw (uno::RuntimeException)
    {
    }
};

ListBox::~ListBox ()
{
}

sal_uInt16 ListBox::InsertEntry (String const& rStr, sal_uInt16 nPos)
{
    return getImpl()->InsertEntry(rStr, nPos);
}

void ListBox::RemoveEntry( sal_uInt16 nPos )
{
    return getImpl()->RemoveEntry( nPos );
}

void ListBox::RemoveEntry( String const& rStr )
{
    return getImpl()->RemoveEntry( GetEntryPos( rStr ) );
}

void ListBox::Clear()
{
    uno::Sequence< rtl::OUString> aNoItems;
    if ( getImpl() )
        getImpl()->setProperty( "StringItemList", uno::Any( aNoItems ) );
}

sal_uInt16 ListBox::GetEntryPos( String const& rStr ) const
{
    return getImpl()->GetEntryPos( rStr );
}

String ListBox::GetEntry( sal_uInt16 nPos ) const
{
    return getImpl()->GetEntry( nPos );
}

sal_uInt16 ListBox::GetEntryCount() const
{
    return getImpl()->GetEntryCount();
}

void ListBox::SelectEntryPos( sal_uInt16 nPos, bool bSelect )
{
#if LAYOUT_API_CALLS_HANDLER
    getImpl()->SelectEntryPos( nPos, bSelect );
#else /* !LAYOUT_API_CALLS_HANDLER */
    GetListBox ()->SelectEntryPos (nPos, bSelect);
#endif /* !LAYOUT_API_CALLS_HANDLER */
}

void ListBox::SelectEntry( String const& rStr, bool bSelect )
{
    SelectEntryPos( GetEntryPos( rStr ), bSelect );
}

sal_uInt16 ListBox::GetSelectEntryCount() const
{
    return getImpl()->GetSelectEntryCount();
}

sal_uInt16 ListBox::GetSelectEntryPos( sal_uInt16 nSelIndex ) const
{
    return getImpl()->GetSelectEntryPos( nSelIndex );
}

String ListBox::GetSelectEntry( sal_uInt16 nSelIndex ) const
{
    return GetEntry( GetSelectEntryPos( nSelIndex ) );
}

Link& ListBox::GetSelectHdl ()
{
    return getImpl()->GetSelectHdl ();
}

void ListBox::SetSelectHdl( Link const& link )
{
    getImpl()->SetSelectHdl( link );
}

Link& ListBox::GetClickHdl ()
{
    return getImpl()->GetSelectHdl ();
}

void ListBox::SetClickHdl( Link const& link )
{
    if (getImpl() && getImpl()->mxListBox.is ())
        getImpl()->SetClickHdl( link );
}

Link& ListBox::GetDoubleClickHdl ()
{
    return getImpl()->GetSelectHdl ();
}

void ListBox::SetDoubleClickHdl( Link const& link )
{
    getImpl()->SetDoubleClickHdl( link );
}

void ListBox::SetEntryData( sal_uInt16 pos, void* data)
{
    GetListBox ()->SetEntryData (pos, data);
}

void* ListBox::GetEntryData( sal_uInt16 pos) const
{
    return GetListBox ()->GetEntryData (pos);
}

void ListBox::SetNoSelection ()
{
    GetListBox ()->SetNoSelection ();
}

IMPL_CONSTRUCTORS (ListBox, Control, "listbox");
IMPL_GET_IMPL (ListBox);
IMPL_GET_WINDOW (ListBox);

IMPL_IMPL (MultiListBox, ListBox)
IMPL_CONSTRUCTORS_BODY( MultiListBox, ListBox, "multilistbox", GetMultiListBox()->EnableMultiSelection( true ); );
IMPL_GET_IMPL( MultiListBox );
IMPL_GET_WINDOW( MultiListBox );
} // namespace layout