xref: /AOO41X/main/sc/source/core/data/column2.cxx (revision 8f4c7c28c0e8f794fb1048a19304c40597e0d6b9)

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

#include "scitems.hxx"
#include <editeng/eeitem.hxx>

#include <svx/algitem.hxx>
#include <editeng/editobj.hxx>
#include <editeng/editstat.hxx>
#include <editeng/emphitem.hxx>
#include <editeng/fhgtitem.hxx>
#include <editeng/forbiddencharacterstable.hxx>
#include <svx/rotmodit.hxx>
#include <editeng/scripttypeitem.hxx>
#include <editeng/unolingu.hxx>
#include <svl/zforlist.hxx>
#include <svl/broadcast.hxx>
#include <svl/listeneriter.hxx>
#include <vcl/outdev.hxx>

#include "column.hxx"
#include "cell.hxx"
#include "document.hxx"
#include "docpool.hxx"
#include "attarray.hxx"
#include "patattr.hxx"
#include "cellform.hxx"
#include "collect.hxx"
#include "stlsheet.hxx"
#include "rechead.hxx"
#include "brdcst.hxx"
#include "editutil.hxx"
#include "subtotal.hxx"
#include "markdata.hxx"
#include "compiler.hxx"			// ScTokenArray GetCodeLen
#include "dbcolect.hxx"
#include "fillinfo.hxx"
#include "segmenttree.hxx"

#include <math.h>

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

// factor from font size to optimal cell height (text width)
#define SC_ROT_BREAK_FACTOR		6

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

inline sal_Bool IsAmbiguousScript( sal_uInt8 nScript )
{
	//!	move to a header file
	return ( nScript != SCRIPTTYPE_LATIN &&
			 nScript != SCRIPTTYPE_ASIAN &&
			 nScript != SCRIPTTYPE_COMPLEX );
}

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

//
//	Datei-Operationen
//

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

//UNUSED2008-05  SCROW ScColumn::NoteCount( SCROW nMaxRow ) const
//UNUSED2008-05  {
//UNUSED2008-05      SCROW nNoteCount = 0;
//UNUSED2008-05      SCSIZE i;
//UNUSED2008-05
//UNUSED2008-05      for (i=0; i<nCount; i++)
//UNUSED2008-05          if ( pItems[i].pCell->GetNotePtr() && pItems[i].nRow<=nMaxRow )
//UNUSED2008-05              ++nNoteCount;
//UNUSED2008-05
//UNUSED2008-05      return nNoteCount;
//UNUSED2008-05  }

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

//UNUSED2008-05  void ScColumn::CorrectSymbolCells( CharSet eStreamCharSet )
//UNUSED2008-05  {
//UNUSED2008-05      //  #99139# find and correct string cells that are formatted with a symbol font,
//UNUSED2008-05      //  but are not in the LoadedSymbolStringCellsList
//UNUSED2008-05      //  (because CELLTYPE_SYMBOLS wasn't written in the file)
//UNUSED2008-05
//UNUSED2008-05      ScFontToSubsFontConverter_AutoPtr xFontConverter;
//UNUSED2008-05      const sal_uLong nFontConverterFlags = FONTTOSUBSFONT_EXPORT | FONTTOSUBSFONT_ONLYOLDSOSYMBOLFONTS;
//UNUSED2008-05
//UNUSED2008-05      sal_Bool bListInitialized = sal_False;
//UNUSED2008-05      ScSymbolStringCellEntry* pCurrentEntry = NULL;
//UNUSED2008-05
//UNUSED2008-05      ScAttrIterator aAttrIter( pAttrArray, 0, MAXROW );
//UNUSED2008-05      SCROW nStt, nEnd;
//UNUSED2008-05      const ScPatternAttr* pAttr = aAttrIter.Next( nStt, nEnd );
//UNUSED2008-05      while ( pAttr )
//UNUSED2008-05      {
//UNUSED2008-05          if ( (xFontConverter = pAttr->GetSubsFontConverter( nFontConverterFlags )) ||
//UNUSED2008-05                  pAttr->IsSymbolFont() )
//UNUSED2008-05          {
//UNUSED2008-05              ScColumnIterator aCellIter( this, nStt, nEnd );
//UNUSED2008-05              SCROW nRow;
//UNUSED2008-05              ScBaseCell* pCell;
//UNUSED2008-05              while ( aCellIter.Next( nRow, pCell ) )
//UNUSED2008-05              {
//UNUSED2008-05                  if ( pCell->GetCellType() == CELLTYPE_STRING )
//UNUSED2008-05                  {
//UNUSED2008-05                      List& rList = pDocument->GetLoadedSymbolStringCellsList();
//UNUSED2008-05                      if (!bListInitialized)
//UNUSED2008-05                      {
//UNUSED2008-05                          pCurrentEntry = (ScSymbolStringCellEntry*)rList.First();
//UNUSED2008-05                          bListInitialized = sal_True;
//UNUSED2008-05                      }
//UNUSED2008-05
//UNUSED2008-05                      while ( pCurrentEntry && pCurrentEntry->nRow < nRow )
//UNUSED2008-05                          pCurrentEntry = (ScSymbolStringCellEntry*)rList.Next();
//UNUSED2008-05
//UNUSED2008-05                      if ( pCurrentEntry && pCurrentEntry->nRow == nRow )
//UNUSED2008-05                      {
//UNUSED2008-05                          //  found
//UNUSED2008-05                      }
//UNUSED2008-05                      else
//UNUSED2008-05                      {
//UNUSED2008-05                          //  not in list -> convert and put into list
//UNUSED2008-05
//UNUSED2008-05                          ScStringCell* pStrCell = (ScStringCell*)pCell;
//UNUSED2008-05                          String aOldStr;
//UNUSED2008-05                          pStrCell->GetString( aOldStr );
//UNUSED2008-05
//UNUSED2008-05                          //  convert back to stream character set (get original data)
//UNUSED2008-05                          ByteString aByteStr( aOldStr, eStreamCharSet );
//UNUSED2008-05
//UNUSED2008-05                          //  convert using symbol encoding, as for CELLTYPE_SYMBOLS cells
//UNUSED2008-05                          String aNewStr( aByteStr, RTL_TEXTENCODING_SYMBOL );
//UNUSED2008-05                          pStrCell->SetString( aNewStr );
//UNUSED2008-05
//UNUSED2008-05                          ScSymbolStringCellEntry * pEntry = new ScSymbolStringCellEntry;
//UNUSED2008-05                          pEntry->pCell = pStrCell;
//UNUSED2008-05                          pEntry->nRow = nRow;
//UNUSED2008-05
//UNUSED2008-05                          if ( pCurrentEntry )
//UNUSED2008-05                              rList.Insert( pEntry );     // before current entry - pCurrentEntry stays valid
//UNUSED2008-05                          else
//UNUSED2008-05                              rList.Insert( pEntry, LIST_APPEND );    // append if already behind last entry
//UNUSED2008-05                      }
//UNUSED2008-05                  }
//UNUSED2008-05              }
//UNUSED2008-05          }
//UNUSED2008-05
//UNUSED2008-05          pAttr = aAttrIter.Next( nStt, nEnd );
//UNUSED2008-05      }
//UNUSED2008-05  }

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

									//	GetNeededSize: optimale Hoehe / Breite in Pixeln

