Attachment #66340 for issue #107203

View | Details | Raw Unified | Return to issue 107203
Collapse All | Expand All




    return pLocale;
}


namespace sc
{

    FillSeriesData::FillSeriesData()
        : eDir(FILL_TO_BOTTOM)
        , eCmd(FILL_LINEAR)
        , eDateCmd(FILL_DAY)
        , fStart(MAXDOUBLE)
        , aStart()
        , fStep(1.0)
        , fMax(MAXDOUBLE)
        , aMax()
        , bUseString(false)
    {
    }

}


Lines 890-896 Link Here

(-)sc/source/core/data/table2.cxx (-1 / +1 lines)
890	}	890	}
891		891
892		892
893	double ScTable::GetValue( SCCOL nCol, SCROW nRow )	893	double ScTable::GetValue( SCCOL nCol, SCROW nRow ) const
894	{	894	{
895	if (ValidColRow( nCol, nRow ))	895	if (ValidColRow( nCol, nRow ))
896	return aCol[nCol].GetValue( nRow );	896	return aCol[nCol].GetValue( nRow );




#include <svtools/zforlist.hxx>
#include <vcl/keycodes.hxx>
#include <rtl/math.hxx>
#include <unotools/charclass.hxx>

#include "attrib.hxx"
#include "patattr.hxx"

#include "rangenam.hxx"
#include "docpool.hxx"
#include "progress.hxx"
#include "sc/valuestringparser.hxx"

#include <math.h>



// -----------------------------------------------------------------------

short lcl_DecompValueString( String& aValue, sal_Int32& nVal, USHORT* pMinDigits = NULL )
{
	if ( !aValue.Len() )
	{
		nVal = 0;
		return 0;
	}
	const sal_Unicode* p = aValue.GetBuffer();
	xub_StrLen nNeg = 0;
	xub_StrLen nNum = 0;
	if ( p[nNum] == '-' )
		nNum = nNeg = 1;
	while ( p[nNum] && CharClass::isAsciiNumeric( p[nNum] ) )
		nNum++;

    sal_Unicode cNext = p[nNum];            // 0 if at the end
    sal_Unicode cLast = p[aValue.Len()-1];

    // #i5550# If there are numbers at the beginning and the end,
    // prefer the one at the beginning only if it's followed by a space.
    // Otherwise, use the number at the end, to enable things like IP addresses.
    if ( nNum > nNeg && ( cNext == 0 || cNext == ' ' || !CharClass::isAsciiNumeric(cLast) ) )
	{	// number at the beginning
		nVal = aValue.Copy( 0, nNum ).ToInt32();
		//	#60893# any number with a leading zero sets the minimum number of digits
		if ( p[nNeg] == '0' && pMinDigits && ( nNum - nNeg > *pMinDigits ) )
			*pMinDigits = nNum - nNeg;
		aValue.Erase( 0, nNum );
		return -1;
	}
	else
	{
		nNeg = 0;
		xub_StrLen nEnd = nNum = aValue.Len() - 1;
		while ( nNum && CharClass::isAsciiNumeric( p[nNum] ) )
			nNum--;
		if ( p[nNum] == '-' )
		{
			nNum--;
			nNeg = 1;
		}
		if ( nNum < nEnd - nNeg )
		{	// number at the end
			nVal = aValue.Copy( nNum + 1 ).ToInt32();
			//	#60893# any number with a leading zero sets the minimum number of digits
			if ( p[nNum+1+nNeg] == '0' && pMinDigits && ( nEnd - nNum - nNeg > *pMinDigits ) )
				*pMinDigits = nEnd - nNum - nNeg;
			aValue.Erase( nNum + 1 );
			return 1;
		}
	}
	nVal = 0;
	return 0;
}

String lcl_ValueString( sal_Int32 nValue, USHORT nMinDigits )
{
	if ( nMinDigits <= 1 )

{
	DBG_ASSERT( nCol1==nCol2 || nRow1==nRow2, "FillAnalyse: falscher Bereich" );

    using sc::ValueStringParser;
	rInc = 0.0;
	rMinDigits = 0;
	rListData = NULL;

		}
		else if ( nCount > 1 )
		{
			// rMinDigits is the maximum of all MinDigits values that has
            // been got from analyzed cells

            const ValueStringParser aValueString1(aStr);
			sal_Int32 nVal1(aValueString1.GetValue());
            rMinDigits = sal::static_int_cast<USHORT>(aValueString1.GetMinDigits());
			if (aValueString1.HasValue())
			{
				sal_Int32 nVal2;
				GetString( nCol+nAddX, nRow+nAddY, aStr );
                const ValueStringParser aValueString2(aStr);
                sal_Int32 nVal2(aValueString2.GetValue());
                rMinDigits = std::max(rMinDigits,
                        sal::static_int_cast<USHORT>(aValueString2.GetMinDigits()));
				if (CanBeOrdered(aValueString1, aValueString2))
				{
					rInc = static_cast<double>(nVal2) - static_cast<double>(nVal1);
                    nCol = sal::static_int_cast<SCCOL>( nCol + nAddX );
                    nRow = sal::static_int_cast<SCROW>( nRow + nAddY );
					BOOL bVal = TRUE;

								((ScStringCell*)pCell)->GetString( aStr );
							else
								((ScEditCell*)pCell)->GetString( aStr );
                            const ValueStringParser aValueString(aStr);
                            nVal2 = aValueString.GetValue();
                            rMinDigits = std::max(rMinDigits,
                                    sal::static_int_cast<USHORT>(aValueString.GetMinDigits()));
                            if (CanBeOrdered(aValueString1, aValueString))
							{
								double nDiff = static_cast<double>(nVal2) - static_cast<double>(nVal1);
								if ( !::rtl::math::approxEqual( nDiff, rInc ) )
									bVal = FALSE;
								nVal1 = nVal2;

		}
		else
		{
			// just set rMinDigits
            const ValueStringParser aValueString(aStr);
            rMinDigits = aValueString.GetMinDigits();
		}
	}
}

			BOOL bFirst = TRUE;
			BOOL bGetCell = TRUE;
			USHORT nCellDigits = 0;
			bool bIsValue(false);
            bool bIsPrefix(false);
			sal_Int32 nStringValue = 0;
			String aValue;
            ScBaseCell* pSrcCell = NULL;

									((ScEditCell*)pSrcCell)->GetString( aValue );
								if ( !(nScFillModeMouseModifier & KEY_MOD1) )
								{
                                    // look at each source cell individually
                                    const sc::ValueStringParser aValueString(aValue);
                                    bIsValue = aValueString.HasValue();
                                    nCellDigits = aValueString.GetMinDigits();
                                    aValue = aValueString.GetBaseSubstring();
                                    nStringValue = aValueString.GetValue();
                                    bIsPrefix = aValueString.IsPrefix();
                                    bIsOrdinalSuffix = aValue.Equals(
                                            ScGlobal::GetOrdinalSuffix( nStringValue));
								}

						break;
					case CELLTYPE_STRING:
					case CELLTYPE_EDIT:
						if (bIsValue)
						{
                            // #i48009# with the "nStringValue+(long)nDelta" expression within the
                            // lcl_ValueString calls, gcc 3.4.1 makes wrong optimizations (ok in 3.4.3),

                            sal_Int32 nNextValue = nStringValue+(sal_Int32)nDelta;

							String aStr;
							if (bIsPrefix)
							{
                                aCol[nCol].Insert( static_cast<SCROW>(nRow),
                                        lcl_getSuffixCell( pDocument,

			if (!bPositive)
				nInc = -nInc;
			double nEndVal = (nInc>=0.0) ? MAXDOUBLE : -MAXDOUBLE;
            sc::FillSeriesData aFillData;
            aFillData.eDir = eFillDir;
            aFillData.eCmd = eFillCmd;
            aFillData.eDateCmd = eDateCmd;
            aFillData.fStep = nInc;
            aFillData.fMax = nEndVal;
			if (bVertical)
                FillSeries( static_cast<SCCOL>(nCol), nRow1,
                        static_cast<SCCOL>(nCol), nRow2, nFillCount, aFillData,
                        nMinDigits, FALSE, rProgress );
                        rProgress );
			else
                FillSeries( nCol1, static_cast<SCROW>(nRow), nCol2,
                        static_cast<SCROW>(nRow), nFillCount, aFillData,
                        nMinDigits, FALSE, rProgress );
                        rProgress );
			nProgress = rProgress.GetState();
		}


							((ScEditCell*)pCell)->GetString( aValue );
						if ( !(nScFillModeMouseModifier & KEY_MOD1) )
						{
                            // look at each source cell individually
                            const sc::ValueStringParser aValueString(aValue);
							sal_Int32 nVal(aValueString.GetValue());
							USHORT nCellDigits(sal::static_int_cast<USHORT>(
                                        aValueString.GetMinDigits()));
                            aValue = aValueString.GetBaseSubstring();
                            if (aValueString.HasValue())
                            {
                                if (aValueString.IsPrefix())
                                {
                                    if (aValue.Equals( ScGlobal::GetOrdinalSuffix( nVal)))
                                        aValue = ScGlobal::GetOrdinalSuffix( nVal + nDelta);

                                    aValue.Insert( lcl_ValueString( nVal + nDelta, nCellDigits ), 0 );
                                }
                                else
                                {
                                    aValue += lcl_ValueString( nVal + nDelta, nCellDigits );
                                }
                            }
                        }
								aValue += lcl_ValueString( nVal + nDelta, nCellDigits );
						}
					}
					break;
					case CELLTYPE_VALUE:

            BOOL bValueOk;
			double nStart;
            sal_Int32 nVal = 0;
			bool bHasValue(false);
            bool bIsPrefix(false);
			ScBaseCell*	pCell = GetCell( nCol1, nRow1 );
			if ( pCell )
			{

							((ScStringCell*)pCell)->GetString( aValue );
						else
							((ScEditCell*)pCell)->GetString( aValue );
                        {
                            const sc::ValueStringParser aValueString(aValue);
                            aValue = aValueString.GetBaseSubstring();
                            bHasValue = aValueString.HasValue();
                            bIsPrefix = aValueString.IsPrefix();
                            nVal = aValueString.GetValue();
                        }
						if (bHasValue)
							nStart = (double)nVal;
						else
							nStart = 0.0;


            if (bValueOk)
			{
				if (bHasValue)
				{
					if (bIsPrefix)
                    {
                        if (aValue.Equals( ScGlobal::GetOrdinalSuffix( nVal)))
                            aValue = ScGlobal::GetOrdinalSuffix( (sal_Int32)nStart );

	rVal = aDate - aNullDate;
}


void
ScTable::FillSeries(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
        ULONG nFillCount, const sc::FillSeriesData& rFillData,
        USHORT nArgMinDigits, bool bAttribs, ScProgress& rProgress)
{
	//
	//	Richtung auswerten
	//

	BOOL bVertical = (rFillData.eDir == FILL_TO_BOTTOM || rFillData.eDir == FILL_TO_TOP);
	BOOL bPositive = (rFillData.eDir == FILL_TO_BOTTOM || rFillData.eDir == FILL_TO_RIGHT);

    ULONG nCol = 0;
    ULONG nRow = 0;


		if (pSrcCell)
		{
            double fMaxValue(rFillData.fMax);
			CellType eCellType = pSrcCell->GetCellType();

			if (rFillData.eCmd == FILL_SIMPLE)				// kopieren
			{
				if (eCellType == CELLTYPE_FORMULA)
				{

				{
					if (!bError && !bOverflow)
					{
						switch (rFillData.eCmd)
						{
							case FILL_LINEAR:
								{
									//	#86365# use multiplication instead of repeated addition
									//	to avoid accumulating rounding errors
									nVal = nStartVal;
									double nAdd = rFillData.fStep;
									if ( !SubTotal::SafeMult( nAdd, (double) ++nIndex ) ||
										 !SubTotal::SafePlus( nVal, nAdd ) )
										bError = TRUE;
								}
								break;
							case FILL_GROWTH:
								if (!SubTotal::SafeMult(nVal, rFillData.fStep))
									bError = TRUE;
								break;
							case FILL_DATE:
								if (fabs(nVal) > _D_MAX_LONG_)
									bError = TRUE;
								else
									IncDate(nVal, nDayOfMonth, rFillData.fStep, rFillData.eDateCmd); break;
								break;
                            default:
                            {
                                // added to avoid warnings
                            }
						}

						if (rFillData.fStep >= 0)
						{
							if (nVal > fMaxValue)			// Zielwert erreicht?
							{
								nVal = fMaxValue;
								bOverflow = TRUE;
							}
						}
						else
						{
							if (nVal < fMaxValue)
							{
								nVal = fMaxValue;
								bOverflow = TRUE;
							}
						}

			}
			else if (eCellType == CELLTYPE_STRING || eCellType == CELLTYPE_EDIT)
			{
				if (rFillData.fStep >= 0)
				{
					if (fMaxValue >= static_cast<double>(LONG_MAX))
						fMaxValue = static_cast<double>(LONG_MAX) - 1;
				}
				else
				{
					if (fMaxValue <= static_cast<double>(LONG_MIN))
						fMaxValue = static_cast<double>(LONG_MIN) + 1;
				}
				String aValue;
				if (eCellType == CELLTYPE_STRING)
					((ScStringCell*)pSrcCell)->GetString( aValue );
				else
					((ScEditCell*)pSrcCell)->GetString( aValue );
                const sc::ValueStringParser aValueString(aValue);
				sal_Int32 nStringValue(aValueString.GetValue());
                USHORT nMinDigits(0);
                if (nArgMinDigits == 0 && rFillData.bUseString)
                {
                    const sc::ValueStringParser aStart(rFillData.aStart);
                    const sc::ValueStringParser aMax(rFillData.aMax);
                    nMinDigits = std::max(aStart.GetMinDigits(), aMax.GetMinDigits());
                }
                else
                {
                    nMinDigits = std::max(
                            nArgMinDigits,
                            sal::static_int_cast<USHORT>(aValueString.GetMinDigits()));
                }
                aValue = aValueString.GetBaseSubstring();
				if (aValueString.HasValue())
				{
					double nStartVal = static_cast<double>(nStringValue);
					double nVal = nStartVal;
					long nIndex = 0;
					BOOL bError = FALSE;

					{
						if (!bError && !bOverflow)
						{
							switch (rFillData.eCmd)
							{
								case FILL_LINEAR:
									{
										//	#86365# use multiplication instead of repeated addition
										//	to avoid accumulating rounding errors
										nVal = nStartVal;
										double nAdd = rFillData.fStep;
										if ( !SubTotal::SafeMult( nAdd, (double) ++nIndex ) ||
											 !SubTotal::SafePlus( nVal, nAdd ) )
											bError = TRUE;
									}
									break;
								case FILL_GROWTH:
									if (!SubTotal::SafeMult(nVal, rFillData.fStep))
										bError = TRUE;
									break;
                                default:

                                }
							}

							if (rFillData.fStep >= 0)
							{
								if (nVal > fMaxValue)			// Zielwert erreicht?
								{
									nVal = fMaxValue;
									bOverflow = TRUE;
								}
							}
							else
							{
								if (nVal < fMaxValue)
								{
									nVal = fMaxValue;
									bOverflow = TRUE;
								}
							}

							aCol[nCol].SetError(static_cast<SCROW>(nRow), errNoValue);
						else if (!bOverflow)
						{
							nStringValue = static_cast<sal_Int32>(nVal);
							String aStr;
							if (aValueString.IsPrefix())
							{
                                aCol[nCol].Insert( static_cast<SCROW>(nRow),
                                        lcl_getSuffixCell( pDocument,

					ULONG nFillCount, FillDir eFillDir, FillCmd eFillCmd, FillDateCmd eFillDateCmd,
					double nStepValue, double nMaxValue)
{
    sc::FillSeriesData aFillData;
    aFillData.eDir = eFillDir;
    aFillData.eCmd = eFillCmd;
    aFillData.eDateCmd = eFillDateCmd;
    aFillData.fStep = nStepValue;
    aFillData.fMax = nMaxValue;
    Fill(nCol1, nRow1, nCol2, nRow2, nFillCount, aFillData);
}


void ScTable::Fill( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
					ULONG nFillCount, const sc::FillSeriesData& rFillData)
{
	ULONG nProgCount;
	if (rFillData.eDir == FILL_TO_BOTTOM || rFillData.eDir == FILL_TO_TOP)
		nProgCount = nCol2 - nCol1 + 1;
	else
		nProgCount = nRow2 - nRow1 + 1;


	bSharedNameInserted = FALSE;

	if (rFillData.eCmd == FILL_AUTO)
		FillAuto(nCol1, nRow1, nCol2, nRow2, nFillCount, rFillData.eDir, aProgress);
	else
		FillSeries(nCol1, nRow1, nCol2, nRow2, nFillCount, rFillData, 0, true, aProgress);
					eFillCmd, eFillDateCmd, nStepValue, nMaxValue, 0, TRUE, aProgress);

	if (bSharedNameInserted)						// Wurde Shared-Name eingefuegt?
		pDocument->GetRangeName()->SetSharedMaxIndex(

{
	for (SCCOL i=0; i<=MAXCOL; i++) aCol[i].CompileColRowNameFormula();
}










}

void ScDocument::Fill(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, const ScMarkData& rMark,
                        ULONG nFillCount, FillDir eFillDir, FillCmd eFillCmd, FillDateCmd eFillDateCmd,
                        double nStepValue, double nMaxValue)
{
    sc::FillSeriesData aFillData;
    aFillData.eDir = eFillDir;
    aFillData.eCmd = eFillCmd;
    aFillData.eDateCmd = eFillDateCmd;
    aFillData.fStep = nStepValue;
    aFillData.fMax = nMaxValue;
    Fill(nCol1, nRow1, nCol2, nRow2, rMark, nFillCount, aFillData);
}


void
ScDocument::Fill(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
        const ScMarkData& rMark, ULONG nFillCount,
        const sc::FillSeriesData& rFillData)
{
	PutInOrder( nCol1, nCol2 );
	PutInOrder( nRow1, nRow2 );
	for (SCTAB i=0; i <= MAXTAB; i++)
		if (pTab[i])
			if (rMark.GetTableSelect(i))
				pTab[i]->Fill(nCol1, nRow1, nCol2, nRow2, nFillCount, rFillData);
								nFillCount, eFillDir, eFillCmd, eFillDateCmd,
								nStepValue, nMaxValue);
}

String ScDocument::GetAutoFillPreview( const ScRange& rSource, SCCOL nEndX, SCROW nEndY )

Lines 112-117 Link Here

(-)sc/source/core/data/makefile.mk (+1 lines)
112	$(SLO)$/tabprotection.obj \	112	$(SLO)$/tabprotection.obj \
113	$(SLO)$/userdat.obj \	113	$(SLO)$/userdat.obj \
114	$(SLO)$/validat.obj \	114	$(SLO)$/validat.obj \
		115	$(SLO)$/valuestringparser.obj \
115	$(SLO)$/postit.obj	116	$(SLO)$/postit.obj
116		117
117	EXCEPTIONSFILES= \	118	EXCEPTIONSFILES= \




/*************************************************************************
 *
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * Copyright 2008 by Sun Microsystems, Inc.
 *
 * OpenOffice.org - a multi-platform office productivity suite
 *
 * $RCSfile: $
 * $Revision: $
 *
 * This file is part of OpenOffice.org.
 *
 * OpenOffice.org is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 3
 * only, as published by the Free Software Foundation.
 *
 * OpenOffice.org is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License version 3 for more details
 * (a copy is included in the LICENSE file that accompanied this code).
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 3 along with OpenOffice.org.  If not, see
 * <http://www.openoffice.org/license.html>
 * for a copy of the LGPLv3 License.
 *
 ************************************************************************/

#include "precompiled_sc.hxx"

#include <unotools/charclass.hxx>

#include "global.hxx"
#include "sc/valuestringparser.hxx"


namespace sc
{

    namespace
    {
        
        short lcl_DecompValueString( String& aValue, sal_Int32& nVal, USHORT* pMinDigits = NULL )
        {
            if ( !aValue.Len() )
            {
                nVal = 0;
                return 0;
            }
            const sal_Unicode* p = aValue.GetBuffer();
            xub_StrLen nNeg = 0;
            xub_StrLen nNum = 0;
            if ( p[nNum] == '-' )
                nNum = nNeg = 1;
            while ( p[nNum] && CharClass::isAsciiNumeric( p[nNum] ) )
                nNum++;

            sal_Unicode cNext = p[nNum];            // 0 if at the end
            sal_Unicode cLast = p[aValue.Len()-1];

            // #i5550# If there are numbers at the beginning and the end,
            // prefer the one at the beginning only if it's followed by a space.
            // Otherwise, use the number at the end, to enable things like IP addresses.
            if ( nNum > nNeg && ( cNext == 0 || cNext == ' ' || !CharClass::isAsciiNumeric(cLast) ) )
            {	// number at the beginning
                nVal = aValue.Copy( 0, nNum ).ToInt32();
                //	#60893# any number with a leading zero sets the minimum number of digits
                if ( p[nNeg] == '0' && pMinDigits && ( nNum - nNeg > *pMinDigits ) )
                    *pMinDigits = nNum - nNeg;
                aValue.Erase( 0, nNum );
                return -1;
            }
            else
            {
                nNeg = 0;
                xub_StrLen nEnd = nNum = aValue.Len() - 1;
                while ( nNum && CharClass::isAsciiNumeric( p[nNum] ) )
                    nNum--;
                if ( p[nNum] == '-' )
                {
                    nNum--;
                    nNeg = 1;
                }
                if ( nNum < nEnd - nNeg )
                {	// number at the end
                    nVal = aValue.Copy( nNum + 1 ).ToInt32();
                    //	#60893# any number with a leading zero sets the minimum number of digits
                    if ( p[nNum+1+nNeg] == '0' && pMinDigits && ( nEnd - nNum - nNeg > *pMinDigits ) )
                        *pMinDigits = nEnd - nNum - nNeg;
                    aValue.Erase( nNum + 1 );
                    return 1;
                }
            }
            nVal = 0;
            return 0;
        }

    }


    ValueStringParser::ValueStringParser(const String& rString)
        : m_aString(rString)
        , m_aNumericSubstring()
        , m_aBaseSubstring()
        , m_nValue(0)
        , m_nMinDigits(0)
        , m_bHasValue(false)
        , m_bIsPrefix(false)
    {
        impl_DecompValueString();
    }


    bool
    ValueStringParser::HasValue() const
    {
        return m_bHasValue;
    }


    sal_Int32
    ValueStringParser::GetValue() const
    {
        return m_nValue;
    }


    sal_Int16
    ValueStringParser::GetMinDigits() const
    {
        return m_nMinDigits;
    }


    const String&
    ValueStringParser::GetNumericSubstring() const
    {
        if (m_bHasValue && m_aNumericSubstring.Len() == 0)
        {
            if (m_bIsPrefix)
            {
                m_aNumericSubstring = m_aString.Copy(0,
                        m_aString.Len() - m_aBaseSubstring.Len());
            }
            else
            {
                m_aNumericSubstring = m_aString.Copy(m_aBaseSubstring.Len());
            }
        }

        return m_aNumericSubstring;
    }


    const String&
    ValueStringParser::GetBaseSubstring() const
    {
        return m_aBaseSubstring;
    }


    bool
    ValueStringParser::IsPrefix() const
    {
        return m_bIsPrefix;
    }


    void
    ValueStringParser::impl_DecompValueString()
    {
        String aString(m_aString);
        sal_Int32 nValue(0);
        USHORT nMinDigits(0);
        const short nResult(lcl_DecompValueString(aString, nValue, &nMinDigits));
        m_aBaseSubstring = aString;
        if (nResult != 0)
        {
            m_bHasValue = true;
            m_nValue = nValue;
            m_nMinDigits = nMinDigits;
            m_bIsPrefix = nResult < 0;
        }
    }


    bool
    CanBeOrdered(
            const ValueStringParser& rValueString1,
            const ValueStringParser& rValueString2)
    {
        if (rValueString1.HasValue() && rValueString2.HasValue()
                && rValueString1.IsPrefix() == rValueString2.IsPrefix())
        {
            if (rValueString1.IsPrefix())
            {
                // check if both base substrings are ordinal suffixes
                const String aSuffix1(ScGlobal::GetOrdinalSuffix(rValueString1.GetValue()));
                const String aSuffix2(ScGlobal::GetOrdinalSuffix(rValueString2.GetValue()));
                if (rValueString1.GetBaseSubstring() == aSuffix1
                        && rValueString2.GetBaseSubstring() == aSuffix2)
                {
                    return true;
                }
                // if they are not, just continue and check, if they are
                // the same
            }
            return rValueString1.GetBaseSubstring() == rValueString2.GetBaseSubstring();
        }
        return false;
    }

}

// vim: set sts=4 sw=4 et:

Lines 5424-5431 Link Here

(-)sc/source/ui/unoobj/cellsuno.cxx (-2 / +8 lines)
5424	if (!bError)	5424	if (!bError)
5425	{	5425	{
5426	ScDocFunc aFunc(*pDocSh);	5426	ScDocFunc aFunc(*pDocSh);
5427	aFunc.FillSeries( aRange, NULL, eDir, eCmd, eDateCmd,	5427	sc::FillSeriesData aFillData;
5428	MAXDOUBLE, fStep, fEndValue, TRUE, TRUE );	5428	aFillData.eDir = eDir;
		5429	aFillData.eCmd = eCmd;
		5430	aFillData.eDateCmd = eDateCmd;
		5431	aFillData.fStart = MAXDOUBLE;
		5432	aFillData.fStep = fStep;
		5433	aFillData.fMax = fEndValue;
		5434	aFunc.FillSeries( aRange, NULL, aFillData, TRUE, TRUE );
5429	}	5435	}
5430	}	5436	}
5431	}	5437	}




            pDoc->CopyToDocument( aCopyRange, IDF_AUTOFILL, FALSE, pUndoDoc, &aMark );
		}

        sc::FillSeriesData aFillData;
        aFillData.eDir = eDir;
        aFillData.eCmd = FILL_SIMPLE;
        aFillData.eDateCmd = FILL_DAY;
        aFillData.fStart = MAXDOUBLE;
        aFillData.fStep = 1.0;
        aFillData.fMax = 1e307;

		pDoc->Fill( aSourceArea.aStart.Col(), aSourceArea.aStart.Row(),
					aSourceArea.aEnd.Col(), aSourceArea.aEnd.Row(), aMark,
					nCount, aFillData );
		AdjustRowHeight(rRange);

		if ( bRecord )		// Draw-Undo erst jetzt verfuegbar
		{
			rDocShell.GetUndoManager()->AddUndoAction(
				new ScUndoAutoFill( &rDocShell, aDestArea, aSourceArea, pUndoDoc, aMark,
									aFillData,
									pDoc->GetRangeName()->GetSharedMaxIndex()+1 ) );
		}


	return bSuccess;
}


bool
ScDocFunc::FillSeries(
        const ScRange& rRange, const ScMarkData* pTabMark,
        const sc::FillSeriesData& rFillData, bool bRecord, bool bApi)
{
	ScDocShellModificator aModificator( rDocShell );


		SCSIZE nCount = pDoc->GetEmptyLinesInBlock(
				aSourceArea.aStart.Col(), aSourceArea.aStart.Row(), aSourceArea.aStart.Tab(),
				aSourceArea.aEnd.Col(), aSourceArea.aEnd.Row(), aSourceArea.aEnd.Tab(),
				DirFromFillDir(rFillData.eDir) );

		//	#27665# mindestens eine Zeile/Spalte als Quellbereich behalten:
		SCSIZE nTotLines = ( rFillData.eDir == FILL_TO_BOTTOM || rFillData.eDir == FILL_TO_TOP ) ?
            static_cast<SCSIZE>( aSourceArea.aEnd.Row() - aSourceArea.aStart.Row() + 1 ) :
            static_cast<SCSIZE>( aSourceArea.aEnd.Col() - aSourceArea.aStart.Col() + 1 );
		if ( nCount >= nTotLines )
			nCount = nTotLines - 1;

		switch (rFillData.eDir)
		{
			case FILL_TO_BOTTOM:
                aSourceArea.aEnd.SetRow( sal::static_int_cast<SCROW>( aSourceArea.aEnd.Row() - nCount ) );

		if (aDestArea.aStart.Col() <= aDestArea.aEnd.Col() &&
			aDestArea.aStart.Row() <= aDestArea.aEnd.Row())
		{
			if (rFillData.fStart != MAXDOUBLE)
			{
				SCCOL nValX = (rFillData.eDir == FILL_TO_LEFT)
                    ? aDestArea.aEnd.Col() : aDestArea.aStart.Col();
				SCROW nValY = (rFillData.eDir == FILL_TO_TOP )
                    ? aDestArea.aEnd.Row() : aDestArea.aStart.Row();
				SCTAB nTab = aDestArea.aStart.Tab();
                if (rFillData.bUseString)
                {
                    OSL_ENSURE(rFillData.aStart.Len() != 0, "there is no starting string");
                    pDoc->SetString(nValX, nValY, nTab, rFillData.aStart);
                }
                else
                {
                    pDoc->SetValue(nValX, nValY, nTab, rFillData.fStart);
                }
			}
			pDoc->Fill( aSourceArea.aStart.Col(), aSourceArea.aStart.Row(),
						aSourceArea.aEnd.Col(), aSourceArea.aEnd.Row(), aMark,
						nCount, rFillData );
			AdjustRowHeight(rRange);

			rDocShell.PostPaintGridAll();

		{
			rDocShell.GetUndoManager()->AddUndoAction(
				new ScUndoAutoFill( &rDocShell, aDestArea, aSourceArea, pUndoDoc, aMark,
									rFillData,
									pDoc->GetRangeName()->GetSharedMaxIndex()+1 ) );
		}


            IDF_AUTOFILL, FALSE, pUndoDoc, &aMark );
	}

    {
        sc::FillSeriesData aFillData;
        aFillData.eDir = eDir;
        aFillData.eCmd = eCmd;
        aFillData.eDateCmd = eDateCmd;
        aFillData.fStep = fStep;
        aFillData.fMax = fMax;

        pDoc->Fill( aSourceArea.aStart.Col(), aSourceArea.aStart.Row(),
                    aSourceArea.aEnd.Col(), aSourceArea.aEnd.Row(), aMark,
                    nCount, aFillData );

        AdjustRowHeight(aDestArea);
	{
		rDocShell.GetUndoManager()->AddUndoAction(
			new ScUndoAutoFill( &rDocShell, aDestArea, aSourceArea, pUndoDoc, aMark,
								eDir, eCmd, eDateCmd, MAXDOUBLE, fStep, fMax,
								pDoc->GetRangeName()->GetSharedMaxIndex()+1 ) );
	}

        if ( bRecord )		// Draw-Undo erst jetzt verfuegbar
        {
            aFillData.fStart = MAXDOUBLE;
            rDocShell.GetUndoManager()->AddUndoAction(
                new ScUndoAutoFill( &rDocShell, aDestArea, aSourceArea, pUndoDoc, aMark,
                                    aFillData,
                                    pDoc->GetRangeName()->GetSharedMaxIndex()+1 ) );
        }
    }

	rDocShell.PostPaintGridAll();
//	rDocShell.PostPaintDataChanged();
	aModificator.SetDocumentModified();

Lines 181-186 Link Here

(-)sc/source/ui/attrdlg/scdlgfact.hxx (+1 lines)
181	virtual double GetStep() const;	181	virtual double GetStep() const;
182	virtual double GetMax() const;	182	virtual double GetMax() const;
183	virtual String GetStartStr() const;	183	virtual String GetStartStr() const;
		184	virtual String GetMaxStr() const;
184	virtual void SetEdStartValEnabled(BOOL bFlag=FALSE);	185	virtual void SetEdStartValEnabled(BOOL bFlag=FALSE);
185	};	186	};
186		187

Lines 326-331 Link Here

(-)sc/source/ui/attrdlg/scdlgfact.cxx (+4 lines)
326	{	326	{
327	return pDlg->GetStartStr();	327	return pDlg->GetStartStr();
328	}	328	}
		329	String AbstractScFillSeriesDlg_Impl::GetMaxStr() const
		330	{
		331	return pDlg->GetMaxStr();
		332	}
329	void AbstractScFillSeriesDlg_Impl::SetEdStartValEnabled(BOOL bFlag)	333	void AbstractScFillSeriesDlg_Impl::SetEdStartValEnabled(BOOL bFlag)
330	{	334	{
331	pDlg->SetEdStartValEnabled(bFlag);	335	pDlg->SetEdStartValEnabled(bFlag);




#include "document.hxx"
#include "miscdlgs.hrc"

#define _FILLDLG_CXX
#include "filldlg.hxx"
#include "sc/valuestringparser.hxx"




	else
		bValOk = rDoc.GetFormatTable()->IsNumberFormat( aStr, nKey, fStartVal );

    if (!bValOk)
    {
        sc::ValueStringParser aValueString(aStr);
        bValOk = aValueString.HasValue();
        if (bValOk)
        {
            fStartVal = aValueString.GetValue();
        }
    }

	return bValOk;
}


	else
		bValOk = rDoc.GetFormatTable()->IsNumberFormat( aStr, nKey, fEndVal );

    if (!bValOk)
    {
        sc::ValueStringParser aValueString(aStr);
        bValOk = aValueString.HasValue();
        if (bValOk)
        {
            fEndVal = aValueString.GetValue();
        }
    }

	return bValOk;
}


namespace
{

    bool
    lcl_CheckStartEndString(const String& rStart, const String& rEnd)
    {
        const sc::ValueStringParser aStartValueString(rStart);
        const sc::ValueStringParser aEndValueString(rEnd);
        const bool bStartEmpty(rStart.Len() == 0);
        const bool bEndEmpty(rEnd.Len() == 0);
        const bool bStartIsValue(aStartValueString.HasValue());
        const bool bEndIsValue(aEndValueString.HasValue());
        bool bValOk((bStartEmpty || bStartIsValue) && (bEndEmpty || bEndIsValue));
        if (bValOk)
        {
            if (bStartIsValue && bEndIsValue)
            {
                bValOk = CanBeOrdered(aStartValueString, aEndValueString);
            }
        }
        return bValOk;
    }

}

//----------------------------------------------------------------------------
// Handler:
//----------------------------------------------------------------------------

		bAllOk = FALSE;
		pEdWrong = &aEdEndVal;
	}
    else if (!lcl_CheckStartEndString(aEdStartVal.GetText(), aEdEndVal.GetText()))
    {
        bAllOk = FALSE;
        pEdWrong = &aEdEndVal;
    }
	if ( bAllOk )
		EndDialog( RET_OK );
	else


	return 0;
}








ScUndoAutoFill::ScUndoAutoFill( ScDocShell* pNewDocShell,
				const ScRange& rRange, const ScRange& rSourceArea,
				ScDocument* pNewUndoDoc, const ScMarkData& rMark,
				const sc::FillSeriesData& rFillData, USHORT nMaxShIndex )
				double fNewStartValue, double fNewStepValue, double fNewMaxValue,
				USHORT nMaxShIndex )
		//
	:	ScBlockUndo( pNewDocShell, rRange, SC_UNDO_AUTOHEIGHT ),
		//
		aSource			( rSourceArea ),
		aMarkData		( rMark ),
		pUndoDoc		( pNewUndoDoc ),
		m_aFillData(rFillData),
        nStartChangeAction(0L),
        nEndChangeAction(0L),
		fStartValue		( fNewStartValue ),
		fStepValue		( fNewStepValue ),
		fMaxValue		( fNewMaxValue ),
		nMaxSharedIndex	( nMaxShIndex)
{
	SetChangeTrack();

//!	Tabellen selektieren

    SCCOLROW nCount = 0;
	switch (m_aFillData.eDir)
	{
		case FILL_TO_BOTTOM:
			nCount = aBlockRange.aEnd.Row() - aSource.aEnd.Row();

	}

	ScDocument* pDoc = pDocShell->GetDocument();
	if (m_aFillData.fStart != MAXDOUBLE)
	{
		SCCOL nValX = (m_aFillData.eDir == FILL_TO_LEFT)
            ? aSource.aEnd.Col() : aSource.aStart.Col();
		SCROW nValY = (m_aFillData.eDir == FILL_TO_TOP )
            ? aSource.aEnd.Row() : aSource.aStart.Row();
		SCTAB nTab = aSource.aStart.Tab();
        if (m_aFillData.bUseString)
        {
            OSL_ENSURE(rFillData.aStart.Len() != 0, "there is no starting string");
            pDoc->SetString(nValX, nValY, nTab, m_aFillData.aStart);
        }
        else
        {
            pDoc->SetValue(nValX, nValY, nTab, m_aFillData.fStart);
        }
	}
	pDoc->Fill(aSource.aStart.Col(), aSource.aStart.Row(),
				aSource.aEnd.Col(),   aSource.aEnd.Row(),
				aMarkData, nCount, m_aFillData)
        ;
				fStepValue, fMaxValue );

	SetChangeTrack();


	if (rTarget.ISA(ScTabViewTarget))
	{
		ScTabViewShell& rViewShell = *((ScTabViewTarget&)rTarget).GetViewShell();
		if (m_aFillData.eCmd==FILL_SIMPLE)
			rViewShell.FillSimple(m_aFillData.eDir, TRUE);
		else
			rViewShell.FillSeries(m_aFillData, true);
								   fStartValue, fStepValue, fMaxValue, TRUE );
	}
}


Lines 48-53 Link Here

(-)sc/source/ui/inc/undoblk.hxx (-9 / +7 lines)
48	class SvxSearchItem;	48	class SvxSearchItem;
49	class SdrUndoAction;	49	class SdrUndoAction;
50		50
		51	// namespace sc
		52	// {
		53	// struct FillSeriesData;
		54	// }
		55
51	//----------------------------------------------------------------------------	56	//----------------------------------------------------------------------------
52		57
53	class ScUndoInsertCells: public ScMoveUndo	58	class ScUndoInsertCells: public ScMoveUndo
Lines 413-421 Link Here
413	ScUndoAutoFill( ScDocShell* pNewDocShell,	418	ScUndoAutoFill( ScDocShell* pNewDocShell,
414	const ScRange& rRange, const ScRange& rSourceArea,	419	const ScRange& rRange, const ScRange& rSourceArea,
415	ScDocument* pNewUndoDoc, const ScMarkData& rMark,	420	ScDocument* pNewUndoDoc, const ScMarkData& rMark,
416	FillDir eNewFillDir,	421	const sc::FillSeriesData& rFillData,
417	FillCmd eNewFillCmd, FillDateCmd eNewFillDateCmd,
418	double fNewStartValue, double fNewStepValue, double fNewMaxValue,
419	USHORT nMaxShIndex );	422	USHORT nMaxShIndex );
420	virtual ~ScUndoAutoFill();	423	virtual ~ScUndoAutoFill();
421		424
Lines 430-441 Link Here
430	ScRange aSource;	433	ScRange aSource;
431	ScMarkData aMarkData;	434	ScMarkData aMarkData;
432	ScDocument* pUndoDoc;	435	ScDocument* pUndoDoc;
433	FillDir eFillDir;	436	sc::FillSeriesData m_aFillData;
434	FillCmd eFillCmd;
435	FillDateCmd eFillDateCmd;
436	double fStartValue;
437	double fStepValue;
438	double fMaxValue;
439	ULONG nStartChangeAction;	437	ULONG nStartChangeAction;
440	ULONG nEndChangeAction;	438	ULONG nEndChangeAction;
441	USHORT nMaxSharedIndex;	439	USHORT nMaxSharedIndex;

Lines 244-253 Link Here

(-)sc/source/ui/inc/viewfunc.hxx (-4 / +5 lines)
244	BOOL RemoveMerge( BOOL bRecord = TRUE );	244	BOOL RemoveMerge( BOOL bRecord = TRUE );
245		245
246	void FillSimple( FillDir eDir, BOOL bRecord = TRUE );	246	void FillSimple( FillDir eDir, BOOL bRecord = TRUE );
247	void FillSeries( FillDir eDir, FillCmd eCmd, FillDateCmd eDateCmd,	247	void FillSeries( FillDir eDir, FillCmd eCmd, FillDateCmd eDateCmd,
248	double fStart, double fStep, double fMax, BOOL bRecord = TRUE );	248	double fStart, double fStep, double fMax, BOOL bRecord = TRUE );
249	void FillAuto( FillDir eDir, SCCOL nStartCol, SCROW nStartRow,	249	void FillSeries(const sc::FillSeriesData& rFillData, bool bRecord = true);
250	SCCOL nEndCol, SCROW nEndRow, ULONG nCount, BOOL bRecord = TRUE );	250	void FillAuto( FillDir eDir, SCCOL nStartCol, SCROW nStartRow,
		251	SCCOL nEndCol, SCROW nEndRow, ULONG nCount, BOOL bRecord = TRUE );
251	void FillCrossDblClick();	252	void FillCrossDblClick();
252		253
253	void TransliterateText( sal_Int32 nType );	254	void TransliterateText( sal_Int32 nType );

Lines 78-83 Link Here

(-)sc/source/ui/inc/filldlg.hxx (-3 / +4 lines)
78	double GetMax() const { return fEndVal; }	78	double GetMax() const { return fEndVal; }
79		79
80	String GetStartStr() const { return aEdStartVal.GetText(); }	80	String GetStartStr() const { return aEdStartVal.GetText(); }
		81	String GetMaxStr() const
		82	{
		83	return aEdEndVal.GetText();
		84	}
81		85
82	void SetEdStartValEnabled(BOOL bFlag=FALSE);	86	void SetEdStartValEnabled(BOOL bFlag=FALSE);
83		87
Lines 129-135 Link Here
129	double fIncrement;	133	double fIncrement;
130	double fEndVal;	134	double fEndVal;
131		135
132	#ifdef _FILLDLG_CXX
133	private:	136	private:
134	void Init( USHORT nPossDir );	137	void Init( USHORT nPossDir );
135	BOOL CheckStartVal();	138	BOOL CheckStartVal();
Lines 138-147 Link Here
138		141
139	DECL_LINK( OKHdl, void * );	142	DECL_LINK( OKHdl, void * );
140	DECL_LINK( DisableHdl, Button * );	143	DECL_LINK( DisableHdl, Button * );
141	#endif
142	};	144	};
143		145
144		146
145
146	#endif // SC_FILLDLG_HXX	147	#endif // SC_FILLDLG_HXX
147		148




	BOOL			TabOp( const ScRange& rRange, const ScMarkData* pTabMark,
							const ScTabOpParam& rParam, BOOL bRecord, BOOL bApi );

    BOOL			FillSimple( const ScRange& rRange, const ScMarkData* pTabMark,
                                FillDir eDir, BOOL bRecord, BOOL bApi );
	bool			FillSeries(const ScRange& rRange, const ScMarkData* pTabMark,
                                const sc::FillSeriesData& rFillData, bool bRecord, bool bApi);
								double fStart, double fStep, double fMax,
								BOOL bRecord, BOOL bApi );
					// FillAuto: rRange wird von Source-Range auf Dest-Range angepasst
    BOOL			FillAuto( ScRange& rRange, const ScMarkData* pTabMark,
                                FillDir eDir, ULONG nCount, BOOL bRecord, BOOL bApi );

	BOOL			ResizeMatrix( const ScRange& rOldRange, const ScAddress& rNewEnd, BOOL bApi );





//----------------------------------------------------------------------------

void ScViewFunc::FillSeries( FillDir eDir, FillCmd eCmd, FillDateCmd eDateCmd,
                             double fStart, double fStep, double fMax, BOOL bRecord )
{
    sc::FillSeriesData aFillData;
    aFillData.eDir = eDir;
    aFillData.eCmd = eCmd;
    aFillData.eDateCmd = eDateCmd;
    aFillData.fStart = fStart;
    aFillData.fStep = fStep;
    aFillData.fMax = fMax;
    FillSeries(aFillData, bRecord);
}


void
ScViewFunc::FillSeries(const sc::FillSeriesData& rFillData, bool bRecord)
{
	ScRange aRange;
	if (GetViewData()->GetSimpleArea(aRange) == SC_MARK_SIMPLE)
	{
		ScDocShell* pDocSh = GetViewData()->GetDocShell();
		const ScMarkData& rMark = GetViewData()->GetMarkData();
		BOOL bSuccess = pDocSh->GetDocFunc().
						FillSeries(aRange, &rMark, rFillData, bRecord, FALSE);
									fStart, fStep, fMax, bRecord, FALSE );
		if (bSuccess)
		{
			pDocSh->UpdateOle(GetViewData());

Lines 111-116 Link Here

(-)sc/source/ui/view/cellsh1.cxx (-64 / +97 lines)
111	#include <svx/svxdlg.hxx> //CHINA001	111	#include <svx/svxdlg.hxx> //CHINA001
112	#include <svx/dialogs.hrc> //CHINA001	112	#include <svx/dialogs.hrc> //CHINA001
113	#include "scabstdlg.hxx" //CHINA001	113	#include "scabstdlg.hxx" //CHINA001
		114	#include "sc/valuestringparser.hxx"
		115
114	#define IS_AVAILABLE(WhichId,ppItem) \	116	#define IS_AVAILABLE(WhichId,ppItem) \
115	(pReqArgs->GetItemState((WhichId), TRUE, ppItem ) == SFX_ITEM_SET)	117	(pReqArgs->GetItemState((WhichId), TRUE, ppItem ) == SFX_ITEM_SET)
116		118
Lines 126-131 Link Here
126	using namespace ::com::sun::star::beans;	128	using namespace ::com::sun::star::beans;
127	using namespace ::com::sun::star::uno;	129	using namespace ::com::sun::star::uno;
128		130
		131
		132	namespace
		133	{
		134
		135	sc::FillSeriesData
		136	lcl_CreateFillSeriesData(const AbstractScFillSeriesDlg& rFillDlg)
		137	{
		138	sc::FillSeriesData aFillData;
		139	aFillData.eDir = rFillDlg.GetFillDir();
		140	aFillData.eCmd = rFillDlg.GetFillCmd();
		141	aFillData.eDateCmd = rFillDlg.GetFillDateCmd();
		142	{
		143	const sc::ValueStringParser aValueString(rFillDlg.GetStartStr());
		144	aFillData.bUseString = aValueString.GetBaseSubstring().Len() != 0;
		145	if (aFillData.bUseString)
		146	{
		147	aFillData.aStart = rFillDlg.GetStartStr();
		148	aFillData.aMax = rFillDlg.GetMaxStr();
		149	}
		150	}
		151	aFillData.fStart = rFillDlg.GetStart();
		152	aFillData.fMax = rFillDlg.GetMax();
		153	aFillData.fStep = rFillDlg.GetStep();
		154
		155	return aFillData;
		156	}
		157
		158
		159	double
		160	lcl_GetNumericValue(const String& rStr)
		161	{
		162	double fResult(0.0);
		163	sc::ValueStringParser aValueString(rStr);
		164	if (aValueString.HasValue())
		165	{
		166	fResult = aValueString.GetValue();
		167	}
		168	return fResult;
		169	}
		170
		171	}
		172
129	//------------------------------------------------------------------	173	//------------------------------------------------------------------
130	void ScCellShell::ExecuteEdit( SfxRequest& rReq )	174	void ScCellShell::ExecuteEdit( SfxRequest& rReq )
131	{	175	{
Lines 561-572 Link Here
561	SCROW nEndRow;	605	SCROW nEndRow;
562	SCTAB nEndTab;	606	SCTAB nEndTab;
563	USHORT nPossDir = FDS_OPT_NONE;	607	USHORT nPossDir = FDS_OPT_NONE;
564	FillDir eFillDir = FILL_TO_BOTTOM;	608	sc::FillSeriesData aFillData;
565	FillCmd eFillCmd = FILL_LINEAR;
566	FillDateCmd eFillDateCmd = FILL_DAY;
567	double fStartVal = MAXDOUBLE;
568	double fIncVal = 1;
569	double fMaxVal = MAXDOUBLE;
570	BOOL bDoIt = FALSE;	609	BOOL bDoIt = FALSE;
571		610
572	GetViewData()->GetSimpleArea( nStartCol, nStartRow, nStartTab,	611	GetViewData()->GetSimpleArea( nStartCol, nStartRow, nStartTab,
Lines 575-587 Link Here
575	if( nStartCol!=nEndCol )	614	if( nStartCol!=nEndCol )
576	{	615	{
577	nPossDir \|= FDS_OPT_HORZ;	616	nPossDir \|= FDS_OPT_HORZ;
578	eFillDir=FILL_TO_RIGHT;	617	aFillData.eDir = FILL_TO_RIGHT;
579	}	618	}
580		619
581	if( nStartRow!=nEndRow )	620	if( nStartRow!=nEndRow )
582	{	621	{
583	nPossDir \|= FDS_OPT_VERT;	622	nPossDir \|= FDS_OPT_VERT;
584	eFillDir=FILL_TO_BOTTOM;	623	aFillData.eDir = FILL_TO_BOTTOM;
585	}	624	}
586		625
587	ScDocument* pDoc = GetViewData()->GetDocument();	626	ScDocument* pDoc = GetViewData()->GetDocument();
Lines 613-654 Link Here
613	if( aFillDir.Len() )	652	if( aFillDir.Len() )
614	switch( aFillDir.GetChar(0) )	653	switch( aFillDir.GetChar(0) )
615	{	654	{
616	case 'B': case 'b': eFillDir=FILL_TO_BOTTOM; break;	655	case 'B': case 'b': aFillData.eDir = FILL_TO_BOTTOM; break;
617	case 'R': case 'r': eFillDir=FILL_TO_RIGHT; break;	656	case 'R': case 'r': aFillData.eDir = FILL_TO_RIGHT; break;
618	case 'T': case 't': eFillDir=FILL_TO_TOP; break;	657	case 'T': case 't': aFillData.eDir = FILL_TO_TOP; break;
619	case 'L': case 'l': eFillDir=FILL_TO_LEFT; break;	658	case 'L': case 'l': aFillData.eDir = FILL_TO_LEFT; break;
620	}	659	}
621		660
622	if( aFillCmd.Len() )	661	if( aFillCmd.Len() )
623	switch( aFillCmd.GetChar(0) )	662	switch( aFillCmd.GetChar(0) )
624	{	663	{
625	case 'S': case 's': eFillCmd=FILL_SIMPLE; break;	664	case 'S': case 's': aFillData.eCmd = FILL_SIMPLE; break;
626	case 'L': case 'l': eFillCmd=FILL_LINEAR; break;	665	case 'L': case 'l': aFillData.eCmd = FILL_LINEAR; break;
627	case 'G': case 'g': eFillCmd=FILL_GROWTH; break;	666	case 'G': case 'g': aFillData.eCmd = FILL_GROWTH; break;
628	case 'D': case 'd': eFillCmd=FILL_DATE; break;	667	case 'D': case 'd': aFillData.eCmd = FILL_DATE; break;
629	case 'A': case 'a': eFillCmd=FILL_AUTO; break;	668	case 'A': case 'a': aFillData.eCmd = FILL_AUTO; break;
630	}	669	}
631		670
632	if( aFillDateCmd.Len() )	671	if( aFillDateCmd.Len() )
633	switch( aFillDateCmd.GetChar(0) )	672	switch( aFillDateCmd.GetChar(0) )
634	{	673	{
635	case 'D': case 'd': eFillDateCmd=FILL_DAY; break;	674	case 'D': case 'd': aFillData.eDateCmd = FILL_DAY; break;
636	case 'W': case 'w': eFillDateCmd=FILL_WEEKDAY; break;	675	case 'W': case 'w': aFillData.eDateCmd = FILL_WEEKDAY; break;
637	case 'M': case 'm': eFillDateCmd=FILL_MONTH; break;	676	case 'M': case 'm': aFillData.eDateCmd = FILL_MONTH; break;
638	case 'Y': case 'y': eFillDateCmd=FILL_YEAR; break;	677	case 'Y': case 'y': aFillData.eDateCmd = FILL_YEAR; break;
639	}	678	}
640		679
641	nKey = 0;	680	nKey = 0;
642	if( pFormatter->IsNumberFormat( aFillStart, nKey, fTmpVal ))	681	if( pFormatter->IsNumberFormat( aFillStart, nKey, fTmpVal ))
643	fStartVal = fTmpVal;	682	aFillData.fStart = fTmpVal;
644		683
645	nKey = 0;	684	nKey = 0;
646	if( pFormatter->IsNumberFormat( aFillStep, nKey, fTmpVal ))	685	if( pFormatter->IsNumberFormat( aFillStep, nKey, fTmpVal ))
647	fIncVal = fTmpVal;	686	aFillData.fStep = fTmpVal;
648		687
649	nKey = 0;	688	nKey = 0;
650	if( pFormatter->IsNumberFormat( aFillMax, nKey, fTmpVal ))	689	if( pFormatter->IsNumberFormat( aFillMax, nKey, fTmpVal ))
651	fMaxVal = fTmpVal;	690	aFillData.fMax = fTmpVal;
652		691
653	bDoIt = TRUE;	692	bDoIt = TRUE;
654		693
Lines 670-680 Link Here
670	short nPrivType = pPrivEntry->GetType();	709	short nPrivType = pPrivEntry->GetType();
671	if ( ( nPrivType & NUMBERFORMAT_DATE)>0)	710	if ( ( nPrivType & NUMBERFORMAT_DATE)>0)
672	{	711	{
673	eFillCmd=FILL_DATE;	712	aFillData.eCmd = FILL_DATE;
674	}	713	}
675	else if(eCellType==CELLTYPE_STRING)	714	else if(eCellType==CELLTYPE_STRING)
676	{	715	{
677	eFillCmd=FILL_AUTO;	716	aFillData.eCmd = FILL_AUTO;
678	}	717	}
679	}	718	}
680		719
Lines 688-703 Link Here
688	String aEndStr;	727	String aEndStr;
689		728
690	pDoc->GetInputString( nStartCol, nStartRow, nStartTab, aStartStr);	729	pDoc->GetInputString( nStartCol, nStartRow, nStartTab, aStartStr);
691	pDoc->GetValue( nStartCol, nStartRow, nStartTab, fStartVal );	730	aFillData.fStart = lcl_GetNumericValue(aStartStr);
692		731
693		732
694	if(eFillDir==FILL_TO_BOTTOM && nStartRow < nEndRow )	733	if(aFillData.eDir == FILL_TO_BOTTOM && nStartRow < nEndRow )
695	{	734	{
696	pDoc->GetInputString( nStartCol, nStartRow+1, nStartTab, aEndStr);	735	pDoc->GetInputString( nStartCol, nStartRow+1, nStartTab, aEndStr);
697	if(aEndStr.Len()>0)	736	if(aEndStr.Len()>0)
698	{	737	{
699	pDoc->GetValue( nStartCol, nStartRow+1, nStartTab, fInputEndVal);	738	fInputEndVal = lcl_GetNumericValue(aEndStr);
700	fIncVal=fInputEndVal-fStartVal;	739	aFillData.fStep = fInputEndVal - aFillData.fStart;
701	}	740	}
702	}	741	}
703	else	742	else
Lines 707-756 Link Here
707	pDoc->GetInputString( nStartCol+1, nStartRow, nStartTab, aEndStr);	746	pDoc->GetInputString( nStartCol+1, nStartRow, nStartTab, aEndStr);
708	if(aEndStr.Len()>0)	747	if(aEndStr.Len()>0)
709	{	748	{
710	pDoc->GetValue( nStartCol+1, nStartRow, nStartTab, fInputEndVal);	749	fInputEndVal = lcl_GetNumericValue(aEndStr);
711	fIncVal=fInputEndVal-fStartVal;	750	aFillData.fStep = fInputEndVal - aFillData.fStart;
712	}	751	}
713	}	752	}
714	}	753	}
715	if(eFillCmd==FILL_DATE)	754	if (aFillData.eCmd == FILL_DATE)
716	{	755	{
717	Date aNullDate = *pDoc->GetFormatTable()->GetNullDate();	756	Date aNullDate = *pDoc->GetFormatTable()->GetNullDate();
718	Date aStartDate = aNullDate;	757	Date aStartDate = aNullDate;
719	aStartDate+= (long)fStartVal;	758	aStartDate += static_cast<long>(aFillData.fStart);
720	Date aEndDate = aNullDate;	759	Date aEndDate = aNullDate;
721	aEndDate+= (long)fInputEndVal;	760	aEndDate += static_cast<long>(fInputEndVal);
722	double fTempDate=0;	761	double fTempDate=0;
723		762
724	if(aStartDate.GetYear()!=aEndDate.GetYear())	763	if(aStartDate.GetYear()!=aEndDate.GetYear())
725	{	764	{
726	eFillDateCmd = FILL_YEAR;	765	aFillData.eDateCmd = FILL_YEAR;
727	fTempDate=aEndDate.GetYear()-aStartDate.GetYear();	766	fTempDate=aEndDate.GetYear()-aStartDate.GetYear();
728	}	767	}
729	if(aStartDate.GetMonth()!=aEndDate.GetMonth())	768	if(aStartDate.GetMonth()!=aEndDate.GetMonth())
730	{	769	{
731	eFillDateCmd = FILL_MONTH;	770	aFillData.eDateCmd = FILL_MONTH;
732	fTempDate=fTempDate*12+aEndDate.GetMonth()-aStartDate.GetMonth();	771	fTempDate=fTempDate*12+aEndDate.GetMonth()-aStartDate.GetMonth();
733	}	772	}
734	if(aStartDate.GetDay()==aEndDate.GetDay())	773	if(aStartDate.GetDay()==aEndDate.GetDay())
735	{	774	{
736	fIncVal=fTempDate;	775	aFillData.fStep = fTempDate;
737	}	776	}
738	}	777	}
739	}	778	}
740	//CHINA001 ScFillSeriesDlg* pDlg = new ScFillSeriesDlg(	779	//CHINA001 ScFillSeriesDlg* pDlg = new ScFillSeriesDlg(
741	//CHINA001 pTabViewShell->GetDialogParent(), *pDoc,	780	//CHINA001 pTabViewShell->GetDialogParent(), *pDoc,
742	//CHINA001 eFillDir, eFillCmd, eFillDateCmd,	781	//CHINA001 eDir, eCmd, eDateCmd,
743	//CHINA001 aStartStr, fIncVal, fMaxVal,	782	//CHINA001 aStartStr, fIncVal, fMaxVal,
744	//CHINA001 nPossDir);	783	//CHINA001 nPossDir);
745	ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();	784	ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
746	DBG_ASSERT(pFact, "ScAbstractFactory create fail!");//CHINA001	785	DBG_ASSERT(pFact, "ScAbstractFactory create fail!");//CHINA001
747		786
748	AbstractScFillSeriesDlg* pDlg = pFact->CreateScFillSeriesDlg( pTabViewShell->GetDialogParent(),	787	AbstractScFillSeriesDlg* pDlg = pFact->CreateScFillSeriesDlg(
749	*pDoc,	788	pTabViewShell->GetDialogParent(), *pDoc,
750	eFillDir, eFillCmd, eFillDateCmd,	789	aFillData.eDir, aFillData.eCmd, aFillData.eDateCmd,
751	aStartStr, fIncVal, fMaxVal,	790	aStartStr, aFillData.fStep, aFillData.fMax,
752	nPossDir,	791	nPossDir, RID_SCDLG_FILLSERIES)
753	RID_SCDLG_FILLSERIES);	792	;
754	DBG_ASSERT(pDlg, "Dialog create fail!");//CHINA001	793	DBG_ASSERT(pDlg, "Dialog create fail!");//CHINA001
755		794
756	if ( nStartCol != nEndCol && nStartRow != nEndRow )	795	if ( nStartCol != nEndCol && nStartRow != nEndRow )
Lines 760-779 Link Here
760		799
761	if ( pDlg->Execute() == RET_OK )	800	if ( pDlg->Execute() == RET_OK )
762	{	801	{
763	eFillDir = pDlg->GetFillDir();	802	aFillData = lcl_CreateFillSeriesData(*pDlg);
764	eFillCmd = pDlg->GetFillCmd();	803	aFillData.bUseString = true;
765	eFillDateCmd = pDlg->GetFillDateCmd();	804	if (aFillData.eCmd == FILL_AUTO)
766
767	if(eFillCmd==FILL_AUTO)
768	{	805	{
769	String aStr=pDlg->GetStartStr();	806	if (aFillData.aStart.Len() > 0)
770	if(aStr.Len()>0)	807	pTabViewShell->EnterData(nStartCol, nStartRow, nStartTab, aFillData.aStart);
771	pTabViewShell->EnterData( nStartCol, nStartRow, nStartTab, aStr );
772	}	808	}
773	fStartVal = pDlg->GetStart();	809	bDoIt = TRUE;
774	fIncVal = pDlg->GetStep();
775	fMaxVal = pDlg->GetMax();
776	bDoIt = TRUE;
777	}	810	}
778	delete pDlg;	811	delete pDlg;
779	}	812	}
Lines 781-794 Link Here
781	if( bDoIt )	814	if( bDoIt )
782	{	815	{
783	//nScFillModeMouseModifier = 0; // kein Ctrl/Copy	816	//nScFillModeMouseModifier = 0; // kein Ctrl/Copy
784	pTabViewShell->FillSeries( eFillDir, eFillCmd, eFillDateCmd, fStartVal, fIncVal, fMaxVal );	817	pTabViewShell->FillSeries(aFillData);
785		818
786	if( ! rReq.IsAPI() )	819	if( ! rReq.IsAPI() )
787	{	820	{
788	String aPara;	821	String aPara;
789	Color* pColor=0;	822	Color* pColor=0;
790		823
791	switch( eFillDir )	824	switch( aFillData.eDir )
792	{	825	{
793	case FILL_TO_BOTTOM: aPara = 'B'; break;	826	case FILL_TO_BOTTOM: aPara = 'B'; break;
794	case FILL_TO_RIGHT: aPara = 'R'; break;	827	case FILL_TO_RIGHT: aPara = 'R'; break;
Lines 798-804 Link Here
798	}	831	}
799	rReq.AppendItem( SfxStringItem( FID_FILL_SERIES, aPara ) );	832	rReq.AppendItem( SfxStringItem( FID_FILL_SERIES, aPara ) );
800		833
801	switch( eFillCmd )	834	switch( aFillData.eCmd )
802	{	835	{
803	case FILL_SIMPLE: aPara = 'S'; break;	836	case FILL_SIMPLE: aPara = 'S'; break;
804	case FILL_LINEAR: aPara = 'L'; break;	837	case FILL_LINEAR: aPara = 'L'; break;
Lines 809-815 Link Here
809	}	842	}
810	rReq.AppendItem( SfxStringItem( FN_PARAM_1, aPara ) );	843	rReq.AppendItem( SfxStringItem( FN_PARAM_1, aPara ) );
811		844
812	switch( eFillDateCmd )	845	switch( aFillData.eDateCmd )
813	{	846	{
814	case FILL_DAY: aPara = 'D'; break;	847	case FILL_DAY: aPara = 'D'; break;
815	case FILL_WEEKDAY: aPara = 'W'; break;	848	case FILL_WEEKDAY: aPara = 'W'; break;
Lines 822-834 Link Here
822	ULONG nFormatKey = pFormatter->GetStandardFormat(NUMBERFORMAT_NUMBER,	855	ULONG nFormatKey = pFormatter->GetStandardFormat(NUMBERFORMAT_NUMBER,
823	ScGlobal::eLnge );	856	ScGlobal::eLnge );
824		857
825	pFormatter->GetOutputString( fIncVal, nFormatKey, aPara, &pColor );	858	pFormatter->GetOutputString(aFillData.fStep, nFormatKey, aPara, &pColor);
826	rReq.AppendItem( SfxStringItem( FN_PARAM_3, aPara ) );	859	rReq.AppendItem( SfxStringItem( FN_PARAM_3, aPara ) );
827		860
828	pFormatter->GetOutputString( fStartVal, nFormatKey, aPara, &pColor );	861	pFormatter->GetOutputString(aFillData.fStart, nFormatKey, aPara, &pColor);
829	rReq.AppendItem( SfxStringItem( FN_PARAM_4, aPara ) );	862	rReq.AppendItem( SfxStringItem( FN_PARAM_4, aPara ) );
830		863
831	pFormatter->GetOutputString( fMaxVal, nFormatKey, aPara, &pColor );	864	pFormatter->GetOutputString(aFillData.fMax, nFormatKey, aPara, &pColor);
832	rReq.AppendItem( SfxStringItem( FN_PARAM_5, aPara ) );	865	rReq.AppendItem( SfxStringItem( FN_PARAM_5, aPara ) );
833		866
834	rReq.Done();	867	rReq.Done();

Lines 128-133 Link Here

(-)sc/inc/scabstdlg.hxx (+1 lines)
128	virtual double GetStep() const = 0;	128	virtual double GetStep() const = 0;
129	virtual double GetMax() const = 0;	129	virtual double GetMax() const = 0;
130	virtual String GetStartStr() const = 0;	130	virtual String GetStartStr() const = 0;
		131	virtual String GetMaxStr() const = 0;
131	virtual void SetEdStartValEnabled(BOOL bFlag=FALSE) = 0;	132	virtual void SetEdStartValEnabled(BOOL bFlag=FALSE) = 0;
132	};	133	};
133		134

Lines 275-281 Link Here

(-)sc/inc/table.hxx (-8 / +10 lines)
275	aCol[rPos.Col()].GetValue( rPos.Row() ) :	275	aCol[rPos.Col()].GetValue( rPos.Row() ) :
276	0.0;	276	0.0;
277	}	277	}
278	double GetValue( SCCOL nCol, SCROW nRow );	278	double GetValue( SCCOL nCol, SCROW nRow ) const;
279	void GetFormula( SCCOL nCol, SCROW nRow, String& rFormula,	279	void GetFormula( SCCOL nCol, SCROW nRow, String& rFormula,
280	BOOL bAsciiExport = FALSE );	280	BOOL bAsciiExport = FALSE );
281		281
Lines 441-449 Link Here
441	std::set<USHORT>& rIndexes) const;	441	std::set<USHORT>& rIndexes) const;
442	void ReplaceRangeNamesInUse(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,	442	void ReplaceRangeNamesInUse(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
443	const ScRangeData::IndexMap& rMap );	443	const ScRangeData::IndexMap& rMap );
		444	void Fill( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
		445	ULONG nFillCount, FillDir eFillDir, FillCmd eFillCmd, FillDateCmd eFillDateCmd,
		446	double nStepValue, double nMaxValue);
