Attachment #78920 for issue #12666

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

Lines 136-141 Link Here

(-)sc/inc/dbcolect.hxx (+5 lines)
136	void GetArea(SCTAB& rTab, SCCOL& rCol1, SCROW& rRow1, SCCOL& rCol2, SCROW& rRow2) const;	136	void GetArea(SCTAB& rTab, SCCOL& rCol1, SCROW& rRow1, SCCOL& rCol2, SCROW& rRow2) const;
137	SC_DLLPUBLIC void GetArea(ScRange& rRange) const;	137	SC_DLLPUBLIC void GetArea(ScRange& rRange) const;
138	void SetArea(SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2);	138	void SetArea(SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2);
		139	//If the name of DBData is started with "unnamed", it will be recognized as build in DBData
		140	sal_Bool IsBuildin();
139	void MoveTo(SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2);	141	void MoveTo(SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2);
140	sal_Bool IsByRow() const { return bByRow; }	142	sal_Bool IsByRow() const { return bByRow; }
141	void SetByRow(sal_Bool bByR) { bByRow = bByR; }	143	void SetByRow(sal_Bool bByR) { bByRow = bByR; }
Lines 216-221 Link Here
216	ScDBData* GetDBAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab, sal_Bool bStartOnly) const;	218	ScDBData* GetDBAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab, sal_Bool bStartOnly) const;
217	ScDBData* GetDBAtArea(SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2) const;	219	ScDBData* GetDBAtArea(SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2) const;
218	ScDBData* GetFilterDBAtTable(SCTAB nTab) const;	220	ScDBData* GetFilterDBAtTable(SCTAB nTab) const;
		221	ScDBData* GetDBAtTable(SCTAB nTab, ScGetDBMode eMode) const;
219		222
220	sal_Bool SearchName( const String& rName, sal_uInt16& rIndex ) const;	223	sal_Bool SearchName( const String& rName, sal_uInt16& rIndex ) const;
221		224
Lines 234-239 Link Here
234	void SetRefreshHandler( const Link& rLink )	237	void SetRefreshHandler( const Link& rLink )
235	{ aRefreshHandler = rLink; }	238	{ aRefreshHandler = rLink; }
236	const Link& GetRefreshHandler() const { return aRefreshHandler; }	239	const Link& GetRefreshHandler() const { return aRefreshHandler; }
		240	String GetNewDefaultDBName();
		241	/sal_Bool IsFiltered(SCTAB nTab, SCROW nRow);/
237	};	242	};
238		243
239	#endif	244	#endif

Lines 505-510 Link Here

(-)sc/inc/document.hxx (+1 lines)
505	//UNUSED2008-05 ScRangeData* GetRangeAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab,	505	//UNUSED2008-05 ScRangeData* GetRangeAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab,
506	//UNUSED2008-05 sal_Bool bStartOnly = sal_False) const;	506	//UNUSED2008-05 sal_Bool bStartOnly = sal_False) const;
507	SC_DLLPUBLIC ScRangeData* GetRangeAtBlock( const ScRange& rBlock, String* pName=NULL ) const;	507	SC_DLLPUBLIC ScRangeData* GetRangeAtBlock( const ScRange& rBlock, String* pName=NULL ) const;
		508	ScDBData* GetDBAtTable(SCTAB nTab, ScGetDBMode eMode) const;
508		509
509	SC_DLLPUBLIC ScDPCollection* GetDPCollection();	510	SC_DLLPUBLIC ScDPCollection* GetDPCollection();
510	ScDPObject* GetDPAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab) const;	511	ScDPObject* GetDPAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab) const;
Lines 955-960 Link Here
955	SCROW& rEndRow, sal_Bool bNotes = sal_True ) const;	956	SCROW& rEndRow, sal_Bool bNotes = sal_True ) const;
956	void InvalidateTableArea();	957	void InvalidateTableArea();
957		958
958		959
959	SC_DLLPUBLIC sal_Bool GetDataStart( SCTAB nTab, SCCOL& rStartCol, SCROW& rStartRow ) const;	960	SC_DLLPUBLIC sal_Bool GetDataStart( SCTAB nTab, SCCOL& rStartCol, SCROW& rStartRow ) const;
960		961




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



#ifndef SC_SCGLOB_HXX
#define SC_SCGLOB_HXX

#include "address.hxx"
#include <i18npool/lang.h>
#include <tools/stream.hxx>
#include <osl/endian.h>
#include <com/sun/star/uno/Reference.hxx>
#include "scdllapi.h"

#include <hash_map>

class ImageList;
class Bitmap;
class SfxItemSet;
class Color;

// Macro fuer den Call-Profiler unter WinNT
// mit S_CAP kann eine Messung gestarted, mit E_CAP wieder gestoppt werden
#if defined( WNT ) && defined( PROFILE )

extern "C" {
	void StartCAP();
	void StopCAP();
	void DumpCAP();
};

#define S_CAP	StartCAP();
#define E_CAP	StopCAP(); DumpCAP();

#endif

#if 0
// I18N doesn't get this right, can't specify more than one to ignore
#define SC_COLLATOR_IGNORES ( \
	::com::sun::star::i18n::CollatorOptions::CollatorOptions_IGNORE_CASE | \
	::com::sun::star::i18n::CollatorOptions::CollatorOptions_IGNORE_KANA | \
	::com::sun::star::i18n::CollatorOptions::CollatorOptions_IGNORE_WIDTH )
#else
#define SC_COLLATOR_IGNORES ( \
	::com::sun::star::i18n::CollatorOptions::CollatorOptions_IGNORE_CASE )
#endif
#if 0
// #107998# Don't ignore Width and Kana. The issue was mainly with AutoInput,
// but affects also comparison of names in general.
#define SC_TRANSLITERATION_IGNORECASE ( \
    ::com::sun::star::i18n::TransliterationModules_IGNORE_CASE | \
    ::com::sun::star::i18n::TransliterationModules_IGNORE_KANA | \
    ::com::sun::star::i18n::TransliterationModules_IGNORE_WIDTH )
#define SC_TRANSLITERATION_CASESENSE ( \
    ::com::sun::star::i18n::TransliterationModules_IGNORE_KANA | \
    ::com::sun::star::i18n::TransliterationModules_IGNORE_WIDTH )
#else
#define SC_TRANSLITERATION_IGNORECASE ( \
    ::com::sun::star::i18n::TransliterationModules_IGNORE_CASE )
#define SC_TRANSLITERATION_CASESENSE 0
#endif

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

//	die 1000 Namen des Calc...
//	Clipboard-Namen sind jetzt in so3/soapp.hxx
//	STRING_SCAPP war "scalc3", "scalc4", jetzt nur noch "scalc"

#define STRING_SCAPP	"scalc"
#define	STRING_SCSTREAM	"StarCalcDocument"

#define	STRING_STANDARD	"Standard"

// characters -----------------------------------------------------------------

//	'\r' geht auf'm Mac nicht...
#define CHAR_CR		char(13)

const sal_Unicode CHAR_NBSP     = 0x00A0;
const sal_Unicode CHAR_SHY      = 0x00AD;
const sal_Unicode CHAR_ZWSP     = 0x200B;
const sal_Unicode CHAR_LRM      = 0x200E;
const sal_Unicode CHAR_RLM      = 0x200F;
const sal_Unicode CHAR_NBHY     = 0x2011;
const sal_Unicode CHAR_ZWNBSP   = 0x2060;

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

#define	MINDOUBLE	1.7e-307
#define	MAXDOUBLE	1.7e307

#define MINZOOM 	20
#define MAXZOOM 	400

#ifdef SC_ROWLIMIT_TYPECONVERSION_NOCONVPASS
const size_t MAXSUBTOTAL        = 3;
const size_t MAXQUERY           = 8;
#else
const SCSIZE MAXSUBTOTAL        = 3;
const SCSIZE MAXQUERY           = 8;
#endif

#define SC_START_INDEX_DB_COLL 50000
										// Oberhalb dieser Grenze liegen
										// die Indizes fuer DBBereiche

/*
#ifdef OS2
#define PIXEL_PER_INCH      72.0
#else
#define PIXEL_PER_INCH      96.0
#endif
*/

#define PIXEL_PER_INCH      96.0

#define CM_PER_INCH         2.54
#define POINTS_PER_INCH		72.27
#define PIXEL_PER_POINT		(PIXEL_PER_INCH / POINTS_PER_INCH)
#define INCHT_PER_CM		(1.0 / CM_PER_INCH)
#define POINTS_PER_CM		(POINTS_PER_INCH / CM_PER_INCH)
#define TWIPS_PER_POINT		20.0
#define TWIPS_PER_INCH		(TWIPS_PER_POINT * POINTS_PER_INCH)
#define TWIPS_PER_CM		(TWIPS_PER_INCH / CM_PER_INCH)
#define CM_PER_TWIPS		(CM_PER_INCH / TWIPS_PER_INCH)
#define TWIPS_PER_PIXEL		(TWIPS_PER_INCH / PIXEL_PER_INCH)
#define TWIPS_PER_CHAR		(TWIPS_PER_INCH / 13.6)
#define PIXEL_PER_TWIPS		(PIXEL_PER_INCH / TWIPS_PER_INCH)
#define HMM_PER_TWIPS		(CM_PER_TWIPS * 1000.0)

#define STD_COL_WIDTH		1285
#define STD_EXTRA_WIDTH		113		// 2mm Extra fuer optimale Breite
									// Standard Zeilenhoehe: Text + Rand - STD_ROWHEIGHT_DIFF


#define MAX_EXTRA_WIDTH  	23811	// 42cm in TWIPS
#define MAX_EXTRA_HEIGHT	23811
#define MAX_COL_WIDTH		56693	// 1m in TWIPS
#define MAX_COL_HEIGHT		56693

#define STD_ROWHEIGHT_DIFF	23
#define STD_FONT_HEIGHT		200 	// entspricht 10 Punkt

//!		statt STD_ROW_HEIGHT ScGlobal::nStdRowHeight benutzen !

#define STD_ROW_HEIGHT		(12.8 * TWIPS_PER_POINT) 			// 256 Twips, 0.45 cm

									// Standardgroesse als Ole-Server (Zellen)
#define OLE_STD_CELLS_X		4
#define OLE_STD_CELLS_Y		5

#define SC_SIZE_OPTIMUM		0xFFFF

									// Update-Flags
#define UF_SCROLL_LEFT		1
#define UF_SCROLL_RIGHT		2
#define UF_SCROLL_UP		4
#define UF_SCROLL_DOWN		8
#define UF_ROW				16
#define UF_VIEW				32

									// Repaint-Flags (fuer Messages)
#define PAINT_GRID			1
#define PAINT_TOP			2
#define PAINT_LEFT			4
#define PAINT_EXTRAS		8
#define PAINT_INVERT		16
#define PAINT_MARKS			32
#define PAINT_OBJECTS		64
#define PAINT_SIZE			128
#define PAINT_ALL			( PAINT_GRID | PAINT_TOP | PAINT_LEFT | PAINT_EXTRAS | PAINT_OBJECTS | PAINT_SIZE )


									// Flags fuer Spalten / Zeilen
									// FILTERED immer zusammen mit HIDDEN
									// FILTERED und MANUALSIZE nur fuer Zeilen moeglich
const sal_uInt8   CR_HIDDEN      = 1;
//const sal_uInt8 CR_MARKED      = 2;
//const sal_uInt8 CR_PAGEBREAK   = 4;
const sal_uInt8   CR_MANUALBREAK = 8;
const sal_uInt8   CR_FILTERED    = 16;
const sal_uInt8   CR_MANUALSIZE  = 32;
const sal_uInt8   CR_ALL         = (CR_HIDDEN | CR_MANUALBREAK | CR_FILTERED | CR_MANUALSIZE);

typedef sal_uInt8 ScBreakType;
const ScBreakType BREAK_NONE   = 0;
const ScBreakType BREAK_PAGE   = 1;
const ScBreakType BREAK_MANUAL = 2;

// Insert-/Delete-Flags
const sal_uInt16 IDF_NONE       = 0x0000;
const sal_uInt16 IDF_VALUE      = 0x0001;   /// Numeric values (and numeric results if IDF_FORMULA is not set).
const sal_uInt16 IDF_DATETIME   = 0x0002;   /// Dates, times, datetime values.
const sal_uInt16 IDF_STRING     = 0x0004;   /// Strings (and string results if IDF_FORMULA is not set).
const sal_uInt16 IDF_NOTE       = 0x0008;   /// Cell notes.
const sal_uInt16 IDF_FORMULA    = 0x0010;   /// Formula cells.
const sal_uInt16 IDF_HARDATTR   = 0x0020;   /// Hard cell attributes.
const sal_uInt16 IDF_STYLES     = 0x0040;   /// Cell styles.
const sal_uInt16 IDF_OBJECTS    = 0x0080;   /// Drawing objects.
const sal_uInt16 IDF_EDITATTR   = 0x0100;   /// Rich-text attributes.
const sal_uInt16 IDF_ATTRIB     = IDF_HARDATTR | IDF_STYLES;
const sal_uInt16 IDF_CONTENTS   = IDF_VALUE | IDF_DATETIME | IDF_STRING | IDF_NOTE | IDF_FORMULA;
const sal_uInt16 IDF_ALL        = IDF_CONTENTS | IDF_ATTRIB | IDF_OBJECTS;
const sal_uInt16 IDF_NOCAPTIONS = 0x0200;   /// Internal use only (undo etc.): do not copy/delete caption objects of cell notes.
const sal_uInt16 IDF_ADDNOTES   = 0x0400;   /// Internal use only (copy from clip): do not delete existing cell contents when pasting notes.

