path: root/include/sfx2/controlwrapper.hxx

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   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 .
 */

#ifndef INCLUDED_SFX2_CONTROLWRAPPER_HXX
#define INCLUDED_SFX2_CONTROLWRAPPER_HXX

#include <tools/debug.hxx>
#include <sal/config.h>
#include <sfx2/dllapi.h>

#include <memory>

#include <vcl/button.hxx>
#include <vcl/edit.hxx>
#include <vcl/field.hxx>
#include <vcl/lstbox.hxx>
#include <svtools/valueset.hxx>
#include <svtools/ctrlbox.hxx>


namespace sfx {


/** List position type of VCL ListBox. */
typedef sal_uInt16 ListBoxPosType;
/** List position type of SVTOOLS ValueSet. */
typedef sal_uInt16 ValueSetPosType;


// Helpers


/** A helper class for mapping list positions from/to represented values.

    Deriving from this helper class adds the two functions GetValueFromPos()
    and GetPosFromValue(). The constructor receives an array of MapEntryType
    structures that represents the table of positions and values. It is
    possible to pass a null pointer, this results in a direct mapping between
    list positions and values. If the map exists, it MUST be terminated with an
    entry containing the special "not found" list position passed to the
    constructor. The value contained in this last entry is used as default
    value in case of an error.
 */
template< typename PosT, typename ValueT >
class PosValueMapper
{
public:
    typedef PosT                            PosType;
    typedef ValueT                          ValueType;
    typedef PosValueMapper< PosT, ValueT >  MapperType;

    /** A helper struct that contains a list position - value pair. */
    struct MapEntryType
    {
        PosT                mnPos;      /// Position in the list.
        ValueT              mnValue;    /// Corresponding value.
    };

    /** Constructs the map helper with the passed map.
        @param nNFPos  This list position is used to represent the
        "not found" or "not existing" state.
        @param pMap  The map of list positions/values. If 0, a direct mapping
        is used (simply casting between list position and values). If the map
        exists, it *MUST* be terminated by an entry containing the special
        "not found" list position. */
    explicit     PosValueMapper( PosT nNFPos, const MapEntryType* pMap = nullptr ) :
                            mpMap( pMap ), mnNFPos( nNFPos ) {}

    /** Returns the value at the specified list position.
        @return  The found value, or the value of the last map entry on error. */
    ValueT              GetValueFromPos( PosT nPos ) const;
    /** Returns the list position of the specified value.
        @return  The position, or the special "not found" position on error. */
    PosT                GetPosFromValue( ValueT nValue ) const;

    /** Returns the special "not found" list position. */
    PosT         GetNotFoundPos() const { return mnNFPos; }

private:
    const MapEntryType* mpMap;      /// The list position/value map.
    PosT                mnNFPos;    /// Special "not found" list position.
};


// Base control wrapper classes


/** Base class for all control wrappers.

    Control wrappers are used to have an equal interface for various functions
    used in connections for different types of controls.

    The current tree of base classes/templates and standard control wrappers:

    ControlWrapperBase
     |
     +- SingleControlWrapper< ControlT, ValueT >
     |   |
     |   +- DummyWindowWrapper   [1]
     |   +- CheckBoxWrapper   [1]
     |   +- EditWrapper   [1]
     |   +- SvxColorListBoxWrapper   [1]
     |   |
     |   +- MetricFieldWrapper< ValueT >   [1]
     |   |   |
     |   |   +- [ValueType]MetricFieldWrapper   [1] [2]
     |   |
     |   +- ListBoxWrapper< ValueT >   [1]
     |   |   |
     |   |   +- [ValueType]ListBoxWrapper   [1] [2]
     |   |
     |   +- ValueSetWrapper< ValueT >   [1]
     |       |
     |       +- [ValueType]ValueSetWrapper   [1] [2]
     |
     +- MultiControlWrapperHelper
         |
         +- MultiControlWrapper< ValueT >

    Notes:
    [1] Standard wrappers ready to use.
    [2] [ValueType] is one of Int16, UInt16, Int32, UInt32, UShort, ULong.

    See documentation of class ItemConnectionBase (itemconnect.hxx) for more
    details.
 */
class SFX2_DLLPUBLIC ControlWrapperBase
{
public:
    explicit     ControlWrapperBase() {}
    virtual             ~ControlWrapperBase();

    /** Derived classes enable, disable, show, or hide control(s).
        @descr  Will do nothing, if the corresponding parameter is TRISTATE_INDET. */
    virtual void        ModifyControl( TriState eShow ) = 0;