long ScColumn::GetNeededSize( SCROW nRow, OutputDevice* pDev,
							  double nPPTX, double nPPTY,
							  const Fraction& rZoomX, const Fraction& rZoomY,
							  sal_Bool bWidth, const ScNeededSizeOptions& rOptions )
{
	long nValue=0;
	SCSIZE nIndex;
	double nPPT = bWidth ? nPPTX : nPPTY;
	if (Search(nRow,nIndex))
	{
        ScBaseCell* pCell = pItems[nIndex].pCell;
		const ScPatternAttr* pPattern = rOptions.pPattern;
		if (!pPattern)
			pPattern = pAttrArray->GetPattern( nRow );

		//		zusammengefasst?
		//		Merge nicht in bedingter Formatierung

		const ScMergeAttr*		pMerge = (const ScMergeAttr*)&pPattern->GetItem(ATTR_MERGE);
		const ScMergeFlagAttr*	pFlag = (const ScMergeFlagAttr*)&pPattern->GetItem(ATTR_MERGE_FLAG);

		if ( bWidth )
		{
			if ( pFlag->IsHorOverlapped() )
				return 0;
			if ( rOptions.bSkipMerged && pMerge->GetColMerge() > 1 )
				return 0;
		}
		else
		{
			if ( pFlag->IsVerOverlapped() )
				return 0;
			if ( rOptions.bSkipMerged && pMerge->GetRowMerge() > 1 )
				return 0;
		}

		//		bedingte Formatierung
		const SfxItemSet* pCondSet = NULL;
		if ( ((const SfxUInt32Item&)pPattern->GetItem(ATTR_CONDITIONAL)).GetValue() )
			pCondSet = pDocument->GetCondResult( nCol, nRow, nTab );

		//	Zeilenumbruch?

		const SfxPoolItem* pCondItem;
		SvxCellHorJustify eHorJust;
		if (pCondSet &&
				pCondSet->GetItemState(ATTR_HOR_JUSTIFY, sal_True, &pCondItem) == SFX_ITEM_SET)
			eHorJust = (SvxCellHorJustify)((const SvxHorJustifyItem*)pCondItem)->GetValue();
		else
			eHorJust = (SvxCellHorJustify)((const SvxHorJustifyItem&)
											pPattern->GetItem( ATTR_HOR_JUSTIFY )).GetValue();
        bool bBreak;
		if ( eHorJust == SVX_HOR_JUSTIFY_BLOCK )
            bBreak = true;
		else if ( pCondSet &&
					pCondSet->GetItemState(ATTR_LINEBREAK, sal_True, &pCondItem) == SFX_ITEM_SET)
			bBreak = ((const SfxBoolItem*)pCondItem)->GetValue();
		else
			bBreak = ((const SfxBoolItem&)pPattern->GetItem(ATTR_LINEBREAK)).GetValue();

        SvNumberFormatter* pFormatter = pDocument->GetFormatTable();
        sal_uLong nFormat = pPattern->GetNumberFormat( pFormatter, pCondSet );
        // #i111387# #o11817313# disable automatic line breaks only for "General" number format
        if ( bBreak && pCell->HasValueData() && ( nFormat % SV_COUNTRY_LANGUAGE_OFFSET ) == 0 )
        {
            // also take formula result type into account for number format
            if ( pCell->GetCellType() != CELLTYPE_FORMULA ||
                 ( static_cast<ScFormulaCell*>(pCell)->GetStandardFormat(*pFormatter, nFormat) % SV_COUNTRY_LANGUAGE_OFFSET ) == 0 )
                bBreak = false;
        }

		//	get other attributes from pattern and conditional formatting

        SvxCellOrientation eOrient = pPattern->GetCellOrientation( pCondSet );
		sal_Bool bAsianVertical = ( eOrient == SVX_ORIENTATION_STACKED &&
				((const SfxBoolItem&)pPattern->GetItem( ATTR_VERTICAL_ASIAN, pCondSet )).GetValue() );
		if ( bAsianVertical )
            bBreak = false;

		if ( bWidth && bBreak )		// after determining bAsianVertical (bBreak may be reset)
			return 0;

		long nRotate = 0;
		SvxRotateMode eRotMode = SVX_ROTATE_MODE_STANDARD;
		if ( eOrient == SVX_ORIENTATION_STANDARD )
		{
			if (pCondSet &&
					pCondSet->GetItemState(ATTR_ROTATE_VALUE, sal_True, &pCondItem) == SFX_ITEM_SET)
				nRotate = ((const SfxInt32Item*)pCondItem)->GetValue();
			else
				nRotate = ((const SfxInt32Item&)pPattern->GetItem(ATTR_ROTATE_VALUE)).GetValue();
			if ( nRotate )
			{
				if (pCondSet &&
						pCondSet->GetItemState(ATTR_ROTATE_MODE, sal_True, &pCondItem) == SFX_ITEM_SET)
					eRotMode = (SvxRotateMode)((const SvxRotateModeItem*)pCondItem)->GetValue();
				else
					eRotMode = (SvxRotateMode)((const SvxRotateModeItem&)
												pPattern->GetItem(ATTR_ROTATE_MODE)).GetValue();

				if ( nRotate == 18000 )
					eRotMode = SVX_ROTATE_MODE_STANDARD;	// keinen Ueberlauf
			}
		}

        if ( eHorJust == SVX_HOR_JUSTIFY_REPEAT )
        {
            // ignore orientation/rotation if "repeat" is active
            eOrient = SVX_ORIENTATION_STANDARD;
            nRotate = 0;
            bAsianVertical = sal_False;
        }

		const SvxMarginItem* pMargin;
		if (pCondSet &&
				pCondSet->GetItemState(ATTR_MARGIN, sal_True, &pCondItem) == SFX_ITEM_SET)
			pMargin = (const SvxMarginItem*) pCondItem;
		else
			pMargin = (const SvxMarginItem*) &pPattern->GetItem(ATTR_MARGIN);
		sal_uInt16 nIndent = 0;
		if ( eHorJust == SVX_HOR_JUSTIFY_LEFT )
		{
			if (pCondSet &&
					pCondSet->GetItemState(ATTR_INDENT, sal_True, &pCondItem) == SFX_ITEM_SET)
				nIndent = ((const SfxUInt16Item*)pCondItem)->GetValue();
			else
				nIndent = ((const SfxUInt16Item&)pPattern->GetItem(ATTR_INDENT)).GetValue();
		}

		sal_uInt8 nScript = pDocument->GetScriptType( nCol, nRow, nTab, pCell );
		if (nScript == 0) nScript = ScGlobal::GetDefaultScriptType();

		//	also call SetFont for edit cells, because bGetFont may be set only once
		//	bGetFont is set also if script type changes
		if (rOptions.bGetFont)
		{
			Fraction aFontZoom = ( eOrient == SVX_ORIENTATION_STANDARD ) ? rZoomX : rZoomY;
			Font aFont;
			// font color doesn't matter here
			pPattern->GetFont( aFont, SC_AUTOCOL_BLACK, pDev, &aFontZoom, pCondSet, nScript );
			pDev->SetFont(aFont);
		}

		sal_Bool bAddMargin = sal_True;
        CellType eCellType = pCell->GetCellType();

		sal_Bool bEditEngine = ( eCellType == CELLTYPE_EDIT ||
								eOrient == SVX_ORIENTATION_STACKED ||
								IsAmbiguousScript( nScript ) ||
                                ((eCellType == CELLTYPE_FORMULA) && ((ScFormulaCell*)pCell)->IsMultilineResult()) );

		if (!bEditEngine)									// direkte Ausgabe
		{
			String aValStr;
			Color* pColor;
			ScCellFormat::GetString( pCell, nFormat, aValStr, &pColor,
										*pFormatter,
										sal_True, rOptions.bFormula, ftCheck );
			if (aValStr.Len())
			{
				//	SetFont ist nach oben verschoben

				Size aSize( pDev->GetTextWidth( aValStr ), pDev->GetTextHeight() );
				if ( eOrient != SVX_ORIENTATION_STANDARD )
				{
					long nTemp = aSize.Width();
					aSize.Width() = aSize.Height();
					aSize.Height() = nTemp;
				}
				else if ( nRotate )
				{
					//!	unterschiedliche Skalierung X/Y beruecksichtigen

					double nRealOrient = nRotate * F_PI18000;	// nRotate sind 1/100 Grad
					double nCosAbs = fabs( cos( nRealOrient ) );
					double nSinAbs = fabs( sin( nRealOrient ) );
					long nHeight = (long)( aSize.Height() * nCosAbs + aSize.Width() * nSinAbs );
					long nWidth;
					if ( eRotMode == SVX_ROTATE_MODE_STANDARD )
						nWidth  = (long)( aSize.Width() * nCosAbs + aSize.Height() * nSinAbs );
					else if ( rOptions.bTotalSize )
					{
						nWidth = (long) ( pDocument->GetColWidth( nCol,nTab ) * nPPT );
						bAddMargin = sal_False;
						//	nur nach rechts:
						//!	unterscheiden nach Ausrichtung oben/unten (nur Text/ganze Hoehe)
						if ( pPattern->GetRotateDir( pCondSet ) == SC_ROTDIR_RIGHT )
							nWidth += (long)( pDocument->GetRowHeight( nRow,nTab ) *
												nPPT * nCosAbs / nSinAbs );
					}
					else
						nWidth  = (long)( aSize.Height() / nSinAbs );	//! begrenzen?

					if ( bBreak && !rOptions.bTotalSize )
					{
						//	#47744# limit size for line break
						long nCmp = pDev->GetFont().GetSize().Height() * SC_ROT_BREAK_FACTOR;
						if ( nHeight > nCmp )
							nHeight = nCmp;
					}

					aSize = Size( nWidth, nHeight );
				}
				nValue = bWidth ? aSize.Width() : aSize.Height();

				if ( bAddMargin )
				{
					if (bWidth)
					{
						nValue += (long) ( pMargin->GetLeftMargin() * nPPT ) +
								  (long) ( pMargin->GetRightMargin() * nPPT );
						if ( nIndent )
							nValue += (long) ( nIndent * nPPT );
					}
					else
						nValue += (long) ( pMargin->GetTopMargin() * nPPT ) +
								  (long) ( pMargin->GetBottomMargin() * nPPT );
				}

												//	Zeilenumbruch ausgefuehrt ?

				if ( bBreak && !bWidth )
				{
					//	Test mit EditEngine zur Sicherheit schon bei 90%
					//	(wegen Rundungsfehlern und weil EditEngine teilweise anders formatiert)

					long nDocPixel = (long) ( ( pDocument->GetColWidth( nCol,nTab ) -
										pMargin->GetLeftMargin() - pMargin->GetRightMargin() -
										nIndent )
										* nPPT );
					nDocPixel = (nDocPixel * 9) / 10;			// zur Sicherheit
					if ( aSize.Width() > nDocPixel )
						bEditEngine = sal_True;
				}
			}
		}

		if (bEditEngine)
		{
			//	der Font wird bei !bEditEngine nicht jedesmal neu gesetzt
			Font aOldFont = pDev->GetFont();

			MapMode aHMMMode( MAP_100TH_MM, Point(), rZoomX, rZoomY );

			// am Dokument speichern ?
			ScFieldEditEngine* pEngine = pDocument->CreateFieldEditEngine();

			pEngine->SetUpdateMode( sal_False );
            sal_Bool bTextWysiwyg = ( pDev->GetOutDevType() == OUTDEV_PRINTER );
            sal_uInt32 nCtrl = pEngine->GetControlWord();
            if ( bTextWysiwyg )
                nCtrl |= EE_CNTRL_FORMAT100;
            else
                nCtrl &= ~EE_CNTRL_FORMAT100;
            pEngine->SetControlWord( nCtrl );
			MapMode aOld = pDev->GetMapMode();
			pDev->SetMapMode( aHMMMode );
			pEngine->SetRefDevice( pDev );
            pDocument->ApplyAsianEditSettings( *pEngine );
			SfxItemSet* pSet = new SfxItemSet( pEngine->GetEmptyItemSet() );
			pPattern->FillEditItemSet( pSet, pCondSet );

//			no longer needed, are setted with the text (is faster)
//			pEngine->SetDefaults( pSet );

			if ( ((const SfxBoolItem&)pSet->Get(EE_PARA_HYPHENATE)).GetValue() ) {

				com::sun::star::uno::Reference<com::sun::star::linguistic2::XHyphenator> xXHyphenator( LinguMgr::GetHyphenator() );
                pEngine->SetHyphenator( xXHyphenator );
            }

			Size aPaper = Size( 1000000, 1000000 );
			if ( eOrient==SVX_ORIENTATION_STACKED && !bAsianVertical )
				aPaper.Width() = 1;
			else if (bBreak)
			{
				double fWidthFactor = nPPTX;
				if ( bTextWysiwyg )
				{
					//	#95593# if text is formatted for printer, don't use PixelToLogic,
					//	to ensure the exact same paper width (and same line breaks) as in
					//	ScEditUtil::GetEditArea, used for output.

					fWidthFactor = HMM_PER_TWIPS;
				}

				// use original width for hidden columns:
				long nDocWidth = (long) ( pDocument->GetOriginalWidth(nCol,nTab) * fWidthFactor );
				SCCOL nColMerge = pMerge->GetColMerge();
				if (nColMerge > 1)
					for (SCCOL nColAdd=1; nColAdd<nColMerge; nColAdd++)
						nDocWidth += (long) ( pDocument->GetColWidth(nCol+nColAdd,nTab) * fWidthFactor );
				nDocWidth -= (long) ( pMargin->GetLeftMargin() * fWidthFactor )
						   + (long) ( pMargin->GetRightMargin() * fWidthFactor )
						   + 1; 	// Ausgabebereich ist Breite-1 Pixel (wegen Gitterlinien)
				if ( nIndent )
					nDocWidth -= (long) ( nIndent * fWidthFactor );

				// space for AutoFilter button:  20 * nZoom/100
				if ( pFlag->HasAutoFilter() && !bTextWysiwyg )
					nDocWidth -= (rZoomX.GetNumerator()*20)/rZoomX.GetDenominator();

				aPaper.Width() = nDocWidth;

				if ( !bTextWysiwyg )
					aPaper = pDev->PixelToLogic( aPaper, aHMMMode );
			}
			pEngine->SetPaperSize(aPaper);

			if ( pCell->GetCellType() == CELLTYPE_EDIT )
			{
				const EditTextObject* pData;
				((ScEditCell*)pCell)->GetData(pData);
				pEngine->SetTextNewDefaults(*pData, pSet);
			}
			else
			{
				Color* pColor;
				String aString;
				ScCellFormat::GetString( pCell, nFormat, aString, &pColor,
											*pFormatter,
											sal_True, rOptions.bFormula, ftCheck );
				if (aString.Len())
					pEngine->SetTextNewDefaults(aString, pSet);
				else
					pEngine->SetDefaults(pSet);
			}

			sal_Bool bEngineVertical = pEngine->IsVertical();
			pEngine->SetVertical( bAsianVertical );
			pEngine->SetUpdateMode( sal_True );

			sal_Bool bEdWidth = bWidth;
			if ( eOrient != SVX_ORIENTATION_STANDARD && eOrient != SVX_ORIENTATION_STACKED )
				bEdWidth = !bEdWidth;
			if ( nRotate )
			{
				//!	unterschiedliche Skalierung X/Y beruecksichtigen

				Size aSize( pEngine->CalcTextWidth(), pEngine->GetTextHeight() );
				double nRealOrient = nRotate * F_PI18000;	// nRotate sind 1/100 Grad
				double nCosAbs = fabs( cos( nRealOrient ) );
				double nSinAbs = fabs( sin( nRealOrient ) );
				long nHeight = (long)( aSize.Height() * nCosAbs + aSize.Width() * nSinAbs );
				long nWidth;
				if ( eRotMode == SVX_ROTATE_MODE_STANDARD )
					nWidth  = (long)( aSize.Width() * nCosAbs + aSize.Height() * nSinAbs );
				else if ( rOptions.bTotalSize )
				{
					nWidth = (long) ( pDocument->GetColWidth( nCol,nTab ) * nPPT );
					bAddMargin = sal_False;
					if ( pPattern->GetRotateDir( pCondSet ) == SC_ROTDIR_RIGHT )
						nWidth += (long)( pDocument->GetRowHeight( nRow,nTab ) *
											nPPT * nCosAbs / nSinAbs );
				}
				else
					nWidth  = (long)( aSize.Height() / nSinAbs );	//! begrenzen?
				aSize = Size( nWidth, nHeight );

				Size aPixSize = pDev->LogicToPixel( aSize, aHMMMode );
				if ( bEdWidth )
					nValue = aPixSize.Width();
				else
				{
					nValue = aPixSize.Height();

					if ( bBreak && !rOptions.bTotalSize )
					{
						//	#47744# limit size for line break
						long nCmp = aOldFont.GetSize().Height() * SC_ROT_BREAK_FACTOR;
						if ( nValue > nCmp )
							nValue = nCmp;
					}
				}
			}
			else if ( bEdWidth )
			{
				if (bBreak)
					nValue = 0;
				else
					nValue = pDev->LogicToPixel(Size( pEngine->CalcTextWidth(), 0 ),
										aHMMMode).Width();
			}
			else			// Hoehe
			{
				nValue = pDev->LogicToPixel(Size( 0, pEngine->GetTextHeight() ),
									aHMMMode).Height();

                // With non-100% zoom and several lines or paragraphs, don't shrink below the result with FORMAT100 set
                if ( !bTextWysiwyg && ( rZoomY.GetNumerator() != 1 || rZoomY.GetDenominator() != 1 ) &&
                     ( pEngine->GetParagraphCount() > 1 || ( bBreak && pEngine->GetLineCount(0) > 1 ) ) )
                {
                    pEngine->SetControlWord( nCtrl | EE_CNTRL_FORMAT100 );
                    pEngine->QuickFormatDoc( sal_True );
                    long nSecondValue = pDev->LogicToPixel(Size( 0, pEngine->GetTextHeight() ), aHMMMode).Height();
                    if ( nSecondValue > nValue )
                        nValue = nSecondValue;
                }
			}

			if ( nValue && bAddMargin )
			{
				if (bWidth)
				{
					nValue += (long) ( pMargin->GetLeftMargin() * nPPT ) +
							  (long) ( pMargin->GetRightMargin() * nPPT );
					if (nIndent)
						nValue += (long) ( nIndent * nPPT );
				}
				else
				{
					nValue += (long) ( pMargin->GetTopMargin() * nPPT ) +
							  (long) ( pMargin->GetBottomMargin() * nPPT );

					if ( bAsianVertical && pDev->GetOutDevType() != OUTDEV_PRINTER )
					{
						//	add 1pt extra (default margin value) for line breaks with SetVertical
						nValue += (long) ( 20 * nPPT );
					}
				}
			}

			//	EditEngine is cached and re-used, so the old vertical flag must be restored
			pEngine->SetVertical( bEngineVertical );

			pDocument->DisposeFieldEditEngine(pEngine);

			pDev->SetMapMode( aOld );
			pDev->SetFont( aOldFont );
		}

		if (bWidth)
		{
			//		Platz fuer Autofilter-Button
			//		20 * nZoom/100
			//		bedingte Formatierung hier nicht interessant

			sal_Int16 nFlags = ((const ScMergeFlagAttr&)pPattern->GetItem(ATTR_MERGE_FLAG)).GetValue();
			if (nFlags & SC_MF_AUTO)
				nValue += (rZoomX.GetNumerator()*20)/rZoomX.GetDenominator();
		}
	}
	return nValue;
}