/// Copy flags for auto/series fill functions: do not touch notes and drawing objects.
const sal_uInt16 IDF_AUTOFILL   = IDF_ALL & ~(IDF_NOTE | IDF_OBJECTS);

#define PASTE_NOFUNC		0
#define PASTE_ADD			1
#define PASTE_SUB			2
#define PASTE_MUL			3
#define PASTE_DIV			4

#define PASTE_NONEMPTY		5

										// Bits fuer HasAttr
#define HASATTR_LINES			1
#define HASATTR_MERGED			2
#define HASATTR_OVERLAPPED		4
#define HASATTR_PROTECTED		8
#define HASATTR_SHADOW			16
#define HASATTR_NEEDHEIGHT		32
#define HASATTR_SHADOW_RIGHT	64
#define HASATTR_SHADOW_DOWN		128
#define HASATTR_AUTOFILTER		256
#define HASATTR_CONDITIONAL		512
#define HASATTR_ROTATE			1024
#define HASATTR_NOTOVERLAPPED	2048
#define HASATTR_RTL				4096
#define HASATTR_RIGHTORCENTER   8192    // right or centered logical alignment

#define HASATTR_PAINTEXT		( HASATTR_LINES | HASATTR_SHADOW | HASATTR_CONDITIONAL )


#define EMPTY_STRING ScGlobal::GetEmptyString()

										//	Layer-ID's fuer Drawing
#define SC_LAYER_FRONT		0
#define SC_LAYER_BACK		1
#define SC_LAYER_INTERN		2
#define SC_LAYER_CONTROLS	3
#define SC_LAYER_HIDDEN     4

										//	Tabellen linken
#define SC_LINK_NONE		0
#define SC_LINK_NORMAL		1
#define SC_LINK_VALUE		2

										//	Eingabe
#define SC_ENTER_NORMAL		0
#define SC_ENTER_BLOCK		1
#define SC_ENTER_MATRIX		2

										//	Step = 10pt, max. Einzug = 100 Schritte
#define SC_INDENT_STEP		200
#define SC_MAX_INDENT		20000

										//	Szenario-Flags
#define SC_SCENARIO_COPYALL		1
#define SC_SCENARIO_SHOWFRAME	2
#define SC_SCENARIO_PRINTFRAME	4
#define SC_SCENARIO_TWOWAY		8
#define SC_SCENARIO_ATTRIB		16
#define SC_SCENARIO_VALUE		32
#define SC_SCENARIO_PROTECT		64


#ifndef DELETEZ
#define DELETEZ(pPtr) { delete pPtr; pPtr = 0; }
#endif

									// Ist Bit in Set gesetzt?
#define IS_SET(bit,set)(((set)&(bit))==(bit))

#define SEL_ALL			-1	// Eingabezeile: alles Selektieren
#define RES_CANCEL		0	// Resultate der Funk.AutoPilot-Seiten
#define RES_BACKWARD	1
#define RES_END			2

enum CellType
	{
		CELLTYPE_NONE,
		CELLTYPE_VALUE,
		CELLTYPE_STRING,
		CELLTYPE_FORMULA,
		CELLTYPE_NOTE,
		CELLTYPE_EDIT,
		CELLTYPE_SYMBOLS 		// fuer Laden/Speichern
#if DBG_UTIL
   		,CELLTYPE_DESTROYED
#endif
	};

enum DelCellCmd
	{
		DEL_CELLSUP,
		DEL_CELLSLEFT,
		DEL_DELROWS,
		DEL_DELCOLS,
		DEL_NONE
	};

enum InsCellCmd
	{
		INS_CELLSDOWN,
		INS_CELLSRIGHT,
		INS_INSROWS,
		INS_INSCOLS,
		INS_NONE
	};

enum UpdateRefMode
	{
		URM_INSDEL,
		URM_COPY,
		URM_MOVE,
		URM_REORDER
	};

enum FillDir
	{
		FILL_TO_BOTTOM,
		FILL_TO_RIGHT,
		FILL_TO_TOP,
		FILL_TO_LEFT
	};

enum FillCmd
	{
		FILL_SIMPLE,
		FILL_LINEAR,
		FILL_GROWTH,
		FILL_DATE,
		FILL_AUTO
	};

enum FillDateCmd
	{
		FILL_DAY,
		FILL_WEEKDAY,
		FILL_MONTH,
		FILL_YEAR
	};

enum ScDirection
	{
		DIR_BOTTOM,
		DIR_RIGHT,
		DIR_TOP,
		DIR_LEFT
	};

enum ScSizeMode
	{
		SC_SIZE_DIRECT,				// set size or hide if value is 0
		SC_SIZE_OPTIMAL,			// set optimal size for everything
		SC_SIZE_SHOW,				// show with original size
		SC_SIZE_VISOPT,				// set optimal size only if visible
		SC_SIZE_ORIGINAL			// only set size, don't change visible flag
	};

enum ScInputMode
	{
		SC_INPUT_NONE,
		SC_INPUT_TYPE,				// Eingabe, ohne im Inplace-Modus zu sein
		SC_INPUT_TABLE,				// Textcursor in der Tabelle
		SC_INPUT_TOP				// Textcursor in der Eingabezeile
	};

enum ScVObjMode						// Ausgabemodi von Objekten auf einer Seite
{
	VOBJ_MODE_SHOW,
	VOBJ_MODE_HIDE
	// #i80528# VOBJ_MODE_DUMMY removed, no longer supported
};

enum ScAnchorType 					// Verankerung eines Zeichenobjekts
{
	SCA_CELL,
	SCA_PAGE,
	SCA_DONTKNOW 					// bei Mehrfachselektion
};

enum ScGetDBMode
{
	SC_DB_MAKE,		// wenn noetig, "unbenannt" anlegen
	SC_DB_IMPORT,	// wenn noetig, "Importx" anlegen
	SC_DB_OLD,		// nicht neu anlegen
	SC_DB_MAKE_FILTER,   // to create a new filter/sort/subtotal
	SC_DB_MAKE_SORT,
	SC_DB_MAKE_SUBTOTAL,
    SC_DB_OLD_FILTER   //to find a existed filter
};

/// For ScDBFunc::GetDBData()
enum ScGetDBSelection
{
    /** Keep selection as is, expand to used data area if no selection. */
    SC_DBSEL_KEEP,

    /** Shrink selection to sheet's data area. */
    SC_DBSEL_SHRINK_TO_SHEET_DATA,

    /** Shrink selection to actually used data area within the selection. */
    SC_DBSEL_SHRINK_TO_USED_DATA,

    /** If only one row or portion thereof is selected, shrink row to used data 
        columns and select further rows down until end of data. If an area is 
        selected, shrink rows to actually used columns. Else, no selection, 
        expand to used data area. */
    SC_DBSEL_ROW_DOWN,

    /** Behave as if the range corresponding to a ScDBData area was selected, 
        for API use. */
    SC_DBSEL_FORCE_MARK
};

enum ScLkUpdMode
{					//Verknuepfungen
	LM_ALWAYS,		//immer aktualisieren
	LM_NEVER,		//niemals
	LM_ON_DEMAND,	//auf nachfrage
	LM_UNKNOWN		//Shit happens
};


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

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

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

// enum with values equal to old DBObject enum from sdb
enum ScDBObject
{
	ScDbTable,
	ScDbQuery
};

struct ScImportParam
{
	SCCOL			nCol1;
	SCROW			nRow1;
	SCCOL			nCol2;
	SCROW			nRow2;
	sal_Bool			bImport;
	String			aDBName;					// Alias der Datenbank
	String			aStatement;
	sal_Bool			bNative;
	sal_Bool			bSql;						// Statement oder Name?
	sal_uInt8			nType;						// enum DBObject

	ScImportParam();
	ScImportParam( const ScImportParam& r );
	~ScImportParam();

	ScImportParam&	operator=	( const ScImportParam& r );
	sal_Bool			operator==	( const ScImportParam& r ) const;
//UNUSED2009-05 void			Clear		();
};

struct ScStringHashCode
{
    size_t operator()( const String& rStr ) const
    {
        return rtl_ustr_hashCode_WithLength( rStr.GetBuffer(), rStr.Len() );
    }
};

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

class ScDocument;
class ScDocShell;
class ScDocShellRef;
class SvxSearchItem;
class ScAutoFormat;
class FuncCollection;
class ScUnoAddInCollection;
class ScUserList;
class SvxBrushItem;
class ScFunctionList;
class ScFunctionMgr;
class SfxItemPool;
class SdrModel;
class EditTextObject;
class SfxObjectShell;
class SvNumberFormatter;
class ScUnitConverter;
class CharClass;
class LocaleDataWrapper;
class SvtSysLocale;
class CalendarWrapper;
class CollatorWrapper;
class IntlWrapper;
class OutputDevice;

namespace com { namespace sun { namespace star {
    namespace lang {
        struct Locale;
    }
    namespace i18n {
        class XOrdinalSuffix;
    }
}}}
namespace utl {
    class TransliterationWrapper;
}

#ifndef _SCALC_EXE
class ScGlobal
{
	static SvxSearchItem*	pSearchItem;
	static ScAutoFormat*	pAutoFormat;
	static FuncCollection*	pFuncCollection;
	static ScUnoAddInCollection* pAddInCollection;
	static ScUserList*		pUserList;
	static String**			ppRscString;
	static String* 			pStrScDoc;
	static String*          pEmptyString;
	static String*			pStrClipDocName;
	static SvxBrushItem*    pEmptyBrushItem;
	static SvxBrushItem*	pButtonBrushItem;
	static SvxBrushItem*	pEmbeddedBrushItem;
	static SvxBrushItem*	pProtectedBrushItem;

    static ImageList*       pOutlineBitmaps;
    static ImageList*       pOutlineBitmapsHC;

//	static Bitmap*			pAnchorBitmap;
//	static Bitmap*			pGrayAnchorBitmap;

	static ScFunctionList*	pStarCalcFunctionList;
	static ScFunctionMgr*	pStarCalcFunctionMgr;

	static ScUnitConverter*	pUnitConverter;

    static  SvNumberFormatter*  pEnglishFormatter;          // for UNO / XML export

    static ::com::sun::star::uno::Reference< ::com::sun::star::i18n::XOrdinalSuffix> xOrdinalSuffix;
    static CalendarWrapper*		pCalendar;
    static CollatorWrapper*		pCaseCollator;
    static CollatorWrapper*		pCollator;
    static ::utl::TransliterationWrapper* pTransliteration;
    static ::utl::TransliterationWrapper* pCaseTransliteration;
    static IntlWrapper*         pScIntlWrapper;
    static ::com::sun::star::lang::Locale*		pLocale;

public:	
    static SvtSysLocale*        pSysLocale;
    // for faster access a pointer to the single instance provided by SvtSysLocale
    SC_DLLPUBLIC static const CharClass*     pCharClass;
    // for faster access a pointer to the single instance provided by SvtSysLocale
    SC_DLLPUBLIC static const LocaleDataWrapper* pLocaleData;
    SC_DLLPUBLIC static const LocaleDataWrapper* GetpLocaleData();

    static CalendarWrapper*     GetCalendar();
    SC_DLLPUBLIC static CollatorWrapper*		GetCollator();
    static CollatorWrapper*		GetCaseCollator();
    static IntlWrapper*         GetScIntlWrapper();
    static ::com::sun::star::lang::Locale*		GetLocale();
    
    SC_DLLPUBLIC static ::utl::TransliterationWrapper* GetpTransliteration(); //CHINA001
    static ::utl::TransliterationWrapper* GetCaseTransliteration();
    
    SC_DLLPUBLIC static LanguageType	   		eLnge;
	static sal_Unicode			cListDelimiter;

	static const String&	 	GetClipDocName();
	static void 			 	SetClipDocName( const String& rNew );
	SC_DLLPUBLIC static const SvxSearchItem&	GetSearchItem();
	SC_DLLPUBLIC static void					SetSearchItem( const SvxSearchItem& rNew );
    SC_DLLPUBLIC static ScAutoFormat*		GetAutoFormat();
	static void					ClearAutoFormat(); //BugId 54209
	static FuncCollection*		GetFuncCollection();
    SC_DLLPUBLIC static ScUnoAddInCollection* GetAddInCollection();
    SC_DLLPUBLIC static ScUserList*			GetUserList();
	static void					SetUserList( const ScUserList* pNewList );
    SC_DLLPUBLIC static const String&		GetRscString( sal_uInt16 nIndex );
	static void					OpenURL( const String& rURL, const String& rTarget );
    SC_DLLPUBLIC static String				GetAbsDocName( const String& rFileName,
												SfxObjectShell* pShell );
    SC_DLLPUBLIC static String				GetDocTabName( const String& rFileName,
												const String& rTabName );
    SC_DLLPUBLIC static sal_uLong				GetStandardFormat( SvNumberFormatter&,
									sal_uLong nFormat, short nType );
    SC_DLLPUBLIC static sal_uLong				GetStandardFormat( double, SvNumberFormatter&,
									sal_uLong nFormat, short nType );

