/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sc.hxx"



//----------------------------------------------------------------------------
#include <rangelst.hxx>

#include <sfx2/dispatch.hxx>
#include <svl/stritem.hxx>
#include <vcl/msgbox.hxx>
#include <unotools/charclass.hxx>
#include <stdlib.h>

#define _AREASDLG_CXX
#include "areasdlg.hxx"
#undef _AREASDLG_CXX

#include "scresid.hxx"
#include "rangenam.hxx"
#include "reffact.hxx"
#include "tabvwsh.hxx"
#include "docsh.hxx"
#include "globstr.hrc"
#include "pagedlg.hrc"
#include "compiler.hxx"

// STATIC DATA ---------------------------------------------------------------

// List box positions for print range (PR)
const sal_uInt16 SC_AREASDLG_PR_NONE    = 0;
const sal_uInt16 SC_AREASDLG_PR_ENTIRE  = 1;
const sal_uInt16 SC_AREASDLG_PR_USER    = 2;
const sal_uInt16 SC_AREASDLG_PR_SELECT  = 3;
const sal_uInt16 SC_AREASDLG_PR_OFFSET  = 4;

// List box positions for repeat ranges (RR)
const sal_uInt16 SC_AREASDLG_RR_NONE    = 0;
const sal_uInt16 SC_AREASDLG_RR_USER    = 1;
const sal_uInt16 SC_AREASDLG_RR_OFFSET  = 2;

//============================================================================

#define HDL(hdl)			LINK( this, ScPrintAreasDlg, hdl )
#define ERRORBOX(nId)		ErrorBox( this, WinBits(WB_OK|WB_DEF_OK), \
							ScGlobal::GetRscString( nId ) ).Execute()
#define SWAP(x1,x2)			{ int n=x1; x1=x2; x2=n; }

// globale Funktionen (->am Ende der Datei):

bool    lcl_CheckRepeatString( const String& rStr, ScDocument* pDoc, bool bIsRow, ScRange* pRange );
void	lcl_GetRepeatRangeString( const ScRange* pRange, ScDocument* pDoc, bool bIsRow, String& rStr );

#if 0
static void printAddressFlags(sal_uInt16 nFlag)
{
    if ((nFlag & SCA_COL_ABSOLUTE  ) == SCA_COL_ABSOLUTE  )  printf("SCA_COL_ABSOLUTE \n");
    if ((nFlag & SCA_ROW_ABSOLUTE  ) == SCA_ROW_ABSOLUTE  )  printf("SCA_ROW_ABSOLUTE \n");
    if ((nFlag & SCA_TAB_ABSOLUTE  ) == SCA_TAB_ABSOLUTE  )  printf("SCA_TAB_ABSOLUTE \n");
    if ((nFlag & SCA_TAB_3D        ) == SCA_TAB_3D        )  printf("SCA_TAB_3D       \n");
    if ((nFlag & SCA_COL2_ABSOLUTE ) == SCA_COL2_ABSOLUTE )  printf("SCA_COL2_ABSOLUTE\n");
    if ((nFlag & SCA_ROW2_ABSOLUTE ) == SCA_ROW2_ABSOLUTE )  printf("SCA_ROW2_ABSOLUTE\n");
    if ((nFlag & SCA_TAB2_ABSOLUTE ) == SCA_TAB2_ABSOLUTE )  printf("SCA_TAB2_ABSOLUTE\n");
    if ((nFlag & SCA_TAB2_3D       ) == SCA_TAB2_3D       )  printf("SCA_TAB2_3D      \n");
    if ((nFlag & SCA_VALID_ROW     ) == SCA_VALID_ROW     )  printf("SCA_VALID_ROW    \n");
    if ((nFlag & SCA_VALID_COL     ) == SCA_VALID_COL     )  printf("SCA_VALID_COL    \n");
    if ((nFlag & SCA_VALID_TAB     ) == SCA_VALID_TAB     )  printf("SCA_VALID_TAB    \n");
    if ((nFlag & SCA_FORCE_DOC     ) == SCA_FORCE_DOC     )  printf("SCA_FORCE_DOC    \n");
    if ((nFlag & SCA_VALID_ROW2    ) == SCA_VALID_ROW2    )  printf("SCA_VALID_ROW2   \n");
    if ((nFlag & SCA_VALID_COL2    ) == SCA_VALID_COL2    )  printf("SCA_VALID_COL2   \n");
    if ((nFlag & SCA_VALID_TAB2    ) == SCA_VALID_TAB2    )  printf("SCA_VALID_TAB2   \n");
    if ((nFlag & SCA_VALID         ) == SCA_VALID         )  printf("SCA_VALID        \n");
    if ((nFlag & SCA_ABS           ) == SCA_ABS           )  printf("SCA_ABS          \n");
    if ((nFlag & SCR_ABS           ) == SCR_ABS           )  printf("SCR_ABS          \n");
    if ((nFlag & SCA_ABS_3D        ) == SCA_ABS_3D        )  printf("SCA_ABS_3D       \n");
    if ((nFlag & SCR_ABS_3D        ) == SCR_ABS_3D        )  printf("SCR_ABS_3D       \n");
}
#endif

