Attachment #55967 for issue #35913

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

Lines 475-480 public: Link Here

(-)sc/inc/cell.hxx (+3 lines)
475	inline BOOL IsHyperLinkCell() const { return pCode && pCode->IsHyperLink(); }	475	inline BOOL IsHyperLinkCell() const { return pCode && pCode->IsHyperLink(); }
476	EditTextObject* CreateURLObject() ;	476	EditTextObject* CreateURLObject() ;
477	void GetURLResult( String& rURL, String& rCellText );	477	void GetURLResult( String& rURL, String& rCellText );
		478
		479	/** Determines whether or not the result string contains more than one paragraph */
		480	bool IsMultilineResult();
478	};	481	};
479		482
480	// Iterator fuer Referenzen in einer Formelzelle	483	// Iterator fuer Referenzen in einer Formelzelle

Lines 63-70 class ScEditUtil Link Here

(-)sc/inc/editutil.hxx (+5 lines)
63		63
64	public:	64	public:
65	static String ModifyDelimiters( const String& rOld );	65	static String ModifyDelimiters( const String& rOld );
		66
		67	/// Retrieves string with paragraphs delimited by spaces
66	static String GetSpaceDelimitedString( const EditEngine& rEngine );	68	static String GetSpaceDelimitedString( const EditEngine& rEngine );
67		69
		70	/// Retrieves string with paragraphs delimited by new lines ('\n').
		71	static String GetMultilineString( const EditEngine& rEngine );
		72