444	void Fill( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,	447	void Fill( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
445	ULONG nFillCount, FillDir eFillDir, FillCmd eFillCmd, FillDateCmd eFillDateCmd,	448	ULONG nFillCount, const sc::FillSeriesData& rFillData);
446	double nStepValue, double nMaxValue);
447	String GetAutoFillPreview( const ScRange& rSource, SCCOL nEndX, SCROW nEndY );	449	String GetAutoFillPreview( const ScRange& rSource, SCCOL nEndX, SCROW nEndY );
448		450
449	void UpdateSelectionFunction( ScFunctionData& rData,	451	void UpdateSelectionFunction( ScFunctionData& rData,
Lines 664-674 Link Here
664	void DestroySortCollator();	666	void DestroySortCollator();
665		667
666	private:	668	private:
667	void FillSeries( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,	669	void FillSeries(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
668	ULONG nFillCount, FillDir eFillDir, FillCmd eFillCmd,	670	ULONG nFillCount, const sc::FillSeriesData& rFillData,
669	FillDateCmd eFillDateCmd,	671	USHORT nMinDigits, bool bAttribs, ScProgress& rProgress);
670	double nStepValue, double nMaxValue, USHORT nMinDigits,
671	BOOL bAttribs, ScProgress& rProgress );
672	void FillAnalyse( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,	672	void FillAnalyse( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
673	FillCmd& rCmd, FillDateCmd& rDateCmd,	673	FillCmd& rCmd, FillDateCmd& rDateCmd,
674	double& rInc, USHORT& rMinDigits,	674	double& rInc, USHORT& rMinDigits,
Lines 752-757 Link Here
752	// also invalidates script type, broadcasts for "calc as shown"	752	// also invalidates script type, broadcasts for "calc as shown"
753	void InvalidateTextWidth( const ScAddress* pAdrFrom, const ScAddress* pAdrTo,	753	void InvalidateTextWidth( const ScAddress* pAdrFrom, const ScAddress* pAdrTo,
754	BOOL bNumFormatChanged, BOOL bBroadcast );	754	BOOL bNumFormatChanged, BOOL bBroadcast );
		755
		756	bool impl_getNumericValue(const SCCOL nCol, const SCROW nRow, double& rValue) const;
755	};	757	};
756		758
757		759




/*************************************************************************
 *
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * Copyright 2008 by Sun Microsystems, Inc.
 *
 * OpenOffice.org - a multi-platform office productivity suite
 *
 * $RCSfile: $
 * $Revision: $
 *
 * This file is part of OpenOffice.org.
 *
 * OpenOffice.org is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 3
 * only, as published by the Free Software Foundation.
 *
 * OpenOffice.org is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License version 3 for more details
 * (a copy is included in the LICENSE file that accompanied this code).
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 3 along with OpenOffice.org.  If not, see
 * <http://www.openoffice.org/license.html>
 * for a copy of the LGPLv3 License.
 *
 ************************************************************************/

#ifndef SC_VALUESTRINGPARSER_HXX_INCLUDED
#define SC_VALUESTRINGPARSER_HXX_INCLUDED

#include <tools/string.hxx>

#include "scdllapi.h"


namespace sc
{

    /** Extract numeric value from a string and supply more info about it.
        Only integer numbers staying at the beginning or at the end of the
        string are recognized.

        The only function usable when there is no numeric value (i.e. when
        HasValue() returns false) is GetBaseSubstring(), returning the
        original string. The other functions return default values of their
        respective types.
     */
    class SC_DLLPUBLIC ValueStringParser
    {
    public:
        /** Examine rString for possible numeric value.
         */
        SC_DLLPUBLIC ValueStringParser(const String& rString);

        /** Tell if the string contains (recognizable) numeric value.
         */
        SC_DLLPUBLIC bool HasValue() const;

        /** Get the found numeric value.
         */
        SC_DLLPUBLIC sal_Int32 GetValue() const;

        /** Get the minimum number of digits required for representation
            of the number. Value 0 means there is no requirement.
         */
        SC_DLLPUBLIC sal_Int16 GetMinDigits() const;

        /** Get the numeric substring (if any). This function returns
            nonempty string iff HasValue() == true.
         */
        SC_DLLPUBLIC const String& GetNumericSubstring() const;

        /** Get the base (i.e. non-numeric substring.
         */
        SC_DLLPUBLIC const String& GetBaseSubstring() const;

        /** Tell if the number is prefix of the base substring.
         */
        SC_DLLPUBLIC bool IsPrefix() const;

    private:
        void impl_DecompValueString();

    private:
        String m_aString;
        mutable String m_aNumericSubstring;
        String m_aBaseSubstring;
        sal_Int32 m_nValue;
        sal_Int16 m_nMinDigits;
        bool m_bHasValue;
        bool m_bIsPrefix;
    };

    /** Test if the two parsed strings can be ordered. They can be iff
        they both have numeric value and either share a common prefix/suffix
        or their suffix makes valid ordinal numbers from both of them.
     */
    SC_DLLPUBLIC bool
    CanBeOrdered(
            const ValueStringParser& rValueString1,
            const ValueStringParser& rValueString2);

}

#endif

// vim: set sts=4 sw=4 et:




extern ::utl::TransliterationWrapper* GetScGlobalpTransliteration();//CHINA001
extern const LocaleDataWrapper* GetScGlobalpLocaleData();

namespace sc
{

    struct FillSeriesData
    {
        FillDir eDir;
        FillCmd eCmd;
        FillDateCmd eDateCmd;
        double fStart;
        String aStart;
        double fStep;
        double fMax;
        String aMax;
        bool bUseString;

        FillSeriesData();
    };

}

#endif

Return to issue 107203

Lines 2008-2010 Link Here

(-)sc/source/core/data/global.cxx (+19 lines)
2008	return pLocale;	2008	return pLocale;
2009	}	2009	}
2010		2010
		2011
		2012	namespace sc
		2013	{
		2014
		2015	FillSeriesData::FillSeriesData()
		2016	: eDir(FILL_TO_BOTTOM)
		2017	, eCmd(FILL_LINEAR)
		2018	, eDateCmd(FILL_DAY)
		2019	, fStart(MAXDOUBLE)
		2020	, aStart()
		2021	, fStep(1.0)
		2022	, fMax(MAXDOUBLE)
		2023	, aMax()
		2024	, bUseString(false)
		2025	{
		2026	}
		2027
		2028	}
		2029