    /** Derived classes return true if the control is in "don't know" state. */
    virtual bool        IsControlDontKnow() const = 0;
    /** Derived classes set the control to "don't know" state. */
    virtual void        SetControlDontKnow( bool bSet ) = 0;

private:
                        ControlWrapperBase( const ControlWrapperBase& ) = delete;
    ControlWrapperBase& operator=( const ControlWrapperBase& ) = delete;
};


// Single control wrappers


/** Base class template for control wrappers containing one single control.

    Classes created from this template store the reference to a single control
    object. It is not required that the control is derived from VCL's Window
    class. Derived classes have to implement the abstract functions
    ShowControl(), EnableControl(), IsControlDontKnow(), SetControlDontKnow(),
    GetControlValue(), and SetControlValue().

    As already stated, it is not required for ControlT to be a VCL Window.
    Anyway, ControlT must support the following functions:
    - void ControlT::Enable( bool )
    - void ControlT::Show( bool )
 */
template< typename ControlT, typename ValueT >
class SingleControlWrapper : public ControlWrapperBase
{
public:
    typedef ControlT                                 ControlType;
    typedef ValueT                                   ControlValueType;
    typedef SingleControlWrapper< ControlT, ValueT > SingleControlWrapperType;

    explicit     SingleControlWrapper( ControlT& rControl ) : mrControl( rControl ) {}

    /** Returns a reference to the control this connection works on. */
    const ControlT& GetControl() const { return mrControl; }
    /** Returns a reference to the control this connection works on. */
    ControlT&    GetControl() { return mrControl; }

    /** Enables, disables, shows, or hides the control.
        @descr  Does nothing, if the corresponding parameter is TRISTATE_INDET. */
    virtual void        ModifyControl( TriState eShow ) override;

    /** Derived classes return the value the control contains. */
    virtual ValueT      GetControlValue() const = 0;
    /** Derived classes set the contents of the control to the passed value. */
    virtual void        SetControlValue( ValueT aValue ) = 0;

private:
    ControlT&           mrControl;  /// The control of this wrapper.
};


/** A dummy wrapper for a VCL Window that does nothing special.

    This wrapper is used to implement the DummyItemConnection. It does not
    connect an item to a control, but handles the special flags to disable or
    hide a control, if an item is unknown.
 */
class SFX2_DLLPUBLIC DummyWindowWrapper:
    public SingleControlWrapper< vcl::Window, void* >
{
public:
    explicit            DummyWindowWrapper( vcl::Window& rWindow );

    virtual bool        IsControlDontKnow() const override;
    virtual void        SetControlDontKnow( bool ) override;

    virtual void*       GetControlValue() const override;
    virtual void        SetControlValue( void* ) override;
};


/** A wrapper for the VCL CheckBox. */
class SFX2_DLLPUBLIC CheckBoxWrapper:
    public SingleControlWrapper< CheckBox, bool >
{
public:
    explicit            CheckBoxWrapper( CheckBox& rCheckBox );

    virtual bool        IsControlDontKnow() const override;
    virtual void        SetControlDontKnow( bool bSet ) override;

    virtual bool        GetControlValue() const override;
    virtual void        SetControlValue( bool bValue ) override;
};


/** A wrapper for the VCL MetricField.

    Adds support for field units during accessing the control value. The
    wrapper respects the field unit set at the control itself and converts it
    from/to the field unit passed to the constructor.
 */
template< typename ValueT >
class MetricFieldWrapper : public SingleControlWrapper< MetricField, ValueT >
{
public:
    explicit     MetricFieldWrapper( MetricField& rField, FieldUnit eUnit = FUNIT_NONE ) :
                            SingleControlWrapper< MetricField, ValueT >( rField ), meUnit( eUnit ) {}

    virtual bool        IsControlDontKnow() const SAL_OVERRIDE;
    virtual void        SetControlDontKnow( bool bSet ) SAL_OVERRIDE;