//============================================================================
//	class ScPrintAreasDlg

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

ScPrintAreasDlg::ScPrintAreasDlg( SfxBindings* pB, SfxChildWindow* pCW, Window* pParent )
	:	ScAnyRefDlg		( pB, pCW, pParent, RID_SCDLG_AREAS),
		//
		aFlPrintArea    ( this, ScResId( FL_PRINTAREA ) ),
		aLbPrintArea	( this, ScResId( LB_PRINTAREA ) ),
        aEdPrintArea    ( this, this, ScResId( ED_PRINTAREA ) ),
		aRbPrintArea	( this, ScResId( RB_PRINTAREA ), &aEdPrintArea, this ),
		//
		aFlRepeatRow    ( this, ScResId( FL_REPEATROW ) ),
		aLbRepeatRow	( this, ScResId( LB_REPEATROW ) ),
        aEdRepeatRow    ( this, this, ScResId( ED_REPEATROW ) ),
		aRbRepeatRow	( this, ScResId( RB_REPEATROW ), &aEdRepeatRow, this ),
		//
		aFlRepeatCol    ( this, ScResId( FL_REPEATCOL ) ),
		aLbRepeatCol	( this, ScResId( LB_REPEATCOL ) ),
        aEdRepeatCol    ( this, this, ScResId( ED_REPEATCOL ) ),
		aRbRepeatCol	( this, ScResId( RB_REPEATCOL ), &aEdRepeatCol, this ),
		//
		aBtnOk			( this, ScResId( BTN_OK ) ),
		aBtnCancel		( this, ScResId( BTN_CANCEL ) ),
		aBtnHelp		( this, ScResId( BTN_HELP ) ),
		//
		bDlgLostFocus	( sal_False ),
		pRefInputEdit	( &aEdPrintArea ),
		pDoc			( NULL ),
		pViewData		( NULL ),
		nCurTab 		( 0 )
{
	ScTabViewShell* pScViewSh = PTR_CAST( ScTabViewShell, SfxViewShell::Current() );
	ScDocShell*		pScDocSh  = PTR_CAST( ScDocShell,     SfxObjectShell::Current() );

	DBG_ASSERT( pScDocSh, "Current DocumentShell not found :-(" );

	pDoc = pScDocSh->GetDocument();

	if ( pScViewSh )
	{
		pViewData = pScViewSh->GetViewData();
		nCurTab   = pViewData->GetTabNo();
	}

	Impl_Reset();

	//@BugID 54702 Enablen/Disablen nur noch in Basisklasse
	//SFX_APPWINDOW->Enable();

	FreeResource();
}


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

ScPrintAreasDlg::~ScPrintAreasDlg()
{
	// Extra-Data an ListBox-Entries abraeumen
	ListBox* pLb[3] = { &aLbPrintArea, &aLbRepeatRow, &aLbRepeatCol };

	for ( sal_uInt16 i=0; i<3; i++ )
	{
		sal_uInt16 nCount = pLb[i]->GetEntryCount();
		for ( sal_uInt16 j=0; j<nCount; j++ )
			delete (String*)pLb[i]->GetEntryData(j);
	}
}


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

sal_Bool ScPrintAreasDlg::Close()
{
	return DoClose( ScPrintAreasDlgWrapper::GetChildWindowId() );
}


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

sal_Bool ScPrintAreasDlg::IsTableLocked() const
{
	//	Druckbereiche gelten pro Tabelle, darum macht es keinen Sinn,
	//	bei der Eingabe die Tabelle umzuschalten

	return sal_True;
}


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