long ScColumn::GetSimpleTextNeededSize( SCSIZE nIndex, OutputDevice* pDev,
		sal_Bool bWidth )
{
	long nValue=0;
	if ( nIndex < nCount )
	{
		SCROW nRow = pItems[nIndex].nRow;
		const ScPatternAttr* pPattern = pAttrArray->GetPattern( nRow );
		ScBaseCell* pCell = pItems[nIndex].pCell;
		String aValStr;
		Color* pColor;
		SvNumberFormatter* pFormatter = pDocument->GetFormatTable();
		sal_uLong nFormat = pPattern->GetNumberFormat( pFormatter );
		ScCellFormat::GetString( pCell, nFormat, aValStr, &pColor,
									*pFormatter, sal_True, sal_False, ftCheck );
		if ( aValStr.Len() )
		{
			if ( bWidth )
				nValue = pDev->GetTextWidth( aValStr );
			else
				nValue = pDev->GetTextHeight();
		}
	}
	return nValue;
}

sal_uInt16 ScColumn::GetOptimalColWidth( OutputDevice* pDev, double nPPTX, double nPPTY,
										const Fraction& rZoomX, const Fraction& rZoomY,
										sal_Bool bFormula, sal_uInt16 nOldWidth,
										const ScMarkData* pMarkData,
										sal_Bool bSimpleTextImport )
{
	if (nCount == 0)
		return nOldWidth;

	sal_uInt16	nWidth = (sal_uInt16) (nOldWidth * nPPTX);
	sal_Bool	bFound = sal_False;

	SCSIZE nIndex;
	ScMarkedDataIter aDataIter(this, pMarkData, sal_True);
	if ( bSimpleTextImport )
	{	// alles eins bis auf NumberFormate
		const ScPatternAttr* pPattern = GetPattern( 0 );
		Font aFont;
		// font color doesn't matter here
		pPattern->GetFont( aFont, SC_AUTOCOL_BLACK, pDev, &rZoomX, NULL );
		pDev->SetFont( aFont );
		const SvxMarginItem* pMargin = (const SvxMarginItem*) &pPattern->GetItem(ATTR_MARGIN);
		long nMargin = (long) ( pMargin->GetLeftMargin() * nPPTX ) +
						(long) ( pMargin->GetRightMargin() * nPPTX );

		while (aDataIter.Next( nIndex ))
		{
			sal_uInt16 nThis = (sal_uInt16) (GetSimpleTextNeededSize( nIndex, pDev,
				sal_True ) + nMargin);
			if (nThis)
			{
				if (nThis>nWidth || !bFound)
				{
					nWidth = nThis;
					bFound = sal_True;
				}
			}
		}
	}
	else
	{
		ScNeededSizeOptions aOptions;
		aOptions.bFormula = bFormula;
		const ScPatternAttr* pOldPattern = NULL;
		sal_uInt8 nOldScript = 0;

		while (aDataIter.Next( nIndex ))
		{
			SCROW nRow = pItems[nIndex].nRow;

			sal_uInt8 nScript = pDocument->GetScriptType( nCol, nRow, nTab, pItems[nIndex].pCell );
			if (nScript == 0) nScript = ScGlobal::GetDefaultScriptType();

			const ScPatternAttr* pPattern = GetPattern( nRow );
			aOptions.pPattern = pPattern;
			aOptions.bGetFont = (pPattern != pOldPattern || nScript != nOldScript);
			sal_uInt16 nThis = (sal_uInt16) GetNeededSize( nRow, pDev, nPPTX, nPPTY,
				rZoomX, rZoomY, sal_True, aOptions );
			pOldPattern = pPattern;
			if (nThis)
			{
				if (nThis>nWidth || !bFound)
				{
					nWidth = nThis;
					bFound = sal_True;
				}
			}
		}
	}

	if (bFound)
	{
		nWidth += 2;
		sal_uInt16 nTwips = (sal_uInt16) (nWidth / nPPTX);
		return nTwips;
	}
	else
		return nOldWidth;
}