Lines 905-921 Link Here

(-)sc/source/core/data/documen3.cxx (-5 / +18 lines)
905	}	905	}
906		906
907	void ScDocument::Fill(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, const ScMarkData& rMark,	907	void ScDocument::Fill(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, const ScMarkData& rMark,
908	ULONG nFillCount, FillDir eFillDir, FillCmd eFillCmd, FillDateCmd eFillDateCmd,	908	ULONG nFillCount, FillDir eFillDir, FillCmd eFillCmd, FillDateCmd eFillDateCmd,
909	double nStepValue, double nMaxValue)	909	double nStepValue, double nMaxValue)
910	{	910	{
		911	sc::FillSeriesData aFillData;
		912	aFillData.eDir = eFillDir;
		913	aFillData.eCmd = eFillCmd;
		914	aFillData.eDateCmd = eFillDateCmd;
		915	aFillData.fStep = nStepValue;
		916	aFillData.fMax = nMaxValue;
		917	Fill(nCol1, nRow1, nCol2, nRow2, rMark, nFillCount, aFillData);
		918	}
		919
		920
		921	void
		922	ScDocument::Fill(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
		923	const ScMarkData& rMark, ULONG nFillCount,
		924	const sc::FillSeriesData& rFillData)
		925	{
911	PutInOrder( nCol1, nCol2 );	926	PutInOrder( nCol1, nCol2 );
912	PutInOrder( nRow1, nRow2 );	927	PutInOrder( nRow1, nRow2 );
913	for (SCTAB i=0; i <= MAXTAB; i++)	928	for (SCTAB i=0; i <= MAXTAB; i++)
914	if (pTab[i])	929	if (pTab[i])
915	if (rMark.GetTableSelect(i))	930	if (rMark.GetTableSelect(i))
916	pTab[i]->Fill(nCol1, nRow1, nCol2, nRow2,	931	pTab[i]->Fill(nCol1, nRow1, nCol2, nRow2, nFillCount, rFillData);
917	nFillCount, eFillDir, eFillCmd, eFillDateCmd,
918	nStepValue, nMaxValue);
919	}	932	}
920		933
921	String ScDocument::GetAutoFillPreview( const ScRange& rSource, SCCOL nEndX, SCROW nEndY )	934	String ScDocument::GetAutoFillPreview( const ScRange& rSource, SCCOL nEndX, SCROW nEndY )