68	public:	73	public:
69	ScEditUtil( ScDocument* pDocument, SCCOL nX, SCROW nY, SCTAB nZ,	74	ScEditUtil( ScDocument* pDocument, SCCOL nX, SCROW nY, SCTAB nZ,
70	const Point& rScrPosPixel,	75	const Point& rScrPosPixel,

Lines 38-43 Link Here

(-)sc/inc/formularesult.hxx (-3 / +37 lines)
38	and memory consumption. */	38	and memory consumption. */
39	class ScFormulaResult	39	class ScFormulaResult
40	{	40	{
		41	enum Multiline
		42	{
		43	MULTILINE_UNKNOWN = 0,
		44	MULTILINE_FALSE,
		45	MULTILINE_TRUE
		46	};
41	union	47	union
42	{	48	{
43	double mfValue; // double result direct for performance and memory consumption	49	double mfValue; // double result direct for performance and memory consumption
Lines 47-52 class ScFormulaResult Link Here
47	bool mbToken :1; // whether content of union is a token	53	bool mbToken :1; // whether content of union is a token
48	bool mbEmpty :1; // empty cell result	54	bool mbEmpty :1; // empty cell result
49	bool mbEmptyDisplayedAsString :1; // only if mbEmpty	55	bool mbEmptyDisplayedAsString :1; // only if mbEmpty
		56	Multiline meMultiline :2; // result is multiline
50		57
51	/** Reset mnError, mbEmpty and mbEmptyDisplayedAsString to their defaults	58	/** Reset mnError, mbEmpty and mbEmptyDisplayedAsString to their defaults
52	prior to assigning other types */	59	prior to assigning other types */
Lines 69-80 public: Link Here
69	/** Effectively type svUnknown. */	76	/** Effectively type svUnknown. */
70	ScFormulaResult()	77	ScFormulaResult()
71	: mpToken(NULL), mnError(0), mbToken(true),	78	: mpToken(NULL), mnError(0), mbToken(true),
72	mbEmpty(false), mbEmptyDisplayedAsString(false) {}	79	mbEmpty(false), mbEmptyDisplayedAsString(false),
		80	meMultiline(MULTILINE_UNKNOWN) {}
73		81
74	ScFormulaResult( const ScFormulaResult & r )	82	ScFormulaResult( const ScFormulaResult & r )
75	: mnError( r.mnError), mbToken( r.mbToken),	83	: mnError( r.mnError), mbToken( r.mbToken),
76	mbEmpty( r.mbEmpty),	84	mbEmpty( r.mbEmpty),
77	mbEmptyDisplayedAsString( r.mbEmptyDisplayedAsString)	85	mbEmptyDisplayedAsString( r.mbEmptyDisplayedAsString),
		86	meMultiline( r.meMultiline)
78	{	87	{
79	if (mbToken)	88	if (mbToken)
80	{	89	{
Lines 99-105 public: Link Here
99	/** Same comments as for SetToken() apply! */	108	/** Same comments as for SetToken() apply! */
100	explicit ScFormulaResult( const ScToken* p )	109	explicit ScFormulaResult( const ScToken* p )
101	: mnError(0), mbToken(false),	110	: mnError(0), mbToken(false),
102	mbEmpty(false), mbEmptyDisplayedAsString(false)	111	mbEmpty(false), mbEmptyDisplayedAsString(false),
		112	meMultiline(MULTILINE_UNKNOWN)
103	{	113	{
104	SetToken( p);	114	SetToken( p);
105	}	115	}
Lines 153-158 public: Link Here
153	details instead. */	163	details instead. */
154	inline bool IsValue() const;	164	inline bool IsValue() const;
155		165
		166	/** Determines whether or not the result is a string containing more than
		167	one paragraph */
		168	inline bool IsMultiline();
		169
156	/** Get error code if set or GetCellResultType() is svError or svUnknown,	170	/** Get error code if set or GetCellResultType() is svError or svUnknown,
157	else 0. */	171	else 0. */
158	inline USHORT GetResultError() const;	172	inline USHORT GetResultError() const;
Lines 211-216 inline void ScFormulaResult::ResetToDefaults() Link Here
211	mnError = 0;	225	mnError = 0;
212	mbEmpty = false;	226	mbEmpty = false;
213	mbEmptyDisplayedAsString = false;	227	mbEmptyDisplayedAsString = false;
		228	meMultiline = MULTILINE_UNKNOWN;
214	}	229	}
215		230
216		231
Lines 232-241 inline void ScFormulaResult::ResolveToken( const ScToken * p ) Link Here
232	mbToken = false;	247	mbToken = false;
233	// set in case mnError is 0 now, which shouldn't happen but ...	248	// set in case mnError is 0 now, which shouldn't happen but ...
234	mfValue = 0.0;	249	mfValue = 0.0;
		250	meMultiline = MULTILINE_FALSE;
235	break;	251	break;
236	case svEmptyCell:	252	case svEmptyCell:
237	mbEmpty = true;	253	mbEmpty = true;
238	mbEmptyDisplayedAsString = static_cast<const ScEmptyCellToken*>(p)->IsDisplayedAsString();	254	mbEmptyDisplayedAsString = static_cast<const ScEmptyCellToken*>(p)->IsDisplayedAsString();
		255	meMultiline = MULTILINE_FALSE;
239	p->DecRef();	256	p->DecRef();
240	mbToken = false;	257	mbToken = false;
241	break;	258	break;
Lines 243-248 inline void ScFormulaResult::ResolveToken( const ScToken * p ) Link Here
243	mfValue = p->GetDouble();	260	mfValue = p->GetDouble();
244	p->DecRef();	261	p->DecRef();
245	mbToken = false;	262	mbToken = false;
		263	meMultiline = MULTILINE_FALSE;
246	break;	264	break;
247	default:	265	default:
248	mpToken = p;	266	mpToken = p;
Lines 270-275 inline void ScFormulaResult::Assign( const ScFormulaResult & r ) Link Here
270	mbToken = false;	288	mbToken = false;
271	mbEmpty = true;	289	mbEmpty = true;
272	mbEmptyDisplayedAsString = r.mbEmptyDisplayedAsString;	290	mbEmptyDisplayedAsString = r.mbEmptyDisplayedAsString;
		291	meMultiline = r.meMultiline;
273	}	292	}
274	else if (r.mbToken)	293	else if (r.mbToken)
275	{	294	{
Lines 352-357 inline void ScFormulaResult::SetDouble( double f ) Link Here
352	mpToken->DecRef();	371	mpToken->DecRef();
353	mfValue = f;	372	mfValue = f;
354	mbToken = false;	373	mbToken = false;
		374	meMultiline = MULTILINE_FALSE;
355	}	375	}
356	}	376	}
357		377
Lines 404-409 inline bool ScFormulaResult::IsValue() const Link Here
404	return sv == svDouble \|\| sv == svError \|\| sv == svEmptyCell;	424	return sv == svDouble \|\| sv == svError \|\| sv == svEmptyCell;
405	}	425	}
406		426
		427	inline bool ScFormulaResult::IsMultiline()
		428	{
		429	if (meMultiline == MULTILINE_UNKNOWN)
		430	{
		431	const String& rStr = GetString();
		432	if (rStr.Len() && rStr.Search( _LF ) != STRING_NOTFOUND)
		433	meMultiline = MULTILINE_TRUE;
		434	else
		435	meMultiline = MULTILINE_FALSE;
		436	}
		437	return meMultiline == MULTILINE_TRUE;
		438	}
		439
407		440
408	inline USHORT ScFormulaResult::GetResultError() const	441	inline USHORT ScFormulaResult::GetResultError() const
409	{	442	{
Lines 537-542 inline void ScFormulaResult::SetHybridDouble( double f ) Link Here
537	{	570	{
538	mfValue = f;	571	mfValue = f;
539	mbToken = false;	572	mbToken = false;
		573	meMultiline = MULTILINE_FALSE;
540	}	574	}
541	}	575	}
542		576

Lines 1813-1818 void ScFormulaCell::GetURLResult( String& rURL, String& rCellText ) Link Here

(-)sc/source/core/data/cell.cxx (+7 lines)
1813	}	1813	}
1814	}	1814	}
1815		1815
		1816	bool ScFormulaCell::IsMultilineResult()
		1817	{
		1818	if (!IsValue())
		1819	return aResult.IsMultiline();
		1820	return false;
		1821	}
		1822