sal_uInt16 lcl_GetAttribHeight( const ScPatternAttr& rPattern, sal_uInt16 nFontHeightId )
{
	sal_uInt16 nHeight = (sal_uInt16) ((const SvxFontHeightItem&) rPattern.GetItem(nFontHeightId)).GetHeight();
	const SvxMarginItem* pMargin = (const SvxMarginItem*) &rPattern.GetItem(ATTR_MARGIN);
	nHeight += nHeight / 5;
	//	gibt bei 10pt 240

	if ( ((const SvxEmphasisMarkItem&)rPattern.
			GetItem(ATTR_FONT_EMPHASISMARK)).GetEmphasisMark() != EMPHASISMARK_NONE )
	{
		//	add height for emphasis marks
		//!	font metrics should be used instead
		nHeight += nHeight / 4;
	}

	if ( nHeight + 240 > ScGlobal::nDefFontHeight )
	{
        nHeight = sal::static_int_cast<sal_uInt16>( nHeight + ScGlobal::nDefFontHeight );
		nHeight -= 240;
	}

	//	Standard-Hoehe: TextHeight + Raender - 23
	//	-> 257 unter Windows

	if (nHeight > STD_ROWHEIGHT_DIFF)
		nHeight -= STD_ROWHEIGHT_DIFF;

	nHeight += pMargin->GetTopMargin() + pMargin->GetBottomMargin();

	return nHeight;
}

//	pHeight in Twips
//	nMinHeight, nMinStart zur Optimierung: ab nRow >= nMinStart ist mindestens nMinHeight
//	(wird nur bei bStdAllowed ausgewertet)