Lines 3775-3790 Link Here

(-)sc/source/ui/docshell/docfunc.cxx (-26 / +55 lines)
3775	pDoc->CopyToDocument( aCopyRange, IDF_AUTOFILL, FALSE, pUndoDoc, &aMark );	3775	pDoc->CopyToDocument( aCopyRange, IDF_AUTOFILL, FALSE, pUndoDoc, &aMark );
3776	}	3776	}
3777		3777
		3778	sc::FillSeriesData aFillData;
		3779	aFillData.eDir = eDir;
		3780	aFillData.eCmd = FILL_SIMPLE;
		3781	aFillData.eDateCmd = FILL_DAY;
		3782	aFillData.fStart = MAXDOUBLE;
		3783	aFillData.fStep = 1.0;
		3784	aFillData.fMax = 1e307;
		3785
3778	pDoc->Fill( aSourceArea.aStart.Col(), aSourceArea.aStart.Row(),	3786	pDoc->Fill( aSourceArea.aStart.Col(), aSourceArea.aStart.Row(),
3779	aSourceArea.aEnd.Col(), aSourceArea.aEnd.Row(), aMark,	3787	aSourceArea.aEnd.Col(), aSourceArea.aEnd.Row(), aMark,
3780	nCount, eDir, FILL_SIMPLE );	3788	nCount, aFillData );
3781	AdjustRowHeight(rRange);	3789	AdjustRowHeight(rRange);
3782		3790
3783	if ( bRecord ) // Draw-Undo erst jetzt verfuegbar	3791	if ( bRecord ) // Draw-Undo erst jetzt verfuegbar
3784	{	3792	{
3785	rDocShell.GetUndoManager()->AddUndoAction(	3793	rDocShell.GetUndoManager()->AddUndoAction(
3786	new ScUndoAutoFill( &rDocShell, aDestArea, aSourceArea, pUndoDoc, aMark,	3794	new ScUndoAutoFill( &rDocShell, aDestArea, aSourceArea, pUndoDoc, aMark,
3787	eDir, FILL_SIMPLE, FILL_DAY, MAXDOUBLE, 1.0, 1e307,	3795	aFillData,
3788	pDoc->GetRangeName()->GetSharedMaxIndex()+1 ) );	3796	pDoc->GetRangeName()->GetSharedMaxIndex()+1 ) );
3789	}	3797	}
3790		3798
Lines 3800-3809 Link Here
3800	return bSuccess;	3808	return bSuccess;
3801	}	3809	}
3802		3810
3803	BOOL ScDocFunc::FillSeries( const ScRange& rRange, const ScMarkData* pTabMark,	3811
3804	FillDir eDir, FillCmd eCmd, FillDateCmd eDateCmd,	3812	bool
3805	double fStart, double fStep, double fMax,	3813	ScDocFunc::FillSeries(
3806	BOOL bRecord, BOOL bApi )	3814	const ScRange& rRange, const ScMarkData* pTabMark,
		3815	const sc::FillSeriesData& rFillData, bool bRecord, bool bApi)