void ScPrintAreasDlg::SetReference( const ScRange& rRef, ScDocument* /* pDoc */ )
{
	if ( pRefInputEdit )
	{
		if ( rRef.aStart != rRef.aEnd )
			RefInputStart( pRefInputEdit );

		String	aStr;
        const formula::FormulaGrammar::AddressConvention eConv = pDoc->GetAddressConvention();

		if ( &aEdPrintArea == pRefInputEdit )
		{
			rRef.Format( aStr, SCR_ABS, pDoc, eConv );

//			aEdPrintArea.ReplaceSelected( aStr );

			String aVal = aEdPrintArea.GetText();
			Selection aSel = aEdPrintArea.GetSelection();
            aSel.Justify();
			aVal.Erase( (xub_StrLen)aSel.Min(), (xub_StrLen)aSel.Len() );
			aVal.Insert( aStr, (xub_StrLen)aSel.Min() );
			Selection aNewSel( aSel.Min(), aSel.Min()+aStr.Len() );
			aEdPrintArea.SetRefString( aVal );
			aEdPrintArea.SetSelection( aNewSel );
		}
		else
		{
			sal_Bool bRow = ( &aEdRepeatRow == pRefInputEdit );
            lcl_GetRepeatRangeString(&rRef, pDoc, bRow, aStr);
			pRefInputEdit->SetRefString( aStr );
		}
	}

	Impl_ModifyHdl( pRefInputEdit );
}


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

void ScPrintAreasDlg::AddRefEntry()
{
	if ( pRefInputEdit == &aEdPrintArea )
	{
        const sal_Unicode sep = ScCompiler::GetNativeSymbol(ocSep).GetChar(0);
		String aVal = aEdPrintArea.GetText();
		aVal += sep;
		aEdPrintArea.SetText(aVal);

		xub_StrLen nLen = aVal.Len();
		aEdPrintArea.SetSelection( Selection( nLen, nLen ) );

		Impl_ModifyHdl( &aEdPrintArea );
	}
}


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

void ScPrintAreasDlg::Deactivate()
{
	bDlgLostFocus = sal_True;
}


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

void ScPrintAreasDlg::SetActive()
{
	if ( bDlgLostFocus )
	{
		bDlgLostFocus = sal_False;

		if ( pRefInputEdit )
		{
			pRefInputEdit->GrabFocus();
			Impl_ModifyHdl( pRefInputEdit );
		}
	}
	else
		GrabFocus();

	RefInputDone();
}


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

