/* -*- 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 .

 */

#include <oox/ole/axcontrol.hxx>

#include <com/sun/star/awt/FontSlant.hpp>

#include <com/sun/star/awt/FontStrikeout.hpp>

#include <com/sun/star/awt/FontUnderline.hpp>

#include <com/sun/star/awt/FontWeight.hpp>

#include <com/sun/star/awt/ImagePosition.hpp>

#include <com/sun/star/awt/ImageScaleMode.hpp>

#include <com/sun/star/awt/Point.hpp>

#include <com/sun/star/awt/ScrollBarOrientation.hpp>

#include <com/sun/star/awt/Size.hpp>

#include <com/sun/star/awt/TextAlign.hpp>

#include <com/sun/star/awt/VisualEffect.hpp>

#include <com/sun/star/awt/XControlModel.hpp>

#include <com/sun/star/beans/NamedValue.hpp>

#include <com/sun/star/beans/XPropertySet.hpp>

#include <com/sun/star/container/XIndexContainer.hpp>

#include <com/sun/star/drawing/XDrawPage.hpp>

#include <com/sun/star/form/XForm.hpp>

#include <com/sun/star/form/XFormComponent.hpp>

#include <com/sun/star/form/XFormsSupplier.hpp>

#include <com/sun/star/form/binding/XBindableValue.hpp>

#include <com/sun/star/form/binding/XListEntrySink.hpp>

#include <com/sun/star/form/binding/XListEntrySource.hpp>

#include <com/sun/star/form/binding/XValueBinding.hpp>

#include <com/sun/star/frame/XModel.hpp>

#include <com/sun/star/lang/XMultiServiceFactory.hpp>

#include <com/sun/star/sheet/XCellRangeAddressable.hpp>

#include <com/sun/star/sheet/XCellRangeReferrer.hpp>

#include <com/sun/star/style/VerticalAlignment.hpp>

#include <com/sun/star/table/CellAddress.hpp>

#include <com/sun/star/table/CellRangeAddress.hpp>

#include <rtl/tencinfo.h>

#include <osl/diagnose.h>

#include <utility>

#include <vcl/font.hxx>

#include <vcl/outdev.hxx>

#include <vcl/settings.hxx>

#include <vcl/svapp.hxx>

#include <oox/helper/attributelist.hxx>

#include <oox/helper/binaryinputstream.hxx>

#include <oox/helper/graphichelper.hxx>

#include <oox/helper/propertymap.hxx>

#include <oox/ole/axbinarywriter.hxx>

#include <oox/token/properties.hxx>

#include <oox/token/tokens.hxx>

#include <comphelper/diagnose_ex.hxx>

#include <o3tl/string_view.hxx>