    SC_DLLPUBLIC static double				nScreenPPTX;
    SC_DLLPUBLIC static double				nScreenPPTY;

	static ScDocShellRef*	pDrawClipDocShellRef;

	static sal_uInt16			nDefFontHeight;
	static sal_uInt16			nStdRowHeight;

    SC_DLLPUBLIC static long				nLastRowHeightExtra;
	static long				nLastColWidthExtra;

	static void             Init();						// am Anfang
	static void             InitAddIns();
	static void				Clear();					// bei Programmende

	static void				UpdatePPT(OutputDevice* pDev);

	static void             InitTextHeight(SfxItemPool* pPool);
	static SvxBrushItem*	GetEmptyBrushItem()	{ return pEmptyBrushItem; }
    static SvxBrushItem*    GetButtonBrushItem();
	static SvxBrushItem*	GetEmbeddedBrushItem()	{ return pEmbeddedBrushItem; }
	static SvxBrushItem*	GetProtectedBrushItem()	{ return pProtectedBrushItem; }
    SC_DLLPUBLIC    static const String&	GetEmptyString();
	static const String& 	GetScDocString();

    /** Returns the specified image list with outline symbols.
        @param bHC  false = standard symbols; true = high contrast symbols. */
    static ImageList*       GetOutlineSymbols( bool bHC );

//	static const Bitmap&	GetAnchorBitmap();
//	static const Bitmap&	GetGrayAnchorBitmap();

    static bool             HasStarCalcFunctionList();
	static ScFunctionList*	GetStarCalcFunctionList();
	static ScFunctionMgr*	GetStarCalcFunctionMgr();
    static void             ResetFunctionList();

	static String			GetErrorString(sal_uInt16 nErrNumber);
	static String			GetLongErrorString(sal_uInt16 nErrNumber);
	static sal_Bool				EETextObjEqual( const EditTextObject* pObj1,
											const EditTextObject* pObj2 );
	static sal_Bool				CheckWidthInvalidate( sal_Bool& bNumFormatChanged,
												  const SfxItemSet& rNewAttrs,
												  const SfxItemSet& rOldAttrs );
	static sal_Bool				HasAttrChanged( const SfxItemSet& rNewAttrs,
											const SfxItemSet& rOldAttrs,
											const sal_uInt16	  nWhich );

	static ScUnitConverter*	GetUnitConverter();

	/// strchr() functionality on unicode, as long as we need it for ScToken etc.
	static const sal_Unicode* UnicodeStrChr( const sal_Unicode* pStr, sal_Unicode c );

	static inline sal_Unicode ToUpperAlpha( sal_Unicode c )
		{ return ( c >= 'a' && c <= 'z' ) ? ( c-'a'+'A' ) : c; }

    /** Adds the string rToken to rTokenList, using a list separator character.
        @param rTokenList  The string list where the token will be appended to.
        @param rToken  The token string to append to the token list.
        @param cSep  The character to separate the tokens.
        @param nSepCount  Specifies how often cSep is inserted between two tokens.
        @param bForceSep  true = Always insert separator; false = Only, if not at begin or end. */
    SC_DLLPUBLIC static void             AddToken(
                                String& rTokenList, const String& rToken,
                                sal_Unicode cSep, xub_StrLen nSepCount = 1,
                                bool bForceSep = false );

    /** Returns true, if the first and last character of the string is cQuote. */
    SC_DLLPUBLIC static bool             IsQuoted( const String& rString, sal_Unicode cQuote = '\'' );

    /** Inserts the character cQuote at beginning and end of rString.
        @param bEscapeEmbedded      If <TRUE/>, embedded quote characters are
                                    escaped by doubling them.
     */
SC_DLLPUBLIC    static void             AddQuotes( String& rString, sal_Unicode cQuote = '\'', bool bEscapeEmbedded = true );

    /** Erases the character cQuote from rString, if it exists at beginning AND end.
        @param bUnescapeEmbedded    If <TRUE/>, embedded doubled quote characters
                                    are unescaped by replacing them with a
                                    single instance.
     */
SC_DLLPUBLIC    static void             EraseQuotes( String& rString, sal_Unicode cQuote = '\'', bool bUnescapeEmbedded = true );

    /** Finds an unquoted instance of cChar in rString, starting at
        offset nStart. Unquoted instances may occur when concatenating two
        quoted strings with a separator, for example, 's1':'s2'. Embedded
        quotes have to be escaped by being doubled. Caller must ensure that
        nStart points into an unquoted range or the opening quote. Specialty:
        if cChar==cQuote the first cQuote character from nStart on is found.
        @returns offset if found, else STRING_NOTFOUND
     */
SC_DLLPUBLIC    static xub_StrLen       FindUnquoted( const String& rString, sal_Unicode cChar, xub_StrLen nStart = 0, sal_Unicode cQuote = '\'' );

    /** Finds an unquoted instance of cChar in null-terminated pString. Same
        semantics as FindUnquoted( const String&, ...)
        @returns: pointer to cChar if found, else NULL
     */
SC_DLLPUBLIC    static const sal_Unicode* FindUnquoted( const sal_Unicode* pString, sal_Unicode cChar, sal_Unicode cQuote = '\'' );


	static	CharSet			GetCharsetValue( const String& rCharSet );
	static	String			GetCharsetString( CharSet eVal );

    /// a "ReadOnly" formatter for UNO/XML export
    static  SvNumberFormatter*  GetEnglishFormatter();

	static sal_Bool IsSystemRTL();						// depending on system language
	static LanguageType GetEditDefaultLanguage();	// for EditEngine::SetDefaultLanguage
    SC_DLLPUBLIC static sal_uInt8	GetDefaultScriptType();				// for all WEAK characters
    /** Map ATTR_((CJK|CTL)_)?FONT_... to proper WhichIDs.
        If more than one SCRIPTTYPE_... values are or'ed together, prefers
        first COMPLEX, then ASIAN */
    SC_DLLPUBLIC static sal_uInt16 GetScriptedWhichID( sal_uInt8 nScriptType, sal_uInt16 nWhich );

    /** Adds a language item to the item set, if the number format item contains
        a language that differs from its parent's language. */
    SC_DLLPUBLIC static void             AddLanguage( SfxItemSet& rSet, SvNumberFormatter& rFormatter );

    /** Obtain the ordinal suffix for a number according to the system locale */
    static String           GetOrdinalSuffix( sal_Int32 nNumber);
};
#endif

//==================================================================
// evtl. in dbdata.hxx auslagern (?):

enum ScQueryOp
	{
		SC_EQUAL,
		SC_LESS,
		SC_GREATER,
		SC_LESS_EQUAL,
		SC_GREATER_EQUAL,
		SC_NOT_EQUAL,
		SC_TOPVAL,
		SC_BOTVAL,
		SC_TOPPERC,
        SC_BOTPERC,
        SC_CONTAINS,
        SC_DOES_NOT_CONTAIN,
        SC_BEGINS_WITH,
        SC_DOES_NOT_BEGIN_WITH,
        SC_ENDS_WITH,
        SC_DOES_NOT_END_WITH
	};

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

enum ScQueryConnect
	{
		SC_AND,
		SC_OR
	};

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

enum ScSubTotalFunc
	{
		SUBTOTAL_FUNC_NONE	= 0,
		SUBTOTAL_FUNC_AVE	= 1,
		SUBTOTAL_FUNC_CNT	= 2,
		SUBTOTAL_FUNC_CNT2	= 3,
		SUBTOTAL_FUNC_MAX	= 4,
		SUBTOTAL_FUNC_MIN	= 5,
		SUBTOTAL_FUNC_PROD	= 6,
		SUBTOTAL_FUNC_STD	= 7,
		SUBTOTAL_FUNC_STDP	= 8,
		SUBTOTAL_FUNC_SUM	= 9,
		SUBTOTAL_FUNC_VAR	= 10,
		SUBTOTAL_FUNC_VARP	= 11
	};


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

/*
 * Dialog liefert die ausgezeichneten Feldwerte "leer"/"nicht leer"
 * als Konstanten SC_EMPTYFIELDS bzw. SC_NONEMPTYFIELDS in nVal in
 * Verbindung mit dem Schalter bQueryByString auf FALSE.
 */

#define SC_EMPTYFIELDS		((double)0x0042)
#define SC_NONEMPTYFIELDS	((double)0x0043)

namespace utl
{
	class SearchParam;
	class TextSearch;
}

struct ScQueryEntry
{
	sal_Bool			bDoQuery;
	sal_Bool			bQueryByString;
    bool            bQueryByDate;
	SCCOLROW		nField;
	ScQueryOp		eOp;
	ScQueryConnect  eConnect;
	String*			pStr;
	double			nVal;
	utl::SearchParam*	pSearchParam;		// falls RegExp, nicht gespeichert
	utl::TextSearch*	pSearchText;		// falls RegExp, nicht gespeichert

	ScQueryEntry();
	ScQueryEntry(const ScQueryEntry& r);
	~ScQueryEntry();

	// legt ggbf. pSearchParam und pSearchText an, immer RegExp!
	utl::TextSearch*	GetSearchTextPtr( sal_Bool bCaseSens );

	void			Clear();
	ScQueryEntry&	operator=( const ScQueryEntry& r );
	sal_Bool			operator==( const ScQueryEntry& r ) const;
};

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

struct SC_DLLPUBLIC ScSubTotalParam
{
	SCCOL			nCol1;			// Selektierter Bereich
	SCROW			nRow1;
	SCCOL			nCol2;
	SCROW			nRow2;
	sal_Bool			bRemoveOnly;
	sal_Bool			bReplace;					// vorhandene Ergebnisse ersetzen
	sal_Bool			bPagebreak;					// Seitenumbruch bei Gruppenwechsel
	sal_Bool			bCaseSens;					// Gross-/Kleinschreibung
	sal_Bool			bDoSort;					// vorher sortieren
	sal_Bool			bAscending;					// aufsteigend sortieren
	sal_Bool			bUserDef;					// Benutzer-def. Sort.Reihenfolge
	sal_uInt16			nUserIndex;                 // Index auf Liste
	sal_Bool			bIncludePattern;			// Formate mit sortieren
	sal_Bool			bGroupActive[MAXSUBTOTAL];	// aktive Gruppen
	SCCOL			nField[MAXSUBTOTAL];		// zugehoeriges Feld
	SCCOL			nSubTotals[MAXSUBTOTAL];	// Anzahl der SubTotals
	SCCOL*			pSubTotals[MAXSUBTOTAL];	// Array der zu berechnenden Spalten
	ScSubTotalFunc*	pFunctions[MAXSUBTOTAL];	// Array der zugehoerige Funktionen

	ScSubTotalParam();
	ScSubTotalParam( const ScSubTotalParam& r );

	ScSubTotalParam&	operator=		( const ScSubTotalParam& r );
	sal_Bool				operator==		( const ScSubTotalParam& r ) const;
	void				Clear			();
	void 				SetSubTotals	( sal_uInt16				nGroup,
										  const SCCOL*			ptrSubTotals,
										  const ScSubTotalFunc*	ptrFuncions,
										  sal_uInt16				nCount );
};

// -----------------------------------------------------------------------
class ScArea;

struct ScConsolidateParam
{
	SCCOL			nCol;					// Cursor Position /
	SCROW			nRow;					// bzw. Anfang des Zielbereiches
	SCTAB			nTab;
	ScSubTotalFunc	eFunction;				// Berechnungsvorschrift
	sal_uInt16			nDataAreaCount;			// Anzahl der Datenbereiche
	ScArea**		ppDataAreas;			// Zeiger-Array auf Datenbereiche
	sal_Bool			bByCol;					// nach Spalten
	sal_Bool			bByRow;					// nach Zeilen
	sal_Bool			bReferenceData;			// Quelldaten referenzieren

	ScConsolidateParam();
	ScConsolidateParam( const ScConsolidateParam& r );
	~ScConsolidateParam();

	ScConsolidateParam&	operator=		( const ScConsolidateParam& r );
	sal_Bool				operator==		( const ScConsolidateParam& r ) const;
	void				Clear			(); // = ClearDataAreas()+Members
	void				ClearDataAreas	();
	void				SetAreas		( ScArea* const* ppAreas, sal_uInt16 nCount );
};

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

#endif

Lines 192-197 Link Here