void ScColumn::GetOptimalHeight( SCROW nStartRow, SCROW nEndRow, sal_uInt16* pHeight,
								OutputDevice* pDev,
								double nPPTX, double nPPTY,
								const Fraction& rZoomX, const Fraction& rZoomY,
								sal_Bool bShrink, sal_uInt16 nMinHeight, SCROW nMinStart )
{
	ScAttrIterator aIter( pAttrArray, nStartRow, nEndRow );

	SCROW nStart = -1;
	SCROW nEnd = -1;
	SCROW nEditPos = 0;
	SCROW nNextEnd = 0;

	//	bei bedingter Formatierung werden immer die einzelnen Zellen angesehen

	const ScPatternAttr* pPattern = aIter.Next(nStart,nEnd);
	while ( pPattern )
	{
		const ScMergeAttr*		pMerge = (const ScMergeAttr*)&pPattern->GetItem(ATTR_MERGE);
		const ScMergeFlagAttr*	pFlag = (const ScMergeFlagAttr*)&pPattern->GetItem(ATTR_MERGE_FLAG);
		if ( pMerge->GetRowMerge() > 1 || pFlag->IsOverlapped() )
		{
			//	nix - vertikal bei der zusammengefassten und den ueberdeckten,
			//		  horizontal nur bei den ueberdeckten (unsichtbaren) -
			//		  eine nur horizontal zusammengefasste wird aber beruecksichtigt
		}
		else
		{
            SCROW nRow = 0;
            sal_Bool bStdAllowed = (pPattern->GetCellOrientation() == SVX_ORIENTATION_STANDARD);
			sal_Bool bStdOnly = sal_False;
			if (bStdAllowed)
			{
				sal_Bool bBreak = ((SfxBoolItem&)pPattern->GetItem(ATTR_LINEBREAK)).GetValue() ||
								((SvxCellHorJustify)((const SvxHorJustifyItem&)pPattern->
									GetItem( ATTR_HOR_JUSTIFY )).GetValue() ==
									SVX_HOR_JUSTIFY_BLOCK);
				bStdOnly = !bBreak;

				// bedingte Formatierung: Zellen durchgehen
				if ( bStdOnly && ((const SfxUInt32Item&)pPattern->
									GetItem(ATTR_CONDITIONAL)).GetValue() )
					bStdOnly = sal_False;

				// gedrehter Text: Zellen durchgehen
				if ( bStdOnly && ((const SfxInt32Item&)pPattern->
									GetItem(ATTR_ROTATE_VALUE)).GetValue() )
					bStdOnly = sal_False;
			}

			if (bStdOnly)
				if (HasEditCells(nStart,nEnd,nEditPos))		// includes mixed script types
				{
					if (nEditPos == nStart)
					{
						bStdOnly = sal_False;
						if (nEnd > nEditPos)
							nNextEnd = nEnd;
						nEnd = nEditPos;				// einzeln ausrechnen
						bStdAllowed = sal_False;			// wird auf jeden Fall per Zelle berechnet
					}
					else
					{
						nNextEnd = nEnd;
						nEnd = nEditPos - 1;			// Standard - Teil
					}
				}

			if (bStdAllowed)
			{
				sal_uInt16 nLatHeight = 0;
				sal_uInt16 nCjkHeight = 0;
				sal_uInt16 nCtlHeight = 0;
				sal_uInt16 nDefHeight;
				sal_uInt8 nDefScript = ScGlobal::GetDefaultScriptType();
				if ( nDefScript == SCRIPTTYPE_ASIAN )
					nDefHeight = nCjkHeight = lcl_GetAttribHeight( *pPattern, ATTR_CJK_FONT_HEIGHT );
				else if ( nDefScript == SCRIPTTYPE_COMPLEX )
					nDefHeight = nCtlHeight = lcl_GetAttribHeight( *pPattern, ATTR_CTL_FONT_HEIGHT );
				else
					nDefHeight = nLatHeight = lcl_GetAttribHeight( *pPattern, ATTR_FONT_HEIGHT );

				//	if everything below is already larger, the loop doesn't have to
				//	be run again
				SCROW nStdEnd = nEnd;
				if ( nDefHeight <= nMinHeight && nStdEnd >= nMinStart )
					nStdEnd = (nMinStart>0) ? nMinStart-1 : 0;

				for (nRow=nStart; nRow<=nStdEnd; nRow++)
					if (nDefHeight > pHeight[nRow-nStartRow])
						pHeight[nRow-nStartRow] = nDefHeight;

				if ( bStdOnly )
				{
					//	if cells are not handled individually below,
					//	check for cells with different script type

					SCSIZE nIndex;
					Search(nStart,nIndex);
					while ( nIndex < nCount && (nRow=pItems[nIndex].nRow) <= nEnd )
					{
						sal_uInt8 nScript = pDocument->GetScriptType( nCol, nRow, nTab, pItems[nIndex].pCell );
						if ( nScript != nDefScript )
						{
							if ( nScript == SCRIPTTYPE_ASIAN )
							{
								if ( nCjkHeight == 0 )
									nCjkHeight = lcl_GetAttribHeight( *pPattern, ATTR_CJK_FONT_HEIGHT );
								if (nCjkHeight > pHeight[nRow-nStartRow])
									pHeight[nRow-nStartRow] = nCjkHeight;
							}
							else if ( nScript == SCRIPTTYPE_COMPLEX )
							{
								if ( nCtlHeight == 0 )
									nCtlHeight = lcl_GetAttribHeight( *pPattern, ATTR_CTL_FONT_HEIGHT );
								if (nCtlHeight > pHeight[nRow-nStartRow])
									pHeight[nRow-nStartRow] = nCtlHeight;
							}
							else
							{
								if ( nLatHeight == 0 )
									nLatHeight = lcl_GetAttribHeight( *pPattern, ATTR_FONT_HEIGHT );
								if (nLatHeight > pHeight[nRow-nStartRow])
									pHeight[nRow-nStartRow] = nLatHeight;
							}
						}
						++nIndex;
					}
				}
			}

			if (!bStdOnly)						// belegte Zellen suchen
			{
				ScNeededSizeOptions aOptions;

				SCSIZE nIndex;
				Search(nStart,nIndex);
				while ( (nIndex < nCount) ? ((nRow=pItems[nIndex].nRow) <= nEnd) : sal_False )
				{
					//	Zellhoehe nur berechnen, wenn sie spaeter auch gebraucht wird (#37928#)

					if ( bShrink || !(pDocument->GetRowFlags(nRow, nTab) & CR_MANUALSIZE) )
					{
						aOptions.pPattern = pPattern;
						sal_uInt16 nHeight = (sal_uInt16)
								( GetNeededSize( nRow, pDev, nPPTX, nPPTY,
													rZoomX, rZoomY, sal_False, aOptions ) / nPPTY );
						if (nHeight > pHeight[nRow-nStartRow])
							pHeight[nRow-nStartRow] = nHeight;
					}
					++nIndex;
				}
			}
		}

		if (nNextEnd > 0)
		{
			nStart = nEnd + 1;
			nEnd = nNextEnd;
			nNextEnd = 0;
		}
		else
			pPattern = aIter.Next(nStart,nEnd);
	}
}

sal_Bool ScColumn::GetNextSpellingCell(SCROW& nRow, sal_Bool bInSel, const ScMarkData& rData) const
{
	sal_Bool bStop = sal_False;
	CellType eCellType;
	SCSIZE nIndex;
	if (!bInSel && Search(nRow, nIndex))
	{
		eCellType = GetCellType(nRow);
		if ( (eCellType == CELLTYPE_STRING || eCellType == CELLTYPE_EDIT) &&
			 !(HasAttrib( nRow, nRow, HASATTR_PROTECTED) &&
			   pDocument->IsTabProtected(nTab)) )
				return sal_True;
	}
	while (!bStop)
	{
		if (bInSel)
		{
			nRow = rData.GetNextMarked(nCol, nRow, sal_False);
			if (!ValidRow(nRow))
			{
				nRow = MAXROW+1;
				bStop = sal_True;
			}
			else
			{
				eCellType = GetCellType(nRow);
				if ( (eCellType == CELLTYPE_STRING || eCellType == CELLTYPE_EDIT) &&
					 !(HasAttrib( nRow, nRow, HASATTR_PROTECTED) &&
					   pDocument->IsTabProtected(nTab)) )
						return sal_True;
				else
					nRow++;
			}
		}
		else if (GetNextDataPos(nRow))
		{
			eCellType = GetCellType(nRow);
			if ( (eCellType == CELLTYPE_STRING || eCellType == CELLTYPE_EDIT) &&
				 !(HasAttrib( nRow, nRow, HASATTR_PROTECTED) &&
				   pDocument->IsTabProtected(nTab)) )
					return sal_True;
			else
				nRow++;
		}
		else
		{
			nRow = MAXROW+1;
			bStop = sal_True;
		}
	}
	return sal_False;
}

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

void ScColumn::RemoveAutoSpellObj()
{
	ScTabEditEngine* pEngine = NULL;

	for (SCSIZE i=0; i<nCount; i++)
		if ( pItems[i].pCell->GetCellType() == CELLTYPE_EDIT )
		{
			ScEditCell* pOldCell = (ScEditCell*) pItems[i].pCell;
			const EditTextObject* pData = pOldCell->GetData();
			//	keine Abfrage auf HasOnlineSpellErrors, damit es auch
			//	nach dem Laden funktioniert

			//	Fuer den Test auf harte Formatierung (ScEditAttrTester) sind die Defaults
			//	in der EditEngine unwichtig. Wenn der Tester spaeter einmal gleiche
			//	Attribute in Default und harter Formatierung erkennen und weglassen sollte,
			//	muessten an der EditEngine zu jeder Zelle die richtigen Defaults gesetzt
			//	werden!

			//	auf Attribute testen
			if ( !pEngine )
				pEngine = new ScTabEditEngine(pDocument);
			pEngine->SetText( *pData );
			ScEditAttrTester aTester( pEngine );
			if ( aTester.NeedsObject() )					// nur Spell-Errors entfernen
			{
				EditTextObject* pNewData = pEngine->CreateTextObject();	// ohne BIGOBJ
				pOldCell->SetData( pNewData, pEngine->GetEditTextObjectPool() );
				delete pNewData;
			}
			else											// String erzeugen
			{
				String aText = ScEditUtil::GetSpaceDelimitedString( *pEngine );
				ScBaseCell* pNewCell = new ScStringCell( aText );
                pNewCell->TakeBroadcaster( pOldCell->ReleaseBroadcaster() );
				pNewCell->TakeNote( pOldCell->ReleaseNote() );
				pItems[i].pCell = pNewCell;
				delete pOldCell;
			}
		}

	delete pEngine;
}