void ScPrintAreasDlg::Impl_Reset()
{
	String			aStrRange;
	const ScRange*	pRepeatColRange = pDoc->GetRepeatColRange( nCurTab );
	const ScRange*	pRepeatRowRange = pDoc->GetRepeatRowRange( nCurTab );

	aEdPrintArea.SetModifyHdl	( HDL(Impl_ModifyHdl) );
	aEdRepeatRow.SetModifyHdl	( HDL(Impl_ModifyHdl) );
	aEdRepeatCol.SetModifyHdl	( HDL(Impl_ModifyHdl) );
	aEdPrintArea.SetGetFocusHdl( HDL(Impl_GetFocusHdl) );
	aEdRepeatRow.SetGetFocusHdl( HDL(Impl_GetFocusHdl) );
	aEdRepeatCol.SetGetFocusHdl( HDL(Impl_GetFocusHdl) );
	aLbPrintArea.SetGetFocusHdl( HDL(Impl_GetFocusHdl) );
	aLbRepeatRow.SetGetFocusHdl( HDL(Impl_GetFocusHdl) );
	aLbRepeatCol.SetGetFocusHdl( HDL(Impl_GetFocusHdl) );
	aLbPrintArea.SetSelectHdl	( HDL(Impl_SelectHdl) );
	aLbRepeatRow.SetSelectHdl	( HDL(Impl_SelectHdl) );
	aLbRepeatCol.SetSelectHdl	( HDL(Impl_SelectHdl) );
	aBtnOk		.SetClickHdl 	( HDL(Impl_BtnHdl)    );
	aBtnCancel	.SetClickHdl 	( HDL(Impl_BtnHdl)    );

	Impl_FillLists();

	//-------------------------
	// Druckbereich
	//-------------------------
	aStrRange.Erase();
    String aOne;
    const formula::FormulaGrammar::AddressConvention eConv = pDoc->GetAddressConvention();
    const sal_Unicode sep = ScCompiler::GetNativeSymbol(ocSep).GetChar(0);
    sal_uInt16 nRangeCount = pDoc->GetPrintRangeCount( nCurTab );
    for (sal_uInt16 i=0; i<nRangeCount; i++)
    {
        const ScRange* pPrintRange = pDoc->GetPrintRange( nCurTab, i );
        if (pPrintRange)
        {
            if ( aStrRange.Len() )
                aStrRange += sep;
            pPrintRange->Format( aOne, SCR_ABS, pDoc, eConv );
            aStrRange += aOne;
        }
    }
    aEdPrintArea.SetText( aStrRange );

	//-------------------------------
	// Wiederholungszeile
	//-------------------------------
    lcl_GetRepeatRangeString(pRepeatRowRange, pDoc, true, aStrRange);
	aEdRepeatRow.SetText( aStrRange );

	//--------------------------------
	// Wiederholungsspalte
	//--------------------------------
    lcl_GetRepeatRangeString(pRepeatColRange, pDoc, false, aStrRange);
	aEdRepeatCol.SetText( aStrRange );

	Impl_ModifyHdl( &aEdPrintArea );
	Impl_ModifyHdl( &aEdRepeatRow );
	Impl_ModifyHdl( &aEdRepeatCol );
    if( pDoc->IsPrintEntireSheet( nCurTab ) )
        aLbPrintArea.SelectEntryPos( SC_AREASDLG_PR_ENTIRE );

	aEdPrintArea.SaveValue();	// fuer FillItemSet() merken:
	aEdRepeatRow.SaveValue();
	aEdRepeatCol.SaveValue();
}


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

sal_Bool ScPrintAreasDlg::Impl_GetItem( Edit* pEd, SfxStringItem& rItem )
{
	String	aRangeStr = pEd->GetText();
	sal_Bool	bDataChanged = (pEd->GetSavedValue() != aRangeStr);

	if ( (aRangeStr.Len() > 0) && &aEdPrintArea != pEd )
	{
		ScRange aRange;
        const formula::FormulaGrammar::AddressConvention eConv = pDoc->GetAddressConvention();
        lcl_CheckRepeatString(aRangeStr, pDoc, &aEdRepeatRow == pEd, &aRange);
		aRange.Format(aRangeStr, SCR_ABS, pDoc, eConv);
	}

	rItem.SetValue( aRangeStr );

	return bDataChanged;
}


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

sal_Bool ScPrintAreasDlg::Impl_CheckRefStrings()
{
	sal_Bool		bOk = sal_False;
	String		aStrPrintArea	= aEdPrintArea.GetText();
	String		aStrRepeatRow	= aEdRepeatRow.GetText();
	String		aStrRepeatCol	= aEdRepeatCol.GetText();

	sal_Bool bPrintAreaOk = sal_True;
	if ( aStrPrintArea.Len() )
	{
        const sal_uInt16 nValidAddr  = SCA_VALID | SCA_VALID_ROW | SCA_VALID_COL;
        const sal_uInt16 nValidRange = nValidAddr | SCA_VALID_ROW2 | SCA_VALID_COL2;
        const formula::FormulaGrammar::AddressConvention eConv = pDoc->GetAddressConvention();
        const sal_Unicode sep  = ScCompiler::GetNativeSymbol(ocSep).GetChar(0);
        // const sal_Unicode rsep = ScCompiler::GetNativeSymbol(ocRange).GetChar(0);

        ScAddress aAddr;
		ScRange aRange;
		xub_StrLen nSepCount = aStrPrintArea.GetTokenCount(sep);
		for ( xub_StrLen i = 0; i < nSepCount && bPrintAreaOk; ++i )
		{
			String aOne = aStrPrintArea.GetToken(i, sep);
            sal_uInt16 nResult = aRange.Parse( aOne, pDoc, eConv );
            if ((nResult & nValidRange) != nValidRange)
            {
                sal_uInt16 nAddrResult = aAddr.Parse( aOne, pDoc, eConv );
                if ((nAddrResult & nValidAddr) != nValidAddr)
                    bPrintAreaOk = sal_False;
            }
		}
	}

	sal_Bool bRepeatRowOk = (aStrRepeatRow.Len() == 0);
	if ( !bRepeatRowOk )
        bRepeatRowOk = lcl_CheckRepeatString(aStrRepeatRow, pDoc, true, NULL);

	sal_Bool bRepeatColOk = (aStrRepeatCol.Len() == 0);
	if ( !bRepeatColOk )
        bRepeatColOk = lcl_CheckRepeatString(aStrRepeatCol, pDoc, false, NULL);

	// Fehlermeldungen

	bOk = (bPrintAreaOk && bRepeatRowOk && bRepeatColOk);

	if ( !bOk )
	{
		Edit* pEd = NULL;

			 if ( !bPrintAreaOk ) pEd = &aEdPrintArea;
		else if ( !bRepeatRowOk ) pEd = &aEdRepeatRow;
		else if ( !bRepeatColOk ) pEd = &aEdRepeatCol;

		ERRORBOX( STR_INVALID_TABREF );
		pEd->GrabFocus();
	}

	return bOk;
}


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