    virtual ValueT      GetControlValue() const SAL_OVERRIDE;
    virtual void        SetControlValue( ValueT nValue ) SAL_OVERRIDE;

private:
    FieldUnit           meUnit;
};


#define WRAPPER_LISTBOX_ENTRY_NOTFOUND  0xFFFF  /* XXX was value of LISTBOX_ENTRY_NOTFOUND */

/** A wrapper for the VCL ListBox.

    If a position<->value map is passed to the constructor, it MUST be
    terminated with an entry containing WRAPPER_LISTBOX_ENTRY_NOTFOUND as list
    position. See documentation of the PosValueMapper template for details.
 */
template< typename ValueT >
class ListBoxWrapper :
        public SingleControlWrapper< ListBox, ValueT >,
        public PosValueMapper< ListBoxPosType, ValueT >
{
    typedef PosValueMapper< ListBoxPosType, ValueT > MapperType;

public:
    typedef typename MapperType::MapEntryType MapEntryType;

    /** @param pMap  Optional list position <-> value map.
        See PosValueMapper documentation for details. */
    explicit     ListBoxWrapper( ListBox& rListBox, const MapEntryType* pMap = nullptr ) :
                            SingleControlWrapper< ListBox, ValueT >( rListBox ), MapperType( WRAPPER_LISTBOX_ENTRY_NOTFOUND, pMap ) {}

    virtual bool        IsControlDontKnow() const SAL_OVERRIDE
                            { return this->GetControl().GetSelectEntryCount() == 0; }
    virtual void        SetControlDontKnow( bool bSet ) SAL_OVERRIDE
                            { if( bSet ) this->GetControl().SetNoSelection(); }

    virtual ValueT      GetControlValue() const SAL_OVERRIDE;
    virtual void        SetControlValue( ValueT nValue ) SAL_OVERRIDE;
};


#define WRAPPER_VALUESET_ITEM_NOTFOUND  0xFFFF  /* XXX was value of VALUESET_ITEM_NOTFOUND */

/** A wrapper for the SVTOOLS ValueSet.

    If a position<->value map is passed to the constructor, it MUST be
    terminated with an entry containing WRAPPER_VALUESET_ITEM_NOTFOUND as list
    position. See documentation of the PosValueMapper template for details.
 */
template< typename ValueT >
class ValueSetWrapper :
        public SingleControlWrapper< ValueSet, ValueT >,
        public PosValueMapper< ValueSetPosType, ValueT >
{
    typedef PosValueMapper< ValueSetPosType, ValueT > MapperType;

public:
    typedef typename MapperType::MapEntryType MapEntryType;

    /** @param pMap  Optional position <-> value map.
        See PosValueMapper documentation for details. */
    explicit     ValueSetWrapper( ValueSet& rValueSet, const MapEntryType* pMap = nullptr ) :
                            SingleControlWrapper< ValueSet, ValueT >( rValueSet ), MapperType( WRAPPER_VALUESET_ITEM_NOTFOUND, pMap ) {}

    virtual bool        IsControlDontKnow() const SAL_OVERRIDE
                            { return this->GetControl().IsNoSelection(); }
    virtual void        SetControlDontKnow( bool bSet ) SAL_OVERRIDE
                            { if( bSet ) this->GetControl().SetNoSelection(); }

    virtual ValueT      GetControlValue() const SAL_OVERRIDE;
    virtual void        SetControlValue( ValueT nValue ) SAL_OVERRIDE;
};


// Multi control wrappers


struct MultiControlWrapperHelper_Impl;

/** A container of control wrappers.

    Derived classes should define control wrapper members and register them in
    their constructor, using the function RegisterControlWrapper().

    This wrapper implements the abstract functions of the ControlWrapperBase
    base class by calling the functions of all registered wrappers.
 */
class SFX2_DLLPUBLIC MultiControlWrapperHelper : public ControlWrapperBase
{
public:
    explicit            MultiControlWrapperHelper();
    virtual             ~MultiControlWrapperHelper() override;

    /** Registers a control wrapper (should be a member of a derived class). */
    void                RegisterControlWrapper( ControlWrapperBase& rWrapper );

    /** Enables, disables, shows, or hides the registered controls. */
    virtual void        ModifyControl( TriState eShow ) override;

    /** Returns true if all registered controls are in "don't know" state. */
    virtual bool        IsControlDontKnow() const override;
    /** Sets all registered controls to "don't know" state. */
    virtual void        SetControlDontKnow( bool bSet ) override;

private:
    std::unique_ptr< MultiControlWrapperHelper_Impl > mxImpl;
};


/** A multi control wrapper with extended interface.

    This template class extends the MultiControlWrapperHelper class by the
    functions GetControlValue() and SetControlValue(), known from the
    SingleControlWrapper template. This makes it possible to use this template
    in item connections expecting a single control wrapper. The type ValueT
    should be able to contain the values of all controls handled in this
    wrapper. In most cases, the easiest way to achieve this is to use the
    related item type directly, using the IdentItemWrapper template
    (itemwrapper.hxx).
 */
template< typename ValueT >
class MultiControlWrapper : public MultiControlWrapperHelper
{
public:
    typedef MultiControlWrapperHelper       ControlType;
    typedef ValueT                          ControlValueType;
    typedef MultiControlWrapper< ValueT >   MultiControlWrapperType;