void ScColumn::RemoveEditAttribs( SCROW nStartRow, SCROW nEndRow )
{
	ScFieldEditEngine* pEngine = NULL;

	SCSIZE i;
	Search( nStartRow, i );
	for (; i<nCount && pItems[i].nRow <= nEndRow; i++)
		if ( pItems[i].pCell->GetCellType() == CELLTYPE_EDIT )
		{
			ScEditCell* pOldCell = (ScEditCell*) pItems[i].pCell;
			const EditTextObject* pData = pOldCell->GetData();

			//	Fuer den Test auf harte Formatierung (ScEditAttrTester) sind die Defaults
			//	in der EditEngine unwichtig. Wenn der Tester spaeter einmal gleiche
			//	Attribute in Default und harter Formatierung erkennen und weglassen sollte,
			//	muessten an der EditEngine zu jeder Zelle die richtigen Defaults gesetzt
			//	werden!

			//	auf Attribute testen
			if ( !pEngine )
			{
				//pEngine = new ScTabEditEngine(pDocument);
				pEngine = new ScFieldEditEngine( pDocument->GetEditPool() );
				//	EE_CNTRL_ONLINESPELLING falls schon Fehler drin sind
				pEngine->SetControlWord( pEngine->GetControlWord() | EE_CNTRL_ONLINESPELLING );
                pDocument->ApplyAsianEditSettings( *pEngine );
			}
			pEngine->SetText( *pData );
			sal_uInt16 nParCount = pEngine->GetParagraphCount();
			for (sal_uInt16 nPar=0; nPar<nParCount; nPar++)
			{
				pEngine->QuickRemoveCharAttribs( nPar );
				const SfxItemSet& rOld = pEngine->GetParaAttribs( nPar );
				if ( rOld.Count() )
				{
					SfxItemSet aNew( *rOld.GetPool(), rOld.GetRanges() );	// leer
					pEngine->SetParaAttribs( nPar, aNew );
				}
			}
			//	URL-Felder in Text wandeln (andere gibt's nicht, darum pType=0)
			pEngine->RemoveFields( sal_True );

			sal_Bool bSpellErrors = pEngine->HasOnlineSpellErrors();
			sal_Bool bNeedObject = bSpellErrors || nParCount>1;			// Errors/Absaetze behalten
			//	ScEditAttrTester nicht mehr noetig, Felder sind raus

			if ( bNeedObject )										// bleibt Edit-Zelle
			{
				sal_uLong nCtrl = pEngine->GetControlWord();
				sal_uLong nWantBig = bSpellErrors ? EE_CNTRL_ALLOWBIGOBJS : 0;
				if ( ( nCtrl & EE_CNTRL_ALLOWBIGOBJS ) != nWantBig )
					pEngine->SetControlWord( (nCtrl & ~EE_CNTRL_ALLOWBIGOBJS) | nWantBig );
				EditTextObject* pNewData = pEngine->CreateTextObject();
				pOldCell->SetData( pNewData, pEngine->GetEditTextObjectPool() );
				delete pNewData;
			}
			else											// String erzeugen
			{
				String aText = ScEditUtil::GetSpaceDelimitedString( *pEngine );
				ScBaseCell* pNewCell = new ScStringCell( aText );
                pNewCell->TakeBroadcaster( pOldCell->ReleaseBroadcaster() );
				pNewCell->TakeNote( pOldCell->ReleaseNote() );
				pItems[i].pCell = pNewCell;
				delete pOldCell;
			}
		}

	delete pEngine;
}

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

sal_Bool ScColumn::TestTabRefAbs(SCTAB nTable)
{
	sal_Bool bRet = sal_False;
	if (pItems)
		for (SCSIZE i = 0; i < nCount; i++)
			if ( pItems[i].pCell->GetCellType() == CELLTYPE_FORMULA )
				if (((ScFormulaCell*)pItems[i].pCell)->TestTabRefAbs(nTable))
					bRet = sal_True;
	return bRet;
}

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

ScColumnIterator::ScColumnIterator( const ScColumn* pCol, SCROW nStart, SCROW nEnd ) :
	pColumn( pCol ),
	nTop( nStart ),
	nBottom( nEnd )
{
	pColumn->Search( nTop, nPos );
}

ScColumnIterator::~ScColumnIterator()
{
}

sal_Bool ScColumnIterator::Next( SCROW& rRow, ScBaseCell*& rpCell )
{
	if ( nPos < pColumn->nCount )
	{
		rRow = pColumn->pItems[nPos].nRow;
		if ( rRow <= nBottom )
		{
			rpCell = pColumn->pItems[nPos].pCell;
			++nPos;
			return sal_True;
		}
	}

	rRow = 0;
	rpCell = NULL;
	return sal_False;
}

SCSIZE ScColumnIterator::GetIndex() const			// Index zur letzen abgefragten Zelle
{
	return nPos - 1;		// bei Next ist Pos hochgezaehlt worden
}

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

ScMarkedDataIter::ScMarkedDataIter( const ScColumn* pCol, const ScMarkData* pMarkData,
									sal_Bool bAllIfNone ) :
	pColumn( pCol ),
	pMarkIter( NULL ),
	bNext( sal_True ),
	bAll( bAllIfNone )
{
	if (pMarkData && pMarkData->IsMultiMarked())
		pMarkIter = new ScMarkArrayIter( pMarkData->GetArray() + pCol->GetCol() );
}

ScMarkedDataIter::~ScMarkedDataIter()
{
	delete pMarkIter;
}

sal_Bool ScMarkedDataIter::Next( SCSIZE& rIndex )
{
	sal_Bool bFound = sal_False;
	do
	{
		if (bNext)
		{
			if (!pMarkIter || !pMarkIter->Next( nTop, nBottom ))
			{
				if (bAll)					// ganze Spalte
				{
					nTop	= 0;
					nBottom	= MAXROW;
				}
				else
					return sal_False;
			}
			pColumn->Search( nTop, nPos );
			bNext = sal_False;
			bAll  = sal_False;					// nur beim ersten Versuch
		}

		if ( nPos >= pColumn->nCount )
			return sal_False;

		if ( pColumn->pItems[nPos].nRow <= nBottom )
			bFound = sal_True;
		else
			bNext = sal_True;
	}
	while (!bFound);

	rIndex = nPos++;
	return sal_True;
}

//UNUSED2009-05 sal_uInt16 ScColumn::GetErrorData( SCROW nRow ) const
//UNUSED2009-05 {
//UNUSED2009-05     SCSIZE  nIndex;
//UNUSED2009-05     if (Search(nRow, nIndex))
//UNUSED2009-05     {
//UNUSED2009-05         ScBaseCell* pCell = pItems[nIndex].pCell;
//UNUSED2009-05         switch (pCell->GetCellType())
//UNUSED2009-05         {
//UNUSED2009-05             case CELLTYPE_FORMULA :
//UNUSED2009-05                 return ((ScFormulaCell*)pCell)->GetErrCode();
//UNUSED2009-05 //            break;
//UNUSED2009-05             default:
//UNUSED2009-05             return 0;
//UNUSED2009-05         }
//UNUSED2009-05     }
//UNUSED2009-05     return 0;
//UNUSED2009-05 }

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

sal_Bool ScColumn::IsEmptyData() const
{
	return (nCount == 0);
}

sal_Bool ScColumn::IsEmptyVisData(sal_Bool bNotes) const
{
	if (!pItems || nCount == 0)
		return sal_True;
	else
	{
		sal_Bool bVisData = sal_False;
		SCSIZE i;
		for (i=0; i<nCount && !bVisData; i++)
		{
			ScBaseCell* pCell = pItems[i].pCell;
            if ( pCell->GetCellType() != CELLTYPE_NOTE || (bNotes && pCell->HasNote()) )
				bVisData = sal_True;
		}
		return !bVisData;
	}
}

SCSIZE ScColumn::VisibleCount( SCROW nStartRow, SCROW nEndRow ) const
{
	//	Notizen werden nicht mitgezaehlt

	SCSIZE nVisCount = 0;
	SCSIZE nIndex;
	Search( nStartRow, nIndex );
	while ( nIndex < nCount && pItems[nIndex].nRow <= nEndRow )
	{
		if ( pItems[nIndex].nRow >= nStartRow &&
			 pItems[nIndex].pCell->GetCellType() != CELLTYPE_NOTE )
		{
			++nVisCount;
		}
		++nIndex;
	}
	return nVisCount;
}

SCROW ScColumn::GetLastVisDataPos(sal_Bool bNotes) const
{
	SCROW nRet = 0;
	if (pItems)
	{
		SCSIZE i;
		sal_Bool bFound = sal_False;
		for (i=nCount; i>0 && !bFound; )
		{
			--i;
			ScBaseCell* pCell = pItems[i].pCell;
            if ( pCell->GetCellType() != CELLTYPE_NOTE || (bNotes && pCell->HasNote()) )
			{
				bFound = sal_True;
				nRet = pItems[i].nRow;
			}
		}
	}
	return nRet;
}

SCROW ScColumn::GetFirstVisDataPos(sal_Bool bNotes) const
{
	SCROW nRet = 0;
	if (pItems)
	{
		SCSIZE i;
		sal_Bool bFound = sal_False;
		for (i=0; i<nCount && !bFound; i++)
		{
			ScBaseCell* pCell = pItems[i].pCell;
            if ( pCell->GetCellType() != CELLTYPE_NOTE || (bNotes && pCell->HasNote()) )
			{
				bFound = sal_True;
				nRet = pItems[i].nRow;
			}
		}
	}
	return nRet;
}