3807	{	3816	{
3808	ScDocShellModificator aModificator( rDocShell );	3817	ScDocShellModificator aModificator( rDocShell );
3809		3818
Lines 3839-3854 Link Here
3839	SCSIZE nCount = pDoc->GetEmptyLinesInBlock(	3848	SCSIZE nCount = pDoc->GetEmptyLinesInBlock(
3840	aSourceArea.aStart.Col(), aSourceArea.aStart.Row(), aSourceArea.aStart.Tab(),	3849	aSourceArea.aStart.Col(), aSourceArea.aStart.Row(), aSourceArea.aStart.Tab(),
3841	aSourceArea.aEnd.Col(), aSourceArea.aEnd.Row(), aSourceArea.aEnd.Tab(),	3850	aSourceArea.aEnd.Col(), aSourceArea.aEnd.Row(), aSourceArea.aEnd.Tab(),
3842	DirFromFillDir(eDir) );	3851	DirFromFillDir(rFillData.eDir) );
3843		3852
3844	// #27665# mindestens eine Zeile/Spalte als Quellbereich behalten:	3853	// #27665# mindestens eine Zeile/Spalte als Quellbereich behalten:
3845	SCSIZE nTotLines = ( eDir == FILL_TO_BOTTOM \|\| eDir == FILL_TO_TOP ) ?	3854	SCSIZE nTotLines = ( rFillData.eDir == FILL_TO_BOTTOM \|\| rFillData.eDir == FILL_TO_TOP ) ?
3846	static_cast<SCSIZE>( aSourceArea.aEnd.Row() - aSourceArea.aStart.Row() + 1 ) :	3855	static_cast<SCSIZE>( aSourceArea.aEnd.Row() - aSourceArea.aStart.Row() + 1 ) :
3847	static_cast<SCSIZE>( aSourceArea.aEnd.Col() - aSourceArea.aStart.Col() + 1 );	3856	static_cast<SCSIZE>( aSourceArea.aEnd.Col() - aSourceArea.aStart.Col() + 1 );
3848	if ( nCount >= nTotLines )	3857	if ( nCount >= nTotLines )
3849	nCount = nTotLines - 1;	3858	nCount = nTotLines - 1;
3850		3859
3851	switch (eDir)	3860	switch (rFillData.eDir)
3852	{	3861	{
3853	case FILL_TO_BOTTOM:	3862	case FILL_TO_BOTTOM:
3854	aSourceArea.aEnd.SetRow( sal::static_int_cast<SCROW>( aSourceArea.aEnd.Row() - nCount ) );	3863	aSourceArea.aEnd.SetRow( sal::static_int_cast<SCROW>( aSourceArea.aEnd.Row() - nCount ) );
Lines 3885-3900 Link Here
3885	if (aDestArea.aStart.Col() <= aDestArea.aEnd.Col() &&	3894	if (aDestArea.aStart.Col() <= aDestArea.aEnd.Col() &&
3886	aDestArea.aStart.Row() <= aDestArea.aEnd.Row())	3895	aDestArea.aStart.Row() <= aDestArea.aEnd.Row())
3887	{	3896	{
3888	if ( fStart != MAXDOUBLE )	3897	if (rFillData.fStart != MAXDOUBLE)
3889	{	3898	{
3890	SCCOL nValX = (eDir == FILL_TO_LEFT) ? aDestArea.aEnd.Col() : aDestArea.aStart.Col();	3899	SCCOL nValX = (rFillData.eDir == FILL_TO_LEFT)
3891	SCROW nValY = (eDir == FILL_TO_TOP ) ? aDestArea.aEnd.Row() : aDestArea.aStart.Row();	3900	? aDestArea.aEnd.Col() : aDestArea.aStart.Col();
		3901	SCROW nValY = (rFillData.eDir == FILL_TO_TOP )
		3902	? aDestArea.aEnd.Row() : aDestArea.aStart.Row();
3892	SCTAB nTab = aDestArea.aStart.Tab();	3903	SCTAB nTab = aDestArea.aStart.Tab();
3893	pDoc->SetValue( nValX, nValY, nTab, fStart );	3904	if (rFillData.bUseString)
		3905	{
		3906	OSL_ENSURE(rFillData.aStart.Len() != 0, "there is no starting string");
		3907	pDoc->SetString(nValX, nValY, nTab, rFillData.aStart);
		3908	}
		3909	else
		3910	{
		3911	pDoc->SetValue(nValX, nValY, nTab, rFillData.fStart);
		3912	}
3894	}	3913	}
3895	pDoc->Fill( aSourceArea.aStart.Col(), aSourceArea.aStart.Row(),	3914	pDoc->Fill( aSourceArea.aStart.Col(), aSourceArea.aStart.Row(),
3896	aSourceArea.aEnd.Col(), aSourceArea.aEnd.Row(), aMark,	3915	aSourceArea.aEnd.Col(), aSourceArea.aEnd.Row(), aMark,
3897	nCount, eDir, eCmd, eDateCmd, fStep, fMax );	3916	nCount, rFillData );
3898	AdjustRowHeight(rRange);	3917	AdjustRowHeight(rRange);
3899		3918
3900	rDocShell.PostPaintGridAll();	3919	rDocShell.PostPaintGridAll();
Lines 3906-3912 Link Here
3906	{	3925	{
3907	rDocShell.GetUndoManager()->AddUndoAction(	3926	rDocShell.GetUndoManager()->AddUndoAction(
3908	new ScUndoAutoFill( &rDocShell, aDestArea, aSourceArea, pUndoDoc, aMark,	3927	new ScUndoAutoFill( &rDocShell, aDestArea, aSourceArea, pUndoDoc, aMark,
3909	eDir, eCmd, eDateCmd, fStart, fStep, fMax,	3928	rFillData,
3910	pDoc->GetRangeName()->GetSharedMaxIndex()+1 ) );	3929	pDoc->GetRangeName()->GetSharedMaxIndex()+1 ) );
3911	}	3930	}
3912		3931
Lines 4021-4040 Link Here
4021	IDF_AUTOFILL, FALSE, pUndoDoc, &aMark );	4040	IDF_AUTOFILL, FALSE, pUndoDoc, &aMark );
4022	}	4041	}
4023		4042
4024	pDoc->Fill( aSourceArea.aStart.Col(), aSourceArea.aStart.Row(),	4043	{
4025	aSourceArea.aEnd.Col(), aSourceArea.aEnd.Row(), aMark,	4044	sc::FillSeriesData aFillData;
4026	nCount, eDir, eCmd, eDateCmd, fStep, fMax );	4045	aFillData.eDir = eDir;
		4046	aFillData.eCmd = eCmd;
		4047	aFillData.eDateCmd = eDateCmd;
		4048	aFillData.fStep = fStep;
		4049	aFillData.fMax = fMax;
4027		4050
4028	AdjustRowHeight(aDestArea);	4051	pDoc->Fill( aSourceArea.aStart.Col(), aSourceArea.aStart.Row(),
		4052	aSourceArea.aEnd.Col(), aSourceArea.aEnd.Row(), aMark,
		4053	nCount, aFillData );
4029		4054
4030	if ( bRecord ) // Draw-Undo erst jetzt verfuegbar	4055	AdjustRowHeight(aDestArea);
4031	{
4032	rDocShell.GetUndoManager()->AddUndoAction(
4033	new ScUndoAutoFill( &rDocShell, aDestArea, aSourceArea, pUndoDoc, aMark,
4034	eDir, eCmd, eDateCmd, MAXDOUBLE, fStep, fMax,
4035	pDoc->GetRangeName()->GetSharedMaxIndex()+1 ) );
4036	}
4037		4056
		4057	if ( bRecord ) // Draw-Undo erst jetzt verfuegbar
		4058	{
		4059	aFillData.fStart = MAXDOUBLE;
		4060	rDocShell.GetUndoManager()->AddUndoAction(
		4061	new ScUndoAutoFill( &rDocShell, aDestArea, aSourceArea, pUndoDoc, aMark,
		4062	aFillData,
		4063	pDoc->GetRangeName()->GetSharedMaxIndex()+1 ) );
		4064	}
		4065	}
		4066
4038	rDocShell.PostPaintGridAll();	4067	rDocShell.PostPaintGridAll();
4039	// rDocShell.PostPaintDataChanged();	4068	// rDocShell.PostPaintDataChanged();
4040	aModificator.SetDocumentModified();	4069	aModificator.SetDocumentModified();

Lines 1232-1247 Link Here

(-)sc/source/ui/view/viewfun2.cxx (-3 / +16 lines)
1232	//----------------------------------------------------------------------------	1232	//----------------------------------------------------------------------------
1233		1233
1234	void ScViewFunc::FillSeries( FillDir eDir, FillCmd eCmd, FillDateCmd eDateCmd,	1234	void ScViewFunc::FillSeries( FillDir eDir, FillCmd eCmd, FillDateCmd eDateCmd,
1235	double fStart, double fStep, double fMax, BOOL bRecord )	1235	double fStart, double fStep, double fMax, BOOL bRecord )
1236	{	1236	{
		1237	sc::FillSeriesData aFillData;
		1238	aFillData.eDir = eDir;
		1239	aFillData.eCmd = eCmd;
		1240	aFillData.eDateCmd = eDateCmd;
		1241	aFillData.fStart = fStart;
		1242	aFillData.fStep = fStep;
		1243	aFillData.fMax = fMax;
		1244	FillSeries(aFillData, bRecord);
		1245	}
		1246
		1247
		1248	void
		1249	ScViewFunc::FillSeries(const sc::FillSeriesData& rFillData, bool bRecord)
		1250	{
1237	ScRange aRange;	1251	ScRange aRange;
1238	if (GetViewData()->GetSimpleArea(aRange) == SC_MARK_SIMPLE)	1252	if (GetViewData()->GetSimpleArea(aRange) == SC_MARK_SIMPLE)
1239	{	1253	{
1240	ScDocShell* pDocSh = GetViewData()->GetDocShell();	1254	ScDocShell* pDocSh = GetViewData()->GetDocShell();
1241	const ScMarkData& rMark = GetViewData()->GetMarkData();	1255	const ScMarkData& rMark = GetViewData()->GetMarkData();
1242	BOOL bSuccess = pDocSh->GetDocFunc().	1256	BOOL bSuccess = pDocSh->GetDocFunc().
1243	FillSeries( aRange, &rMark, eDir, eCmd, eDateCmd,	1257	FillSeries(aRange, &rMark, rFillData, bRecord, FALSE);
1244	fStart, fStep, fMax, bRecord, FALSE );
1245	if (bSuccess)	1258	if (bSuccess)
1246	{	1259	{
1247	pDocSh->UpdateOle(GetViewData());	1260	pDocSh->UpdateOle(GetViewData());

Lines 965-968 Link Here

(-)sc/inc/global.hxx (+20 lines)
965	extern ::utl::TransliterationWrapper* GetScGlobalpTransliteration();//CHINA001	965	extern ::utl::TransliterationWrapper* GetScGlobalpTransliteration();//CHINA001
966	extern const LocaleDataWrapper* GetScGlobalpLocaleData();	966	extern const LocaleDataWrapper* GetScGlobalpLocaleData();
967		967
		968	namespace sc
		969	{
		970
		971	struct FillSeriesData
		972	{
		973	FillDir eDir;
		974	FillCmd eCmd;
		975	FillDateCmd eDateCmd;
		976	double fStart;
		977	String aStart;
		978	double fStep;
		979	double fMax;
		980	String aMax;
		981	bool bUseString;
		982
		983	FillSeriesData();
		984	};
		985
		986	}
		987
968	#endif	988	#endif

Line 0 Link Here

(-)sc/source/core/data/valuestringparser.cxx (+217 lines)
		1	/*************************************************************************
		2	*
		3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
		4	*
		5	* Copyright 2008 by Sun Microsystems, Inc.
		6	*
		7	* OpenOffice.org - a multi-platform office productivity suite
		8	*
		9	* $RCSfile: $
		10	* $Revision: $
		11	*
		12	* This file is part of OpenOffice.org.
		13	*
		14	* OpenOffice.org is free software: you can redistribute it and/or modify
		15	* it under the terms of the GNU Lesser General Public License version 3
		16	* only, as published by the Free Software Foundation.
		17	*
		18	* OpenOffice.org is distributed in the hope that it will be useful,
		19	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		20	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		21	* GNU Lesser General Public License version 3 for more details
		22	* (a copy is included in the LICENSE file that accompanied this code).
		23	*
		24	* You should have received a copy of the GNU Lesser General Public License
		25	* version 3 along with OpenOffice.org. If not, see
		26	* <http://www.openoffice.org/license.html>
		27	* for a copy of the LGPLv3 License.
		28	*
		29	************************************************************************/
		30
		31	#include "precompiled_sc.hxx"
		32
		33	#include <unotools/charclass.hxx>
		34
		35	#include "global.hxx"
		36	#include "sc/valuestringparser.hxx"
		37
		38
		39	namespace sc
		40	{
		41
		42	namespace
		43	{
		44
		45	short lcl_DecompValueString( String& aValue, sal_Int32& nVal, USHORT* pMinDigits = NULL )
		46	{
		47	if ( !aValue.Len() )
		48	{
		49	nVal = 0;
		50	return 0;
		51	}
		52	const sal_Unicode* p = aValue.GetBuffer();
		53	xub_StrLen nNeg = 0;
		54	xub_StrLen nNum = 0;
		55	if ( p[nNum] == '-' )
		56	nNum = nNeg = 1;
		57	while ( p[nNum] && CharClass::isAsciiNumeric( p[nNum] ) )
		58	nNum++;
		59
		60	sal_Unicode cNext = p[nNum]; // 0 if at the end
		61	sal_Unicode cLast = p[aValue.Len()-1];
		62
		63	// #i5550# If there are numbers at the beginning and the end,
		64	// prefer the one at the beginning only if it's followed by a space.
65	// Otherwise, use the number at the end, to enable things like IP addresses.
66	if ( nNum > nNeg && ( cNext == 0 \|\| cNext == ' ' \|\| !CharClass::isAsciiNumeric(cLast) ) )
67	{ // number at the beginning
68	nVal = aValue.Copy( 0, nNum ).ToInt32();
69	// #60893# any number with a leading zero sets the minimum number of digits
70	if ( p[nNeg] == '0' && pMinDigits && ( nNum - nNeg > *pMinDigits ) )
71	*pMinDigits = nNum - nNeg;
72	aValue.Erase( 0, nNum );
73	return -1;
74	}
75	else
76	{
77	nNeg = 0;
78	xub_StrLen nEnd = nNum = aValue.Len() - 1;
79	while ( nNum && CharClass::isAsciiNumeric( p[nNum] ) )
80	nNum--;
81	if ( p[nNum] == '-' )
82	{
83	nNum--;
84	nNeg = 1;
85	}
86	if ( nNum < nEnd - nNeg )
87	{ // number at the end
88	nVal = aValue.Copy( nNum + 1 ).ToInt32();
89	// #60893# any number with a leading zero sets the minimum number of digits
90	if ( p[nNum+1+nNeg] == '0' && pMinDigits && ( nEnd - nNum - nNeg > *pMinDigits ) )
91	*pMinDigits = nEnd - nNum - nNeg;
92	aValue.Erase( nNum + 1 );
93	return 1;
94	}
95	}
96	nVal = 0;
97	return 0;
98	}
99
100	}
101
102
103	ValueStringParser::ValueStringParser(const String& rString)
104	: m_aString(rString)
105	, m_aNumericSubstring()
106	, m_aBaseSubstring()
107	, m_nValue(0)
108	, m_nMinDigits(0)
109	, m_bHasValue(false)
110	, m_bIsPrefix(false)
111	{
112	impl_DecompValueString();
113	}
114
115
116	bool
117	ValueStringParser::HasValue() const
118	{
119	return m_bHasValue;
120	}
121
122
123	sal_Int32
124	ValueStringParser::GetValue() const
125	{
126	return m_nValue;
127	}
128
129
130	sal_Int16
131	ValueStringParser::GetMinDigits() const
132	{
133	return m_nMinDigits;
134	}
135
136
137	const String&
138	ValueStringParser::GetNumericSubstring() const
139	{
140	if (m_bHasValue && m_aNumericSubstring.Len() == 0)
141	{
142	if (m_bIsPrefix)
143	{
144	m_aNumericSubstring = m_aString.Copy(0,
145	m_aString.Len() - m_aBaseSubstring.Len());
146	}
147	else
148	{
149	m_aNumericSubstring = m_aString.Copy(m_aBaseSubstring.Len());
150	}
151	}
152
153	return m_aNumericSubstring;
154	}
155
156
157	const String&
158	ValueStringParser::GetBaseSubstring() const
159	{
160	return m_aBaseSubstring;
161	}
162
163
164	bool
165	ValueStringParser::IsPrefix() const
166	{
167	return m_bIsPrefix;
168	}
169
170
171	void
172	ValueStringParser::impl_DecompValueString()
173	{
174	String aString(m_aString);
175	sal_Int32 nValue(0);
176	USHORT nMinDigits(0);
177	const short nResult(lcl_DecompValueString(aString, nValue, &nMinDigits));
178	m_aBaseSubstring = aString;
179	if (nResult != 0)
180	{
181	m_bHasValue = true;
182	m_nValue = nValue;
183	m_nMinDigits = nMinDigits;
184	m_bIsPrefix = nResult < 0;
185	}
186	}
187
188
189	bool
190	CanBeOrdered(
191	const ValueStringParser& rValueString1,
192	const ValueStringParser& rValueString2)
193	{
194	if (rValueString1.HasValue() && rValueString2.HasValue()
195	&& rValueString1.IsPrefix() == rValueString2.IsPrefix())
196	{
197	if (rValueString1.IsPrefix())
198	{
199	// check if both base substrings are ordinal suffixes
200	const String aSuffix1(ScGlobal::GetOrdinalSuffix(rValueString1.GetValue()));
201	const String aSuffix2(ScGlobal::GetOrdinalSuffix(rValueString2.GetValue()));
202	if (rValueString1.GetBaseSubstring() == aSuffix1
203	&& rValueString2.GetBaseSubstring() == aSuffix2)
204	{
205	return true;
206	}
207	// if they are not, just continue and check, if they are
208	// the same
209	}
210	return rValueString1.GetBaseSubstring() == rValueString2.GetBaseSubstring();
211	}
212	return false;
213	}
214
215	}
216
217	// vim: set sts=4 sw=4 et:

Lines 45-53 Link Here

(-)sc/source/ui/miscdlgs/filldlg.cxx (-6 / +51 lines)
45	#include "document.hxx"	45	#include "document.hxx"
46	#include "miscdlgs.hrc"	46	#include "miscdlgs.hrc"
47		47
48	#define _FILLDLG_CXX
49	#include "filldlg.hxx"	48	#include "filldlg.hxx"
50	#undef _FILLDLG_CXX	49	#include "sc/valuestringparser.hxx"
51		50
52		51
53		52
Lines 247-252 Link Here
247	else	246	else
248	bValOk = rDoc.GetFormatTable()->IsNumberFormat( aStr, nKey, fStartVal );	247	bValOk = rDoc.GetFormatTable()->IsNumberFormat( aStr, nKey, fStartVal );
249		248
		249	if (!bValOk)
		250	{
		251	sc::ValueStringParser aValueString(aStr);
		252	bValOk = aValueString.HasValue();
		253	if (bValOk)
		254	{
		255	fStartVal = aValueString.GetValue();
		256	}
		257	}
		258
250	return bValOk;	259	return bValOk;
251	}	260	}
252		261
Lines 278-287 Link Here
278	else	287	else
279	bValOk = rDoc.GetFormatTable()->IsNumberFormat( aStr, nKey, fEndVal );	288	bValOk = rDoc.GetFormatTable()->IsNumberFormat( aStr, nKey, fEndVal );
280		289
		290	if (!bValOk)
		291	{
		292	sc::ValueStringParser aValueString(aStr);
		293	bValOk = aValueString.HasValue();
		294	if (bValOk)
		295	{
		296	fEndVal = aValueString.GetValue();
		297	}
		298	}
		299
281	return bValOk;	300	return bValOk;
282	}	301	}
283		302
284		303
		304	namespace
		305	{
		306
		307	bool
		308	lcl_CheckStartEndString(const String& rStart, const String& rEnd)
		309	{
		310	const sc::ValueStringParser aStartValueString(rStart);
		311	const sc::ValueStringParser aEndValueString(rEnd);
		312	const bool bStartEmpty(rStart.Len() == 0);
		313	const bool bEndEmpty(rEnd.Len() == 0);
		314	const bool bStartIsValue(aStartValueString.HasValue());
		315	const bool bEndIsValue(aEndValueString.HasValue());
		316	bool bValOk((bStartEmpty \|\| bStartIsValue) && (bEndEmpty \|\| bEndIsValue));
		317	if (bValOk)
		318	{
		319	if (bStartIsValue && bEndIsValue)
		320	{
		321	bValOk = CanBeOrdered(aStartValueString, aEndValueString);
		322	}
		323	}
		324	return bValOk;
		325	}
		326
		327	}
		328
285	//----------------------------------------------------------------------------	329	//----------------------------------------------------------------------------
286	// Handler:	330	// Handler:
287	//----------------------------------------------------------------------------	331	//----------------------------------------------------------------------------
Lines 359-364 Link Here
359	bAllOk = FALSE;	403	bAllOk = FALSE;
360	pEdWrong = &aEdEndVal;	404	pEdWrong = &aEdEndVal;
361	}	405	}
		406	else if (!lcl_CheckStartEndString(aEdStartVal.GetText(), aEdEndVal.GetText()))
		407	{
		408	bAllOk = FALSE;
		409	pEdWrong = &aEdEndVal;
		410	}
362	if ( bAllOk )	411	if ( bAllOk )
363	EndDialog( RET_OK );	412	EndDialog( RET_OK );
364	else	413	else
Lines 372-378 Link Here
372		421
373	return 0;	422	return 0;
374	}	423	}
375
376
377
378

Lines 578-598 Link Here

(-)sc/source/ui/undo/undoblk3.cxx (-22 / +25 lines)
578	ScUndoAutoFill::ScUndoAutoFill( ScDocShell* pNewDocShell,	578	ScUndoAutoFill::ScUndoAutoFill( ScDocShell* pNewDocShell,
579	const ScRange& rRange, const ScRange& rSourceArea,	579	const ScRange& rRange, const ScRange& rSourceArea,
580	ScDocument* pNewUndoDoc, const ScMarkData& rMark,	580	ScDocument* pNewUndoDoc, const ScMarkData& rMark,
581	FillDir eNewFillDir, FillCmd eNewFillCmd, FillDateCmd eNewFillDateCmd,	581	const sc::FillSeriesData& rFillData, USHORT nMaxShIndex )
582	double fNewStartValue, double fNewStepValue, double fNewMaxValue,
583	USHORT nMaxShIndex )
584	//	582	//
585	: ScBlockUndo( pNewDocShell, rRange, SC_UNDO_AUTOHEIGHT ),	583	: ScBlockUndo( pNewDocShell, rRange, SC_UNDO_AUTOHEIGHT ),
586	//	584	//
587	aSource ( rSourceArea ),	585	aSource ( rSourceArea ),
588	aMarkData ( rMark ),	586	aMarkData ( rMark ),
589	pUndoDoc ( pNewUndoDoc ),	587	pUndoDoc ( pNewUndoDoc ),
590	eFillDir ( eNewFillDir ),	588	m_aFillData(rFillData),
591	eFillCmd ( eNewFillCmd ),	589	nStartChangeAction(0L),
592	eFillDateCmd ( eNewFillDateCmd ),	590	nEndChangeAction(0L),
593	fStartValue ( fNewStartValue ),
594	fStepValue ( fNewStepValue ),
595	fMaxValue ( fNewMaxValue ),
596	nMaxSharedIndex ( nMaxShIndex)	591	nMaxSharedIndex ( nMaxShIndex)
597	{	592	{
598	SetChangeTrack();	593	SetChangeTrack();
Lines 702-708 Link Here
702	//! Tabellen selektieren	697	//! Tabellen selektieren
703		698
704	SCCOLROW nCount = 0;	699	SCCOLROW nCount = 0;
705	switch (eFillDir)	700	switch (m_aFillData.eDir)
706	{	701	{
707	case FILL_TO_BOTTOM:	702	case FILL_TO_BOTTOM:
708	nCount = aBlockRange.aEnd.Row() - aSource.aEnd.Row();	703	nCount = aBlockRange.aEnd.Row() - aSource.aEnd.Row();
Lines 719-736 Link Here
719	}	714	}
720		715
721	ScDocument* pDoc = pDocShell->GetDocument();	716	ScDocument* pDoc = pDocShell->GetDocument();
722	if ( fStartValue != MAXDOUBLE )	717	if (m_aFillData.fStart != MAXDOUBLE)
723	{	718	{
724	SCCOL nValX = (eFillDir == FILL_TO_LEFT) ? aSource.aEnd.Col() : aSource.aStart.Col();	719	SCCOL nValX = (m_aFillData.eDir == FILL_TO_LEFT)
725	SCROW nValY = (eFillDir == FILL_TO_TOP ) ? aSource.aEnd.Row() : aSource.aStart.Row();	720	? aSource.aEnd.Col() : aSource.aStart.Col();
		721	SCROW nValY = (m_aFillData.eDir == FILL_TO_TOP )
		722	? aSource.aEnd.Row() : aSource.aStart.Row();
726	SCTAB nTab = aSource.aStart.Tab();	723	SCTAB nTab = aSource.aStart.Tab();
727	pDoc->SetValue( nValX, nValY, nTab, fStartValue );	724	if (m_aFillData.bUseString)
		725	{
		726	OSL_ENSURE(rFillData.aStart.Len() != 0, "there is no starting string");
		727	pDoc->SetString(nValX, nValY, nTab, m_aFillData.aStart);
		728	}
		729	else
		730	{
		731	pDoc->SetValue(nValX, nValY, nTab, m_aFillData.fStart);
		732	}
728	}	733	}
729	pDoc->Fill( aSource.aStart.Col(), aSource.aStart.Row(),	734	pDoc->Fill(aSource.aStart.Col(), aSource.aStart.Row(),
730	aSource.aEnd.Col(), aSource.aEnd.Row(),	735	aSource.aEnd.Col(), aSource.aEnd.Row(),
731	aMarkData, nCount,	736	aMarkData, nCount, m_aFillData)
732	eFillDir, eFillCmd, eFillDateCmd,	737	;
733	fStepValue, fMaxValue );
734		738
735	SetChangeTrack();	739	SetChangeTrack();
736		740
Lines 751-761 Link Here
751	if (rTarget.ISA(ScTabViewTarget))	755	if (rTarget.ISA(ScTabViewTarget))
752	{	756	{
753	ScTabViewShell& rViewShell = *((ScTabViewTarget&)rTarget).GetViewShell();	757	ScTabViewShell& rViewShell = *((ScTabViewTarget&)rTarget).GetViewShell();
754	if (eFillCmd==FILL_SIMPLE)	758	if (m_aFillData.eCmd==FILL_SIMPLE)
755	rViewShell.FillSimple( eFillDir, TRUE );	759	rViewShell.FillSimple(m_aFillData.eDir, TRUE);
756	else	760	else
757	rViewShell.FillSeries( eFillDir, eFillCmd, eFillDateCmd,	761	rViewShell.FillSeries(m_aFillData, true);
758	fStartValue, fStepValue, fMaxValue, TRUE );
759	}	762	}
760	}	763	}
761		764

Lines 154-168 Link Here

(-)sc/source/ui/inc/docfunc.hxx (-8 / +6 lines)
154	BOOL TabOp( const ScRange& rRange, const ScMarkData* pTabMark,	154	BOOL TabOp( const ScRange& rRange, const ScMarkData* pTabMark,
155	const ScTabOpParam& rParam, BOOL bRecord, BOOL bApi );	155	const ScTabOpParam& rParam, BOOL bRecord, BOOL bApi );
156		156
157	BOOL FillSimple( const ScRange& rRange, const ScMarkData* pTabMark,	157	BOOL FillSimple( const ScRange& rRange, const ScMarkData* pTabMark,
158	FillDir eDir, BOOL bRecord, BOOL bApi );	158	FillDir eDir, BOOL bRecord, BOOL bApi );
159	BOOL FillSeries( const ScRange& rRange, const ScMarkData* pTabMark,	159	bool FillSeries(const ScRange& rRange, const ScMarkData* pTabMark,
160	FillDir eDir, FillCmd eCmd, FillDateCmd eDateCmd,	160	const sc::FillSeriesData& rFillData, bool bRecord, bool bApi);
161	double fStart, double fStep, double fMax,
162	BOOL bRecord, BOOL bApi );
163	// FillAuto: rRange wird von Source-Range auf Dest-Range angepasst	161	// FillAuto: rRange wird von Source-Range auf Dest-Range angepasst
164	BOOL FillAuto( ScRange& rRange, const ScMarkData* pTabMark,	162	BOOL FillAuto( ScRange& rRange, const ScMarkData* pTabMark,
165	FillDir eDir, ULONG nCount, BOOL bRecord, BOOL bApi );	163	FillDir eDir, ULONG nCount, BOOL bRecord, BOOL bApi );
166		164
167	BOOL ResizeMatrix( const ScRange& rOldRange, const ScAddress& rNewEnd, BOOL bApi );	165	BOOL ResizeMatrix( const ScRange& rOldRange, const ScAddress& rNewEnd, BOOL bApi );
168		166

Line 0 Link Here

(-)sc/inc/sc/valuestringparser.hxx (+110 lines)
		1	/*************************************************************************
		2	*
		3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
		4	*
		5	* Copyright 2008 by Sun Microsystems, Inc.
		6	*
		7	* OpenOffice.org - a multi-platform office productivity suite
		8	*
		9	* $RCSfile: $
		10	* $Revision: $
		11	*
		12	* This file is part of OpenOffice.org.
		13	*
		14	* OpenOffice.org is free software: you can redistribute it and/or modify
		15	* it under the terms of the GNU Lesser General Public License version 3
		16	* only, as published by the Free Software Foundation.
		17	*
		18	* OpenOffice.org is distributed in the hope that it will be useful,
		19	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		20	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		21	* GNU Lesser General Public License version 3 for more details
		22	* (a copy is included in the LICENSE file that accompanied this code).
		23	*
		24	* You should have received a copy of the GNU Lesser General Public License
		25	* version 3 along with OpenOffice.org. If not, see
		26	* <http://www.openoffice.org/license.html>
		27	* for a copy of the LGPLv3 License.
		28	*
		29	************************************************************************/
		30
		31	#ifndef SC_VALUESTRINGPARSER_HXX_INCLUDED
		32	#define SC_VALUESTRINGPARSER_HXX_INCLUDED
		33
		34	#include <tools/string.hxx>
		35
		36	#include "scdllapi.h"
		37
		38
		39	namespace sc
		40	{
		41
		42	/** Extract numeric value from a string and supply more info about it.
		43	Only integer numbers staying at the beginning or at the end of the
		44	string are recognized.
		45
		46	The only function usable when there is no numeric value (i.e. when
		47	HasValue() returns false) is GetBaseSubstring(), returning the
		48	original string. The other functions return default values of their
		49	respective types.
		50	*/
		51	class SC_DLLPUBLIC ValueStringParser
		52	{
		53	public:
		54	/** Examine rString for possible numeric value.
		55	*/
		56	SC_DLLPUBLIC ValueStringParser(const String& rString);
		57
		58	/** Tell if the string contains (recognizable) numeric value.
		59	*/
		60	SC_DLLPUBLIC bool HasValue() const;
		61
		62	/** Get the found numeric value.
		63	*/
		64	SC_DLLPUBLIC sal_Int32 GetValue() const;
65
66	/** Get the minimum number of digits required for representation
67	of the number. Value 0 means there is no requirement.
68	*/
69	SC_DLLPUBLIC sal_Int16 GetMinDigits() const;
70
71	/** Get the numeric substring (if any). This function returns
72	nonempty string iff HasValue() == true.
73	*/
74	SC_DLLPUBLIC const String& GetNumericSubstring() const;
75
76	/** Get the base (i.e. non-numeric substring.
77	*/
78	SC_DLLPUBLIC const String& GetBaseSubstring() const;
79
80	/** Tell if the number is prefix of the base substring.
81	*/
82	SC_DLLPUBLIC bool IsPrefix() const;
83
84	private:
85	void impl_DecompValueString();
86
87	private:
88	String m_aString;
89	mutable String m_aNumericSubstring;
90	String m_aBaseSubstring;
91	sal_Int32 m_nValue;
92	sal_Int16 m_nMinDigits;
93	bool m_bHasValue;
94	bool m_bIsPrefix;
95	};
96
97	/** Test if the two parsed strings can be ordered. They can be iff
98	they both have numeric value and either share a common prefix/suffix
99	or their suffix makes valid ordinal numbers from both of them.
100	*/
101	SC_DLLPUBLIC bool
102	CanBeOrdered(
103	const ValueStringParser& rValueString1,
104	const ValueStringParser& rValueString2);
105
106	}
107
108	#endif
109
110	// vim: set sts=4 sw=4 et:

Lines 740-745 Link Here

(-)sc/inc/document.hxx (-5 / +9 lines)
740	SC_DLLPUBLIC void GetInputString( SCCOL nCol, SCROW nRow, SCTAB nTab, String& rString );	740	SC_DLLPUBLIC void GetInputString( SCCOL nCol, SCROW nRow, SCTAB nTab, String& rString );
741	SC_DLLPUBLIC double GetValue( const ScAddress& );	741	SC_DLLPUBLIC double GetValue( const ScAddress& );
742	SC_DLLPUBLIC void GetValue( SCCOL nCol, SCROW nRow, SCTAB nTab, double& rValue );	742	SC_DLLPUBLIC void GetValue( SCCOL nCol, SCROW nRow, SCTAB nTab, double& rValue );
		743
743	SC_DLLPUBLIC double RoundValueAsShown( double fVal, ULONG nFormat );	744	SC_DLLPUBLIC double RoundValueAsShown( double fVal, ULONG nFormat );
744	SC_DLLPUBLIC void GetNumberFormat( SCCOL nCol, SCROW nRow, SCTAB nTab,	745	SC_DLLPUBLIC void GetNumberFormat( SCCOL nCol, SCROW nRow, SCTAB nTab,
745	sal_uInt32& rFormat );	746	sal_uInt32& rFormat );
Lines 1070-1080 Link Here
1070		1071
1071	void UpdateGrow( const ScRange& rArea, SCCOL nGrowX, SCROW nGrowY );	1072	void UpdateGrow( const ScRange& rArea, SCCOL nGrowX, SCROW nGrowY );
1072		1073
1073	void Fill( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,	1074	void Fill( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
1074	const ScMarkData& rMark,	1075	const ScMarkData& rMark,
1075	ULONG nFillCount, FillDir eFillDir = FILL_TO_BOTTOM,	1076	ULONG nFillCount, FillDir eFillDir = FILL_TO_BOTTOM,
1076	FillCmd eFillCmd = FILL_LINEAR, FillDateCmd eFillDateCmd = FILL_DAY,	1077	FillCmd eFillCmd = FILL_LINEAR, FillDateCmd eFillDateCmd = FILL_DAY,
1077	double nStepValue = 1.0, double nMaxValue = 1E307);	1078	double nStepValue = 1.0, double nMaxValue = 1E307);
		1079	void Fill(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
		1080	const ScMarkData& rMark, ULONG nFillCount,
		1081	const sc::FillSeriesData& rFillData);
1078	String GetAutoFillPreview( const ScRange& rSource, SCCOL nEndX, SCROW nEndY );	1082	String GetAutoFillPreview( const ScRange& rSource, SCCOL nEndX, SCROW nEndY );
1079		1083
1080	BOOL GetSelectionFunction( ScSubTotalFunc eFunc,	1084	BOOL GetSelectionFunction( ScSubTotalFunc eFunc,