(-)sc/source/core/data/documen3.cxx (-1 / +9 lines)
192	else	192	else
193	return NULL;	193	return NULL;
194	}	194	}
		195	ScDBData* ScDocument::GetDBAtTable(SCTAB nTab, ScGetDBMode eMode) const
		196	{
		197	if (pDBCollection)
		198	return pDBCollection->GetDBAtTable(nTab, eMode);
		199	else
		200	return NULL;
		201	}
195		202
196	ScDBData* ScDocument::GetFilterDBAtTable(SCTAB nTab) const	203	ScDBData* ScDocument::GetFilterDBAtTable(SCTAB nTab) const
197	{	204	{
Lines 1291-1297 Link Here
1291		1298
1292	sal_Bool ScDocument::HasAutoFilter( SCCOL nCurCol, SCROW nCurRow, SCTAB nCurTab )	1299	sal_Bool ScDocument::HasAutoFilter( SCCOL nCurCol, SCROW nCurRow, SCTAB nCurTab )
1293	{	1300	{
1294	ScDBData* pDBData = GetDBAtCursor( nCurCol, nCurRow, nCurTab );	1301	//ScDBData* pDBData = GetDBAtCursor( nCurCol, nCurRow, nCurTab );
		1302	ScDBData* pDBData = GetDBAtTable(nCurTab, SC_DB_OLD_FILTER);
1295	sal_Bool bHasAutoFilter = ( pDBData != NULL );	1303	sal_Bool bHasAutoFilter = ( pDBData != NULL );
1296		1304
1297	if ( pDBData )	1305	if ( pDBData )

Lines 36-41 Link Here

(-)sc/source/core/tool/dbcolect.cxx (-6 / +71 lines)
36	#include "queryparam.hxx"	36	#include "queryparam.hxx"
37	#include "globstr.hrc"	37	#include "globstr.hrc"
38		38
		39	#define SC_DBNAME_UNNAMED "__Anonymous_Sheet_DB__"
39		40
40	//---------------------------------------------------------------------------------------	41	//---------------------------------------------------------------------------------------
41		42
Lines 690-697 Link Here
690	{	691	{
691	return new ScDBData(*this);	692	return new ScDBData(*this);
692	}	693	}
		694	sal_Bool ScDBData::IsBuildin()
		695	{
		696	String aNoName = String::CreateFromAscii(SC_DBNAME_UNNAMED);
		697	String aBeginName = aName.Copy(0,22);
		698	return (sal_Bool)(!ScGlobal::GetpTransliteration()->compareString( aNoName, aBeginName ));
		699	}
693		700
694
695	//---------------------------------------------------------------------------------------	701	//---------------------------------------------------------------------------------------
696	// Compare zum Sortieren	702	// Compare zum Sortieren
697		703
Lines 714-726 Link Here
714	ScDBData* pNoNameData = NULL;	720	ScDBData* pNoNameData = NULL;
715	if (pItems)	721	if (pItems)
716	{	722	{
717	const String& rNoName = ScGlobal::GetRscString( STR_DB_NONAME );
718		723
719	for (sal_uInt16 i = 0; i < nCount; i++)	724	for (sal_uInt16 i = 0; i < nCount; i++)
720	if (((ScDBData*)pItems[i])->IsDBAtCursor(nCol, nRow, nTab, bStartOnly))	725	if (((ScDBData*)pItems[i])->IsDBAtCursor(nCol, nRow, nTab, bStartOnly))
721	{	726	{
722	ScDBData* pDB = (ScDBData*)pItems[i];	727	ScDBData* pDB = (ScDBData*)pItems[i];
723	if ( pDB->GetName() == rNoName )	728	if ( pDB->IsBuildin() )
724	pNoNameData = pDB;	729	pNoNameData = pDB;
725	else	730	else
726	return pDB;	731	return pDB;
Lines 734-746 Link Here
734	ScDBData* pNoNameData = NULL;	739	ScDBData* pNoNameData = NULL;
735	if (pItems)	740	if (pItems)
736	{	741	{
737	const String& rNoName = ScGlobal::GetRscString( STR_DB_NONAME );
738		742
739	for (sal_uInt16 i = 0; i < nCount; i++)	743	for (sal_uInt16 i = 0; i < nCount; i++)
740	if (((ScDBData*)pItems[i])->IsDBAtArea(nTab, nCol1, nRow1, nCol2, nRow2))	744	if (((ScDBData*)pItems[i])->IsDBAtArea(nTab, nCol1, nRow1, nCol2, nRow2))
741	{	745	{
742	ScDBData* pDB = (ScDBData*)pItems[i];	746	ScDBData* pDB = (ScDBData*)pItems[i];
743	if ( pDB->GetName() == rNoName )	747	if ( pDB->IsBuildin() )
744	pNoNameData = pDB;	748	pNoNameData = pDB;
745	else	749	else
746	return pDB;	750	return pDB;
Lines 903-908 Link Here
903	return bInserted;	907	return bInserted;
904	}	908	}
905		909
		910	String ScDBCollection::GetNewDefaultDBName()
		911	{
		912	String aNoName = String::CreateFromAscii(SC_DBNAME_UNNAMED);
		913	String aNewName;
		914	unsigned short nDummy;
		915	int i = 1;
		916	do
		917	{
		918	aNewName = aNoName;
		919	aNewName += String::CreateFromInt32( i++ );
		920	}while(SearchName(aNewName,nDummy));
		921	return aNewName;
		922	}
		923	/*
		924	sal_Bool ScDBCollection::IsFiltered(SCTAB nTab, SCROW nRow)
		925	{
		926	SCCOL nLastCol;
		927	SCROW nLastRow;
		928	pDoc->GetLastAttrCellArea(nTab, nLastCol, nLastRow);
906		929
		930	if ( pItems )
		931	{
		932	for (unsigned short i = 0; i < nCount; i++)
		933	{
		934	ScDBData* pData = (ScDBData*)pItems[i];
		935	if ( pData->nTable == nTab && pData->HasQueryParam() && pData->bQueryInplace )
		936	if ( nRow >= (pData->nStartRow + (pData->HasHeader()?1:0)) && nRow <= pData->nEndRow && nRow <= nLastRow )
		937	return sal_True;
		938	}
		939	}
		940	return sal_False;
		941	}
		942	*/
		943	ScDBData* ScDBCollection::GetDBAtTable(SCTAB nTab, ScGetDBMode eMode) const
		944	{
		945	ScDBData* pDataEmpty = NULL;
		946	if (pItems)
		947	{
		948	for (unsigned short i = 0; i < nCount; i++)
		949	{
		950	ScDBData* pDBTemp = (ScDBData*)pItems[i];
		951	if ( pDBTemp->nTable == nTab ) //Sym2_7885 mod
		952	{
		953	sal_Bool bImport = pDBTemp->HasImportParam();
		954	sal_Bool bFilter = pDBTemp->HasAutoFilter() \|\| pDBTemp->HasQueryParam();
		955	sal_Bool bSort = pDBTemp->HasSortParam();
		956	sal_Bool bSubtotal = pDBTemp->HasSubTotalParam();
		957	sal_Bool bAnyParam = bImport \|\| bFilter \|\| bSort \|\| bSubtotal;
		958	if ( ((eMode == SC_DB_MAKE_SORT) && bSort && !bFilter) \|\| //Sym2_7334 mod 20100420
		959	((eMode == SC_DB_MAKE_SUBTOTAL) && bSubtotal && !bFilter ) \|\|
		960	((eMode == SC_DB_MAKE_FILTER \|\| eMode == SC_DB_OLD_FILTER) && bFilter ) )
		961	{
		962	return pDBTemp;
		963	}
		964	else if ( pDBTemp->IsBuildin() && !bAnyParam ) //Sym2_7885 mod
		965	{
		966	pDataEmpty = pDBTemp;
		967	}
		968	}
		969	}
		970	}
907		971
908		972	return pDataEmpty;
		973	}

Lines 1032-1038 Link Here

(-)sc/source/core/tool/rangeutl.cxx (-1 / +2 lines)
1032	if ( pDBCollection && nPos < pDBCollection->GetCount() )	1032	if ( pDBCollection && nPos < pDBCollection->GetCount() )
1033	{	1033	{
1034	ScDBData* pData = (*pDBCollection)[nPos++];	1034	ScDBData* pData = (*pDBCollection)[nPos++];
1035	if (pData && pData->GetName() != aStrNoName)	1035	// if (pData && pData->GetName() != aStrNoName)
		1036	if (pData && !pData->IsBuildin())
1036	{	1037	{
1037	pData->GetArea( rRange );	1038	pData->GetArea( rRange );
1038	rName = pData->GetName();	1039	rName = pData->GetName();




					&& (rEnd.Col()   == nCol2) && (rEnd.Row()   == nRow2 ) )
				{
					pDBData->GetName( theDbName );
					//if ( theDbName != aStrNoName )
					if ( !pDBData->IsBuildin() )
						aEdName.SetText( theDbName );
					else
						aEdName.SetText( EMPTY_STRING );

			if ( pDbData )
			{
				pDbData->GetName( aString );
				//if ( aString != aStrNoName )
				if ( !pDbData->IsBuildin() )
					aEdName.InsertEntry( aString );
			}
		}

Lines 186-192 Link Here

(-)sc/source/ui/dbgui/foptmgr.cxx (-1 / +1 lines)
186	rBtnHeader.Check( pDBData->HasHeader() );	186	rBtnHeader.Check( pDBData->HasHeader() );
187	pDBData->GetName( theDbName );	187	pDBData->GetName( theDbName );
188		188
189	if ( theDbName != rStrNoName )	189	if ( !pDBData->IsBuildin() )
190	{	190	{
191	rBtnHeader.Disable();	191	rBtnHeader.Disable();
192	}	192	}

Lines 592-598 Link Here

(-)sc/source/ui/docshell/dbdocfun.cxx (-2 / +2 lines)
592	if (pDestData)	592	if (pDestData)
593	pNewData = pDestData; // Bereich vorhanden -> anpassen	593	pNewData = pDestData; // Bereich vorhanden -> anpassen
594	else // Bereich ab Cursor/Markierung wird angelegt	594	else // Bereich ab Cursor/Markierung wird angelegt
595	pNewData = rDocShell.GetDBData(aDestPos, SC_DB_MAKE, SC_DBSEL_FORCE_MARK );	595	pNewData = rDocShell.GetDBData(aDestPos, SC_DB_MAKE_SORT, SC_DBSEL_FORCE_MARK );
596	if (pNewData)	596	if (pNewData)
597	{	597	{
598	pNewData->SetArea( nTab,	598	pNewData->SetArea( nTab,
Lines 919-925 Link Here
919	pNewData = rDocShell.GetDBData(	919	pNewData = rDocShell.GetDBData(
920	ScRange( aLocalParam.nCol1, aLocalParam.nRow1, nDestTab,	920	ScRange( aLocalParam.nCol1, aLocalParam.nRow1, nDestTab,
921	aLocalParam.nCol2, aLocalParam.nRow2, nDestTab ),	921	aLocalParam.nCol2, aLocalParam.nRow2, nDestTab ),
922	SC_DB_MAKE, SC_DBSEL_FORCE_MARK );	922	SC_DB_MAKE_FILTER, SC_DBSEL_FORCE_MARK );
923		923
924	if (pNewData)	924	if (pNewData)
925	{	925	{

Lines 150-155 Link Here

(-)sc/source/ui/docshell/docsh5.cxx (-2 / +171 lines)
150		150
151	ScDBData* ScDocShell::GetDBData( const ScRange& rMarked, ScGetDBMode eMode, ScGetDBSelection eSel )	151	ScDBData* ScDocShell::GetDBData( const ScRange& rMarked, ScGetDBMode eMode, ScGetDBSelection eSel )
152	{	152	{
		153	if ( eMode == SC_DB_MAKE_FILTER \|\| eMode == SC_DB_MAKE_SORT \|\| eMode == SC_DB_MAKE_SUBTOTAL \|\| eMode == SC_DB_OLD_FILTER )
		154	return GetDBDataAdd(rMarked, eMode, eSel);
153	SCCOL nCol = rMarked.aStart.Col();	155	SCCOL nCol = rMarked.aStart.Col();
154	SCROW nRow = rMarked.aStart.Row();	156	SCROW nRow = rMarked.aStart.Row();
155	SCTAB nTab = rMarked.aStart.Tab();	157	SCTAB nTab = rMarked.aStart.Tab();
Lines 184-190 Link Here
184	SCCOL nOldCol2;	186	SCCOL nOldCol2;
185	SCROW nOldRow2;	187	SCROW nOldRow2;
186	pData->GetArea( nDummy, nOldCol1,nOldRow1, nOldCol2,nOldRow2 );	188	pData->GetArea( nDummy, nOldCol1,nOldRow1, nOldCol2,nOldRow2 );
187	sal_Bool bIsNoName = ( pData->GetName() == ScGlobal::GetRscString( STR_DB_NONAME ) );	189	// sal_Bool bIsNoName = ( pData->GetName() == ScGlobal::GetRscString( STR_DB_NONAME ) );
		190	sal_Bool bIsNoName = pData->IsBuildin();
188		191
189	if (!bSelected)	192	if (!bSelected)
190	{	193	{
Lines 322-328 Link Here
322	while (pColl->SearchName( aNewName, nDummy ));	325	while (pColl->SearchName( aNewName, nDummy ));
323	}	326	}
324	else	327	else
325	aNewName = ScGlobal::GetRscString( STR_DB_NONAME );	328	//aNewName = ScGlobal::GetRscString( STR_DB_NONAME );
		329	aNewName = pColl->GetNewDefaultDBName();
		330
326	pNoNameData = new ScDBData( aNewName, nTab,	331	pNoNameData = new ScDBData( aNewName, nTab,
327	nStartCol,nStartRow, nEndCol,nEndRow,	332	nStartCol,nStartRow, nEndCol,nEndRow,
328	sal_True, bHasHeader );	333	sal_True, bHasHeader );
Lines 351-356 Link Here
351	return pData;	356	return pData;
352	}	357	}
353		358
		359	ScDBData* ScDocShell::GetDBDataAdd( const ScRange& rMarked, ScGetDBMode eMode, ScGetDBSelection eSel )
		360	{
		361	SCCOL nCol = rMarked.aStart.Col();
		362	SCROW nRow = rMarked.aStart.Row();
		363	SCTAB nTab = rMarked.aStart.Tab();
		364
		365	SCCOL nStartCol = nCol;
		366	SCROW nStartRow = nRow;
		367	SCTAB nStartTab = nTab;
		368	SCCOL nEndCol = rMarked.aEnd.Col();
		369	SCROW nEndRow = rMarked.aEnd.Row();
		370	SCTAB nEndTab = rMarked.aEnd.Tab();
		371
		372	ScDBData* pData = NULL;
		373	ScDBData* pCursorData;
		374	pCursorData = aDocument.GetDBAtArea( nTab, nStartCol, nStartRow, nEndCol, nEndRow );
		375	if ( !pCursorData )
		376	pCursorData = aDocument.GetDBAtCursor( nStartCol, nStartRow, nTab );
		377
		378	//Get DBData at current table
		379	ScDBData* pTableData = aDocument.GetDBAtTable( nTab, eMode );
		380
		381	if ( eMode == SC_DB_OLD_FILTER )
		382	return pTableData;
		383
		384	sal_Bool bSelected = ( eSel == SC_DBSEL_FORCE_MARK \|\| rMarked.aStart != rMarked.aEnd );
		385	bool bOnlyDown = (!bSelected && eSel == SC_DBSEL_ROW_DOWN && rMarked.aStart.Row() == rMarked.aEnd.Row());
		386
		387	sal_Bool bUseThis = sal_False;
		388	if (pCursorData)
		389	{
		390	SCTAB nDummy;
		391	SCCOL nOldCol1;
		392	SCROW nOldRow1;
		393	SCCOL nOldCol2;
		394	SCROW nOldRow2;
		395	pCursorData->GetArea( nDummy, nOldCol1,nOldRow1, nOldCol2,nOldRow2 );
		396	if ( !bSelected )
		397	{
		398	ScRange tmpRange;
		399	if ( !pCursorData->IsBuildin() && pCursorData->GetAdvancedQuerySource(tmpRange))
		400	bUseThis = sal_True;
		401	else
		402	{
		403	nStartCol = nCol;
		404	nStartRow = nRow;
		405	nEndCol = nStartCol;
		406	nEndRow = nStartRow;
		407	aDocument.GetDataArea( nTab, nStartCol, nStartRow, nEndCol, nEndRow, sal_False, bOnlyDown );
		408	if ( nOldCol1 != nStartCol \|\| nOldCol2 != nEndCol \|\| nOldRow1 != nStartRow )
		409	bUseThis = sal_False;
		410	else
		411	{
		412	bUseThis = sal_True;
		413	if ( nOldRow2 != nEndRow )// Range of new end-line expand
		414	pCursorData->SetArea( nTab, nOldCol1,nOldRow1, nOldCol2,nEndRow );
		415	}
		416	}
		417
		418	}
		419	else
		420	{
		421	if ( nOldCol1 == nStartCol && nOldRow1 == nStartRow && nOldCol2 == nEndCol && nOldRow2 == nEndRow )
		422	bUseThis = sal_True;
423	else
424	bUseThis = sal_False; // Always take mark (Bug 11964)
425	}
426	}
427
428	if ( bUseThis )
429	{
430	pData = pCursorData;
431	if ( pTableData && eMode == SC_DB_MAKE_FILTER && !(pTableData == pCursorData ) )
432	{
433	if ( !pOldAutoDBRange )
434	pOldAutoDBRange = new ScDBData(*pTableData);
435	SCCOL nOldX1;
436	SCROW nOldY1;
437	SCCOL nOldX2;
438	SCROW nOldY2;
439	SCTAB nOldTab;
440	pTableData->GetArea( nOldTab, nOldX1, nOldY1, nOldX2, nOldY2 );
441
442	if (pTableData->HasQueryParam())
443	{
444	ScQueryParam aParam;
445	pTableData->GetQueryParam(aParam);
446	SCSIZE nEC = aParam.GetEntryCount();
447	for (SCSIZE i=0; i<nEC; i++)
448	aParam.GetEntry(i).bDoQuery = sal_False;
449	aParam.bDuplicate = sal_True;
450	ScDBDocFunc aDBDocFunc( *this );
451	aDBDocFunc.Query( nTab, aParam, NULL, sal_False, sal_False );
452	}
453
454	DBAreaDeleted( nOldTab, nOldX1, nOldY1, nOldX2, nOldY2 );
455	pTableData->SetQueryParam( ScQueryParam() );
456	pTableData->SetAutoFilter( sal_False );
457	}
458
459	}
460	else
461	{
462	if ( bSelected )
463	{
464	// bMark = sal_False;
465	}
466	else
467	{
468	nStartCol = nCol;
469	nStartRow = nRow;
470	nEndCol = nStartCol;
471	nEndRow = nStartRow;
472	aDocument.GetDataArea( nTab, nStartCol, nStartRow, nEndCol, nEndRow, sal_False, bOnlyDown );
473	}
474	sal_Bool bHasHeader = aDocument.HasColHeader( nStartCol,nStartRow, nEndCol,nEndRow, nTab );
475	ScDBCollection* pColl = aDocument.GetDBCollection();
476	if ( pTableData )
477	{
478	if ( !pOldAutoDBRange )
479	pOldAutoDBRange = new ScDBData(*pTableData);
480	SCCOL nOldX1;
481	SCROW nOldY1;
482	SCCOL nOldX2;
483	SCROW nOldY2;
484	SCTAB nOldTab;
485	pTableData->GetArea( nOldTab, nOldX1, nOldY1, nOldX2, nOldY2 );
486
487	if (pTableData->HasQueryParam())
488	{
489	ScQueryParam aParam;
490	pTableData->GetQueryParam(aParam);
491	SCSIZE nEC = aParam.GetEntryCount();
492	for (SCSIZE i=0; i<nEC; i++)
493	aParam.GetEntry(i).bDoQuery = sal_False;
494	aParam.bDuplicate = sal_True;
495	ScDBDocFunc aDBDocFunc( *this );
496	aDBDocFunc.Query( nTab, aParam, NULL, sal_False, sal_False );
497	}
498
499	DBAreaDeleted( nOldTab, nOldX1, nOldY1, nOldX2, nOldY2 );
500
501	pTableData->SetSortParam( ScSortParam() );
502	pTableData->SetQueryParam( ScQueryParam() );
503	pTableData->SetSubTotalParam( ScSubTotalParam() );
504
505	pTableData->SetArea( nTab, nStartCol, nStartRow, nEndCol, nEndRow );
506	pTableData->SetByRow( sal_True );
507	pTableData->SetHeader( bHasHeader );
508	pTableData->SetAutoFilter( sal_False );
509	}
510	else
511	{
512	String aNewName = pColl->GetNewDefaultDBName();
513	pTableData = new ScDBData( aNewName, nTab, nStartCol,nStartRow, nEndCol,nEndRow, sal_True, bHasHeader );
514	pColl->Insert( pTableData );
515	}
516	pData = pTableData;
517	}
518
519	return pData;
520	}
521
522
354	ScDBData* ScDocShell::GetOldAutoDBRange()	523	ScDBData* ScDocShell::GetOldAutoDBRange()
355	{	524	{
356	ScDBData* pRet = pOldAutoDBRange;	525	ScDBData* pRet = pOldAutoDBRange;

Lines 75-80 Link Here

(-)sc/source/ui/inc/dbfunc.hxx (+1 lines)
75	// DB-Bereich vom Cursor	75	// DB-Bereich vom Cursor
76	ScDBData* GetDBData( sal_Bool bMarkArea = sal_True, ScGetDBMode eMode = SC_DB_MAKE, ScGetDBSelection eSel = SC_DBSEL_KEEP );	76	ScDBData* GetDBData( sal_Bool bMarkArea = sal_True, ScGetDBMode eMode = SC_DB_MAKE, ScGetDBSelection eSel = SC_DBSEL_KEEP );
77		77
		78	//ScRange GetDBRange( BOOL bMark, bool bIgnoreNotes );
78	void NotifyCloseDbNameDlg( const ScDBCollection& rNewColl, const List& rDelAreaList );	79	void NotifyCloseDbNameDlg( const ScDBCollection& rNewColl, const List& rDelAreaList );
79		80
80	void Consolidate( const ScConsolidateParam& rParam, sal_Bool bRecord = sal_True );	81	void Consolidate( const ScConsolidateParam& rParam, sal_Bool bRecord = sal_True );




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



#ifndef SC_DOCSHELL_HXX
#define SC_DOCSHELL_HXX


#include <sfx2/objsh.hxx>

#include <sfx2/docfac.hxx>
#include <sfx2/sfxmodelfactory.hxx>
#include <sfx2/viewsh.hxx>

#include "scdllapi.h"
#include "scdll.hxx"
#include "document.hxx"
#include "shellids.hxx"
#include "refreshtimer.hxx"

#include <hash_map>

class ScEditEngineDefaulter;
class FontList;
class SfxStyleSheetBasePool;
class SfxStyleSheetHint;
struct ChartSelectionInfo;
class INetURLObject;

class ScPaintItem;
class ScViewData;
class ScDocFunc;
class ScDrawLayer;
class ScTabViewShell;
class ScSbxDocHelper;
class ScAutoStyleList;
class ScRange;
class ScMarkData;
class ScPaintLockData;
class ScJobSetup;
class ScChangeAction;
class VirtualDevice;
class ScImportOptions;
class ScDocShellModificator;
class ScOptSolverSave;
class ScSheetSaveData;

namespace sfx2 { class FileDialogHelper; }
struct DocShell_Impl;

typedef ::std::hash_map< sal_uLong, sal_uLong > ScChangeActionMergeMap;

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

//enum ScDBFormat { SC_FORMAT_SDF, SC_FORMAT_DBF };

									// Extra-Flags fuer Repaint
#define SC_PF_LINES         1
#define SC_PF_TESTMERGE     2
#define SC_PF_WHOLEROWS     4

class SC_DLLPUBLIC ScDocShell: public SfxObjectShell, public SfxListener
{
	static const sal_Char __FAR_DATA pStarCalcDoc[];
	static const sal_Char __FAR_DATA pStyleName[];

	ScDocument          aDocument;

	String				aDdeTextFmt;
	String				aConvFilterName; //@ #BugId	54198

	double				nPrtToScreenFactor;
//!   FontList*           pFontList;
    DocShell_Impl*      pImpl;
	ScDocFunc*			pDocFunc;

	//SfxObjectCreateMode	eShellMode;

	sal_Bool				bIsInplace;			// wird von der View gesetzt
	sal_Bool				bHeaderOn;
	sal_Bool				bFooterOn;
	sal_Bool				bNoInformLost;
	sal_Bool				bIsEmpty;
	sal_Bool				bIsInUndo;
	sal_Bool				bDocumentModifiedPending;
	sal_uInt16				nDocumentLock;
    sal_Int16           nCanUpdate;  // stores the UpdateDocMode from loading a document till update links
    sal_Bool                bUpdateEnabled;

    ScDBData*           pOldAutoDBRange;

	ScSbxDocHelper* 	pDocHelper;

	ScAutoStyleList*	pAutoStyleList;
	ScPaintLockData*	pPaintLockData;
	ScJobSetup*			pOldJobSetup;
    ScOptSolverSave*    pSolverSaveData;
    ScSheetSaveData*    pSheetSaveData;

    ScDocShellModificator* pModificator; // #109979#; is used to load XML (created in BeforeXMLLoading and destroyed in AfterXMLLoading)

	SC_DLLPRIVATE void			InitItems();
	SC_DLLPRIVATE void			DoEnterHandler();
    SC_DLLPRIVATE void          InitOptions(bool bForLoading);
	SC_DLLPRIVATE void			ResetDrawObjectShell();

    // SUNWS needs a forward declared friend, otherwise types and members
    // of the outer class are not accessible.
    class PrepareSaveGuard;
    friend class ScDocShell::PrepareSaveGuard;
    /** Do things that need to be done before saving to our own format and 
        necessary clean ups in dtor. */
    class PrepareSaveGuard
    {
        public:
            explicit    PrepareSaveGuard( ScDocShell & rDocShell );
                        ~PrepareSaveGuard();
        private:
                        ScDocShell & mrDocShell;
    };

    SC_DLLPRIVATE sal_Bool            LoadXML( SfxMedium* pMedium, const ::com::sun::star::uno::Reference< ::com::sun::star::embed::XStorage >& );
    SC_DLLPRIVATE sal_Bool            SaveXML( SfxMedium* pMedium, const ::com::sun::star::uno::Reference< ::com::sun::star::embed::XStorage >& );
	SC_DLLPRIVATE SCTAB			GetSaveTab();

	SC_DLLPRIVATE sal_uLong			DBaseImport( const String& rFullFileName, CharSet eCharSet,
								 sal_Bool bSimpleColWidth[MAXCOLCOUNT] );
	SC_DLLPRIVATE sal_uLong			DBaseExport( const String& rFullFileName, CharSet eCharSet,
								 sal_Bool& bHasMemo );

	SC_DLLPRIVATE static sal_Bool		MoveFile( const INetURLObject& rSource, const INetURLObject& rDest );
	SC_DLLPRIVATE static sal_Bool		KillFile( const INetURLObject& rURL );
	SC_DLLPRIVATE static sal_Bool		IsDocument( const INetURLObject& rURL );

	SC_DLLPRIVATE void			LockPaint_Impl(sal_Bool bDoc);
	SC_DLLPRIVATE void			UnlockPaint_Impl(sal_Bool bDoc);
	SC_DLLPRIVATE void			LockDocument_Impl(sal_uInt16 nNew);
	SC_DLLPRIVATE void			UnlockDocument_Impl(sal_uInt16 nNew);

    SC_DLLPRIVATE void          EnableSharedSettings( bool bEnable );
    SC_DLLPRIVATE ::com::sun::star::uno::Reference< ::com::sun::star::frame::XModel > LoadSharedDocument();
	ScDBData*		GetDBDataAdd( const ScRange& rMarked, ScGetDBMode eMode, ScGetDBSelection eSel );

    SC_DLLPRIVATE void          UseSheetSaveEntries();

protected:

	virtual void Notify( SfxBroadcaster& rBC, const SfxHint& rHint );

public:
					TYPEINFO();

					SFX_DECL_INTERFACE(SCID_DOC_SHELL)
					SFX_DECL_OBJECTFACTORY();

					ScDocShell( const ScDocShell& rDocShell );
					ScDocShell( const sal_uInt64 i_nSfxCreationFlags = SFXMODEL_EMBEDDED_OBJECT );
					~ScDocShell();

    using SotObject::GetInterface;
    using SfxShell::Activate;           // with sal_Bool bMDI
    using SfxShell::Deactivate;         // with sal_Bool bMDI
    using SfxObjectShell::Print;        // print styles

	virtual void    Activate();
	virtual void    Deactivate();

    virtual ::svl::IUndoManager*
                    GetUndoManager();

	virtual void	FillClass( SvGlobalName * pClassName,
							   sal_uInt32 * pFormat,
							   String * pAppName,
							   String * pFullTypeName,
							   String * pShortTypeName,
							   sal_Int32 nFileFormat,
                               sal_Bool bTemplate = sal_False ) const;

    virtual sal_Bool    InitNew( const ::com::sun::star::uno::Reference< ::com::sun::star::embed::XStorage >& );
    virtual sal_Bool    Load( SfxMedium& rMedium );
    virtual sal_Bool    LoadFrom( SfxMedium& rMedium );
	virtual sal_Bool    ConvertFrom( SfxMedium &rMedium );
	virtual sal_Bool    Save();
    virtual sal_Bool    SaveAs( SfxMedium& rMedium );
	virtual sal_Bool    ConvertTo( SfxMedium &rMedium );
	virtual sal_uInt16	PrepareClose( sal_Bool bUI = sal_True, sal_Bool bForBrowsing = sal_False );
	virtual void	PrepareReload();
	virtual sal_Bool	IsInformationLost();
	virtual void	LoadStyles( SfxObjectShell &rSource );
	virtual sal_Bool	Insert( SfxObjectShell &rSource,
								sal_uInt16 nSourceIdx1, sal_uInt16 nSourceIdx2, sal_uInt16 nSourceIdx3,
								sal_uInt16 &nIdx1, sal_uInt16 &nIdx2, sal_uInt16 &nIdx3, sal_uInt16 &rIdxDeleted );

    virtual sal_Bool    SaveCompleted( const ::com::sun::star::uno::Reference< ::com::sun::star::embed::XStorage >& );      // SfxInPlaceObject
	virtual sal_Bool	DoSaveCompleted( SfxMedium * pNewStor);		// SfxObjectShell
    virtual sal_Bool QuerySlotExecutable( sal_uInt16 nSlotId );

	virtual void	Draw( OutputDevice *, const JobSetup & rSetup,
								sal_uInt16 nAspect = ASPECT_CONTENT );

	virtual void    SetVisArea( const Rectangle & rVisArea );

    using SfxObjectShell::GetVisArea;
	virtual Rectangle GetVisArea( sal_uInt16 nAspect ) const;

	virtual Printer* GetDocumentPrinter();

	virtual void	SetModified( sal_Bool = sal_True );

	void			SetVisAreaOrSize( const Rectangle& rVisArea, sal_Bool bModifyStart );

	virtual SfxDocumentInfoDialog*  CreateDocumentInfoDialog( Window *pParent,
															  const SfxItemSet &rSet );

	void	GetDocStat( ScDocStat& rDocStat );

	ScDocument*     GetDocument()	{ return &aDocument; }
	ScDocFunc&		GetDocFunc()	{ return *pDocFunc; }

	SfxPrinter*		GetPrinter( sal_Bool bCreateIfNotExist = sal_True );
	sal_uInt16			SetPrinter( SfxPrinter* pNewPrinter, sal_uInt16 nDiffFlags = SFX_PRINTER_ALL );

	void			UpdateFontList();

	String			CreateObjectName( const String& rPrefix );

	ScDrawLayer*	MakeDrawLayer();

	void 			AsciiSave( SvStream& rStream, const ScImportOptions& rOpt );

	void			GetSbxState( SfxItemSet &rSet );
	void			GetDrawObjState( SfxItemSet &rSet );

	void            Execute( SfxRequest& rReq );
	void            GetState( SfxItemSet &rSet );
	void			ExecutePageStyle ( SfxViewShell& rCaller, SfxRequest& rReq, SCTAB nCurTab );
	void			GetStatePageStyle( SfxViewShell& rCaller, SfxItemSet& rSet, SCTAB nCurTab );

	void			CompareDocument( ScDocument& rOtherDoc );
    void            MergeDocument( ScDocument& rOtherDoc, bool bShared = false, bool bCheckDuplicates = false, sal_uLong nOffset = 0, ScChangeActionMergeMap* pMergeMap = NULL, bool bInverseMap = false );
    bool            MergeSharedDocument( ScDocShell* pSharedDocShell );

	ScChangeAction*	GetChangeAction( const ScAddress& rPos );
	void			SetChangeComment( ScChangeAction* pAction, const String& rComment );
	void			ExecuteChangeCommentDialog( ScChangeAction* pAction, Window* pParent,sal_Bool bPrevNext=sal_True );
                    /// Protect/unprotect ChangeTrack and return <TRUE/> if
                    /// protection was successfully changed.
                    /// If bJustQueryIfProtected==sal_True protection is not
                    /// changed and <TRUE/> is returned if not protected or
                    /// password was entered correctly.
    sal_Bool            ExecuteChangeProtectionDialog( Window* _pParent, sal_Bool bJustQueryIfProtected = sal_False );

	void			SetPrintZoom( SCTAB nTab, sal_uInt16 nScale, sal_uInt16 nPages );
	sal_Bool			AdjustPrintZoom( const ScRange& rRange );

	void			LoadStylesArgs( ScDocShell& rSource, sal_Bool bReplace, sal_Bool bCellStyles, sal_Bool bPageStyles );

	void			PageStyleModified( const String& rStyleName, sal_Bool bApi );

	void			NotifyStyle( const SfxStyleSheetHint& rHint );
	void			DoAutoStyle( const ScRange& rRange, const String& rStyle );

	Window*			GetActiveDialogParent();
	void			ErrorMessage( sal_uInt16 nGlobStrId );
	sal_Bool			IsEditable() const;

	sal_Bool			AdjustRowHeight( SCROW nStartRow, SCROW nEndRow, SCTAB nTab );
    void            UpdateAllRowHeights( const ScMarkData* pTabMark = NULL );
    void            UpdatePendingRowHeights( SCTAB nUpdateTab, bool bBefore = false );

	void			RefreshPivotTables( const ScRange& rSource );
	void			DoConsolidate( const ScConsolidateParam& rParam, sal_Bool bRecord = sal_True );
	void			UseScenario( SCTAB nTab, const String& rName, sal_Bool bRecord = sal_True );
	SCTAB			MakeScenario( SCTAB nTab, const String& rName, const String& rComment,
									const Color& rColor, sal_uInt16 nFlags,
									ScMarkData& rMark, sal_Bool bRecord = sal_True );
	void			ModifyScenario( SCTAB nTab, const String& rName, const String& rComment,
									const Color& rColor, sal_uInt16 nFlags );
	sal_Bool			MoveTable( SCTAB nSrcTab, SCTAB nDestTab, sal_Bool bCopy, sal_Bool bRecord );

	void			DoRecalc( sal_Bool bApi );
	void			DoHardRecalc( sal_Bool bApi );

	void			UpdateOle( const ScViewData* pViewData, sal_Bool bSnapSize = sal_False);
	sal_Bool		IsOle();

	void			DBAreaDeleted( SCTAB nTab, SCCOL nX1, SCROW nY1, SCCOL nX2, SCROW nY2 );
	ScDBData*		GetDBData( const ScRange& rMarked, ScGetDBMode eMode, ScGetDBSelection eSel );
    ScDBData*       GetOldAutoDBRange();    // has to be deleted by caller!
    void            CancelAutoDBRange();    // called when dialog is cancelled
	ScDBCollection* GetDBCollection(){ return aDocument.GetDBCollection();}

	void			UpdateLinks();			// Link-Eintraege aktuallisieren
	sal_Bool			ReloadTabLinks();		// Links ausfuehren (Inhalt aktualisieren)

	void            PostEditView( ScEditEngineDefaulter* pEditEngine, const ScAddress& rCursorPos );

	void            PostPaint( SCCOL nStartCol, SCROW nStartRow, SCTAB nStartTab,
							SCCOL nEndCol, SCROW nEndRow, SCTAB nEndTab, sal_uInt16 nPart,
							sal_uInt16 nExtFlags = 0 );
	void            PostPaint( const ScRange& rRange, sal_uInt16 nPart, sal_uInt16 nExtFlags = 0 );

	void            PostPaintCell( SCCOL nCol, SCROW nRow, SCTAB nTab );
	void            PostPaintCell( const ScAddress& rPos );
	void            PostPaintGridAll();
	void            PostPaintExtras();

    bool            IsPaintLocked() const { return pPaintLockData != NULL; }

	void            PostDataChanged();

	void			UpdatePaintExt( sal_uInt16& rExtFlags, SCCOL nStartCol, SCROW nStartRow, SCTAB nStartTab,
													   SCCOL nEndCol, SCROW nEndRow, SCTAB nEndTab );
	void			UpdatePaintExt( sal_uInt16& rExtFlags, const ScRange& rRange );

	void			SetDocumentModified( sal_Bool bIsModified = sal_True );
	void			SetDrawModified( sal_Bool bIsModified = sal_True );

	void			LockPaint();
	void			UnlockPaint();
	sal_uInt16			GetLockCount() const;
	void			SetLockCount(sal_uInt16 nNew);

	void			LockDocument();
	void			UnlockDocument();

    DECL_LINK( DialogClosedHdl, sfx2::FileDialogHelper* );

	virtual SfxStyleSheetBasePool*	GetStyleSheetPool();

	void			SetInplace( sal_Bool bInplace );
	sal_Bool			IsEmpty() const;
	void			SetEmpty(sal_Bool bSet);

	sal_Bool			IsInUndo() const				{ return bIsInUndo; }
	void			SetInUndo(sal_Bool bSet);

	void			CalcOutputFactor();
	double			GetOutputFactor() const;
	void			GetPageOnFromPageStyleSet( const SfxItemSet* pStyleSet,
											   SCTAB			 nCurTab,
											   sal_Bool&			 rbHeader,
											   sal_Bool&			 rbFooter );

	virtual long DdeGetData( const String& rItem, const String& rMimeType,
								::com::sun::star::uno::Any & rValue );
	virtual long DdeSetData( const String& rItem, const String& rMimeType,
								const ::com::sun::star::uno::Any & rValue );
	virtual ::sfx2::SvLinkSource* DdeCreateLinkSource( const String& rItem );

	const String& GetDdeTextFmt() const { return aDdeTextFmt; }

	SfxBindings*	GetViewBindings();

	ScTabViewShell* GetBestViewShell( sal_Bool bOnlyVisible = sal_True );
	ScSbxDocHelper* GetDocHelperObject() { return pDocHelper; }

	void			SetDocumentModifiedPending( sal_Bool bVal )
						{ bDocumentModifiedPending = bVal; }
	sal_Bool			IsDocumentModifiedPending() const
						{ return bDocumentModifiedPending; }

    sal_Bool            IsUpdateEnabled() const
                        { return bUpdateEnabled; }
    void            SetUpdateEnabled(sal_Bool bValue)
                        { bUpdateEnabled = bValue; }

	OutputDevice*	GetRefDevice();	// WYSIWYG: Printer, otherwise VirtualDevice...

	static ScViewData* GetViewData();
	static SCTAB	   GetCurTab();

	static ScDocShell* GetShellByNum( sal_uInt16 nDocNo );
	static String	GetOwnFilterName();
        static String   GetHtmlFilterName();
	static String	GetWebQueryFilterName();
	static String	GetAsciiFilterName();
	static String	GetLotusFilterName();
	static String	GetDBaseFilterName();
	static String	GetDifFilterName();
	static sal_Bool		HasAutomaticTableName( const String& rFilter );

	DECL_LINK( RefreshDBDataHdl, ScRefreshTimer* );

    void            BeforeXMLLoading();
    void            AfterXMLLoading(sal_Bool bRet);

    virtual sal_uInt16 GetHiddenInformationState( sal_uInt16 nStates );

    const ScOptSolverSave* GetSolverSaveData() const    { return pSolverSaveData; }     // may be null
    void            SetSolverSaveData( const ScOptSolverSave& rData );
	//<!--Added by PengYunQuan for Validity Cell Range Picker
	sal_Bool		AcceptStateUpdate() const;
	//-->Added by PengYunQuan for Validity Cell Range Picker
    ScSheetSaveData* GetSheetSaveData();

    // passwword protection for Calc (derived from SfxObjectShell)
    // see also:    FID_CHG_RECORD, SID_CHG_PROTECT
    virtual bool    IsChangeRecording() const;
    virtual bool    HasChangeRecordProtection() const;
    virtual void    SetChangeRecording( bool bActivate );
    virtual bool    SetProtectionPassword( const String &rPassword );
    virtual bool    GetProtectionHash( /*out*/ ::com::sun::star::uno::Sequence< sal_Int8 > &rPasswordHash );
};


void UpdateAcceptChangesDialog();


SO2_DECL_REF(ScDocShell)
SO2_IMPL_REF(ScDocShell)


// Vor Modifizierungen des Dokuments anlegen und danach zerstoeren.
// Merkt sich im Ctor AutoCalcShellDisabled und IdleDisabled, schaltet sie ab
// und stellt sie im Dtor wieder her, AutoCalcShellDisabled ggbf. auch vor
// einem ScDocShell SetDocumentModified.
// SetDocumentModified hierdran aufrufen statt an der ScDocShell.
// Im Dtor wird wenn ScDocShell bDocumentModifiedPending gesetzt ist und
// bAutoCalcShellDisabled nicht gesetzt ist ein SetDocumentModified gerufen.
class SC_DLLPUBLIC ScDocShellModificator
{
			ScDocShell&		rDocShell;
	ScRefreshTimerProtector	aProtector;
			sal_Bool			bAutoCalcShellDisabled;
			sal_Bool			bIdleDisabled;

							// not implemented
							ScDocShellModificator( const ScDocShellModificator& );
	ScDocShellModificator&	operator=( const ScDocShellModificator& );

public:
							ScDocShellModificator( ScDocShell& );
							~ScDocShellModificator();
			void			SetDocumentModified();
};



#endif



Lines 734-740 Link Here

(-)sc/source/ui/navipi/content.cxx (-1 / +2 lines)
734	{	734	{
735	ScDBData* pData = (*pDbNames)[i];	735	ScDBData* pData = (*pDbNames)[i];
736	String aStrName = pData->GetName();	736	String aStrName = pData->GetName();
737	if ( aStrName != aStrNoName )	737	//if ( aStrName != aStrNoName )
		738	if ( !pData->IsBuildin() )
738	InsertContent( SC_CONTENT_DBAREA, aStrName );	739	InsertContent( SC_CONTENT_DBAREA, aStrName );
739	}	740	}
740	}	741	}

Lines 33-38 Link Here

(-)sc/source/ui/undo/undobase.cxx (-2 / +21 lines)
33	#include "undobase.hxx"	33	#include "undobase.hxx"
34	#include "refundo.hxx"	34	#include "refundo.hxx"
35	#include "docsh.hxx"	35	#include "docsh.hxx"
		36	#include "dbdocfun.hxx"
36	#include "tabvwsh.hxx"	37	#include "tabvwsh.hxx"
37	#include "undoolk.hxx"	38	#include "undoolk.hxx"
38	#include "undodraw.hxx"	39	#include "undodraw.hxx"
Lines 390-396 Link Here
390	sal_uInt16 nNoNameIndex;	391	sal_uInt16 nNoNameIndex;
391	ScDocument* pDoc = pDocShell->GetDocument();	392	ScDocument* pDoc = pDocShell->GetDocument();
392	ScDBCollection* pColl = pDoc->GetDBCollection();	393	ScDBCollection* pColl = pDoc->GetDBCollection();
393	if ( pColl->SearchName( ScGlobal::GetRscString( STR_DB_NONAME ), nNoNameIndex ) )	394	if ( pColl->SearchName( pAutoDBRange->GetName(), nNoNameIndex ) )
394	{	395	{
395	ScDBData* pNoNameData = (*pColl)[nNoNameIndex];	396	ScDBData* pNoNameData = (*pColl)[nNoNameIndex];
396		397
Lines 403-408 Link Here
403	pDocShell->DBAreaDeleted( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );	404	pDocShell->DBAreaDeleted( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
404		405
405	pNoNameData = pAutoDBRange;	406	pNoNameData = pAutoDBRange;
		407	/*if (pAutoDBRange->HasQueryParam()) //maybe conflict with AOO
		408	{
		409	ScQueryParam aParam;
		410	pAutoDBRange->GetQueryParam(aParam);
		411	ScDBDocFunc aDBDocFunc( *pDocShell );
		412	aDBDocFunc.Query( nRangeTab, aParam, NULL, sal_False, sal_False );
		413	}*/
406		414
407	if ( pAutoDBRange->HasAutoFilter() )	415	if ( pAutoDBRange->HasAutoFilter() )
408	{	416	{
Lines 425-431 Link Here
425	sal_uInt16 nNoNameIndex;	433	sal_uInt16 nNoNameIndex;
426	ScDocument* pDoc = pDocShell->GetDocument();	434	ScDocument* pDoc = pDocShell->GetDocument();
427	ScDBCollection* pColl = pDoc->GetDBCollection();	435	ScDBCollection* pColl = pDoc->GetDBCollection();
428	if ( pColl->SearchName( ScGlobal::GetRscString( STR_DB_NONAME ), nNoNameIndex ) )	436	if ( pColl->SearchName( pAutoDBRange->GetName(), nNoNameIndex ) )
429	{	437	{
430	ScDBData* pNoNameData = (*pColl)[nNoNameIndex];	438	ScDBData* pNoNameData = (*pColl)[nNoNameIndex];
431		439
Lines 435-440 Link Here
435	SCROW nRangeY2;	443	SCROW nRangeY2;
436	SCTAB nRangeTab;	444	SCTAB nRangeTab;
437	pNoNameData->GetArea( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );	445	pNoNameData->GetArea( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
		446	/*if (pAutoDBRange->HasQueryParam())
		447	{
		448	ScQueryParam aParam;
		449	pAutoDBRange->GetQueryParam(aParam);
		450	SCSIZE nEC = aParam.GetEntryCount();
		451	for (SCSIZE i=0; i<nEC; i++)
		452	aParam.GetEntry(i).bDoQuery = sal_False;
		453	aParam.bDuplicate = sal_True;
		454	ScDBDocFunc aDBDocFunc( *pDocShell );
		455	aDBDocFunc.Query( nRangeTab, aParam, NULL, sal_False, sal_False );
		456	}*/
438	pDocShell->DBAreaDeleted( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );	457	pDocShell->DBAreaDeleted( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
439		458
440	pNoNameData->SetSortParam( ScSortParam() );	459	pNoNameData->SetSortParam( ScSortParam() );




		{
			String aName;
			pUndoData->GetName( aName );
//			if ( aName == ScGlobal::GetRscString( STR_DB_NONAME ) )
			if (pUndoData->IsBuildin())
				bWasTemp = sal_True;
		}
        DBG_ASSERT(bWasTemp, "Undo: didn't find database range");

			pRet = (*pColl)[nIndex];
		else
		{
            String	aNoNamed = pColl->GetNewDefaultDBName();
			pRet = new ScDBData( aNoNamed/*ScGlobal::GetRscString( STR_DB_NONAME )*/, nTab,
								nCol1,nRow1, nCol2,nRow2, sal_True,
								pDoc->HasColHeader( nCol1,nRow1,nCol2,nRow2,nTab ) );
			pColl->Insert( pRet );




					ScSubTotalParam aSubTotalParam;
					SfxItemSet		aArgSet( GetPool(), SCITEM_SUBTDATA, SCITEM_SUBTDATA );

					//ScDBData* pDBData = pTabViewShell->GetDBData();
                    ScDBData* pDBData = pTabViewShell->GetDBData(sal_True, SC_DB_MAKE_SUBTOTAL);
					pDBData->GetSubTotalParam( aSubTotalParam );
					aSubTotalParam.bRemoveOnly = sal_False;


                //#i60401 ux-ctest: Calc does not support all users' strategies regarding sorting data
                //the patch comes from maoyg
                ScSortParam aSortParam;
                ScDBData*	pDBData = pTabViewShell->GetDBData(sal_True, SC_DB_MAKE_SORT);
                ScViewData* pData   = GetViewData();

                pDBData->GetSortParam( aSortParam );

                if ( pArgs )		// Basic
                {
                    ScSortParam aSortParam;
                    ScDBData*	pDBData = pTabViewShell->GetDBData(sal_True, SC_DB_MAKE_SORT);
                    ScViewData* pData   = GetViewData();

                    pDBData->GetSortParam( aSortParam );

                else
                {
                    ScSortParam aSortParam;
                    ScDBData*	pDBData = pTabViewShell->GetDBData(sal_True, SC_DB_MAKE_SORT);
                    ScViewData* pData   = GetViewData();

                    pDBData->GetSortParam( aSortParam );

		case SID_UNFILTER:
			{
				ScQueryParam aParam;
				ScDBData*	 pDBData = pTabViewShell->GetDBData(sal_True, SC_DB_OLD_FILTER);

				pDBData->GetQueryParam( aParam );
				SCSIZE nEC = aParam.GetEntryCount();





	ScQueryParam	aParam;
	ScDocument*		pDoc	= GetViewData()->GetDocument();
	ScDBData*		pDBData = GetDBData( sal_False, SC_DB_OLD_FILTER, SC_DBSEL_ROW_DOWN );

	
	pDBData->GetQueryParam( aParam );


	SCCOL  nCol;
	SCROW  nRow;
	SCTAB  nTab = GetViewData()->GetTabNo();
	sal_Int16   nFlag;
	//sal_Bool	bHasAuto = sal_True;
	sal_Bool	bHeader;
	sal_Bool	bPaint   = sal_False;

	//!		stattdessen aus DB-Bereich abfragen?

	/*for (nCol=aParam.nCol1; nCol<=aParam.nCol2 && bHasAuto; nCol++)
	{
		nFlag = ((ScMergeFlagAttr*) pDoc->
				GetAttr( nCol, nRow, nTab, ATTR_MERGE_FLAG ))->GetValue();

		if ( (nFlag & SC_MF_AUTO) == 0 )
			bHasAuto = sal_False;
	}*/

	if (pDBData && pDBData->HasAutoFilter())								// aufheben
	{
		//	Filterknoepfe ausblenden
		pDBData->SetByRow( sal_True );				//! Undo, vorher abfragen ??
		pDBData->GetQueryParam( aParam );
		nRow = aParam.nRow1;
        bHeader = pDBData->HasHeader();
		for (nCol=aParam.nCol1; nCol<=aParam.nCol2; nCol++)
		{
			nFlag = ((ScMergeFlagAttr*) pDoc->

	}
	else									// Filterknoepfe einblenden
	{
        pDBData = GetDBData(sal_False, SC_DB_MAKE_FILTER);
        pDBData->SetByRow(sal_True);
        pDBData->GetQueryParam(aParam);
        nRow = aParam.nRow1;
        bHeader = pDBData->HasHeader();
	
		if ( !pDoc->IsBlockEmpty( nTab,
								  aParam.nCol1, aParam.nRow1,
								  aParam.nCol2, aParam.nRow2 ) )

	ScDocument* pDoc = pDocSh->GetDocument();

	ScQueryParam aParam;
	//ScDBData* pDBData = GetDBData( FALSE );
    ScDBData* pDBData = GetDBData(sal_False, SC_DB_OLD_FILTER);

	SCTAB nTab;
	SCCOL nCol1, nCol2;

Lines 171-177 Link Here

(-)sc/source/ui/view/tabvwshc.cxx (-2 / +2 lines)
171	SCITEM_QUERYDATA,	171	SCITEM_QUERYDATA,
172	SCITEM_QUERYDATA );	172	SCITEM_QUERYDATA );
173		173
174	ScDBData* pDBData = GetDBData( sal_True, SC_DB_MAKE, SC_DBSEL_ROW_DOWN);	174	ScDBData* pDBData = GetDBData( sal_True, SC_DB_MAKE_FILTER, SC_DBSEL_ROW_DOWN);
175	pDBData->GetQueryParam( aQueryParam );	175	pDBData->GetQueryParam( aQueryParam );
176		176
177	ScQueryItem aItem( SCITEM_QUERYDATA, GetViewData(), &aQueryParam );	177	ScQueryItem aItem( SCITEM_QUERYDATA, GetViewData(), &aQueryParam );
Lines 196-202 Link Here
196	SCITEM_QUERYDATA,	196	SCITEM_QUERYDATA,
197	SCITEM_QUERYDATA );	197	SCITEM_QUERYDATA );
198		198
199	ScDBData* pDBData = GetDBData( sal_True, SC_DB_MAKE, SC_DBSEL_ROW_DOWN);	199	ScDBData* pDBData = GetDBData( sal_True, SC_DB_MAKE_FILTER, SC_DBSEL_ROW_DOWN);
200	pDBData->GetQueryParam( aQueryParam );	200	pDBData->GetQueryParam( aQueryParam );
201		201
202	aArgSet.Put( ScQueryItem( SCITEM_QUERYDATA,	202	aArgSet.Put( ScQueryItem( SCITEM_QUERYDATA,

Return to issue 12666

Lines 266-272 Link Here

(-)sc/source/ui/dbgui/dbnamdlg.cxx (-2 / +4 lines)
266	&& (rEnd.Col() == nCol2) && (rEnd.Row() == nRow2 ) )	266	&& (rEnd.Col() == nCol2) && (rEnd.Row() == nRow2 ) )
267	{	267	{
268	pDBData->GetName( theDbName );	268	pDBData->GetName( theDbName );
269	if ( theDbName != aStrNoName )	269	//if ( theDbName != aStrNoName )
		270	if ( !pDBData->IsBuildin() )
270	aEdName.SetText( theDbName );	271	aEdName.SetText( theDbName );
271	else	272	else
272	aEdName.SetText( EMPTY_STRING );	273	aEdName.SetText( EMPTY_STRING );
Lines 378-384 Link Here
378	if ( pDbData )	379	if ( pDbData )
379	{	380	{
380	pDbData->GetName( aString );	381	pDbData->GetName( aString );
381	if ( aString != aStrNoName )	382	//if ( aString != aStrNoName )
		383	if ( !pDbData->IsBuildin() )
382	aEdName.InsertEntry( aString );	384	aEdName.InsertEntry( aString );
383	}	385	}
384	}	386	}

Lines 93-99 Link Here

(-)sc/source/ui/undo/undoutil.cxx (-2 / +4 lines)
93	{	93	{
94	String aName;	94	String aName;
95	pUndoData->GetName( aName );	95	pUndoData->GetName( aName );
96	if ( aName == ScGlobal::GetRscString( STR_DB_NONAME ) )	96	// if ( aName == ScGlobal::GetRscString( STR_DB_NONAME ) )
		97	if (pUndoData->IsBuildin())
97	bWasTemp = sal_True;	98	bWasTemp = sal_True;
98	}	99	}
99	DBG_ASSERT(bWasTemp, "Undo: didn't find database range");	100	DBG_ASSERT(bWasTemp, "Undo: didn't find database range");
Lines 104-110 Link Here
104	pRet = (*pColl)[nIndex];	105	pRet = (*pColl)[nIndex];
105	else	106	else
106	{	107	{
107	pRet = new ScDBData( ScGlobal::GetRscString( STR_DB_NONAME ), nTab,	108	String aNoNamed = pColl->GetNewDefaultDBName();
		109	pRet = new ScDBData( aNoNamed/ScGlobal::GetRscString( STR_DB_NONAME )/, nTab,
108	nCol1,nRow1, nCol2,nRow2, sal_True,	110	nCol1,nRow1, nCol2,nRow2, sal_True,
109	pDoc->HasColHeader( nCol1,nRow1,nCol2,nRow2,nTab ) );	111	pDoc->HasColHeader( nCol1,nRow1,nCol2,nRow2,nTab ) );
110	pColl->Insert( pRet );	112	pColl->Insert( pRet );

Lines 357-363 Link Here

(-)sc/source/ui/view/cellsh2.cxx (-5 / +6 lines)
357	ScSubTotalParam aSubTotalParam;	357	ScSubTotalParam aSubTotalParam;
358	SfxItemSet aArgSet( GetPool(), SCITEM_SUBTDATA, SCITEM_SUBTDATA );	358	SfxItemSet aArgSet( GetPool(), SCITEM_SUBTDATA, SCITEM_SUBTDATA );
359		359
360	ScDBData* pDBData = pTabViewShell->GetDBData();	360	//ScDBData* pDBData = pTabViewShell->GetDBData();
		361	ScDBData* pDBData = pTabViewShell->GetDBData(sal_True, SC_DB_MAKE_SUBTOTAL);
361	pDBData->GetSubTotalParam( aSubTotalParam );	362	pDBData->GetSubTotalParam( aSubTotalParam );
362	aSubTotalParam.bRemoveOnly = sal_False;	363	aSubTotalParam.bRemoveOnly = sal_False;
363		364
Lines 411-417 Link Here
411	//#i60401 ux-ctest: Calc does not support all users' strategies regarding sorting data	412	//#i60401 ux-ctest: Calc does not support all users' strategies regarding sorting data
412	//the patch comes from maoyg	413	//the patch comes from maoyg
413	ScSortParam aSortParam;	414	ScSortParam aSortParam;
414	ScDBData* pDBData = pTabViewShell->GetDBData();	415	ScDBData* pDBData = pTabViewShell->GetDBData(sal_True, SC_DB_MAKE_SORT);
415	ScViewData* pData = GetViewData();	416	ScViewData* pData = GetViewData();
416		417
417	pDBData->GetSortParam( aSortParam );	418	pDBData->GetSortParam( aSortParam );
Lines 462-468 Link Here
462	if ( pArgs ) // Basic	463	if ( pArgs ) // Basic
463	{	464	{
464	ScSortParam aSortParam;	465	ScSortParam aSortParam;
465	ScDBData* pDBData = pTabViewShell->GetDBData();	466	ScDBData* pDBData = pTabViewShell->GetDBData(sal_True, SC_DB_MAKE_SORT);
466	ScViewData* pData = GetViewData();	467	ScViewData* pData = GetViewData();
467		468
468	pDBData->GetSortParam( aSortParam );	469	pDBData->GetSortParam( aSortParam );
Lines 525-531 Link Here
525	else	526	else
526	{	527	{
527	ScSortParam aSortParam;	528	ScSortParam aSortParam;
528	ScDBData* pDBData = pTabViewShell->GetDBData();	529	ScDBData* pDBData = pTabViewShell->GetDBData(sal_True, SC_DB_MAKE_SORT);
529	ScViewData* pData = GetViewData();	530	ScViewData* pData = GetViewData();
530		531
531	pDBData->GetSortParam( aSortParam );	532	pDBData->GetSortParam( aSortParam );
Lines 680-686 Link Here
680	case SID_UNFILTER:	681	case SID_UNFILTER:
681	{	682	{
682	ScQueryParam aParam;	683	ScQueryParam aParam;
683	ScDBData* pDBData = pTabViewShell->GetDBData();	684	ScDBData* pDBData = pTabViewShell->GetDBData(sal_True, SC_DB_OLD_FILTER);
684		685
685	pDBData->GetQueryParam( aParam );	686	pDBData->GetQueryParam( aParam );
686	SCSIZE nEC = aParam.GetEntryCount();	687	SCSIZE nEC = aParam.GetEntryCount();

Lines 334-368 Link Here

(-)sc/source/ui/view/dbfunc.cxx (-11 / +20 lines)
334		334
335	ScQueryParam aParam;	335	ScQueryParam aParam;
336	ScDocument* pDoc = GetViewData()->GetDocument();	336	ScDocument* pDoc = GetViewData()->GetDocument();
337	ScDBData* pDBData = GetDBData( sal_False, SC_DB_MAKE, SC_DBSEL_ROW_DOWN );	337	ScDBData* pDBData = GetDBData( sal_False, SC_DB_OLD_FILTER, SC_DBSEL_ROW_DOWN );
338		338
339	pDBData->SetByRow( sal_True ); //! Undo, vorher abfragen ??	339
340	pDBData->GetQueryParam( aParam );
341		340
342		341
343	SCCOL nCol;	342	SCCOL nCol;
344	SCROW nRow = aParam.nRow1;	343	SCROW nRow;
345	SCTAB nTab = GetViewData()->GetTabNo();	344	SCTAB nTab = GetViewData()->GetTabNo();
346	sal_Int16 nFlag;	345	sal_Int16 nFlag;
347	sal_Bool bHasAuto = sal_True;	346	//sal_Bool bHasAuto = sal_True;
348	sal_Bool bHeader = pDBData->HasHeader();	347	sal_Bool bHeader;
349	sal_Bool bPaint = sal_False;	348	sal_Bool bPaint = sal_False;
350		349
351	//! stattdessen aus DB-Bereich abfragen?	350	//! stattdessen aus DB-Bereich abfragen?
352		351
353	for (nCol=aParam.nCol1; nCol<=aParam.nCol2 && bHasAuto; nCol++)	352	/*for (nCol=aParam.nCol1; nCol<=aParam.nCol2 && bHasAuto; nCol++)
354	{	353	{
355	nFlag = ((ScMergeFlagAttr*) pDoc->	354	nFlag = ((ScMergeFlagAttr*) pDoc->
356	GetAttr( nCol, nRow, nTab, ATTR_MERGE_FLAG ))->GetValue();	355	GetAttr( nCol, nRow, nTab, ATTR_MERGE_FLAG ))->GetValue();
357		356
358	if ( (nFlag & SC_MF_AUTO) == 0 )	357	if ( (nFlag & SC_MF_AUTO) == 0 )
359	bHasAuto = sal_False;	358	bHasAuto = sal_False;
360	}	359	}*/
361		360
362	if (bHasAuto) // aufheben	361	if (pDBData && pDBData->HasAutoFilter()) // aufheben
363	{	362	{
364	// Filterknoepfe ausblenden	363	// Filterknoepfe ausblenden
365		364	pDBData->SetByRow( sal_True ); //! Undo, vorher abfragen ??
		365	pDBData->GetQueryParam( aParam );
		366	nRow = aParam.nRow1;
		367	bHeader = pDBData->HasHeader();
366	for (nCol=aParam.nCol1; nCol<=aParam.nCol2; nCol++)	368	for (nCol=aParam.nCol1; nCol<=aParam.nCol2; nCol++)
367	{	369	{
368	nFlag = ((ScMergeFlagAttr*) pDoc->	370	nFlag = ((ScMergeFlagAttr*) pDoc->
Lines 396-401 Link Here
396	}	398	}
397	else // Filterknoepfe einblenden	399	else // Filterknoepfe einblenden
398	{	400	{
		401	pDBData = GetDBData(sal_False, SC_DB_MAKE_FILTER);
		402	pDBData->SetByRow(sal_True);
		403	pDBData->GetQueryParam(aParam);
		404	nRow = aParam.nRow1;
		405	bHeader = pDBData->HasHeader();
		406
399	if ( !pDoc->IsBlockEmpty( nTab,	407	if ( !pDoc->IsBlockEmpty( nTab,
400	aParam.nCol1, aParam.nRow1,	408	aParam.nCol1, aParam.nRow1,
401	aParam.nCol2, aParam.nRow2 ) )	409	aParam.nCol2, aParam.nRow2 ) )
Lines 457-463 Link Here
457	ScDocument* pDoc = pDocSh->GetDocument();	465	ScDocument* pDoc = pDocSh->GetDocument();
458		466
459	ScQueryParam aParam;	467	ScQueryParam aParam;
460	ScDBData* pDBData = GetDBData( sal_False );	468	//ScDBData* pDBData = GetDBData( FALSE );
		469	ScDBData* pDBData = GetDBData(sal_False, SC_DB_OLD_FILTER);
461		470
462	SCTAB nTab;	471	SCTAB nTab;
463	SCCOL nCol1, nCol2;	472	SCCOL nCol1, nCol2;