void ScPrintAreasDlg::Impl_FillLists()
{
	//------------------------------------------------------
	// Selektion holen und String in PrintArea-ListBox merken
	//------------------------------------------------------
	ScRange	aRange;
	String	aStrRange;
	sal_Bool bSimple = sal_True;

	if ( pViewData )
		bSimple = (pViewData->GetSimpleArea( aRange ) == SC_MARK_SIMPLE);

    formula::FormulaGrammar::AddressConvention eConv = pDoc->GetAddressConvention();

	if ( bSimple )
		aRange.Format( aStrRange, SCR_ABS, pDoc, eConv );
	else
	{
		ScRangeListRef aList( new ScRangeList );
		pViewData->GetMarkData().FillRangeListWithMarks( aList, sal_False );
		aList->Format( aStrRange, SCR_ABS, pDoc, eConv );
	}

    aLbPrintArea.SetEntryData( SC_AREASDLG_PR_SELECT, new String( aStrRange ) );

	//------------------------------------------------------
	// Ranges holen und in ListBoxen merken
	//------------------------------------------------------
	ScRangeName*	pRangeNames = pDoc->GetRangeName();
	const sal_uInt16	nCount		= pRangeNames ? pRangeNames->GetCount() : 0;

	if ( nCount > 0 )
	{
		String			aName;
		String			aSymbol;
//        ScRange         aRange;
		ScRangeData*	pData = NULL;

		for ( sal_uInt16 i=0; i<nCount; i++ )
		{
			pData = (ScRangeData*)(pRangeNames->At( i ));
			if ( pData )
			{
				if (   pData->HasType( RT_ABSAREA )
					|| pData->HasType( RT_REFAREA )
					|| pData->HasType( RT_ABSPOS ) )
				{
					pData->GetName( aName );
					pData->GetSymbol( aSymbol );
					if ( aRange.ParseAny( aSymbol, pDoc, eConv ) & SCA_VALID )
					{
						if ( pData->HasType( RT_PRINTAREA ) )
						{
							aRange.Format( aSymbol, SCR_ABS, pDoc, eConv );
							aLbPrintArea.SetEntryData(
								aLbPrintArea.InsertEntry( aName ),
								new String( aSymbol ) );
						}

						if ( pData->HasType( RT_ROWHEADER ) )
						{
                            lcl_GetRepeatRangeString(&aRange, pDoc, true, aSymbol);
							aLbRepeatRow.SetEntryData(
								aLbRepeatRow.InsertEntry( aName ),
								new String( aSymbol ) );
						}

						if ( pData->HasType( RT_COLHEADER ) )
						{
                            lcl_GetRepeatRangeString(&aRange, pDoc, false, aSymbol);
							aLbRepeatCol.SetEntryData(
								aLbRepeatCol.InsertEntry( aName ),
								new String( aSymbol ) );
						}
					}
				}
			}
		}
	}
}


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