namespace oox::ole {

using namespace ::com::sun::star;

using namespace ::com::sun::star::awt;

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

using namespace ::com::sun::star::container;

using namespace ::com::sun::star::drawing;

using namespace ::com::sun::star::form;

using namespace ::com::sun::star::form::binding;

using namespace ::com::sun::star::frame;

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

using namespace ::com::sun::star::sheet;

using namespace ::com::sun::star::style;

using namespace ::com::sun::star::table;

using namespace ::com::sun::star::uno;

namespace {

const sal_uInt32 COMCTL_ID_SIZE             = 0x12344321;

const sal_uInt32 COMCTL_ID_COMMONDATA       = 0xABCDEF01;

const sal_uInt32 COMCTL_COMMON_FLATBORDER   = 0x00000001;

const sal_uInt32 COMCTL_COMMON_ENABLED      = 0x00000002;

const sal_uInt32 COMCTL_COMMON_3DBORDER     = 0x00000004;

const sal_uInt32 COMCTL_ID_COMPLEXDATA      = 0xBDECDE1F;

const sal_uInt32 COMCTL_COMPLEX_FONT        = 0x00000001;

const sal_uInt32 COMCTL_COMPLEX_MOUSEICON   = 0x00000002;

const sal_uInt32 COMCTL_ID_SCROLLBAR_60     = 0x99470A83;

const sal_uInt32 COMCTL_SCROLLBAR_HOR       = 0x00000010;

const sal_uInt32 COMCTL_ID_PROGRESSBAR_50   = 0xE6E17E84;

const sal_uInt32 COMCTL_ID_PROGRESSBAR_60   = 0x97AB8A01;

const sal_uInt32 AX_CMDBUTTON_DEFFLAGS      = 0x0000001B;

const sal_uInt32 AX_LABEL_DEFFLAGS          = 0x0080001B;

const sal_uInt32 AX_IMAGE_DEFFLAGS          = 0x0000001B;

const sal_uInt32 AX_MORPHDATA_DEFFLAGS      = 0x2C80081B;

const sal_uInt32 AX_SPINBUTTON_DEFFLAGS     = 0x0000001B;

const sal_uInt32 AX_SCROLLBAR_DEFFLAGS      = 0x0000001B;

const sal_uInt16 AX_POS_TOPLEFT             = 0;

const sal_uInt16 AX_POS_TOP                 = 1;

const sal_uInt16 AX_POS_TOPRIGHT            = 2;

const sal_uInt16 AX_POS_LEFT                = 3;

const sal_uInt16 AX_POS_CENTER              = 4;

const sal_uInt16 AX_POS_RIGHT               = 5;

const sal_uInt16 AX_POS_BOTTOMLEFT          = 6;

const sal_uInt16 AX_POS_BOTTOM              = 7;

const sal_uInt16 AX_POS_BOTTOMRIGHT         = 8;

#define AX_PICPOS_IMPL( label, image ) ((AX_POS_##label << 16) | AX_POS_##image)

const sal_uInt32 AX_PICPOS_LEFTTOP          = AX_PICPOS_IMPL( TOPRIGHT,    TOPLEFT );

const sal_uInt32 AX_PICPOS_LEFTCENTER       = AX_PICPOS_IMPL( RIGHT,       LEFT );

const sal_uInt32 AX_PICPOS_LEFTBOTTOM       = AX_PICPOS_IMPL( BOTTOMRIGHT, BOTTOMLEFT );

const sal_uInt32 AX_PICPOS_RIGHTTOP         = AX_PICPOS_IMPL( TOPLEFT,     TOPRIGHT );

const sal_uInt32 AX_PICPOS_RIGHTCENTER      = AX_PICPOS_IMPL( LEFT,        RIGHT );

const sal_uInt32 AX_PICPOS_RIGHTBOTTOM      = AX_PICPOS_IMPL( BOTTOMLEFT,  BOTTOMRIGHT );

const sal_uInt32 AX_PICPOS_ABOVELEFT        = AX_PICPOS_IMPL( BOTTOMLEFT,  TOPLEFT );

const sal_uInt32 AX_PICPOS_ABOVECENTER      = AX_PICPOS_IMPL( BOTTOM,      TOP  );

const sal_uInt32 AX_PICPOS_ABOVERIGHT       = AX_PICPOS_IMPL( BOTTOMRIGHT, TOPRIGHT );

const sal_uInt32 AX_PICPOS_BELOWLEFT        = AX_PICPOS_IMPL( TOPLEFT,     BOTTOMLEFT );

const sal_uInt32 AX_PICPOS_BELOWCENTER      = AX_PICPOS_IMPL( TOP,         BOTTOM );

const sal_uInt32 AX_PICPOS_BELOWRIGHT       = AX_PICPOS_IMPL( TOPRIGHT,    BOTTOMRIGHT );

const sal_uInt32 AX_PICPOS_CENTER           = AX_PICPOS_IMPL( CENTER,      CENTER  );

#undef AX_PICPOS_IMPL

const sal_Int32 AX_MATCHENTRY_FIRSTLETTER   = 0;

const sal_Int32 AX_MATCHENTRY_COMPLETE      = 1;

const sal_Int32 AX_MATCHENTRY_NONE          = 2;

const sal_Int32 AX_ORIENTATION_AUTO         = -1;

const sal_Int32 AX_ORIENTATION_VERTICAL     = 0;

const sal_Int32 AX_ORIENTATION_HORIZONTAL   = 1;

const sal_Int32 AX_PROPTHUMB_ON             = -1;

const sal_uInt32 AX_TABSTRIP_TABS           = 0;

const sal_uInt32 AX_TABSTRIP_NONE           = 2;

const sal_uInt32 AX_CONTAINER_ENABLED       = 0x00000004;

const sal_uInt32 AX_CONTAINER_NOCLASSTABLE  = 0x00008000;

const sal_uInt32 AX_CONTAINER_DEFFLAGS      = 0x00000004;

const sal_Int32 AX_CONTAINER_DEFWIDTH       = 4000;

const sal_Int32 AX_CONTAINER_DEFHEIGHT      = 3000;

const sal_Int32 AX_CONTAINER_CYCLEALL       = 0;

const sal_Int32 AX_CONTAINER_SCR_NONE       = 0x00;

const sal_Int16 API_BORDER_NONE             = 0;

const sal_Int16 API_BORDER_SUNKEN           = 1;

const sal_Int16 API_BORDER_FLAT             = 2;

const sal_Int16 API_STATE_UNCHECKED         = 0;

const sal_Int16 API_STATE_CHECKED           = 1;

const sal_Int16 API_STATE_DONTKNOW          = 2;

/** Tries to extract a range address from a defined name. */

bool lclExtractRangeFromName( CellRangeAddress& orRangeAddr, const Reference< XModel >& rxDocModel, const OUString& rAddressString )

{

    try

    {

        PropertySet aPropSet( rxDocModel );

        Reference< XNameAccess > xRangesNA( aPropSet.getAnyProperty( PROP_NamedRanges ), UNO_QUERY_THROW );

        Reference< XCellRangeReferrer > xReferrer( xRangesNA->getByName( rAddressString ), UNO_QUERY_THROW );

        Reference< XCellRangeAddressable > xAddressable( xReferrer->getReferredCells(), UNO_QUERY_THROW );

        orRangeAddr = xAddressable->getRangeAddress();

        return true;

    }

    catch (const Exception&)

    {

        TOOLS_WARN_EXCEPTION("oox", "");

    }

    return false;

}

bool lclExtractAddressFromName( CellAddress& orAddress, const Reference< XModel >& rxDocModel, const OUString& rAddressString )

{

    CellRangeAddress aRangeAddr;

    if( lclExtractRangeFromName( aRangeAddr, rxDocModel, rAddressString ) &&

        (aRangeAddr.StartColumn == aRangeAddr.EndColumn) &&

        (aRangeAddr.StartRow == aRangeAddr.EndRow) )

    {

        orAddress.Sheet = aRangeAddr.Sheet;

        orAddress.Column = aRangeAddr.StartColumn;

        orAddress.Row = aRangeAddr.StartRow;

        return true;

    }

    return false;

}

void lclPrepareConverter( PropertySet& rConverter, const Reference< XModel >& rxDocModel,

        const OUString& rAddressString, sal_Int32 nRefSheet, bool bRange )

{

    if( !rConverter.is() ) try

    {

        Reference< XMultiServiceFactory > xModelFactory( rxDocModel, UNO_QUERY_THROW );

        OUString aServiceName = bRange ?

            u"com.sun.star.table.CellRangeAddressConversion"_ustr :

            u"com.sun.star.table.CellAddressConversion"_ustr;

        rConverter.set( xModelFactory->createInstance( aServiceName ) );

    }

    catch (const Exception&)

    {

        TOOLS_WARN_EXCEPTION("oox", "");

    }

    rConverter.setProperty( PROP_XLA1Representation, rAddressString );

    rConverter.setProperty( PROP_ReferenceSheet, nRefSheet );

}

} // namespace

ControlConverter::ControlConverter( const Reference< XModel >& rxDocModel,

        const GraphicHelper& rGraphicHelper, bool bDefaultColorBgr ) :