1816	EditTextObject* ScFormulaCell::CreateURLObject()	1823	EditTextObject* ScFormulaCell::CreateURLObject()
1817	{	1824	{
1818	String aCellText;	1825	String aCellText;

Lines 163-169 void ScEditCell::GetString( String& rString ) const Link Here

(-)sc/source/core/data/cell2.cxx (-1 / +1 lines)
163	// auch Text von URL-Feldern, Doc-Engine ist eine ScFieldEditEngine	163	// auch Text von URL-Feldern, Doc-Engine ist eine ScFieldEditEngine
164	EditEngine& rEngine = pDoc->GetEditEngine();	164	EditEngine& rEngine = pDoc->GetEditEngine();
165	rEngine.SetText( *pData );	165	rEngine.SetText( *pData );
166	rString = ScEditUtil::GetSpaceDelimitedString(rEngine); // space between paragraphs	166	rString = ScEditUtil::GetMultilineString(rEngine); // string with line separators between paragraphs
167	// kurze Strings fuer Formeln merken	167	// kurze Strings fuer Formeln merken
168	if ( rString.Len() < MAXSTRLEN )	168	if ( rString.Len() < MAXSTRLEN )
169	((ScEditCell*)this)->pString = new String( rString ); //! non-const	169	((ScEditCell*)this)->pString = new String( rString ); //! non-const

Lines 2317-2324 BOOL ScColumn::HasEditCells(SCROW nStartRow, SCROW nEndRow, SCROW& rFirst) const Link Here

(-)sc/source/core/data/column.cxx (-2 / +4 lines)
2317	while ( (nIndex < nCount) ? ((nRow=pItems[nIndex].nRow) <= nEndRow) : FALSE )	2317	while ( (nIndex < nCount) ? ((nRow=pItems[nIndex].nRow) <= nEndRow) : FALSE )
2318	{	2318	{
2319	ScBaseCell* pCell = pItems[nIndex].pCell;	2319	ScBaseCell* pCell = pItems[nIndex].pCell;
2320	if ( pCell->GetCellType() == CELLTYPE_EDIT \|\|	2320	CellType eCellType = pCell->GetCellType();
2321	IsAmbiguousScriptNonZero( pDocument->GetScriptType(nCol, nRow, nTab, pCell) ) )	2321	if ( eCellType == CELLTYPE_EDIT \|\|
		2322	IsAmbiguousScriptNonZero( pDocument->GetScriptType(nCol, nRow, nTab, pCell) ) \|\|
		2323	((eCellType == CELLTYPE_FORMULA) && ((ScFormulaCell*)pCell)->IsMultilineResult()) )
2322	{	2324	{
2323	rFirst = nRow;	2325	rFirst = nRow;
2324	return TRUE;	2326	return TRUE;

Lines 793-801 long ScColumn::GetNeededSize( SCROW nRow, OutputDevice* pDev, Link Here

(-)sc/source/core/data/column2.cxx (-2 / +5 lines)
793	}	793	}
794		794
795	BOOL bAddMargin = TRUE;	795	BOOL bAddMargin = TRUE;
796	BOOL bEditEngine = ( pCell->GetCellType() == CELLTYPE_EDIT \|\|	796	CellType eCellType = pCell->GetCellType();
		797
		798	BOOL bEditEngine = ( eCellType == CELLTYPE_EDIT \|\|
797	eOrient == SVX_ORIENTATION_STACKED \|\|	799	eOrient == SVX_ORIENTATION_STACKED \|\|
798	IsAmbiguousScript( nScript ) );	800	IsAmbiguousScript( nScript ) \|\|
		801	((eCellType == CELLTYPE_FORMULA) && ((ScFormulaCell*)pCell)->IsMultilineResult()) );
799		802
800	if (!bEditEngine) // direkte Ausgabe	803	if (!bEditEngine) // direkte Ausgabe
801	{	804	{




							String aString;
							pForm->GetString(aString);
							if ( aString.Len() )
                            {
                                if ( pForm->IsMultilineResult() )
                                {
                                    pNew = new ScEditCell( aString, pDestDoc );
                                }
                                else
                                {
                                    pNew = new ScStringCell(aString);
                                    // #33224# LeerStrings nicht kopieren
                                }
                            }
						}
					}
					if ( pNew && pSource->GetNotePtr() && ( nFlags & IDF_NOTE ) )




	return aRet;
}

static String lcl_GetDelimitedString( const EditEngine& rEngine, const sal_Char c )
{
	String aRet;
	USHORT nParCount = rEngine.GetParagraphCount();
	for (USHORT nPar=0; nPar<nParCount; nPar++)
	{
		if (nPar > 0)
			aRet += c;
		aRet += rEngine.GetText( nPar );
	}
	return aRet;
}

String ScEditUtil::GetSpaceDelimitedString( const EditEngine& rEngine )
{
    return lcl_GetDelimitedString(rEngine, ' ');
}

String ScEditUtil::GetMultilineString( const EditEngine& rEngine )
{
    return lcl_GetDelimitedString(rEngine, '\n');
}

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

Rectangle ScEditUtil::GetEditArea( const ScPatternAttr* pPattern, BOOL bForceToTop )

Lines 1963-1971 sal_uInt32 XclExpXFBuffer::InsertWithFont( const ScPatternAttr* pPattern, sal_In Link Here

(-)sc/source/filter/excel/xestyle.cxx (-2 / +2 lines)
1963	return InsertCellXF( pPattern, nScript, NUMBERFORMAT_ENTRY_NOT_FOUND, nForceXclFont, bForceLineBreak );	1963	return InsertCellXF( pPattern, nScript, NUMBERFORMAT_ENTRY_NOT_FOUND, nForceXclFont, bForceLineBreak );
1964	}	1964	}
1965		1965
1966	sal_uInt32 XclExpXFBuffer::InsertWithNumFmt( const ScPatternAttr* pPattern, sal_Int16 nScript, ULONG nForceScNumFmt )	1966	sal_uInt32 XclExpXFBuffer::InsertWithNumFmt( const ScPatternAttr* pPattern, sal_Int16 nScript, ULONG nForceScNumFmt, bool bForceLineBreak )
1967	{	1967	{
1968	return InsertCellXF( pPattern, nScript, nForceScNumFmt, EXC_FONT_NOTFOUND, false );	1968	return InsertCellXF( pPattern, nScript, nForceScNumFmt, EXC_FONT_NOTFOUND, bForceLineBreak );
1969	}	1969	}
1970		1970
1971	sal_uInt32 XclExpXFBuffer::InsertStyle( const SfxStyleSheetBase* pStyleSheet )	1971	sal_uInt32 XclExpXFBuffer::InsertStyle( const SfxStyleSheetBase* pStyleSheet )





        // #i41420# find script type according to result type (always latin for numeric results)
        sal_Int16 nScript = ApiScriptType::LATIN;
        bool bForceLineBreak = false;
        if( nFormatType == NUMBERFORMAT_TEXT )
        {
            String aResult;
            mrScFmlaCell.GetString( aResult );
            bForceLineBreak = mrScFmlaCell.IsMultilineResult();
            nScript = XclExpStringHelper::GetLeadingScriptType( rRoot, aResult );
        }
        SetXFId( rRoot.GetXFBuffer().InsertWithNumFmt( pPattern, nScript, nAltScNumFmt, bForceLineBreak ) );
    }

    // *** Convert the formula token array *** --------------------------------

Lines 617-626 public: Link Here

(-)sc/source/filter/inc/xestyle.hxx (-1 / +4 lines)
617	@param nXFFlags Additional flags allowing to control the creation of an XF.	617	@param nXFFlags Additional flags allowing to control the creation of an XF.
618	@param nForceScNumFmt The number format to be exported, e.g. formula	618	@param nForceScNumFmt The number format to be exported, e.g. formula
619	result type. This format will always overwrite the cell's number format.	619	result type. This format will always overwrite the cell's number format.
		620	@param bForceLineBreak true = Set line break flag unconditionally.
		621	This is required for cells that contain multi-line text.
620	@return A unique XF record ID. */	622	@return A unique XF record ID. */
621	sal_uInt32 InsertWithNumFmt(	623	sal_uInt32 InsertWithNumFmt(
622	const ScPatternAttr* pPattern, sal_Int16 nScript,	624	const ScPatternAttr* pPattern, sal_Int16 nScript,
623	ULONG nForceScNumFmt );	625	ULONG nForceScNumFmt,
		626	bool bForceLineBreak );
624	/** Inserts the passed cell style. Creates a style XF record and a STYLE record.	627	/** Inserts the passed cell style. Creates a style XF record and a STYLE record.
625	@return A unique XF record ID. */	628	@return A unique XF record ID. */
626	sal_uInt32 InsertStyle( const SfxStyleSheetBase* pStyleSheet );	629	sal_uInt32 InsertStyle( const SfxStyleSheetBase* pStyleSheet );





	if (!bIsEmpty)
	{
		if ((aCell.nType == table::CellContentType_TEXT && IsEditCell(aCell)) || 
            IsMultiLineFormulaCell(aCell))
		{
            bEditCell = sal_True;
            uno::Reference<text::XText> xText(xCurrentTableCellRange->getCellByPosition(aCell.aCellAddress.Column, aCell.aCellAddress.Row), uno::UNO_QUERY);

	}
}

sal_Bool ScXMLExport::IsMultiLineFormulaCell(ScMyCell& rCell) const
{
    if (!pDoc)
        return false;

    ScAddress aAddr(static_cast<SCCOL>(rCell.aCellAddress.Column), 
                    static_cast<SCROW>(rCell.aCellAddress.Row), 
                    static_cast<SCTAB>(rCell.aCellAddress.Sheet));

    ScBaseCell* pCell = pDoc->GetCell(aAddr);
    if (!pCell || pCell->GetCellType() != CELLTYPE_FORMULA)
        return false;

    return static_cast<ScFormulaCell*>(pCell)->IsMultilineResult();
}

sal_Bool ScXMLExport::IsAnnotationEqual(const uno::Reference<table::XCell>& /* xCell1 */,
                                        const uno::Reference<table::XCell>& /* xCell2 */)
{

Lines 185-190 class ScXMLExport : public SvXMLExport Link Here

(-)sc/source/filter/xml/xmlexprt.hxx (+1 lines)
185	sal_Bool IsEditCell(const com::sun::star::table::CellAddress& aAddress) const;	185	sal_Bool IsEditCell(const com::sun::star::table::CellAddress& aAddress) const;
186	sal_Bool IsEditCell(const com::sun::star::uno::Reference <com::sun::star::table::XCell>& xCell) const;	186	sal_Bool IsEditCell(const com::sun::star::uno::Reference <com::sun::star::table::XCell>& xCell) const;
187	sal_Bool IsEditCell(ScMyCell& rCell) const;	187	sal_Bool IsEditCell(ScMyCell& rCell) const;
		188	sal_Bool IsMultiLineFormulaCell(ScMyCell& rCell) const;
188	sal_Bool IsAnnotationEqual(const com::sun::star::uno::Reference<com::sun::star::table::XCell>& xCell1,	189	sal_Bool IsAnnotationEqual(const com::sun::star::uno::Reference<com::sun::star::table::XCell>& xCell1,
189	const com::sun::star::uno::Reference<com::sun::star::table::XCell>& xCell2);	190	const com::sun::star::uno::Reference<com::sun::star::table::XCell>& xCell2);
190	sal_Bool IsCellEqual (ScMyCell& aCell1, ScMyCell& aCell2);	191	sal_Bool IsCellEqual (ScMyCell& aCell1, ScMyCell& aCell2);

Lines 815-821 void ScTransferObj::StripRefs( ScDocument* pDoc, Link Here

(-)sc/source/ui/app/transobj.cxx (-1 / +4 lines)
815	{	815	{
816	String aStr;	816	String aStr;
817	pFCell->GetString(aStr);	817	pFCell->GetString(aStr);
818	pNew = new ScStringCell( aStr );	818	if ( pFCell->IsMultilineResult() )
		819	pNew = new ScEditCell( aStr, pDestDoc );
		820	else
		821	pNew = new ScStringCell( aStr );
819	}	822	}
820	pDestDoc->PutCell( nCol,nRow,nDestTab, pNew );	823	pDestDoc->PutCell( nCol,nRow,nDestTab, pNew );
821		824

Lines 1606-1611 BOOL ScImportExport::Sylk2Doc( SvStream& rStrm ) Link Here

(-)sc/source/ui/docshell/impex.cxx (+2 lines)
1606		1606
1607	BOOL ScImportExport::Doc2Sylk( SvStream& rStrm )	1607	BOOL ScImportExport::Doc2Sylk( SvStream& rStrm )
1608	{	1608	{
		1609	const String SYLK_LF = String::CreateFromAscii("\x1b :");
1609	SCCOL nCol;	1610	SCCOL nCol;
1610	SCROW nRow;	1611	SCROW nRow;
1611	SCCOL nStartCol = aRange.aStart.Col();	1612	SCCOL nStartCol = aRange.aStart.Col();
Lines 1660-1665 BOOL ScImportExport::Doc2Sylk( SvStream& rStrm ) Link Here
1660	case CELLTYPE_EDIT:	1661	case CELLTYPE_EDIT:
1661	hasstring:	1662	hasstring:
1662	pDoc->GetString( nCol, nRow, aRange.aStart.Tab(), aCellStr );	1663	pDoc->GetString( nCol, nRow, aRange.aStart.Tab(), aCellStr );
		1664	aCellStr.SearchAndReplaceAll( _LF, SYLK_LF );
1663		1665
1664	aBufStr.AssignAscii(RTL_CONSTASCII_STRINGPARAM( "C;X" ));	1666	aBufStr.AssignAscii(RTL_CONSTASCII_STRINGPARAM( "C;X" ));
1665	aBufStr += String::CreateFromInt32( c );	1667	aBufStr += String::CreateFromInt32( c );




				}
				if (bDoCell && !bNeedEdit)
				{
					BOOL bFormulaCell = (pCell->GetCellType() == CELLTYPE_FORMULA );
					if ( bFormulaCell )
						lcl_CreateInterpretProgress( bProgress, pDoc, (ScFormulaCell*)pCell );
					if ( aVars.SetText(pCell) )
						pOldPattern = NULL;
                    bNeedEdit = aVars.HasEditCharacters() ||
					                (bFormulaCell && ((ScFormulaCell*)pCell)->IsMultilineResult());
                }
                if (bDoCell && !bNeedEdit)
                {

Return to issue 35913

Lines 898-905 ScBaseCell* ScColumn::CloneCell(SCSIZE nIndex, USHORT nFlags, Link Here

(-)sc/source/core/data/column3.cxx (-2 / +11 lines)
898	String aString;	898	String aString;
899	pForm->GetString(aString);	899	pForm->GetString(aString);
900	if ( aString.Len() )	900	if ( aString.Len() )
901	pNew = new ScStringCell(aString);	901	{
902	// #33224# LeerStrings nicht kopieren	902	if ( pForm->IsMultilineResult() )
		903	{
		904	pNew = new ScEditCell( aString, pDestDoc );
		905	}
		906	else
		907	{
		908	pNew = new ScStringCell(aString);
		909	// #33224# LeerStrings nicht kopieren
		910	}
		911	}
903	}	912	}
904	}	913	}
905	if ( pNew && pSource->GetNotePtr() && ( nFlags & IDF_NOTE ) )	914	if ( pNew && pSource->GetNotePtr() && ( nFlags & IDF_NOTE ) )

Lines 760-772 XclExpFormulaCell::XclExpFormulaCell( Link Here

(-)sc/source/filter/excel/xetable.cxx (-1 / +3 lines)
760		760
761	// #i41420# find script type according to result type (always latin for numeric results)	761	// #i41420# find script type according to result type (always latin for numeric results)
762	sal_Int16 nScript = ApiScriptType::LATIN;	762	sal_Int16 nScript = ApiScriptType::LATIN;
		763	bool bForceLineBreak = false;
763	if( nFormatType == NUMBERFORMAT_TEXT )	764	if( nFormatType == NUMBERFORMAT_TEXT )
764	{	765	{
765	String aResult;	766	String aResult;
766	mrScFmlaCell.GetString( aResult );	767	mrScFmlaCell.GetString( aResult );
		768	bForceLineBreak = mrScFmlaCell.IsMultilineResult();
767	nScript = XclExpStringHelper::GetLeadingScriptType( rRoot, aResult );	769	nScript = XclExpStringHelper::GetLeadingScriptType( rRoot, aResult );
768	}	770	}
769	SetXFId( rRoot.GetXFBuffer().InsertWithNumFmt( pPattern, nScript, nAltScNumFmt ) );	771	SetXFId( rRoot.GetXFBuffer().InsertWithNumFmt( pPattern, nScript, nAltScNumFmt, bForceLineBreak ) );
770	}	772	}
771		773
772	// * Convert the formula token array * --------------------------------	774	// * Convert the formula token array * --------------------------------

Lines 2410-2416 void ScXMLExport::WriteCell (ScMyCell& aCell) Link Here

(-)sc/source/filter/xml/xmlexprt.cxx (-1 / +18 lines)
2410		2410
2411	if (!bIsEmpty)	2411	if (!bIsEmpty)
2412	{	2412	{
2413	if ((aCell.nType == table::CellContentType_TEXT) && IsEditCell(aCell))	2413	if ((aCell.nType == table::CellContentType_TEXT && IsEditCell(aCell)) \|\|
		2414	IsMultiLineFormulaCell(aCell))
2414	{	2415	{
2415	bEditCell = sal_True;	2416	bEditCell = sal_True;
2416	uno::Reference<text::XText> xText(xCurrentTableCellRange->getCellByPosition(aCell.aCellAddress.Column, aCell.aCellAddress.Row), uno::UNO_QUERY);	2417	uno::Reference<text::XText> xText(xCurrentTableCellRange->getCellByPosition(aCell.aCellAddress.Column, aCell.aCellAddress.Row), uno::UNO_QUERY);
Lines 2907-2912 sal_Bool ScXMLExport::IsEditCell(ScMyCell& rCell) const Link Here
2907	}	2908	}
2908	}	2909	}
2909		2910
		2911	sal_Bool ScXMLExport::IsMultiLineFormulaCell(ScMyCell& rCell) const
		2912	{
		2913	if (!pDoc)
		2914	return false;
		2915
		2916	ScAddress aAddr(static_cast<SCCOL>(rCell.aCellAddress.Column),
		2917	static_cast<SCROW>(rCell.aCellAddress.Row),
		2918	static_cast<SCTAB>(rCell.aCellAddress.Sheet));
		2919
		2920	ScBaseCell* pCell = pDoc->GetCell(aAddr);
		2921	if (!pCell \|\| pCell->GetCellType() != CELLTYPE_FORMULA)
		2922	return false;
		2923
		2924	return static_cast<ScFormulaCell*>(pCell)->IsMultilineResult();
		2925	}
		2926
2910	sal_Bool ScXMLExport::IsAnnotationEqual(const uno::Reference<table::XCell>& /* xCell1 */,	2927	sal_Bool ScXMLExport::IsAnnotationEqual(const uno::Reference<table::XCell>& /* xCell1 */,
2911	const uno::Reference<table::XCell>& /* xCell2 */)	2928	const uno::Reference<table::XCell>& /* xCell2 */)
2912	{	2929	{

Lines 1427-1437 void ScOutputData::DrawStrings( BOOL bPixelToLogic ) Link Here

(-)sc/source/ui/view/output2.cxx (-2 / +4 lines)
1427	}	1427	}
1428	if (bDoCell && !bNeedEdit)	1428	if (bDoCell && !bNeedEdit)
1429	{	1429	{
1430	if ( pCell->GetCellType() == CELLTYPE_FORMULA )	1430	BOOL bFormulaCell = (pCell->GetCellType() == CELLTYPE_FORMULA );
		1431	if ( bFormulaCell )
1431	lcl_CreateInterpretProgress( bProgress, pDoc, (ScFormulaCell*)pCell );	1432	lcl_CreateInterpretProgress( bProgress, pDoc, (ScFormulaCell*)pCell );
1432	if ( aVars.SetText(pCell) )	1433	if ( aVars.SetText(pCell) )
1433	pOldPattern = NULL;	1434	pOldPattern = NULL;
1434	bNeedEdit = aVars.HasEditCharacters();	1435	bNeedEdit = aVars.HasEditCharacters() \|\|
		1436	(bFormulaCell && ((ScFormulaCell*)pCell)->IsMultilineResult());
1435	}	1437	}
1436	if (bDoCell && !bNeedEdit)	1438	if (bDoCell && !bNeedEdit)
1437	{	1439	{

Lines 82-100 String ScEditUtil::ModifyDelimiters( const String& rOld ) Link Here

(-)sc/source/core/tool/editutil.cxx (-2 / +12 lines)
82	return aRet;	82	return aRet;
83	}	83	}
84		84
85	String ScEditUtil::GetSpaceDelimitedString( const EditEngine& rEngine )	85	static String lcl_GetDelimitedString( const EditEngine& rEngine, const sal_Char c )
86	{	86	{
87	String aRet;	87	String aRet;
88	USHORT nParCount = rEngine.GetParagraphCount();	88	USHORT nParCount = rEngine.GetParagraphCount();
89	for (USHORT nPar=0; nPar<nParCount; nPar++)	89	for (USHORT nPar=0; nPar<nParCount; nPar++)
90	{	90	{
91	if (nPar > 0)	91	if (nPar > 0)
92	aRet += ' ';	92	aRet += c;
93	aRet += rEngine.GetText( nPar );	93	aRet += rEngine.GetText( nPar );
94	}	94	}
95	return aRet;	95	return aRet;
96	}	96	}
97		97
		98	String ScEditUtil::GetSpaceDelimitedString( const EditEngine& rEngine )
		99	{
		100	return lcl_GetDelimitedString(rEngine, ' ');
		101	}
		102
		103	String ScEditUtil::GetMultilineString( const EditEngine& rEngine )
		104	{
		105	return lcl_GetDelimitedString(rEngine, '\n');
		106	}
		107
98	//------------------------------------------------------------------------	108	//------------------------------------------------------------------------
99		109
100	Rectangle ScEditUtil::GetEditArea( const ScPatternAttr* pPattern, BOOL bForceToTop )	110	Rectangle ScEditUtil::GetEditArea( const ScPatternAttr* pPattern, BOOL bForceToTop )