IMPL_LINK( ScPrintAreasDlg, Impl_BtnHdl, PushButton*, pBtn )
{
	if ( &aBtnOk == pBtn )
	{
		if ( Impl_CheckRefStrings() )
		{
			sal_Bool			bDataChanged = sal_False;
			String			aStr;
			SfxStringItem	aPrintArea( SID_CHANGE_PRINTAREA, aStr );
			SfxStringItem	aRepeatRow( FN_PARAM_2, aStr );
			SfxStringItem 	aRepeatCol( FN_PARAM_3, aStr );

			//-------------------------
			// Druckbereich veraendert?
			//-------------------------

            // first try the list box, if "Entite sheet" is selected
            sal_Bool bEntireSheet = (aLbPrintArea.GetSelectEntryPos() == SC_AREASDLG_PR_ENTIRE);
            SfxBoolItem aEntireSheet( FN_PARAM_4, bEntireSheet );

            bDataChanged = bEntireSheet != pDoc->IsPrintEntireSheet( nCurTab );
            if( !bEntireSheet )
            {
                // if new list box selection is not "Entire sheet", get the edit field contents
                bDataChanged |= Impl_GetItem( &aEdPrintArea, aPrintArea );
            }

			//-------------------------------
			// Wiederholungszeile veraendert?
			//-------------------------------
			bDataChanged |= Impl_GetItem( &aEdRepeatRow, aRepeatRow );

			//--------------------------------
			// Wiederholungsspalte veraendert?
			//--------------------------------
			bDataChanged |= Impl_GetItem( &aEdRepeatCol, aRepeatCol );

			if ( bDataChanged )
			{
				SetDispatcherLock( sal_False );
				SwitchToDocument();
				GetBindings().GetDispatcher()->Execute( SID_CHANGE_PRINTAREA,
										  SFX_CALLMODE_SLOT | SFX_CALLMODE_RECORD,
                                          &aPrintArea, &aRepeatRow, &aRepeatCol, &aEntireSheet, 0L );
			}

			Close();
		}
	}
	else if ( &aBtnCancel == pBtn )
		Close();

	return 0;
}


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

IMPL_LINK( ScPrintAreasDlg, Impl_GetFocusHdl, Control*, pCtr )
{
	if ( pCtr ==(Control *) &aEdPrintArea ||
		 pCtr ==(Control *) &aEdRepeatRow ||
		 pCtr ==(Control *) &aEdRepeatCol)
	{
		 pRefInputEdit = (formula::RefEdit*) pCtr;
	}
	else if ( pCtr ==(Control *) &aLbPrintArea)
	{
		pRefInputEdit = &aEdPrintArea;
	}
	else if ( pCtr ==(Control *) &aLbRepeatRow)
	{
		pRefInputEdit = &aEdRepeatRow;
	}
	else if ( pCtr ==(Control *) &aLbRepeatCol)
	{
		pRefInputEdit = &aEdRepeatCol;
	}

	return 0;
}


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

IMPL_LINK( ScPrintAreasDlg, Impl_SelectHdl, ListBox*, pLb )
{
    sal_uInt16 nSelPos = pLb->GetSelectEntryPos();
    Edit* pEd = NULL;

    // list box positions of specific entries, default to "repeat row/column" list boxes
    sal_uInt16 nAllSheetPos = SC_AREASDLG_RR_NONE;
    sal_uInt16 nUserDefPos = SC_AREASDLG_RR_USER;
    sal_uInt16 nFirstCustomPos = SC_AREASDLG_RR_OFFSET;

    // find edit field for list box, and list box positions
    if( pLb == &aLbPrintArea )
    {
        pEd = &aEdPrintArea;
        nAllSheetPos = SC_AREASDLG_PR_ENTIRE;
        nUserDefPos = SC_AREASDLG_PR_USER;
        nFirstCustomPos = SC_AREASDLG_PR_SELECT;    // "Selection" and following
    }
    else if( pLb == &aLbRepeatCol )
        pEd = &aEdRepeatCol;
    else if( pLb == &aLbRepeatRow )
        pEd = &aEdRepeatRow;
    else
        return 0;

    // fill edit field according to list box selection
    if( (nSelPos == 0) || (nSelPos == nAllSheetPos) )
        pEd->SetText( EMPTY_STRING );
    else if( nSelPos == nUserDefPos && !pLb->IsTravelSelect() && pEd->GetText().Len() == 0 )
        pLb->SelectEntryPos( 0 );
    else if( nSelPos >= nFirstCustomPos )
        pEd->SetText( *static_cast< String* >( pLb->GetEntryData( nSelPos ) ) );

    return 0;
}


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