    mxDocModel( rxDocModel ),

    mrGraphicHelper( rGraphicHelper ),

    mbDefaultColorBgr( bDefaultColorBgr )

{

    OSL_ENSURE( mxDocModel.is(), "ControlConverter::ControlConverter - missing document model" );

}

ControlConverter::~ControlConverter()

{

}

// Generic conversion ---------------------------------------------------------

void ControlConverter::convertPosition( PropertyMap& rPropMap, const AxPairData& rPos ) const

{

    // position is given in 1/100 mm, UNO needs AppFont units

    awt::Point aAppFontPos = mrGraphicHelper.convertHmmToAppFont( awt::Point( rPos.first, rPos.second ) );

    rPropMap.setProperty( PROP_PositionX, aAppFontPos.X );

    rPropMap.setProperty( PROP_PositionY, aAppFontPos.Y );

}

void ControlConverter::convertSize( PropertyMap& rPropMap, const AxPairData& rSize ) const

{

    // size is given in 1/100 mm, UNO needs AppFont units

    awt::Size aAppFontSize = mrGraphicHelper.convertHmmToAppFont( awt::Size( rSize.first, rSize.second ) );

    rPropMap.setProperty( PROP_Width, aAppFontSize.Width );

    rPropMap.setProperty( PROP_Height, aAppFontSize.Height );

}

void ControlConverter::convertColor( PropertyMap& rPropMap, sal_Int32 nPropId, sal_uInt32 nOleColor ) const

{

    rPropMap.setProperty( nPropId, OleHelper::decodeOleColor( mrGraphicHelper, nOleColor, mbDefaultColorBgr ) );

}

void ControlConverter::convertToMSColor( PropertySet const & rPropSet, sal_Int32 nPropId, sal_uInt32& nOleColor, sal_uInt32 nDefault )

{

    sal_uInt32 nRGB = 0;

    if (rPropSet.getProperty( nRGB, nPropId ))

        nOleColor = OleHelper::encodeOleColor( nRGB );

    else

        nOleColor = nDefault;

}

void ControlConverter::convertPicture( PropertyMap& rPropMap, const StreamDataSequence& rPicData ) const

{

    if( rPicData.hasElements() )

    {

        uno::Reference<graphic::XGraphic> xGraphic = mrGraphicHelper.importGraphic(rPicData);

        if (xGraphic.is())

            rPropMap.setProperty(PROP_Graphic, xGraphic);

    }

}

void ControlConverter::convertOrientation( PropertyMap& rPropMap, bool bHorizontal )

{

    sal_Int32 nScrollOrient = bHorizontal ? ScrollBarOrientation::HORIZONTAL : ScrollBarOrientation::VERTICAL;

    rPropMap.setProperty( PROP_Orientation, nScrollOrient );

}

void ControlConverter::convertToMSOrientation( PropertySet const & rPropSet, bool& bHorizontal )

{

    sal_Int32 nScrollOrient = ScrollBarOrientation::HORIZONTAL;

    if ( rPropSet.getProperty( nScrollOrient, PROP_Orientation ) )

        bHorizontal = ( nScrollOrient == ScrollBarOrientation::HORIZONTAL );

}

void ControlConverter::convertVerticalAlign( PropertyMap& rPropMap, sal_Int32 nVerticalAlign )

{

    VerticalAlignment eAlign = VerticalAlignment_TOP;

    switch( nVerticalAlign )

    {

        case XML_Top:       eAlign = VerticalAlignment_TOP;     break;

        case XML_Center:    eAlign = VerticalAlignment_MIDDLE;  break;

        case XML_Bottom:    eAlign = VerticalAlignment_BOTTOM;  break;

    }

    rPropMap.setProperty( PROP_VerticalAlign, eAlign );

}

void ControlConverter::convertScrollabilitySettings( PropertyMap& rPropMap,

                                         const AxPairData& rScrollPos, const AxPairData& rScrollArea,

                                         sal_Int32 nScrollBars ) const

{

    awt::Size tmpSize = mrGraphicHelper.convertHmmToAppFont( awt::Size( rScrollArea.first, rScrollArea.second ) );

    awt::Point tmpPos = mrGraphicHelper.convertHmmToAppFont( awt::Point( rScrollPos.first, rScrollPos.second ) );

    rPropMap.setProperty( PROP_ScrollHeight, tmpSize.Height );

    rPropMap.setProperty( PROP_ScrollWidth, tmpSize.Width );

    rPropMap.setProperty( PROP_ScrollTop, tmpPos.Y );

    rPropMap.setProperty( PROP_ScrollLeft, tmpPos.X );

    rPropMap.setProperty( PROP_HScroll, ( nScrollBars & 0x1 ) == 0x1 );

    rPropMap.setProperty( PROP_VScroll, ( nScrollBars & 0x2 ) == 0x2 );

}

void ControlConverter::convertScrollBar( PropertyMap& rPropMap,

        sal_Int32 nMin, sal_Int32 nMax, sal_Int32 nPosition,

        sal_Int32 nSmallChange, sal_Int32 nLargeChange, bool bAwtModel )

{

    rPropMap.setProperty( PROP_ScrollValueMin, ::std::min( nMin, nMax ) );

    rPropMap.setProperty( PROP_ScrollValueMax, ::std::max( nMin, nMax ) );

    rPropMap.setProperty( PROP_LineIncrement, nSmallChange );

    rPropMap.setProperty( PROP_BlockIncrement, nLargeChange );

    rPropMap.setProperty( bAwtModel ? PROP_ScrollValue : PROP_DefaultScrollValue, nPosition );

}

void ControlConverter::bindToSources( const Reference< XControlModel >& rxCtrlModel,

        const OUString& rCtrlSource, const OUString& rRowSource, sal_Int32 nRefSheet ) const

{

    // value binding

    if( !rCtrlSource.isEmpty() ) try

    {

        // first check if the XBindableValue interface is supported

        Reference< XBindableValue > xBindable( rxCtrlModel, UNO_QUERY_THROW );

        // convert address string to cell address struct

        CellAddress aAddress;

        if( !lclExtractAddressFromName( aAddress, mxDocModel, rCtrlSource ) )

        {

            lclPrepareConverter( maAddressConverter, mxDocModel, rCtrlSource, nRefSheet, false );

            if( !maAddressConverter.getProperty( aAddress, PROP_Address ) )

                throw RuntimeException();

        }

        // create argument sequence

        Sequence< Any > aArgs{ Any(NamedValue(u"BoundCell"_ustr, Any(aAddress))) };

        // create the CellValueBinding instance and set at the control model

        Reference< XMultiServiceFactory > xModelFactory( mxDocModel, UNO_QUERY_THROW );

        Reference< XValueBinding > xBinding( xModelFactory->createInstanceWithArguments( u"com.sun.star.table.CellValueBinding"_ustr, aArgs ), UNO_QUERY_THROW );

        xBindable->setValueBinding( xBinding );

    }

    catch (const Exception&)

    {

        TOOLS_WARN_EXCEPTION("oox", "");

    }

    // list entry source

    if( rRowSource.isEmpty() )

        return;

    try

    {

        // first check if the XListEntrySink interface is supported

        Reference< XListEntrySink > xEntrySink( rxCtrlModel, UNO_QUERY_THROW );

        // convert address string to cell range address struct

        CellRangeAddress aRangeAddr;

        if( !lclExtractRangeFromName( aRangeAddr, mxDocModel, rRowSource ) )

        {

            lclPrepareConverter( maRangeConverter, mxDocModel, rRowSource, nRefSheet, true );

            if( !maRangeConverter.getProperty( aRangeAddr, PROP_Address ) )

                throw RuntimeException();

        }

        // create argument sequence

        Sequence< Any > aArgs{ Any(NamedValue(u"CellRange"_ustr, Any(aRangeAddr))) };

        // create the EntrySource instance and set at the control model

        Reference< XMultiServiceFactory > xModelFactory( mxDocModel, UNO_QUERY_THROW );

        Reference< XListEntrySource > xEntrySource( xModelFactory->createInstanceWithArguments(u"com.sun.star.table.CellRangeListSource"_ustr, aArgs ), UNO_QUERY_THROW );

        xEntrySink->setListEntrySource( xEntrySource );

    }

    catch (const Exception&)

    {

        TOOLS_WARN_EXCEPTION("oox", "");

    }

}

// ActiveX (Forms 2.0) specific conversion ------------------------------------

void ControlConverter::convertAxBackground( PropertyMap& rPropMap,

        sal_uInt32 nBackColor, sal_uInt32 nFlags, ApiTransparencyMode eTranspMode ) const

{

    bool bOpaque = getFlag( nFlags, AX_FLAGS_OPAQUE );

    switch( eTranspMode )

    {

        case ApiTransparencyMode::NotSupported:

            // fake transparency by using system window background if needed

            convertColor( rPropMap, PROP_BackgroundColor, bOpaque ? nBackColor : AX_SYSCOLOR_WINDOWBACK );

        break;

        case ApiTransparencyMode::Void:

            // keep transparency by leaving the (void) default property value

            if( bOpaque )

                convertColor( rPropMap, PROP_BackgroundColor, nBackColor );

        break;

    }

}

void ControlConverter::convertAxBorder( PropertyMap& rPropMap,

        sal_uInt32 nBorderColor, sal_Int32 nBorderStyle, sal_Int32 nSpecialEffect ) const

{

    sal_Int16 nBorder = (nBorderStyle == AX_BORDERSTYLE_SINGLE) ? API_BORDER_FLAT :

        ((nSpecialEffect == AX_SPECIALEFFECT_FLAT) ? API_BORDER_NONE : API_BORDER_SUNKEN);

    rPropMap.setProperty( PROP_Border, nBorder );

    convertColor( rPropMap, PROP_BorderColor, nBorderColor );

}

void ControlConverter::convertToAxBorder( PropertySet const & rPropSet,

        sal_uInt32& nBorderColor, sal_Int32& nBorderStyle, sal_Int32& nSpecialEffect )

{

    sal_Int16 nBorder = API_BORDER_NONE;

    rPropSet.getProperty( nBorder, PROP_Border );

    nBorderStyle = AX_BORDERSTYLE_NONE;

    nSpecialEffect =  AX_SPECIALEFFECT_FLAT;

    switch ( nBorder )

    {

        case API_BORDER_FLAT:

            nBorderStyle = AX_BORDERSTYLE_SINGLE;

            break;

        case API_BORDER_SUNKEN:

            nSpecialEffect =  AX_SPECIALEFFECT_SUNKEN;

            break;

        case API_BORDER_NONE:

        default:

            break;

    }

    convertToMSColor( rPropSet, PROP_BorderColor, nBorderColor );

}

void ControlConverter::convertAxVisualEffect( PropertyMap& rPropMap, sal_Int32 nSpecialEffect )

{

    sal_Int16 nVisualEffect = (nSpecialEffect == AX_SPECIALEFFECT_FLAT) ? VisualEffect::FLAT : VisualEffect::LOOK3D;

    rPropMap.setProperty( PROP_VisualEffect, nVisualEffect );

}

void ControlConverter::convertToAxVisualEffect( PropertySet const & rPropSet, sal_Int32& nSpecialEffect )

{

    sal_Int16 nVisualEffect = AX_SPECIALEFFECT_FLAT;

    rPropSet.getProperty( nVisualEffect, PROP_VisualEffect );

    // is this appropriate AX_SPECIALEFFECT_XXXX value ?

    if (nVisualEffect == VisualEffect::LOOK3D )

        nSpecialEffect = AX_SPECIALEFFECT_RAISED;

}

void ControlConverter::convertAxPicture( PropertyMap& rPropMap, const StreamDataSequence& rPicData, sal_uInt32 nPicPos ) const

{

    // the picture

    convertPicture( rPropMap, rPicData );

    // picture position

    sal_Int16 nImagePos = ImagePosition::LeftCenter;

    switch( nPicPos )

    {

        case AX_PICPOS_LEFTTOP:     nImagePos = ImagePosition::LeftTop;     break;

        case AX_PICPOS_LEFTCENTER:  nImagePos = ImagePosition::LeftCenter;  break;

        case AX_PICPOS_LEFTBOTTOM:  nImagePos = ImagePosition::LeftBottom;  break;

        case AX_PICPOS_RIGHTTOP:    nImagePos = ImagePosition::RightTop;    break;

        case AX_PICPOS_RIGHTCENTER: nImagePos = ImagePosition::RightCenter; break;

        case AX_PICPOS_RIGHTBOTTOM: nImagePos = ImagePosition::RightBottom; break;

        case AX_PICPOS_ABOVELEFT:   nImagePos = ImagePosition::AboveLeft;   break;

        case AX_PICPOS_ABOVECENTER: nImagePos = ImagePosition::AboveCenter; break;

        case AX_PICPOS_ABOVERIGHT:  nImagePos = ImagePosition::AboveRight;  break;

        case AX_PICPOS_BELOWLEFT:   nImagePos = ImagePosition::BelowLeft;   break;

        case AX_PICPOS_BELOWCENTER: nImagePos = ImagePosition::BelowCenter; break;

        case AX_PICPOS_BELOWRIGHT:  nImagePos = ImagePosition::BelowRight;  break;

        case AX_PICPOS_CENTER:      nImagePos = ImagePosition::Centered;    break;

        default:    OSL_FAIL( "ControlConverter::convertAxPicture - unknown picture position" );

    }

    rPropMap.setProperty( PROP_ImagePosition, nImagePos );

}

void ControlConverter::convertAxPicture( PropertyMap& rPropMap, const StreamDataSequence& rPicData,

        sal_Int32 nPicSizeMode ) const

{

    // the picture

    convertPicture( rPropMap, rPicData );

    // picture scale mode

    sal_Int16 nScaleMode = ImageScaleMode::NONE;

    switch( nPicSizeMode )

    {

        case AX_PICSIZE_CLIP:       nScaleMode = ImageScaleMode::NONE;          break;

        case AX_PICSIZE_STRETCH:    nScaleMode = ImageScaleMode::ANISOTROPIC;   break;

        case AX_PICSIZE_ZOOM:       nScaleMode = ImageScaleMode::ISOTROPIC;     break;

        default:    OSL_FAIL( "ControlConverter::convertAxPicture - unknown picture size mode" );

    }

    rPropMap.setProperty( PROP_ScaleMode, nScaleMode );

}

void ControlConverter::convertAxState( PropertyMap& rPropMap,

        std::u16string_view rValue, sal_Int32 nMultiSelect, ApiDefaultStateMode eDefStateMode, bool bAwtModel )

{

    bool bBooleanState = eDefStateMode == API_DEFAULTSTATE_BOOLEAN;

    bool bSupportsTriState = eDefStateMode == API_DEFAULTSTATE_TRISTATE;

    // state

    sal_Int16 nState = bSupportsTriState ? API_STATE_DONTKNOW : API_STATE_UNCHECKED;

    if( rValue.size() == 1 ) switch( rValue[ 0 ] )

    {

        case '0':   nState = API_STATE_UNCHECKED;   break;

        case '1':   nState = API_STATE_CHECKED;     break;

        // any other string (also empty) means 'dontknow'

    }

    sal_Int32 nPropId = bAwtModel ? PROP_State : PROP_DefaultState;

    if( bBooleanState )

        rPropMap.setProperty( nPropId, nState != API_STATE_UNCHECKED );

    else

        rPropMap.setProperty( nPropId, nState );

    // tristate

    if( bSupportsTriState )

        rPropMap.setProperty( PROP_TriState, nMultiSelect == AX_SELECTION_MULTI );

}

void ControlConverter::convertToAxState( PropertySet const & rPropSet,

        OUString& rValue, sal_Int32& nMultiSelect, ApiDefaultStateMode eDefStateMode )

{

    bool bSupportsTriState = eDefStateMode == API_DEFAULTSTATE_TRISTATE;

    sal_Int16 nState = API_STATE_DONTKNOW;

    // need to use State for current state ( I think this is regardless of whether

    // control is awt or not )

    rPropSet.getProperty( nState, PROP_State );

    rValue.clear(); // empty e.g. 'don't know'

    if ( nState == API_STATE_UNCHECKED )

        rValue = "0";

    else if ( nState == API_STATE_CHECKED )

        rValue = "1";

    // tristate

    if( bSupportsTriState )

    {

        bool bTriStateEnabled = false;

        bool bPropertyExists = rPropSet.getProperty( bTriStateEnabled, PROP_TriState );

        if( bPropertyExists && bTriStateEnabled )

            nMultiSelect = AX_SELECTION_MULTI;

    }

}

void ControlConverter::convertAxOrientation( PropertyMap& rPropMap,

        const AxPairData& rSize, sal_Int32 nOrientation )

{

    bool bHorizontal = true;

    switch( nOrientation )

    {

        case AX_ORIENTATION_AUTO:       bHorizontal = rSize.first > rSize.second;   break;

        case AX_ORIENTATION_VERTICAL:   bHorizontal = false;                        break;

        case AX_ORIENTATION_HORIZONTAL: bHorizontal = true;                         break;

        default:    OSL_FAIL( "ControlConverter::convertAxOrientation - unknown orientation" );

    }

    convertOrientation( rPropMap, bHorizontal );

}

void ControlConverter::convertToAxOrientation( PropertySet const & rPropSet,

        sal_Int32& nOrientation )

{

    bool bHorizontal = true;

    convertToMSOrientation( rPropSet, bHorizontal );

    if ( bHorizontal )

        nOrientation = AX_ORIENTATION_HORIZONTAL;

    else

        nOrientation = AX_ORIENTATION_VERTICAL;

}

ControlModelBase::ControlModelBase() :