sal_Bool ScColumn::HasVisibleDataAt(SCROW nRow) const
{
	SCSIZE nIndex;
	if (Search(nRow, nIndex))
        if (!pItems[nIndex].pCell->IsBlank())
			return sal_True;

	return sal_False;
}

sal_Bool ScColumn::IsEmptyAttr() const
{
	if (pAttrArray)
		return pAttrArray->IsEmpty();
	else
		return sal_True;
}

sal_Bool ScColumn::IsEmpty() const
{
	return (IsEmptyData() && IsEmptyAttr());
}

sal_Bool ScColumn::IsEmptyBlock(SCROW nStartRow, SCROW nEndRow, bool bIgnoreNotes) const
{
	if ( nCount == 0 || !pItems )
		return sal_True;

	SCSIZE nIndex;
	Search( nStartRow, nIndex );
	while ( nIndex < nCount && pItems[nIndex].nRow <= nEndRow )
	{
        if ( !pItems[nIndex].pCell->IsBlank( bIgnoreNotes ) )   // found a cell
			return sal_False;							// not empty
		++nIndex;
	}
	return sal_True;									// no cell found
}

SCSIZE ScColumn::GetEmptyLinesInBlock( SCROW nStartRow, SCROW nEndRow, ScDirection eDir ) const
{
	SCSIZE nLines = 0;
	sal_Bool bFound = sal_False;
	SCSIZE i;
	if (pItems && (nCount > 0))
	{
		if (eDir == DIR_BOTTOM)
		{
			i = nCount;
			while (!bFound && (i > 0))
			{
				i--;
				if ( pItems[i].nRow < nStartRow )
					break;
                bFound = pItems[i].nRow <= nEndRow && !pItems[i].pCell->IsBlank();
			}
			if (bFound)
				nLines = static_cast<SCSIZE>(nEndRow - pItems[i].nRow);
			else
				nLines = static_cast<SCSIZE>(nEndRow - nStartRow);
		}
		else if (eDir == DIR_TOP)
		{
			i = 0;
			while (!bFound && (i < nCount))
			{
				if ( pItems[i].nRow > nEndRow )
					break;
                bFound = pItems[i].nRow >= nStartRow && !pItems[i].pCell->IsBlank();
				i++;
			}
			if (bFound)
				nLines = static_cast<SCSIZE>(pItems[i-1].nRow - nStartRow);
			else
				nLines = static_cast<SCSIZE>(nEndRow - nStartRow);
		}
	}
	else
		nLines = static_cast<SCSIZE>(nEndRow - nStartRow);
	return nLines;
}

SCROW ScColumn::GetFirstDataPos() const
{
    if (nCount)
        return pItems[0].nRow;
    else
        return 0;
}

SCROW ScColumn::GetLastDataPos() const
{
	if (nCount)
		return pItems[nCount-1].nRow;
	else
		return 0;
}

sal_Bool ScColumn::GetPrevDataPos(SCROW& rRow) const
{
	sal_Bool bFound = sal_False;
    SCSIZE i = nCount;
    while (!bFound && (i > 0))
    {
        --i;
        bFound = (pItems[i].nRow < rRow);
        if (bFound)
            rRow = pItems[i].nRow;
    }
    return bFound;
}

sal_Bool ScColumn::GetNextDataPos(SCROW& rRow) const		// greater than rRow
{
    SCSIZE nIndex;
    if (Search( rRow, nIndex ))
        ++nIndex;					// next cell

    sal_Bool bMore = ( nIndex < nCount );
    if ( bMore )
		rRow = pItems[nIndex].nRow;
	return bMore;
}

void ScColumn::FindDataAreaPos(SCROW& rRow, long nMovY) const
{
	if (!nMovY) return;
	sal_Bool bForward = (nMovY>0);

	SCSIZE nIndex;
	sal_Bool bThere = Search(rRow, nIndex);
    if (bThere && pItems[nIndex].pCell->IsBlank())
		bThere = sal_False;

	if (bThere)
	{
		SCROW nLast = rRow;
		SCSIZE nOldIndex = nIndex;
		if (bForward)
		{
			if (nIndex<nCount-1)
			{
				++nIndex;
				while (nIndex<nCount-1 && pItems[nIndex].nRow==nLast+1
                                        && !pItems[nIndex].pCell->IsBlank())
				{
					++nIndex;
					++nLast;
				}
				if (nIndex==nCount-1)
                    if (pItems[nIndex].nRow==nLast+1 && !pItems[nIndex].pCell->IsBlank())
						++nLast;
			}
		}
		else
		{
			if (nIndex>0)
			{
				--nIndex;
				while (nIndex>0 && pItems[nIndex].nRow+1==nLast
                                        && !pItems[nIndex].pCell->IsBlank())
				{
					--nIndex;
					--nLast;
				}
				if (nIndex==0)
                    if (pItems[nIndex].nRow+1==nLast && !pItems[nIndex].pCell->IsBlank())
						--nLast;
			}
		}
		if (nLast==rRow)
		{
			bThere = sal_False;
			nIndex = bForward ? nOldIndex+1 : nOldIndex;
		}
		else
			rRow = nLast;
	}

	if (!bThere)
	{
		if (bForward)
		{
            while (nIndex<nCount && pItems[nIndex].pCell->IsBlank())
				++nIndex;
			if (nIndex<nCount)
				rRow = pItems[nIndex].nRow;
			else
				rRow = MAXROW;
		}
		else
		{
            while (nIndex>0 && pItems[nIndex-1].pCell->IsBlank())
				--nIndex;
			if (nIndex>0)
				rRow = pItems[nIndex-1].nRow;
			else
				rRow = 0;
		}
	}
}

sal_Bool ScColumn::HasDataAt(SCROW nRow) const
{
/*	SCSIZE nIndex;
	return Search( nRow, nIndex );
*/
		//	immer nur sichtbare interessant ?
		//!	dann HasVisibleDataAt raus

	SCSIZE nIndex;
	if (Search(nRow, nIndex))
        if (!pItems[nIndex].pCell->IsBlank())
			return sal_True;

	return sal_False;

}

sal_Bool ScColumn::IsAllAttrEqual( const ScColumn& rCol, SCROW nStartRow, SCROW nEndRow ) const
{
	if (pAttrArray && rCol.pAttrArray)
		return pAttrArray->IsAllEqual( *rCol.pAttrArray, nStartRow, nEndRow );
	else
		return !pAttrArray && !rCol.pAttrArray;
}

sal_Bool ScColumn::IsVisibleAttrEqual( const ScColumn& rCol, SCROW nStartRow, SCROW nEndRow ) const
{
	if (pAttrArray && rCol.pAttrArray)
		return pAttrArray->IsVisibleEqual( *rCol.pAttrArray, nStartRow, nEndRow );
	else
		return !pAttrArray && !rCol.pAttrArray;
}

sal_Bool ScColumn::GetFirstVisibleAttr( SCROW& rFirstRow ) const
{
    if (pAttrArray)
        return pAttrArray->GetFirstVisibleAttr( rFirstRow );
    else
        return sal_False;
}

sal_Bool ScColumn::GetLastVisibleAttr( SCROW& rLastRow ) const
{
    if (pAttrArray)
    {
        // row of last cell is needed
        SCROW nLastData = GetLastVisDataPos( sal_True );    // always including notes, 0 if none

        return pAttrArray->GetLastVisibleAttr( rLastRow, nLastData );
    }
    else
        return sal_False;
}

sal_Bool ScColumn::GetLastAttr( SCROW& rLastRow ) const
{
    if ( pAttrArray )
    {
        // Row of last cell is needed, always including notes, 0 if none.
        SCROW nLastData = GetLastVisDataPos( sal_True );
        return pAttrArray->GetLastAttr( rLastRow, nLastData );
    }
    else
    {
        return sal_False;
    }
}
sal_Bool ScColumn::HasVisibleAttrIn( SCROW nStartRow, SCROW nEndRow ) const
{
	if (pAttrArray)
		return pAttrArray->HasVisibleAttrIn( nStartRow, nEndRow );
	else
		return sal_False;
}

void ScColumn::FindUsed( SCROW nStartRow, SCROW nEndRow, sal_Bool* pUsed ) const
{
    SCROW nRow = 0;
	SCSIZE nIndex;
	Search( nStartRow, nIndex );
	while ( (nIndex < nCount) ? ((nRow=pItems[nIndex].nRow) <= nEndRow) : sal_False )
	{
		pUsed[nRow-nStartRow] = sal_True;
		++nIndex;
	}
}

void ScColumn::StartListening( SvtListener& rLst, SCROW nRow )
{
	SvtBroadcaster* pBC = NULL;
	ScBaseCell* pCell;

	SCSIZE nIndex;
	if (Search(nRow,nIndex))
	{
		pCell = pItems[nIndex].pCell;
		pBC = pCell->GetBroadcaster();
	}
	else
	{
		pCell = new ScNoteCell;
		Insert(nRow, pCell);
	}

	if (!pBC)
	{
		pBC = new SvtBroadcaster;
        pCell->TakeBroadcaster(pBC);
	}
	rLst.StartListening(*pBC);
}