IMPL_LINK( ScPrintAreasDlg, Impl_ModifyHdl, formula::RefEdit*, pEd )
{
    ListBox* pLb = NULL;

    // list box positions of specific entries, default to "repeat row/column" list boxes
    sal_uInt16 nUserDefPos = SC_AREASDLG_RR_USER;
    sal_uInt16 nFirstCustomPos = SC_AREASDLG_RR_OFFSET;

    if( pEd == &aEdPrintArea )
    {
        pLb = &aLbPrintArea;
        nUserDefPos = SC_AREASDLG_PR_USER;
        nFirstCustomPos = SC_AREASDLG_PR_SELECT;    // "Selection" and following
    }
    else if( pEd == &aEdRepeatCol )
		pLb = &aLbRepeatCol;
    else if( pEd == &aEdRepeatRow )
		pLb = &aLbRepeatRow;
    else
        return 0;

    // set list box selection according to edit field
	sal_uInt16	nEntryCount = pLb->GetEntryCount();
	String	aStrEd( pEd->GetText() );
	String	aEdUpper = aStrEd;
	aEdUpper.ToUpperAscii();

    if ( (nEntryCount > nFirstCustomPos) && aStrEd.Len() > 0 )
	{
		sal_Bool	bFound	= sal_False;
		String* pSymbol	= NULL;
		sal_uInt16 i;

        for ( i=nFirstCustomPos; i<nEntryCount && !bFound; i++ )
		{
			pSymbol = (String*)pLb->GetEntryData( i );
			bFound  = ( (*pSymbol == aStrEd) || (*pSymbol == aEdUpper) );
		}

        pLb->SelectEntryPos( bFound ? i-1 : nUserDefPos );
	}
	else
        pLb->SelectEntryPos( aStrEd.Len() ? nUserDefPos : 0 );

	return 0;
}


//============================================================================
// globale Funktionen:

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

// TODO: It might make sense to move these functions to address.?xx. -kohei

bool lcl_CheckOne_OOO( const String& rStr, bool bIsRow, SCCOLROW& rVal )
{
	// Zulaessige Syntax fuer rStr:
	// Row: [$]1-MAXTAB
	// Col: [$]A-IV

	String	aStr	= rStr;
	xub_StrLen nLen = aStr.Len();
	SCCOLROW	nNum	= 0;
	sal_Bool	bStrOk  = ( nLen > 0 ) && ( bIsRow ? ( nLen < 6 ) : ( nLen < 4 ) );

	if ( bStrOk )
	{
		if ( '$' == aStr.GetChar(0) )
			aStr.Erase( 0, 1 );

		if ( bIsRow )
		{
			bStrOk = CharClass::isAsciiNumeric(aStr);

			if ( bStrOk )
			{
				sal_Int32 n = aStr.ToInt32();

                if ( ( bStrOk = (n > 0) && ( n <= MAXROWCOUNT ) ) != sal_False )
					nNum = static_cast<SCCOLROW>(n - 1);
			}
		}
		else
		{
            SCCOL nCol = 0;
			bStrOk = ::AlphaToCol( nCol, aStr);
            nNum = nCol;
		}
	}

	if ( bStrOk )
		rVal = nNum;

	return bStrOk;
}

bool lcl_CheckOne_XL_A1( const String& rStr, bool bIsRow, SCCOLROW& rVal )
{
    // XL A1 style is identical to OOO one for print range formats.
    return lcl_CheckOne_OOO(rStr, bIsRow, rVal);
}

bool lcl_CheckOne_XL_R1C1( const String& rStr, bool bIsRow, SCCOLROW& rVal )
{
    xub_StrLen nLen = rStr.Len();
    if (nLen <= 1)
        // There must be at least two characters.
        return false;

    const sal_Unicode preUpper = bIsRow ? 'R' : 'C';
    const sal_Unicode preLower = bIsRow ? 'r' : 'c';
    if (rStr.GetChar(0) != preUpper && rStr.GetChar(0) != preLower)
        return false;

    String aNumStr = rStr.Copy(1);
    if (!CharClass::isAsciiNumeric(aNumStr))
        return false;

    sal_Int32 nNum = aNumStr.ToInt32();

    if (nNum <= 0)
        return false;

    if ((bIsRow && nNum > MAXROWCOUNT) || (!bIsRow && nNum > MAXCOLCOUNT))
        return false;

    rVal = static_cast<SCCOLROW>(nNum-1);
    return true;
}