    maSize( 0, 0 ),

    mbAwtModel( false )

{

}

ControlModelBase::~ControlModelBase()

{

}

OUString ControlModelBase::getServiceName() const

{

    ApiControlType eCtrlType = getControlType();

    if( mbAwtModel ) switch( eCtrlType )

    {

        case API_CONTROL_BUTTON:        return u"com.sun.star.awt.UnoControlButtonModel"_ustr;

        case API_CONTROL_FIXEDTEXT:     return u"com.sun.star.awt.UnoControlFixedTextModel"_ustr;

        case API_CONTROL_IMAGE:         return u"com.sun.star.awt.UnoControlImageControlModel"_ustr;

        case API_CONTROL_CHECKBOX:      return u"com.sun.star.awt.UnoControlCheckBoxModel"_ustr;

        case API_CONTROL_RADIOBUTTON:   return u"com.sun.star.form.component.RadioButton"_ustr;

        case API_CONTROL_EDIT:          return u"com.sun.star.awt.UnoControlEditModel"_ustr;

        case API_CONTROL_NUMERIC:       return u"com.sun.star.awt.UnoControlNumericFieldModel"_ustr;

        case API_CONTROL_LISTBOX:       return u"com.sun.star.form.component.ListBox"_ustr;

        case API_CONTROL_COMBOBOX:      return u"com.sun.star.form.component.ComboBox"_ustr;

        case API_CONTROL_SPINBUTTON:    return u"com.sun.star.form.component.SpinButton"_ustr;

        case API_CONTROL_SCROLLBAR:     return u"com.sun.star.form.component.ScrollBar"_ustr;

        case API_CONTROL_PROGRESSBAR:   return u"com.sun.star.awt.UnoControlProgressBarModel"_ustr;

        case API_CONTROL_GROUPBOX:      return u"com.sun.star.form.component.GroupBox"_ustr;

        case API_CONTROL_FRAME:         return u"com.sun.star.awt.UnoFrameModel"_ustr;

        case API_CONTROL_PAGE:          return u"com.sun.star.awt.UnoPageModel"_ustr;

        case API_CONTROL_MULTIPAGE:     return u"com.sun.star.awt.UnoMultiPageModel"_ustr;

        case API_CONTROL_DIALOG:        return u"com.sun.star.awt.UnoControlDialogModel"_ustr;

        default:    OSL_FAIL( "ControlModelBase::getServiceName - no AWT model service supported" );

    }

    else switch( eCtrlType )

    {

        case API_CONTROL_BUTTON:        return u"com.sun.star.form.component.CommandButton"_ustr;

        case API_CONTROL_FIXEDTEXT:     return u"com.sun.star.form.component.FixedText"_ustr;

        case API_CONTROL_IMAGE:         return u"com.sun.star.form.component.DatabaseImageControl"_ustr;

        case API_CONTROL_CHECKBOX:      return u"com.sun.star.form.component.CheckBox"_ustr;

        case API_CONTROL_RADIOBUTTON:   return u"com.sun.star.form.component.RadioButton"_ustr;

        case API_CONTROL_EDIT:          return u"com.sun.star.form.component.TextField"_ustr;

        case API_CONTROL_NUMERIC:       return u"com.sun.star.form.component.NumericField"_ustr;

        case API_CONTROL_LISTBOX:       return u"com.sun.star.form.component.ListBox"_ustr;

        case API_CONTROL_COMBOBOX:      return u"com.sun.star.form.component.ComboBox"_ustr;

        case API_CONTROL_SPINBUTTON:    return u"com.sun.star.form.component.SpinButton"_ustr;

        case API_CONTROL_SCROLLBAR:     return u"com.sun.star.form.component.ScrollBar"_ustr;

        case API_CONTROL_GROUPBOX:      return u"com.sun.star.form.component.GroupBox"_ustr;

        default:    OSL_FAIL( "ControlModelBase::getServiceName - no form component service supported" );

    }

    return OUString();

}

void ControlModelBase::importProperty( sal_Int32 /*nPropId*/, const OUString& /*rValue*/ )

{

}

void ControlModelBase::importPictureData( sal_Int32 /*nPropId*/, BinaryInputStream& /*rInStrm*/ )

{

}

void ControlModelBase::convertProperties( PropertyMap& /*rPropMap*/, const ControlConverter& /*rConv*/ ) const

{

}

void ControlModelBase::convertFromProperties( PropertySet& /*rPropMap*/, const ControlConverter& /*rConv*/ )

{

}

void ControlModelBase::convertSize( PropertyMap& rPropMap, const ControlConverter& rConv ) const

{

    rConv.convertSize( rPropMap, maSize );

}

ComCtlModelBase::ComCtlModelBase( sal_uInt32 nDataPartId5, sal_uInt32 nDataPartId6,

        sal_uInt16 nVersion ) :

    maFontData( u"Tahoma"_ustr, 82500 ),

    mnFlags( 0 ),

    mnVersion( nVersion ),

    mnDataPartId5( nDataPartId5 ),

    mnDataPartId6( nDataPartId6 ),

    mbCommonPart( true ),

    mbComplexPart( true )

{

}

bool ComCtlModelBase::importBinaryModel( BinaryInputStream& rInStrm )

{

    // read initial size part and header of the control data part

    if( importSizePart( rInStrm ) && readPartHeader( rInStrm, getDataPartId(), mnVersion ) )

    {

        // if flags part exists, the first int32 of the data part contains its size

        sal_uInt32 nCommonPartSize = 0;

        if (mbCommonPart)

            nCommonPartSize = rInStrm.readuInt32();

        // implementations must read the exact amount of data, stream must point to its end afterwards

        importControlData( rInStrm );

        // read following parts

        if( !rInStrm.isEof() &&

            (!mbCommonPart || importCommonPart( rInStrm, nCommonPartSize )) &&

            (!mbComplexPart || importComplexPart( rInStrm )) )

        {

            return !rInStrm.isEof();

        }

    }

    return false;

}

void ComCtlModelBase::convertProperties( PropertyMap& rPropMap, const ControlConverter& rConv ) const

{

    if( mbCommonPart )

        rPropMap.setProperty( PROP_Enabled, getFlag( mnFlags, COMCTL_COMMON_ENABLED ) );

    ControlModelBase::convertProperties( rPropMap, rConv );

}

sal_uInt32 ComCtlModelBase::getDataPartId() const

{

    switch( mnVersion )

    {

        case COMCTL_VERSION_50: return mnDataPartId5;

        case COMCTL_VERSION_60: return mnDataPartId6;

    }

    OSL_FAIL( "ComCtlObjectBase::getDataPartId - unexpected version" );

    return SAL_MAX_UINT32;

}

bool ComCtlModelBase::readPartHeader( BinaryInputStream& rInStrm, sal_uInt32 nExpPartId, sal_uInt16 nExpMajor, sal_uInt16 nExpMinor )

{

    // no idea if all this is correct...

    sal_uInt32 nPartId = rInStrm.readuInt32();

    sal_uInt16 nMinor = rInStrm.readuInt16();

    sal_uInt16 nMajor = rInStrm.readuInt16();

    bool bPartId = nPartId == nExpPartId;

    OSL_ENSURE( bPartId, "ComCtlObjectBase::readPartHeader - unexpected part identifier" );

    bool bVersion = ((nExpMajor == SAL_MAX_UINT16) || (nExpMajor == nMajor)) && ((nExpMinor == SAL_MAX_UINT16) || (nExpMinor == nMinor));

    OSL_ENSURE( bVersion, "ComCtlObjectBase::readPartHeader - unexpected part version" );

    return !rInStrm.isEof() && bPartId && bVersion;

}

bool ComCtlModelBase::importSizePart( BinaryInputStream& rInStrm )

{

    if( readPartHeader( rInStrm, COMCTL_ID_SIZE, 0, 8 ) )

    {

        maSize.first = rInStrm.readInt32();

        maSize.second = rInStrm.readInt32();

        return !rInStrm.isEof();

    }

    return false;

}

bool ComCtlModelBase::importCommonPart( BinaryInputStream& rInStrm, sal_uInt32 nPartSize )

{

    sal_Int64 nEndPos = rInStrm.tell() + nPartSize;

    if( (nPartSize >= 16) && readPartHeader( rInStrm, COMCTL_ID_COMMONDATA, 5, 0 ) )

    {

        rInStrm.skip( 4 );

        mnFlags = rInStrm.readuInt32();

        rInStrm.seek( nEndPos );

        return !rInStrm.isEof();

    }

    return false;

}

bool ComCtlModelBase::importComplexPart( BinaryInputStream& rInStrm )

{

    if( readPartHeader( rInStrm, COMCTL_ID_COMPLEXDATA, 5, 1 ) )

    {

        sal_uInt32 nContFlags = rInStrm.readuInt32();

        bool bReadOk =

            (!getFlag( nContFlags, COMCTL_COMPLEX_FONT ) || OleHelper::importStdFont( maFontData, rInStrm, true )) &&

            (!getFlag( nContFlags, COMCTL_COMPLEX_MOUSEICON ) || OleHelper::importStdPic( maMouseIcon, rInStrm ));

        return bReadOk && !rInStrm.isEof();

    }

    return false;

}

ComCtlScrollBarModel::ComCtlScrollBarModel( sal_uInt16 nVersion ) :

    ComCtlModelBase( SAL_MAX_UINT32, COMCTL_ID_SCROLLBAR_60, nVersion ),

    mnScrollBarFlags( 0x00000011 ),

    mnLargeChange( 1 ),

    mnSmallChange( 1 ),

    mnMin( 0 ),

    mnMax( 32767 ),

    mnPosition( 0 )

{

}

ApiControlType ComCtlScrollBarModel::getControlType() const

{

    return API_CONTROL_SCROLLBAR;

}

void ComCtlScrollBarModel::convertProperties( PropertyMap& rPropMap, const ControlConverter& rConv ) const

{

    rPropMap.setProperty( PROP_Border, API_BORDER_NONE );

    ControlConverter::convertOrientation( rPropMap, getFlag( mnScrollBarFlags, COMCTL_SCROLLBAR_HOR ) );

    ControlConverter::convertScrollBar( rPropMap, mnMin, mnMax, mnPosition, mnSmallChange, mnLargeChange, mbAwtModel );

    ComCtlModelBase::convertProperties( rPropMap, rConv );

}

void ComCtlScrollBarModel::importControlData( BinaryInputStream& rInStrm )

{

    mnScrollBarFlags = rInStrm.readuInt32();

    mnLargeChange = rInStrm.readInt32();

    mnSmallChange = rInStrm.readInt32();

    mnMin = rInStrm.readInt32();

    mnMax = rInStrm.readInt32();

    mnPosition = rInStrm.readInt32();

}

ComCtlProgressBarModel::ComCtlProgressBarModel( sal_uInt16 nVersion ) :

    ComCtlModelBase( COMCTL_ID_PROGRESSBAR_50, COMCTL_ID_PROGRESSBAR_60, nVersion ),

    mfMin( 0.0 ),

    mfMax( 100.0 ),

    mnVertical( 0 ),

    mnSmooth( 0 )

{

}

ApiControlType ComCtlProgressBarModel::getControlType() const

{

    return API_CONTROL_PROGRESSBAR;

}

void ComCtlProgressBarModel::convertProperties( PropertyMap& rPropMap, const ControlConverter& rConv ) const

{

    sal_uInt16 nBorder = getFlag( mnFlags, COMCTL_COMMON_3DBORDER ) ? API_BORDER_SUNKEN :

        (getFlag( mnFlags, COMCTL_COMMON_FLATBORDER ) ? API_BORDER_FLAT : API_BORDER_NONE);

    rPropMap.setProperty( PROP_Border, nBorder );

    rPropMap.setProperty( PROP_ProgressValueMin, getLimitedValue< sal_Int32, double >( ::std::min( mfMin, mfMax ), 0.0, SAL_MAX_INT32 ) );

    rPropMap.setProperty( PROP_ProgressValueMax, getLimitedValue< sal_Int32, double >( ::std::max( mfMin, mfMax ), 0.0, SAL_MAX_INT32 ) );

    // ComCtl model does not provide current value?

    ComCtlModelBase::convertProperties( rPropMap, rConv );

}

void ComCtlProgressBarModel::importControlData( BinaryInputStream& rInStrm )

{

    mfMin = rInStrm.readFloat();

    mfMax = rInStrm.readFloat();

    if( mnVersion == COMCTL_VERSION_60 )

    {

        mnVertical = rInStrm.readuInt16();

        mnSmooth = rInStrm.readuInt16();

    }

}

AxControlModelBase::AxControlModelBase()

{

}

void AxControlModelBase::importProperty( sal_Int32 nPropId, const OUString& rValue )

{

    switch( nPropId )

    {

        // size of the control shape: format is "width;height"

        case XML_Size:

        {

            sal_Int32 nSepPos = rValue.indexOf( ';' );

            OSL_ENSURE( nSepPos >= 0, "AxControlModelBase::importProperty - missing separator in 'Size' property" );

            if( nSepPos >= 0 )

            {

                maSize.first = o3tl::toInt32(rValue.subView( 0, nSepPos ));

                maSize.second = o3tl::toInt32(rValue.subView( nSepPos + 1 ));

            }

        }

        break;

    }

}

AxFontDataModel::AxFontDataModel( bool bSupportsAlign ) :

    mbSupportsAlign( bSupportsAlign )

{

}

void AxFontDataModel::importProperty( sal_Int32 nPropId, const OUString& rValue )

{

    switch( nPropId )

    {

        case XML_FontName:          maFontData.maFontName = rValue;                                             break;

        case XML_FontEffects:

            maFontData.mnFontEffects = static_cast<AxFontFlags>(AttributeConversion::decodeUnsigned( rValue ));

            break;

        case XML_FontHeight:        maFontData.mnFontHeight = AttributeConversion::decodeInteger( rValue );     break;

        case XML_FontCharSet:       maFontData.mnFontCharSet = AttributeConversion::decodeInteger( rValue );    break;

        case XML_ParagraphAlign:

            maFontData.mnHorAlign = static_cast<AxHorizontalAlign>(AttributeConversion::decodeInteger( rValue ));

            break;

        default:                    AxControlModelBase::importProperty( nPropId, rValue );

    }

}

bool AxFontDataModel::importBinaryModel( BinaryInputStream& rInStrm )

{

    return maFontData.importBinaryModel( rInStrm );

}

void AxFontDataModel::exportBinaryModel( BinaryOutputStream& rOutStrm )

{

    maFontData.exportBinaryModel( rOutStrm );

}

void AxFontDataModel::convertProperties( PropertyMap& rPropMap, const ControlConverter& rConv ) const

{

    // font name

    if( !maFontData.maFontName.isEmpty() )

        rPropMap.setProperty( PROP_FontName, maFontData.maFontName );

    // font effects

    rPropMap.setProperty( PROP_FontWeight, maFontData.mnFontEffects & AxFontFlags::Bold ? awt::FontWeight::BOLD : awt::FontWeight::NORMAL );

    rPropMap.setProperty( PROP_FontSlant, maFontData.mnFontEffects & AxFontFlags::Italic ? FontSlant_ITALIC : FontSlant_NONE );

    if (maFontData.mnFontEffects & AxFontFlags::Underline)

        rPropMap.setProperty( PROP_FontUnderline, maFontData.mbDblUnderline ? awt::FontUnderline::DOUBLE : awt::FontUnderline::SINGLE );

    else

        rPropMap.setProperty( PROP_FontUnderline, awt::FontUnderline::NONE );

    rPropMap.setProperty( PROP_FontStrikeout, maFontData.mnFontEffects & AxFontFlags::Strikeout ? awt::FontStrikeout::SINGLE : awt::FontStrikeout::NONE );

    rPropMap.setProperty( PROP_FontHeight, maFontData.getHeightPoints() );

    // font character set

    rtl_TextEncoding eFontEnc = RTL_TEXTENCODING_DONTKNOW;

    if( (0 <= maFontData.mnFontCharSet) && (maFontData.mnFontCharSet <= SAL_MAX_UINT8) )

        eFontEnc = rtl_getTextEncodingFromWindowsCharset( static_cast< sal_uInt8 >( maFontData.mnFontCharSet ) );

    if( eFontEnc != RTL_TEXTENCODING_DONTKNOW )

        rPropMap.setProperty( PROP_FontCharset, static_cast< sal_Int16 >( eFontEnc ) );

    // text alignment

    if( mbSupportsAlign )

    {

        sal_Int32 nAlign = awt::TextAlign::LEFT;

        switch( maFontData.mnHorAlign )

        {

            case AxHorizontalAlign::Left:      nAlign = awt::TextAlign::LEFT;   break;

            case AxHorizontalAlign::Right:     nAlign = awt::TextAlign::RIGHT;  break;

            case AxHorizontalAlign::Center:    nAlign = awt::TextAlign::CENTER; break;

            default:    OSL_FAIL( "AxFontDataModel::convertProperties - unknown text alignment" );

        }

        // form controls expect short value

        rPropMap.setProperty( PROP_Align, static_cast< sal_Int16 >( nAlign ) );

    }

    // process base class properties

    AxControlModelBase::convertProperties( rPropMap, rConv );