void ScColumn::MoveListeners( SvtBroadcaster& rSource, SCROW nDestRow )
{
	SvtBroadcaster* pBC = NULL;
	ScBaseCell* pCell;

	SCSIZE nIndex;
	if (Search(nDestRow,nIndex))
	{
		pCell = pItems[nIndex].pCell;
		pBC = pCell->GetBroadcaster();
	}
	else
	{
		pCell = new ScNoteCell;
		Insert(nDestRow, pCell);
	}

	if (!pBC)
	{
		pBC = new SvtBroadcaster;
        pCell->TakeBroadcaster(pBC);
	}

    if (rSource.HasListeners())
    {
        SvtListenerIter aIter( rSource);
        for (SvtListener* pLst = aIter.GoStart(); pLst; pLst = aIter.GoNext())
        {
            pLst->StartListening( *pBC);
            pLst->EndListening( rSource);
        }
    }
}

void ScColumn::EndListening( SvtListener& rLst, SCROW nRow )
{
	SCSIZE nIndex;
	if (Search(nRow,nIndex))
	{
		ScBaseCell* pCell = pItems[nIndex].pCell;
		SvtBroadcaster* pBC = pCell->GetBroadcaster();
		if (pBC)
		{
			rLst.EndListening(*pBC);

			if (!pBC->HasListeners())
			{
                if (pCell->IsBlank())
					DeleteAtIndex(nIndex);
				else
                    pCell->DeleteBroadcaster();
			}
		}
//		else
//			DBG_ERROR("ScColumn::EndListening - kein Broadcaster");
	}
//	else
//		DBG_ERROR("ScColumn::EndListening - keine Zelle");
}

void ScColumn::CompileDBFormula()
{
	if (pItems)
		for (SCSIZE i = 0; i < nCount; i++)
		{
			ScBaseCell* pCell = pItems[i].pCell;
			if ( pCell->GetCellType() == CELLTYPE_FORMULA )
				((ScFormulaCell*) pCell)->CompileDBFormula();
		}
}

void ScColumn::CompileDBFormula( sal_Bool bCreateFormulaString )
{
	if (pItems)
		for (SCSIZE i = 0; i < nCount; i++)
		{
			ScBaseCell* pCell = pItems[i].pCell;
			if ( pCell->GetCellType() == CELLTYPE_FORMULA )
				((ScFormulaCell*) pCell)->CompileDBFormula( bCreateFormulaString );
		}
}

void ScColumn::CompileNameFormula( sal_Bool bCreateFormulaString )
{
	if (pItems)
		for (SCSIZE i = 0; i < nCount; i++)
		{
			ScBaseCell* pCell = pItems[i].pCell;
			if ( pCell->GetCellType() == CELLTYPE_FORMULA )
				((ScFormulaCell*) pCell)->CompileNameFormula( bCreateFormulaString );
		}
}

void ScColumn::CompileColRowNameFormula()
{
	if (pItems)
		for (SCSIZE i = 0; i < nCount; i++)
		{
			ScBaseCell* pCell = pItems[i].pCell;
			if ( pCell->GetCellType() == CELLTYPE_FORMULA )
				((ScFormulaCell*) pCell)->CompileColRowNameFormula();
		}
}

void lcl_UpdateSubTotal( ScFunctionData& rData, ScBaseCell* pCell )
{
    double nValue = 0.0;
	sal_Bool bVal = sal_False;
	sal_Bool bCell = sal_True;
	switch (pCell->GetCellType())
	{
		case CELLTYPE_VALUE:
			nValue = ((ScValueCell*)pCell)->GetValue();
			bVal = sal_True;
			break;
		case CELLTYPE_FORMULA:
			{
				if ( rData.eFunc != SUBTOTAL_FUNC_CNT2 )		// da interessiert's nicht
				{
					ScFormulaCell* pFC = (ScFormulaCell*)pCell;
					if ( pFC->GetErrCode() )
					{
						if ( rData.eFunc != SUBTOTAL_FUNC_CNT )	// fuer Anzahl einfach weglassen
							rData.bError = sal_True;
					}
					else if (pFC->IsValue())
					{
						nValue = pFC->GetValue();
						bVal = sal_True;
					}
					// sonst Text
				}
			}
			break;
		case CELLTYPE_NOTE:
			bCell = sal_False;
			break;
		// bei Strings nichts
        default:
        {
            // added to avoid warnings
        }
	}

	if (!rData.bError)
	{
		switch (rData.eFunc)
		{
			case SUBTOTAL_FUNC_SUM:
			case SUBTOTAL_FUNC_AVE:
				if (bVal)
				{
					++rData.nCount;
					if (!SubTotal::SafePlus( rData.nVal, nValue ))
						rData.bError = sal_True;
				}
				break;
			case SUBTOTAL_FUNC_CNT:				// nur Werte
				if (bVal)
					++rData.nCount;
				break;
			case SUBTOTAL_FUNC_CNT2:			// alle
				if (bCell)
					++rData.nCount;
				break;
			case SUBTOTAL_FUNC_MAX:
				if (bVal)
					if (++rData.nCount == 1 || nValue > rData.nVal )
						rData.nVal = nValue;
				break;
			case SUBTOTAL_FUNC_MIN:
				if (bVal)
					if (++rData.nCount == 1 || nValue < rData.nVal )
						rData.nVal = nValue;
				break;
            default:
            {
                // added to avoid warnings
            }
		}
	}
}

//	Mehrfachselektion:
void ScColumn::UpdateSelectionFunction( const ScMarkData& rMark,
										ScFunctionData& rData,
										ScFlatBoolRowSegments& rHiddenRows,
										sal_Bool bDoExclude, SCROW nExStartRow, SCROW nExEndRow )
{
	SCSIZE nIndex;
	ScMarkedDataIter aDataIter(this, &rMark, sal_False);
	while (aDataIter.Next( nIndex ))
	{
		SCROW nRow = pItems[nIndex].nRow;
		bool bRowHidden = rHiddenRows.getValue(nRow);
		if ( !bRowHidden )
			if ( !bDoExclude || nRow < nExStartRow || nRow > nExEndRow )
				lcl_UpdateSubTotal( rData, pItems[nIndex].pCell );
	}
}

//	bei bNoMarked die Mehrfachselektion weglassen
void ScColumn::UpdateAreaFunction( ScFunctionData& rData,
								   ScFlatBoolRowSegments& rHiddenRows,
									SCROW nStartRow, SCROW nEndRow )
{
	SCSIZE nIndex;
	Search( nStartRow, nIndex );
	while ( nIndex<nCount && pItems[nIndex].nRow<=nEndRow )
	{
		SCROW nRow = pItems[nIndex].nRow;
		bool bRowHidden = rHiddenRows.getValue(nRow);
		if ( !bRowHidden )
			lcl_UpdateSubTotal( rData, pItems[nIndex].pCell );
		++nIndex;
	}
}

sal_uLong ScColumn::GetWeightedCount() const
{
	sal_uLong nTotal = 0;

	//	Notizen werden nicht gezaehlt

	for (SCSIZE i=0; i<nCount; i++)
	{
		ScBaseCell* pCell = pItems[i].pCell;
		switch ( pCell->GetCellType() )
		{
			case CELLTYPE_VALUE:
			case CELLTYPE_STRING:
				++nTotal;
				break;
			case CELLTYPE_FORMULA:
				nTotal += 5 + ((ScFormulaCell*)pCell)->GetCode()->GetCodeLen();
				break;
			case CELLTYPE_EDIT:
				nTotal += 50;
				break;
            default:
            {
                // added to avoid warnings
            }
		}
	}

	return nTotal;
}

sal_uLong ScColumn::GetCodeCount() const
{
	sal_uLong nCodeCount = 0;

	for (SCSIZE i=0; i<nCount; i++)
	{
		ScBaseCell* pCell = pItems[i].pCell;
		if ( pCell->GetCellType() == CELLTYPE_FORMULA )
			nCodeCount += ((ScFormulaCell*)pCell)->GetCode()->GetCodeLen();
	}

	return nCodeCount;
}

SCSIZE ScColumn::GetPatternCount()
{
    return this->pAttrArray ? this->pAttrArray->Count() : 0;
}

SCSIZE ScColumn::GetPatternCount( SCROW nRw1, SCROW nRw2 )
{
    return this->pAttrArray ? this->pAttrArray->Count( nRw1, nRw2 ) : 0;
}

bool ScColumn::ReservedPatternCount( SCSIZE nReserved )
{
    return this->pAttrArray ? this->pAttrArray->Reserve( nReserved ) : false;
}