bool lcl_CheckRepeatOne( const String& rStr, formula::FormulaGrammar::AddressConvention eConv, bool bIsRow, SCCOLROW& rVal )
{
    switch (eConv)
    {
        case formula::FormulaGrammar::CONV_OOO:
            return lcl_CheckOne_OOO(rStr, bIsRow, rVal);
        case formula::FormulaGrammar::CONV_XL_A1:
            return lcl_CheckOne_XL_A1(rStr, bIsRow, rVal);
        case formula::FormulaGrammar::CONV_XL_R1C1:
            return lcl_CheckOne_XL_R1C1(rStr, bIsRow, rVal);
        default:
        {
            // added to avoid warnings
        }
    }
    return false;
}

bool lcl_CheckRepeatString( const String& rStr, ScDocument* pDoc, bool bIsRow, ScRange* pRange )
{
    // Row: [valid row] rsep [valid row]
    // Col: [valid col] rsep [valid col]

    const formula::FormulaGrammar::AddressConvention eConv = pDoc->GetAddressConvention();
    const sal_Unicode rsep = ScCompiler::GetNativeSymbol(ocRange).GetChar(0);

    if (pRange)
    {
        // initialize the range value.
        pRange->aStart.SetCol(0);
        pRange->aStart.SetRow(0);
        pRange->aEnd.SetCol(0);
        pRange->aEnd.SetRow(0);
    }

    String aBuf;
    SCCOLROW nVal = 0;
    xub_StrLen nLen = rStr.Len();
    bool bEndPos = false;
    for (xub_StrLen i = 0; i < nLen; ++i)
    {
        const sal_Unicode c = rStr.GetChar(i);
        if (c == rsep)
        {
            if (bEndPos)
                // We aren't supposed to have more than one range separator.
                return false;

            // range separator
            if (aBuf.Len() == 0)
                return false;

            bool bRes = lcl_CheckRepeatOne(aBuf, eConv, bIsRow, nVal);
            if (!bRes)
                return false;

            if (pRange)
            {
                if (bIsRow)
                {
                    pRange->aStart.SetRow(static_cast<SCROW>(nVal));
                    pRange->aEnd.SetRow(static_cast<SCROW>(nVal));
                }
                else
                {
                    pRange->aStart.SetCol(static_cast<SCCOL>(nVal));
                    pRange->aEnd.SetCol(static_cast<SCCOL>(nVal));
                }
            }

            aBuf.Erase();
            bEndPos = true;
        }
        else
            aBuf.Append(c);
    }

    if (aBuf.Len() > 0)
    {
        bool bRes = lcl_CheckRepeatOne(aBuf, eConv, bIsRow, nVal);
        if (!bRes)
            return false;

        if (pRange)
        {
            if (bIsRow)
            {
                if (!bEndPos)
                    pRange->aStart.SetRow(static_cast<SCROW>(nVal));
                pRange->aEnd.SetRow(static_cast<SCROW>(nVal));
            }
            else
            {
                if (!bEndPos)
                    pRange->aStart.SetCol(static_cast<SCCOL>(nVal));
                pRange->aEnd.SetCol(static_cast<SCCOL>(nVal));
            }
        }
    }

    return true;
}

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

void lcl_GetRepeatRangeString( const ScRange* pRange, ScDocument* pDoc, bool bIsRow, String& rStr )
{
    rStr.Erase();
    if (!pRange)
        return;

    const formula::FormulaGrammar::AddressConvention eConv = pDoc->GetAddressConvention();
    const ScAddress& rStart = pRange->aStart;
    const ScAddress& rEnd   = pRange->aEnd;

    const sal_uInt16 nFmt = bIsRow ? (SCA_VALID_ROW | SCA_ROW_ABSOLUTE) : (SCA_VALID_COL | SCA_COL_ABSOLUTE);
    String aTmpStr;
    rStart.Format(aTmpStr, nFmt, pDoc, eConv);
    rStr += aTmpStr;
    if ((bIsRow && rStart.Row() != rEnd.Row()) || (!bIsRow && rStart.Col() != rEnd.Col()))
    {
        rStr += ScCompiler::GetNativeSymbol(ocRange);
        rEnd.Format(aTmpStr, nFmt, pDoc, eConv);
        rStr += aTmpStr;
    }
}