    MultiControlWrapper() : maDefValue( 0 ){}

    /** Returns the default value that can be used in GetControlValue(). */
    const ValueT& GetDefaultValue() const { return maDefValue; }
    /** Sets a default value that can be used in GetControlValue(). */
    void         SetDefaultValue( const ValueT& rDefValue ) { maDefValue = rDefValue; }

    /** Derived classes return the value the control contains. */
    virtual ValueT      GetControlValue() const = 0;
    /** Derived classes set the contents of the control to the passed value. */
    virtual void        SetControlValue( ValueT aValue ) = 0;

private:
    ValueT              maDefValue;
};


//               ***  Implementation of template functions  ***


// Helpers


template< typename PosT, typename ValueT >
ValueT PosValueMapper< PosT, ValueT >::GetValueFromPos( PosT nPos ) const
{
    ValueT nValue;
    if( mpMap )
    {
        const MapEntryType* pEntry = mpMap;
        while( (pEntry->mnPos != nPos) && (pEntry->mnPos != mnNFPos) )
            ++pEntry;
        nValue = pEntry->mnValue;
    }
    else /* if( nPos != mnNFPos ) */
    {
        DBG_ASSERT( nPos != mnNFPos, "sfx2::PosValueMapper< PosT, ValueT >::GetValueFromPos(), previously uninitialized value found!" );
        nValue = static_cast< ValueT >( nPos );
    }

    return nValue;
}

template< typename PosT, typename ValueT >
PosT PosValueMapper< PosT, ValueT >::GetPosFromValue( ValueT nValue ) const
{
    PosT nPos = mnNFPos;
    if( mpMap )
    {
        const MapEntryType* pEntry = mpMap;
        while( (pEntry->mnValue != nValue) && (pEntry->mnPos != mnNFPos) )
            ++pEntry;
        nPos = pEntry->mnPos;
    }
    else if( nValue >= static_cast< ValueT >(0) )
        nPos = static_cast< PosT >( nValue );
    return nPos;
}


// Single control wrappers


template< typename ControlT, typename ValueT >
inline void SingleControlWrapper< ControlT, ValueT >::ModifyControl( TriState eShow )
{
    if( eShow != TRISTATE_INDET )
        mrControl.Show( eShow == TRISTATE_TRUE );
}


template< typename ValueT >
bool MetricFieldWrapper< ValueT >::IsControlDontKnow() const
{
    return this->GetControl().GetText().isEmpty();
}

template< typename ValueT >
void MetricFieldWrapper< ValueT >::SetControlDontKnow( bool bSet )
{
    if( bSet )
        this->GetControl().SetText( OUString() );
}

template< typename ValueT >
ValueT MetricFieldWrapper< ValueT >::GetControlValue() const
{
    return static_cast< ValueT >( this->GetControl().Denormalize( this->GetControl().GetValue( meUnit ) ) );
}

template< typename ValueT >
void MetricFieldWrapper< ValueT >::SetControlValue( ValueT nValue )
{
    this->GetControl().SetValue( this->GetControl().Normalize( static_cast< sal_Int64 >( nValue ) ), meUnit );
}


template< typename ValueT >
ValueT ListBoxWrapper< ValueT >::GetControlValue() const
{
    return this->GetValueFromPos( this->GetControl().GetSelectEntryPos() );
}

template< typename ValueT >
void ListBoxWrapper< ValueT >::SetControlValue( ValueT nValue )
{
    sal_uInt16 nPos = this->GetPosFromValue( nValue );
    if( nPos != this->GetNotFoundPos() )
        this->GetControl().SelectEntryPos( nPos );
}


template< typename ValueT >
ValueT ValueSetWrapper< ValueT >::GetControlValue() const
{
    return this->GetValueFromPos( this->GetControl().GetSelectItemId() );
}

template< typename ValueT >
void ValueSetWrapper< ValueT >::SetControlValue( ValueT nValue )
{
    sal_uInt16 nPos = this->GetPosFromValue( nValue );
    if( nPos != this->GetNotFoundPos() )
        this->GetControl().SelectItem( nPos );
}


} // namespace sfx

#endif

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */