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

#include <userlist.hxx>

#include <dpsave.hxx>

#include <queryparam.hxx>

#include <osl/diagnose.h>

#include <editeng/editobj.hxx>

#include <utility>

/**

 * Status update for entry field

 */

ScInputStatusItem::ScInputStatusItem(

    sal_uInt16 nWhichP, const ScAddress& rCurPos, const ScAddress& rStartPos,

    const ScAddress& rEndPos, OUString _aString, const EditTextObject* pData ) :

    SfxPoolItem ( nWhichP ),

    aCursorPos  ( rCurPos ),

    aStartPos   ( rStartPos ),

    aEndPos     ( rEndPos ),

    aString     (std::move( _aString )),

    pEditData   ( pData ? pData->Clone() : nullptr )

{

}

ScInputStatusItem::ScInputStatusItem( const ScInputStatusItem& rItem ) :

    SfxPoolItem ( rItem ),

    aCursorPos  ( rItem.aCursorPos ),

    aStartPos   ( rItem.aStartPos ),

    aEndPos     ( rItem.aEndPos ),

    aString     ( rItem.aString ),

    pEditData   ( rItem.pEditData ? rItem.pEditData->Clone() : nullptr ),

    maMisspellRanges(rItem.maMisspellRanges)

{

}

ScInputStatusItem::~ScInputStatusItem()

{

}

bool ScInputStatusItem::operator==( const SfxPoolItem& rItem ) const

{

    assert(SfxPoolItem::operator==(rItem));

    return (aStartPos  == static_cast<const ScInputStatusItem&>(rItem).aStartPos)

             && (aEndPos    == static_cast<const ScInputStatusItem&>(rItem).aEndPos)

             && (aCursorPos == static_cast<const ScInputStatusItem&>(rItem).aCursorPos)

             && (aString    == static_cast<const ScInputStatusItem&>(rItem).aString);

             //TODO: Compare Edit data!

}

ScInputStatusItem* ScInputStatusItem::Clone( SfxItemPool * ) const

{

    return new ScInputStatusItem( *this );

}

void ScInputStatusItem::SetMisspellRanges( const sc::MisspellRangeResult& rRanges )

{

    maMisspellRanges = rRanges;

}

// ScPaintHint was moved to hints.cxx

/**

 * Adapt Views when inserting/deleting a table

 */

ScTablesHint::ScTablesHint(sal_uInt16 nNewId, SCTAB nTable1, SCTAB nTable2) :

    SfxHint(SfxHintId::ScTables),

    nId( nNewId ),

    nTab1( nTable1 ),

    nTab2( nTable2 )

{

}

ScTablesHint::~ScTablesHint()

{

}

ScIndexHint::ScIndexHint(SfxHintId nNewId, sal_uInt16 nIdx) :

    SfxHint( nNewId ),

    nIndex( nIdx )

{

}

ScIndexHint::~ScIndexHint()

{

}

/**

 * Create new EditView for Cursorposition

 */

ScEditViewHint::ScEditViewHint( ScEditEngineDefaulter& rEngine, const ScAddress& rCurPos ) :

    SfxHint(SfxHintId::ScEditView),

    rEditEngine( rEngine ),

    aCursorPos( rCurPos )

{

}

ScEditViewHint::~ScEditViewHint()

{

}

/**

 * Data for the sorting dialog

 */

ScSortItem::ScSortItem( sal_uInt16              nWhichP,

                        ScViewData*         ptrViewData,

                        const ScSortParam*  pSortData ) :

        SfxPoolItem ( nWhichP ),

        pViewData   ( ptrViewData )

{

    if ( pSortData ) theSortData = *pSortData;

}

bool ScSortItem::operator==( const SfxPoolItem& rItem ) const

{

    assert(SfxPoolItem::operator==(rItem));

    const ScSortItem& rOther = static_cast<const ScSortItem&>(rItem);

    return (   (pViewData   == rOther.pViewData)

            && (theSortData == rOther.theSortData) );

}

ScSortItem* ScSortItem::Clone( SfxItemPool * ) const

{

    return new ScSortItem( *this );

}

bool ScSortItem::QueryValue( css::uno::Any& rVal, sal_uInt8 /* nMemberUd */ ) const

{

    // Return empty value as there is no useful conversion

    rVal = css::uno::Any();

    return true;

}

/**

 * Data for the Filter dialog

 */

ScQueryItem::ScQueryItem( sal_uInt16                nWhichP,

                          const ScQueryParam*   pQueryData ) :

        SfxPoolItem ( nWhichP ),

        bIsAdvanced ( false )

{

    if (pQueryData)

        mpQueryData.reset(new ScQueryParam(*pQueryData));

    else

        mpQueryData.reset(new ScQueryParam);

}

ScQueryItem::ScQueryItem( const ScQueryItem& rItem ) :

        SfxPoolItem ( rItem ),

        mpQueryData(new ScQueryParam(*rItem.mpQueryData)),

        aAdvSource  ( rItem.aAdvSource ),

        bIsAdvanced ( rItem.bIsAdvanced )

{

}

ScQueryItem::~ScQueryItem()

{

}

void ScQueryItem::SetAdvancedQuerySource(const ScRange* pSource)

{

    if (pSource)

    {

        aAdvSource = *pSource;

        bIsAdvanced = true;

    }

    else

        bIsAdvanced = false;

}

const ScQueryParam& ScQueryItem::GetQueryData() const

{

    return *mpQueryData;

}

bool ScQueryItem::GetAdvancedQuerySource(ScRange& rSource) const

{

    rSource = aAdvSource;

    return bIsAdvanced;

}

bool ScQueryItem::operator==( const SfxPoolItem& rItem ) const

{

    assert(SfxPoolItem::operator==(rItem));

    const ScQueryItem& rQueryItem = static_cast<const ScQueryItem&>(rItem);

    return ( (bIsAdvanced  == rQueryItem.bIsAdvanced)

            && (aAdvSource   == rQueryItem.aAdvSource)

            && (*mpQueryData == *rQueryItem.mpQueryData) );

}

ScQueryItem* ScQueryItem::Clone( SfxItemPool * ) const

{

    return new ScQueryItem( *this );

}

/**

 * Data for the SubTotal dialog

 */

ScSubTotalItem::ScSubTotalItem( sal_uInt16                  nWhichP,

                                ScViewData*             ptrViewData,

                                const ScSubTotalParam*  pSubTotalData ) :

        SfxPoolItem ( nWhichP ),

        pViewData   ( ptrViewData )

{

    if ( pSubTotalData ) theSubTotalData = *pSubTotalData;

}

bool ScSubTotalItem::operator==( const SfxPoolItem& rItem ) const

{

    assert(SfxPoolItem::operator==(rItem));

    const ScSubTotalItem& rSTItem = static_cast<const ScSubTotalItem&>(rItem);

    return (   (pViewData       == rSTItem.pViewData)

            && (theSubTotalData == rSTItem.theSubTotalData) );

}

ScSubTotalItem* ScSubTotalItem::Clone( SfxItemPool * ) const

{

    return new ScSubTotalItem( *this );

}

bool ScSubTotalItem::QueryValue( css::uno::Any& rVal, sal_uInt8 /* nMemberUd */ ) const

{

    // Return empty value as there is no useful conversion

    rVal = css::uno::Any();

    return true;

}

/**

 * Transporter for the UserLIst dialog

 */

ScUserListItem::ScUserListItem( sal_uInt16 nWhichP )

    :   SfxPoolItem ( nWhichP )

{

}

ScUserListItem::ScUserListItem( const ScUserListItem& rItem )

    :   SfxPoolItem ( rItem )

{

    if ( rItem.pUserList )

        pUserList.reset( new ScUserList( *(rItem.pUserList) ) );

}

ScUserListItem::~ScUserListItem()

{

}

bool ScUserListItem::operator==( const SfxPoolItem& rItem ) const

{

    assert(SfxPoolItem::operator==(rItem));

    const ScUserListItem& r = static_cast<const ScUserListItem&>(rItem);

    bool bEqual = false;

    if ( !pUserList || !r.pUserList )

        bEqual = ( !pUserList && !r.pUserList );

    else

        bEqual = ( *pUserList == *(r.pUserList) );

    return bEqual;

}

ScUserListItem* ScUserListItem::Clone( SfxItemPool * ) const

{

    return new ScUserListItem( *this );

}

void ScUserListItem::SetUserList( const ScUserList& rUserList )

{

    pUserList.reset( new ScUserList( rUserList ) );

}

/**

 * Data for the Consolidate dialog

 */

ScConsolidateItem::ScConsolidateItem(

                            sal_uInt16                      nWhichP,

                            const ScConsolidateParam*   pConsolidateData ) :

        SfxPoolItem ( nWhichP )

{

    if ( pConsolidateData ) theConsData = *pConsolidateData;

}

bool ScConsolidateItem::operator==( const SfxPoolItem& rItem ) const

{

    assert(SfxPoolItem::operator==(rItem));

    const ScConsolidateItem& rCItem = static_cast<const ScConsolidateItem&>(rItem);

    return ( theConsData == rCItem.theConsData);

}

ScConsolidateItem* ScConsolidateItem::Clone( SfxItemPool * ) const

{

    return new ScConsolidateItem( *this );

}

/**

 * Data for the Pivot dialog

 */

ScPivotItem::ScPivotItem( sal_uInt16 nWhichP, const ScDPSaveData* pData,

                             const ScRange* pRange, bool bNew ) :

        SfxPoolItem ( nWhichP )

{

    // pSaveData must always exist

    if ( pData )

        pSaveData.reset( new ScDPSaveData(*pData) );

    else

        pSaveData.reset( new ScDPSaveData );

    if ( pRange ) aDestRange = *pRange;

    bNewSheet = bNew;

}

ScPivotItem::ScPivotItem( const ScPivotItem& rItem ) :

        SfxPoolItem ( rItem ),

        aDestRange  ( rItem.aDestRange ),

        bNewSheet   ( rItem.bNewSheet )

{

    assert(rItem.pSaveData && "pSaveData");

    pSaveData.reset( new ScDPSaveData(*rItem.pSaveData) );

}

ScPivotItem::~ScPivotItem()

{

}

bool ScPivotItem::operator==( const SfxPoolItem& rItem ) const

{

    assert(SfxPoolItem::operator==(rItem));

    const ScPivotItem& rPItem = static_cast<const ScPivotItem&>(rItem);

    OSL_ENSURE( pSaveData && rPItem.pSaveData, "pSaveData" );

    return ( *pSaveData == *rPItem.pSaveData &&

             aDestRange == rPItem.aDestRange &&

             bNewSheet  == rPItem.bNewSheet );

}

ScPivotItem* ScPivotItem::Clone( SfxItemPool * ) const

{

    return new ScPivotItem( *this );

}

/**

 * Data for the Solver dialog

 */

ScSolveItem::ScSolveItem( sal_uInt16                nWhichP,

                          const ScSolveParam*   pSolveData )

    :   SfxPoolItem ( nWhichP )

{

    if ( pSolveData ) theSolveData = *pSolveData;

}

bool ScSolveItem::operator==( const SfxPoolItem& rItem ) const

{

    assert(SfxPoolItem::operator==(rItem));

    const ScSolveItem& rPItem = static_cast<const ScSolveItem&>(rItem);

    return ( theSolveData == rPItem.theSolveData );

}

ScSolveItem* ScSolveItem::Clone( SfxItemPool * ) const

{

    return new ScSolveItem( *this );

}

/**

 * Data for the TabOp dialog

 */

ScTabOpItem::ScTabOpItem( sal_uInt16                nWhichP,

                          const ScTabOpParam*   pTabOpData )

    :   SfxPoolItem ( nWhichP )

{

    if ( pTabOpData ) theTabOpData = *pTabOpData;

}

bool ScTabOpItem::operator==( const SfxPoolItem& rItem ) const

{

    assert(SfxPoolItem::operator==(rItem));

    const ScTabOpItem& rPItem = static_cast<const ScTabOpItem&>(rItem);

    return ( theTabOpData == rPItem.theTabOpData );

}

ScTabOpItem* ScTabOpItem::Clone( SfxItemPool * ) const

{

    return new ScTabOpItem( *this );

}

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