/************************************************************************* * * $RCSfile: cellsuno.cxx,v $ * * $Revision: 1.18 $ * * last change: $Author: sab $ $Date: 2001-02-14 15:29:56 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses * * - GNU Lesser General Public License Version 2.1 * - Sun Industry Standards Source License Version 1.1 * * Sun Microsystems Inc., October, 2000 * * GNU Lesser General Public License Version 2.1 * ============================================= * Copyright 2000 by Sun Microsystems, Inc. * 901 San Antonio Road, Palo Alto, CA 94303, USA * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License version 2.1, as published by the Free Software Foundation. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * MA 02111-1307 USA * * * Sun Industry Standards Source License Version 1.1 * ================================================= * The contents of this file are subject to the Sun Industry Standards * Source License Version 1.1 (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.openoffice.org/license.html. * * Software provided under this License is provided on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. * See the License for the specific provisions governing your rights and * obligations concerning the Software. * * The Initial Developer of the Original Code is: Sun Microsystems, Inc. * * Copyright: 2000 by Sun Microsystems, Inc. * * All Rights Reserved. * * Contributor(s): _______________________________________ * * ************************************************************************/ #ifdef PCH #include "ui_pch.hxx" #endif #pragma hdrstop #include "scitems.hxx" #include #define ITEMID_FIELD EE_FEATURE_FIELD #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include // SchMemChart #include #include #include #include #include // DBL_MIN #include #include #include #include #include #include #include #include #include #include #include #include "autoform.hxx" #include "cellsuno.hxx" #include "cursuno.hxx" #include "textuno.hxx" #include "editsrc.hxx" #include "notesuno.hxx" #include "fielduno.hxx" #include "docuno.hxx" // ScTableColumnsObj etc #include "datauno.hxx" #include "dapiuno.hxx" #include "chartuno.hxx" #include "fmtuno.hxx" #include "miscuno.hxx" #include "convuno.hxx" #include "srchuno.hxx" #include "targuno.hxx" #include "docsh.hxx" #include "markdata.hxx" #include "patattr.hxx" #include "docpool.hxx" #include "docfunc.hxx" #include "dbdocfun.hxx" #include "olinefun.hxx" #include "hints.hxx" #include "cell.hxx" #include "undocell.hxx" #include "undotab.hxx" #include "undoblk.hxx" // fuer lcl_ApplyBorder - nach docfunc verschieben! #include "stlsheet.hxx" #include "dbcolect.hxx" #include "attrib.hxx" #include "chartarr.hxx" #include "chartlis.hxx" #include "drwlayer.hxx" #include "printfun.hxx" #include "prnsave.hxx" #include "tablink.hxx" #include "dociter.hxx" #include "rangeutl.hxx" #include "conditio.hxx" #include "validat.hxx" #include "sc.hrc" #include "brdcst.hxx" #include "unoguard.hxx" #include "cellform.hxx" #include "globstr.hrc" #include "unonames.hxx" #include "styleuno.hxx" #include "rangeseq.hxx" using namespace com::sun::star; //------------------------------------------------------------------------ //! ScLinkListener in anderes File verschieben !!! class ScLinkListener : public SfxListener { Link aLink; public: ScLinkListener(const Link& rL) : aLink(rL) {} virtual ~ScLinkListener(); virtual void Notify( SfxBroadcaster& rBC, const SfxHint& rHint ); }; class ScNamedEntry { String aName; ScRange aRange; public: ScNamedEntry(const String& rN, const ScRange& rR) : aName(rN), aRange(rR) {} const String& GetName() const { return aName; } const ScRange& GetRange() const { return aRange; } }; //------------------------------------------------------------------------ // Die Namen in den Maps muessen (nach strcmp) sortiert sein! //! statt Which-ID 0 special IDs verwenden, und nicht ueber Namen vergleichen !!!!!!!!! // Left/Right/Top/BottomBorder are mapped directly to the core items, // not collected/applied to the borders of a range -> ATTR_BORDER can be used directly const SfxItemPropertyMap* lcl_GetCellsPropertyMap() { static SfxItemPropertyMap aCellsPropertyMap_Impl[] = { {MAP_CHAR_LEN(SC_UNONAME_BOTTBORDER),ATTR_BORDER, &::getCppuType((const table::BorderLine*)0), 0, BOTTOM_BORDER | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_CELLBACK), ATTR_BACKGROUND, &getCppuType((sal_Int32*)0), 0, MID_BACK_COLOR }, {MAP_CHAR_LEN(SC_UNONAME_CELLPRO), ATTR_PROTECTION, &getCppuType((util::CellProtection*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLSTYL), 0, &getCppuType((rtl::OUString*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CCOLOR), ATTR_FONT_COLOR, &getCppuType((sal_Int32*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_COUTL), ATTR_FONT_CONTOUR, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CCROSS), ATTR_FONT_CROSSEDOUT,&getBooleanCppuType(), 0, MID_CROSSED_OUT }, {MAP_CHAR_LEN(SC_UNONAME_CFONT), ATTR_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_FAMILY }, {MAP_CHAR_LEN(SC_UNONAME_CFCHARS), ATTR_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_CHAR_SET }, {MAP_CHAR_LEN(SC_UNO_CJK_CFCHARS), ATTR_CJK_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_CHAR_SET }, {MAP_CHAR_LEN(SC_UNO_CTL_CFCHARS), ATTR_CTL_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_CHAR_SET }, {MAP_CHAR_LEN(SC_UNONAME_CFFAMIL), ATTR_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_FAMILY }, {MAP_CHAR_LEN(SC_UNO_CJK_CFFAMIL), ATTR_CJK_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_FAMILY }, {MAP_CHAR_LEN(SC_UNO_CTL_CFFAMIL), ATTR_CTL_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_FAMILY }, {MAP_CHAR_LEN(SC_UNONAME_CFNAME), ATTR_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_FAMILY_NAME }, {MAP_CHAR_LEN(SC_UNO_CJK_CFNAME), ATTR_CJK_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_FAMILY_NAME }, {MAP_CHAR_LEN(SC_UNO_CTL_CFNAME), ATTR_CTL_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_FAMILY_NAME }, {MAP_CHAR_LEN(SC_UNONAME_CFPITCH), ATTR_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_PITCH }, {MAP_CHAR_LEN(SC_UNO_CJK_CFPITCH), ATTR_CJK_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_PITCH }, {MAP_CHAR_LEN(SC_UNO_CTL_CFPITCH), ATTR_CTL_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_PITCH }, {MAP_CHAR_LEN(SC_UNONAME_CFSTYLE), ATTR_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_STYLE_NAME }, {MAP_CHAR_LEN(SC_UNO_CJK_CFSTYLE), ATTR_CJK_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_STYLE_NAME }, {MAP_CHAR_LEN(SC_UNO_CTL_CFSTYLE), ATTR_CTL_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_STYLE_NAME }, {MAP_CHAR_LEN(SC_UNONAME_CHEIGHT), ATTR_FONT_HEIGHT, &getCppuType((float*)0), 0, MID_FONTHEIGHT | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNO_CJK_CHEIGHT), ATTR_CJK_FONT_HEIGHT,&getCppuType((float*)0), 0, MID_FONTHEIGHT | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNO_CTL_CHEIGHT), ATTR_CTL_FONT_HEIGHT,&getCppuType((float*)0), 0, MID_FONTHEIGHT | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_CLOCAL), ATTR_FONT_LANGUAGE, &getCppuType((lang::Locale*)0), 0, MID_LANG_LOCALE }, {MAP_CHAR_LEN(SC_UNO_CJK_CLOCAL), ATTR_CJK_FONT_LANGUAGE,&getCppuType((lang::Locale*)0), 0, MID_LANG_LOCALE }, {MAP_CHAR_LEN(SC_UNO_CTL_CLOCAL), ATTR_CTL_FONT_LANGUAGE,&getCppuType((lang::Locale*)0), 0, MID_LANG_LOCALE }, {MAP_CHAR_LEN(SC_UNONAME_CPOST), ATTR_FONT_POSTURE, &getCppuType((awt::FontSlant*)0), 0, MID_POSTURE }, {MAP_CHAR_LEN(SC_UNO_CJK_CPOST), ATTR_CJK_FONT_POSTURE,&getCppuType((awt::FontSlant*)0), 0, MID_POSTURE }, {MAP_CHAR_LEN(SC_UNO_CTL_CPOST), ATTR_CTL_FONT_POSTURE,&getCppuType((awt::FontSlant*)0), 0, MID_POSTURE }, {MAP_CHAR_LEN(SC_UNONAME_CSHADD), ATTR_FONT_SHADOWED, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CSTRIKE), ATTR_FONT_CROSSEDOUT,&getCppuType((sal_Int16*)0), 0, MID_CROSS_OUT }, {MAP_CHAR_LEN(SC_UNONAME_CUNDER), ATTR_FONT_UNDERLINE,&getCppuType((sal_Int16*)0), 0, MID_UNDERLINE }, {MAP_CHAR_LEN(SC_UNONAME_CWEIGHT), ATTR_FONT_WEIGHT, &getCppuType((float*)0), 0, MID_WEIGHT }, {MAP_CHAR_LEN(SC_UNO_CJK_CWEIGHT), ATTR_CJK_FONT_WEIGHT,&getCppuType((float*)0), 0, MID_WEIGHT }, {MAP_CHAR_LEN(SC_UNO_CTL_CWEIGHT), ATTR_CTL_FONT_WEIGHT,&getCppuType((float*)0), 0, MID_WEIGHT }, {MAP_CHAR_LEN(SC_UNONAME_CHCOLHDR), 0, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CHROWHDR), 0, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CONDFMT), 0, &getCppuType((uno::Reference*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CONDLOC), 0, &getCppuType((uno::Reference*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CONDXML), 0, &getCppuType((uno::Reference*)0), 0 | beans::PropertyAttribute::READONLY, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLHJUS), ATTR_HOR_JUSTIFY, &getCppuType((table::CellHoriJustify*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLTRAN), ATTR_BACKGROUND, &getBooleanCppuType(), 0, MID_GRAPHIC_TRANSPARENT }, {MAP_CHAR_LEN(SC_UNONAME_WRAP), ATTR_LINEBREAK, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_LEFTBORDER),ATTR_BORDER, &::getCppuType((const table::BorderLine*)0), 0, LEFT_BORDER | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_NUMFMT), ATTR_VALUE_FORMAT, &getCppuType((sal_Int32*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLORI), ATTR_ORIENTATION, &getCppuType((table::CellOrientation*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_PBMARGIN), ATTR_MARGIN, &getCppuType((sal_Int32*)0), 0, MID_MARGIN_LO_MARGIN | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_PINDENT), ATTR_INDENT, &getCppuType((sal_Int16*)0), 0, 0 }, //! CONVERT_TWIPS {MAP_CHAR_LEN(SC_UNONAME_PISCHDIST),ATTR_SCRIPTSPACE, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_PISFORBID),ATTR_FORBIDDEN_RULES,&getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_PISHANG), ATTR_HANGPUNCTUATION,&getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_PLMARGIN), ATTR_MARGIN, &getCppuType((sal_Int32*)0), 0, MID_MARGIN_L_MARGIN | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_PRMARGIN), ATTR_MARGIN, &getCppuType((sal_Int32*)0), 0, MID_MARGIN_R_MARGIN | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_PTMARGIN), ATTR_MARGIN, &getCppuType((sal_Int32*)0), 0, MID_MARGIN_UP_MARGIN | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_RIGHTBORDER),ATTR_BORDER, &::getCppuType((const table::BorderLine*)0), 0, RIGHT_BORDER | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_ROTANG), ATTR_ROTATE_VALUE, &getCppuType((sal_Int32*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_ROTREF), ATTR_ROTATE_MODE, &getCppuType((table::CellVertJustify*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_SHADOW), ATTR_SHADOW, &getCppuType((table::ShadowFormat*)0), 0, 0 | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_TBLBORD), 0, &getCppuType((table::TableBorder*)0), 0, 0 | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_TOPBORDER),ATTR_BORDER, &::getCppuType((const table::BorderLine*)0), 0, TOP_BORDER | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_VALIDAT), 0, &getCppuType((uno::Reference*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_VALILOC), 0, &getCppuType((uno::Reference*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_VALIXML), 0, &getCppuType((uno::Reference*)0), 0 | beans::PropertyAttribute::READONLY, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLVJUS), ATTR_VER_JUSTIFY, &getCppuType((table::CellVertJustify*)0), 0, 0 }, {0,0,0,0} }; return aCellsPropertyMap_Impl; } // CellRange enthaelt alle Eintraege von Cells, zusaetzlich eigene Eintraege // mit Which-ID 0 (werden nur fuer getPropertySetInfo benoetigt). const SfxItemPropertyMap* lcl_GetRangePropertyMap() { static SfxItemPropertyMap aRangePropertyMap_Impl[] = { {MAP_CHAR_LEN(SC_UNONAME_BOTTBORDER),ATTR_BORDER, &::getCppuType((const table::BorderLine*)0), 0, BOTTOM_BORDER | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_CELLBACK), ATTR_BACKGROUND, &getCppuType((sal_Int32*)0), 0, MID_BACK_COLOR }, {MAP_CHAR_LEN(SC_UNONAME_CELLPRO), ATTR_PROTECTION, &getCppuType((util::CellProtection*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLSTYL), 0, &getCppuType((rtl::OUString*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CCOLOR), ATTR_FONT_COLOR, &getCppuType((sal_Int32*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_COUTL), ATTR_FONT_CONTOUR, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CCROSS), ATTR_FONT_CROSSEDOUT,&getBooleanCppuType(), 0, MID_CROSSED_OUT }, {MAP_CHAR_LEN(SC_UNONAME_CFONT), ATTR_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_FAMILY }, {MAP_CHAR_LEN(SC_UNONAME_CFCHARS), ATTR_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_CHAR_SET }, {MAP_CHAR_LEN(SC_UNO_CJK_CFCHARS), ATTR_CJK_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_CHAR_SET }, {MAP_CHAR_LEN(SC_UNO_CTL_CFCHARS), ATTR_CTL_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_CHAR_SET }, {MAP_CHAR_LEN(SC_UNONAME_CFFAMIL), ATTR_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_FAMILY }, {MAP_CHAR_LEN(SC_UNO_CJK_CFFAMIL), ATTR_CJK_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_FAMILY }, {MAP_CHAR_LEN(SC_UNO_CTL_CFFAMIL), ATTR_CTL_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_FAMILY }, {MAP_CHAR_LEN(SC_UNONAME_CFNAME), ATTR_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_FAMILY_NAME }, {MAP_CHAR_LEN(SC_UNO_CJK_CFNAME), ATTR_CJK_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_FAMILY_NAME }, {MAP_CHAR_LEN(SC_UNO_CTL_CFNAME), ATTR_CTL_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_FAMILY_NAME }, {MAP_CHAR_LEN(SC_UNONAME_CFPITCH), ATTR_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_PITCH }, {MAP_CHAR_LEN(SC_UNO_CJK_CFPITCH), ATTR_CJK_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_PITCH }, {MAP_CHAR_LEN(SC_UNO_CTL_CFPITCH), ATTR_CTL_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_PITCH }, {MAP_CHAR_LEN(SC_UNONAME_CFSTYLE), ATTR_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_STYLE_NAME }, {MAP_CHAR_LEN(SC_UNO_CJK_CFSTYLE), ATTR_CJK_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_STYLE_NAME }, {MAP_CHAR_LEN(SC_UNO_CTL_CFSTYLE), ATTR_CTL_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_STYLE_NAME }, {MAP_CHAR_LEN(SC_UNONAME_CHEIGHT), ATTR_FONT_HEIGHT, &getCppuType((float*)0), 0, MID_FONTHEIGHT | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNO_CJK_CHEIGHT), ATTR_CJK_FONT_HEIGHT,&getCppuType((float*)0), 0, MID_FONTHEIGHT | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNO_CTL_CHEIGHT), ATTR_CTL_FONT_HEIGHT,&getCppuType((float*)0), 0, MID_FONTHEIGHT | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_CLOCAL), ATTR_FONT_LANGUAGE, &getCppuType((lang::Locale*)0), 0, MID_LANG_LOCALE }, {MAP_CHAR_LEN(SC_UNO_CJK_CLOCAL), ATTR_CJK_FONT_LANGUAGE,&getCppuType((lang::Locale*)0), 0, MID_LANG_LOCALE }, {MAP_CHAR_LEN(SC_UNO_CTL_CLOCAL), ATTR_CTL_FONT_LANGUAGE,&getCppuType((lang::Locale*)0), 0, MID_LANG_LOCALE }, {MAP_CHAR_LEN(SC_UNONAME_CPOST), ATTR_FONT_POSTURE, &getCppuType((awt::FontSlant*)0), 0, MID_POSTURE }, {MAP_CHAR_LEN(SC_UNO_CJK_CPOST), ATTR_CJK_FONT_POSTURE,&getCppuType((awt::FontSlant*)0), 0, MID_POSTURE }, {MAP_CHAR_LEN(SC_UNO_CTL_CPOST), ATTR_CTL_FONT_POSTURE,&getCppuType((awt::FontSlant*)0), 0, MID_POSTURE }, {MAP_CHAR_LEN(SC_UNONAME_CSHADD), ATTR_FONT_SHADOWED, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CSTRIKE), ATTR_FONT_CROSSEDOUT,&getCppuType((sal_Int16*)0), 0, MID_CROSS_OUT }, {MAP_CHAR_LEN(SC_UNONAME_CUNDER), ATTR_FONT_UNDERLINE,&getCppuType((sal_Int16*)0), 0, MID_UNDERLINE }, {MAP_CHAR_LEN(SC_UNONAME_CWEIGHT), ATTR_FONT_WEIGHT, &getCppuType((float*)0), 0, MID_WEIGHT }, {MAP_CHAR_LEN(SC_UNO_CJK_CWEIGHT), ATTR_CJK_FONT_WEIGHT,&getCppuType((float*)0), 0, MID_WEIGHT }, {MAP_CHAR_LEN(SC_UNO_CTL_CWEIGHT), ATTR_CTL_FONT_WEIGHT,&getCppuType((float*)0), 0, MID_WEIGHT }, {MAP_CHAR_LEN(SC_UNONAME_CHCOLHDR), 0, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CHROWHDR), 0, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CONDFMT), 0, &getCppuType((uno::Reference*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CONDLOC), 0, &getCppuType((uno::Reference*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CONDXML), 0, &getCppuType((uno::Reference*)0), 0 | beans::PropertyAttribute::READONLY, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLHJUS), ATTR_HOR_JUSTIFY, &getCppuType((table::CellHoriJustify*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLTRAN), ATTR_BACKGROUND, &getBooleanCppuType(), 0, MID_GRAPHIC_TRANSPARENT }, {MAP_CHAR_LEN(SC_UNONAME_WRAP), ATTR_LINEBREAK, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_LEFTBORDER),ATTR_BORDER, &::getCppuType((const table::BorderLine*)0), 0, LEFT_BORDER | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_NUMFMT), ATTR_VALUE_FORMAT, &getCppuType((sal_Int32*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLORI), ATTR_ORIENTATION, &getCppuType((table::CellOrientation*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_PBMARGIN), ATTR_MARGIN, &getCppuType((sal_Int32*)0), 0, MID_MARGIN_LO_MARGIN | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_PINDENT), ATTR_INDENT, &getCppuType((sal_Int16*)0), 0, 0 }, //! CONVERT_TWIPS {MAP_CHAR_LEN(SC_UNONAME_PISCHDIST),ATTR_SCRIPTSPACE, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_PISFORBID),ATTR_FORBIDDEN_RULES,&getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_PISHANG), ATTR_HANGPUNCTUATION,&getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_PLMARGIN), ATTR_MARGIN, &getCppuType((sal_Int32*)0), 0, MID_MARGIN_L_MARGIN | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_PRMARGIN), ATTR_MARGIN, &getCppuType((sal_Int32*)0), 0, MID_MARGIN_R_MARGIN | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_PTMARGIN), ATTR_MARGIN, &getCppuType((sal_Int32*)0), 0, MID_MARGIN_UP_MARGIN | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_POS), 0, &getCppuType((awt::Point*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_RIGHTBORDER),ATTR_BORDER, &::getCppuType((const table::BorderLine*)0), 0, RIGHT_BORDER | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_ROTANG), ATTR_ROTATE_VALUE, &getCppuType((sal_Int32*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_ROTREF), ATTR_ROTATE_MODE, &getCppuType((table::CellVertJustify*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_SHADOW), ATTR_SHADOW, &getCppuType((table::ShadowFormat*)0), 0, 0 | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_SIZE), 0, &getCppuType((awt::Size*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_TBLBORD), 0, &getCppuType((table::TableBorder*)0), 0, 0 | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_TOPBORDER),ATTR_BORDER, &::getCppuType((const table::BorderLine*)0), 0, TOP_BORDER | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_VALIDAT), 0, &getCppuType((uno::Reference*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_VALILOC), 0, &getCppuType((uno::Reference*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_VALIXML), 0, &getCppuType((uno::Reference*)0), 0 | beans::PropertyAttribute::READONLY, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLVJUS), ATTR_VER_JUSTIFY, &getCppuType((table::CellVertJustify*)0), 0, 0 }, {0,0,0,0} }; return aRangePropertyMap_Impl; } // Cell enthaelt alle Eintraege von CellRange, zusaetzlich eigene Eintraege // mit Which-ID 0 (werden nur fuer getPropertySetInfo benoetigt). const SfxItemPropertyMap* lcl_GetCellPropertyMap() { static SfxItemPropertyMap aCellPropertyMap_Impl[] = { {MAP_CHAR_LEN(SC_UNONAME_BOTTBORDER),ATTR_BORDER, &::getCppuType((const table::BorderLine*)0), 0, BOTTOM_BORDER | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_CELLBACK), ATTR_BACKGROUND, &getCppuType((sal_Int32*)0), 0, MID_BACK_COLOR }, {MAP_CHAR_LEN(SC_UNONAME_CELLPRO), ATTR_PROTECTION, &getCppuType((util::CellProtection*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLSTYL), 0, &getCppuType((rtl::OUString*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CCOLOR), ATTR_FONT_COLOR, &getCppuType((sal_Int32*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_COUTL), ATTR_FONT_CONTOUR, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CCROSS), ATTR_FONT_CROSSEDOUT,&getBooleanCppuType(), 0, MID_CROSSED_OUT }, {MAP_CHAR_LEN(SC_UNONAME_CFONT), ATTR_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_FAMILY }, {MAP_CHAR_LEN(SC_UNONAME_CFCHARS), ATTR_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_CHAR_SET }, {MAP_CHAR_LEN(SC_UNO_CJK_CFCHARS), ATTR_CJK_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_CHAR_SET }, {MAP_CHAR_LEN(SC_UNO_CTL_CFCHARS), ATTR_CTL_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_CHAR_SET }, {MAP_CHAR_LEN(SC_UNONAME_CFFAMIL), ATTR_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_FAMILY }, {MAP_CHAR_LEN(SC_UNO_CJK_CFFAMIL), ATTR_CJK_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_FAMILY }, {MAP_CHAR_LEN(SC_UNO_CTL_CFFAMIL), ATTR_CTL_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_FAMILY }, {MAP_CHAR_LEN(SC_UNONAME_CFNAME), ATTR_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_FAMILY_NAME }, {MAP_CHAR_LEN(SC_UNO_CJK_CFNAME), ATTR_CJK_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_FAMILY_NAME }, {MAP_CHAR_LEN(SC_UNO_CTL_CFNAME), ATTR_CTL_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_FAMILY_NAME }, {MAP_CHAR_LEN(SC_UNONAME_CFPITCH), ATTR_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_PITCH }, {MAP_CHAR_LEN(SC_UNO_CJK_CFPITCH), ATTR_CJK_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_PITCH }, {MAP_CHAR_LEN(SC_UNO_CTL_CFPITCH), ATTR_CTL_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_PITCH }, {MAP_CHAR_LEN(SC_UNONAME_CFSTYLE), ATTR_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_STYLE_NAME }, {MAP_CHAR_LEN(SC_UNO_CJK_CFSTYLE), ATTR_CJK_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_STYLE_NAME }, {MAP_CHAR_LEN(SC_UNO_CTL_CFSTYLE), ATTR_CTL_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_STYLE_NAME }, {MAP_CHAR_LEN(SC_UNONAME_CHEIGHT), ATTR_FONT_HEIGHT, &getCppuType((float*)0), 0, MID_FONTHEIGHT | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNO_CJK_CHEIGHT), ATTR_CJK_FONT_HEIGHT,&getCppuType((float*)0), 0, MID_FONTHEIGHT | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNO_CTL_CHEIGHT), ATTR_CTL_FONT_HEIGHT,&getCppuType((float*)0), 0, MID_FONTHEIGHT | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_CLOCAL), ATTR_FONT_LANGUAGE, &getCppuType((lang::Locale*)0), 0, MID_LANG_LOCALE }, {MAP_CHAR_LEN(SC_UNO_CJK_CLOCAL), ATTR_CJK_FONT_LANGUAGE,&getCppuType((lang::Locale*)0), 0, MID_LANG_LOCALE }, {MAP_CHAR_LEN(SC_UNO_CTL_CLOCAL), ATTR_CTL_FONT_LANGUAGE,&getCppuType((lang::Locale*)0), 0, MID_LANG_LOCALE }, {MAP_CHAR_LEN(SC_UNONAME_CPOST), ATTR_FONT_POSTURE, &getCppuType((awt::FontSlant*)0), 0, MID_POSTURE }, {MAP_CHAR_LEN(SC_UNO_CJK_CPOST), ATTR_CJK_FONT_POSTURE,&getCppuType((awt::FontSlant*)0), 0, MID_POSTURE }, {MAP_CHAR_LEN(SC_UNO_CTL_CPOST), ATTR_CTL_FONT_POSTURE,&getCppuType((awt::FontSlant*)0), 0, MID_POSTURE }, {MAP_CHAR_LEN(SC_UNONAME_CSHADD), ATTR_FONT_SHADOWED, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CSTRIKE), ATTR_FONT_CROSSEDOUT,&getCppuType((sal_Int16*)0), 0, MID_CROSS_OUT }, {MAP_CHAR_LEN(SC_UNONAME_CUNDER), ATTR_FONT_UNDERLINE,&getCppuType((sal_Int16*)0), 0, MID_UNDERLINE }, {MAP_CHAR_LEN(SC_UNONAME_CWEIGHT), ATTR_FONT_WEIGHT, &getCppuType((float*)0), 0, MID_WEIGHT }, {MAP_CHAR_LEN(SC_UNO_CJK_CWEIGHT), ATTR_CJK_FONT_WEIGHT,&getCppuType((float*)0), 0, MID_WEIGHT }, {MAP_CHAR_LEN(SC_UNO_CTL_CWEIGHT), ATTR_CTL_FONT_WEIGHT,&getCppuType((float*)0), 0, MID_WEIGHT }, {MAP_CHAR_LEN(SC_UNONAME_CHCOLHDR), 0, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CHROWHDR), 0, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CONDFMT), 0, &getCppuType((uno::Reference*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CONDLOC), 0, &getCppuType((uno::Reference*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CONDXML), 0, &getCppuType((uno::Reference*)0), 0 | beans::PropertyAttribute::READONLY, 0 }, {MAP_CHAR_LEN(SC_UNONAME_FORMLOC), 0, &getCppuType((rtl::OUString*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_FORMRT), 0, &getCppuType((table::CellContentType*)0), 0 | beans::PropertyAttribute::READONLY, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLHJUS), ATTR_HOR_JUSTIFY, &getCppuType((table::CellHoriJustify*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLTRAN), ATTR_BACKGROUND, &getBooleanCppuType(), 0, MID_GRAPHIC_TRANSPARENT }, {MAP_CHAR_LEN(SC_UNONAME_WRAP), ATTR_LINEBREAK, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_LEFTBORDER),ATTR_BORDER, &::getCppuType((const table::BorderLine*)0), 0, LEFT_BORDER | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_NUMFMT), ATTR_VALUE_FORMAT, &getCppuType((sal_Int32*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLORI), ATTR_ORIENTATION, &getCppuType((table::CellOrientation*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_PBMARGIN), ATTR_MARGIN, &getCppuType((sal_Int32*)0), 0, MID_MARGIN_LO_MARGIN | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_PINDENT), ATTR_INDENT, &getCppuType((sal_Int16*)0), 0, 0 }, //! CONVERT_TWIPS {MAP_CHAR_LEN(SC_UNONAME_PISCHDIST),ATTR_SCRIPTSPACE, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_PISFORBID),ATTR_FORBIDDEN_RULES,&getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_PISHANG), ATTR_HANGPUNCTUATION,&getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_PLMARGIN), ATTR_MARGIN, &getCppuType((sal_Int32*)0), 0, MID_MARGIN_L_MARGIN | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_PRMARGIN), ATTR_MARGIN, &getCppuType((sal_Int32*)0), 0, MID_MARGIN_R_MARGIN | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_PTMARGIN), ATTR_MARGIN, &getCppuType((sal_Int32*)0), 0, MID_MARGIN_UP_MARGIN | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_POS), 0, &getCppuType((awt::Point*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_RIGHTBORDER),ATTR_BORDER, &::getCppuType((const table::BorderLine*)0), 0, RIGHT_BORDER | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_ROTANG), ATTR_ROTATE_VALUE, &getCppuType((sal_Int32*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_ROTREF), ATTR_ROTATE_MODE, &getCppuType((table::CellVertJustify*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_SHADOW), ATTR_SHADOW, &getCppuType((table::ShadowFormat*)0), 0, 0 | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_SIZE), 0, &getCppuType((awt::Size*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_TBLBORD), 0, &getCppuType((table::TableBorder*)0), 0, 0 | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_TOPBORDER),ATTR_BORDER, &::getCppuType((const table::BorderLine*)0), 0, TOP_BORDER | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_VALIDAT), 0, &getCppuType((uno::Reference*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_VALILOC), 0, &getCppuType((uno::Reference*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_VALIXML), 0, &getCppuType((uno::Reference*)0), 0 | beans::PropertyAttribute::READONLY, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLVJUS), ATTR_VER_JUSTIFY, &getCppuType((table::CellVertJustify*)0), 0, 0 }, {0,0,0,0} }; return aCellPropertyMap_Impl; } // Column und Row enthalten alle Eintraege von CellRange, zusaetzlich eigene Eintraege // mit Which-ID 0 (werden nur fuer getPropertySetInfo benoetigt). const SfxItemPropertyMap* lcl_GetColumnPropertyMap() { static SfxItemPropertyMap aColumnPropertyMap_Impl[] = { {MAP_CHAR_LEN(SC_UNONAME_BOTTBORDER),ATTR_BORDER, &::getCppuType((const table::BorderLine*)0), 0, BOTTOM_BORDER | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_CELLBACK), ATTR_BACKGROUND, &getCppuType((sal_Int32*)0), 0, MID_BACK_COLOR }, {MAP_CHAR_LEN(SC_UNONAME_CELLPRO), ATTR_PROTECTION, &getCppuType((util::CellProtection*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLSTYL), 0, &getCppuType((rtl::OUString*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CCOLOR), ATTR_FONT_COLOR, &getCppuType((sal_Int32*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_COUTL), ATTR_FONT_CONTOUR, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CCROSS), ATTR_FONT_CROSSEDOUT,&getBooleanCppuType(), 0, MID_CROSSED_OUT }, {MAP_CHAR_LEN(SC_UNONAME_CFONT), ATTR_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_FAMILY }, {MAP_CHAR_LEN(SC_UNONAME_CFCHARS), ATTR_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_CHAR_SET }, {MAP_CHAR_LEN(SC_UNO_CJK_CFCHARS), ATTR_CJK_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_CHAR_SET }, {MAP_CHAR_LEN(SC_UNO_CTL_CFCHARS), ATTR_CTL_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_CHAR_SET }, {MAP_CHAR_LEN(SC_UNONAME_CFFAMIL), ATTR_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_FAMILY }, {MAP_CHAR_LEN(SC_UNO_CJK_CFFAMIL), ATTR_CJK_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_FAMILY }, {MAP_CHAR_LEN(SC_UNO_CTL_CFFAMIL), ATTR_CTL_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_FAMILY }, {MAP_CHAR_LEN(SC_UNONAME_CFNAME), ATTR_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_FAMILY_NAME }, {MAP_CHAR_LEN(SC_UNO_CJK_CFNAME), ATTR_CJK_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_FAMILY_NAME }, {MAP_CHAR_LEN(SC_UNO_CTL_CFNAME), ATTR_CTL_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_FAMILY_NAME }, {MAP_CHAR_LEN(SC_UNONAME_CFPITCH), ATTR_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_PITCH }, {MAP_CHAR_LEN(SC_UNO_CJK_CFPITCH), ATTR_CJK_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_PITCH }, {MAP_CHAR_LEN(SC_UNO_CTL_CFPITCH), ATTR_CTL_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_PITCH }, {MAP_CHAR_LEN(SC_UNONAME_CFSTYLE), ATTR_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_STYLE_NAME }, {MAP_CHAR_LEN(SC_UNO_CJK_CFSTYLE), ATTR_CJK_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_STYLE_NAME }, {MAP_CHAR_LEN(SC_UNO_CTL_CFSTYLE), ATTR_CTL_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_STYLE_NAME }, {MAP_CHAR_LEN(SC_UNONAME_CHEIGHT), ATTR_FONT_HEIGHT, &getCppuType((float*)0), 0, MID_FONTHEIGHT | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNO_CJK_CHEIGHT), ATTR_CJK_FONT_HEIGHT,&getCppuType((float*)0), 0, MID_FONTHEIGHT | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNO_CTL_CHEIGHT), ATTR_CTL_FONT_HEIGHT,&getCppuType((float*)0), 0, MID_FONTHEIGHT | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_CLOCAL), ATTR_FONT_LANGUAGE, &getCppuType((lang::Locale*)0), 0, MID_LANG_LOCALE }, {MAP_CHAR_LEN(SC_UNO_CJK_CLOCAL), ATTR_CJK_FONT_LANGUAGE,&getCppuType((lang::Locale*)0), 0, MID_LANG_LOCALE }, {MAP_CHAR_LEN(SC_UNO_CTL_CLOCAL), ATTR_CTL_FONT_LANGUAGE,&getCppuType((lang::Locale*)0), 0, MID_LANG_LOCALE }, {MAP_CHAR_LEN(SC_UNONAME_CPOST), ATTR_FONT_POSTURE, &getCppuType((awt::FontSlant*)0), 0, MID_POSTURE }, {MAP_CHAR_LEN(SC_UNO_CJK_CPOST), ATTR_CJK_FONT_POSTURE,&getCppuType((awt::FontSlant*)0), 0, MID_POSTURE }, {MAP_CHAR_LEN(SC_UNO_CTL_CPOST), ATTR_CTL_FONT_POSTURE,&getCppuType((awt::FontSlant*)0), 0, MID_POSTURE }, {MAP_CHAR_LEN(SC_UNONAME_CSHADD), ATTR_FONT_SHADOWED, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CSTRIKE), ATTR_FONT_CROSSEDOUT,&getCppuType((sal_Int16*)0), 0, MID_CROSS_OUT }, {MAP_CHAR_LEN(SC_UNONAME_CUNDER), ATTR_FONT_UNDERLINE,&getCppuType((sal_Int16*)0), 0, MID_UNDERLINE }, {MAP_CHAR_LEN(SC_UNONAME_CWEIGHT), ATTR_FONT_WEIGHT, &getCppuType((float*)0), 0, MID_WEIGHT }, {MAP_CHAR_LEN(SC_UNO_CJK_CWEIGHT), ATTR_CJK_FONT_WEIGHT,&getCppuType((float*)0), 0, MID_WEIGHT }, {MAP_CHAR_LEN(SC_UNO_CTL_CWEIGHT), ATTR_CTL_FONT_WEIGHT,&getCppuType((float*)0), 0, MID_WEIGHT }, {MAP_CHAR_LEN(SC_UNONAME_CHCOLHDR), 0, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CHROWHDR), 0, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CONDFMT), 0, &getCppuType((uno::Reference*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CONDLOC), 0, &getCppuType((uno::Reference*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CONDXML), 0, &getCppuType((uno::Reference*)0), 0 | beans::PropertyAttribute::READONLY, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLHJUS), ATTR_HOR_JUSTIFY, &getCppuType((table::CellHoriJustify*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLTRAN), ATTR_BACKGROUND, &getBooleanCppuType(), 0, MID_GRAPHIC_TRANSPARENT }, // {MAP_CHAR_LEN(SC_UNONAME_CELLFILT), 0, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_MANPAGE), 0, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_NEWPAGE), 0, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_WRAP), ATTR_LINEBREAK, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLVIS), 0, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_LEFTBORDER),ATTR_BORDER, &::getCppuType((const table::BorderLine*)0), 0, LEFT_BORDER | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_NUMFMT), ATTR_VALUE_FORMAT, &getCppuType((sal_Int32*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_OWIDTH), 0, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLORI), ATTR_ORIENTATION, &getCppuType((table::CellOrientation*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_PBMARGIN), ATTR_MARGIN, &getCppuType((sal_Int32*)0), 0, MID_MARGIN_LO_MARGIN | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_PINDENT), ATTR_INDENT, &getCppuType((sal_Int16*)0), 0, 0 }, //! CONVERT_TWIPS {MAP_CHAR_LEN(SC_UNONAME_PISCHDIST),ATTR_SCRIPTSPACE, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_PISFORBID),ATTR_FORBIDDEN_RULES,&getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_PISHANG), ATTR_HANGPUNCTUATION,&getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_PLMARGIN), ATTR_MARGIN, &getCppuType((sal_Int32*)0), 0, MID_MARGIN_L_MARGIN | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_PRMARGIN), ATTR_MARGIN, &getCppuType((sal_Int32*)0), 0, MID_MARGIN_R_MARGIN | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_PTMARGIN), ATTR_MARGIN, &getCppuType((sal_Int32*)0), 0, MID_MARGIN_UP_MARGIN | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_POS), 0, &getCppuType((awt::Point*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_RIGHTBORDER),ATTR_BORDER, &::getCppuType((const table::BorderLine*)0), 0, RIGHT_BORDER | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_ROTANG), ATTR_ROTATE_VALUE, &getCppuType((sal_Int32*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_ROTREF), ATTR_ROTATE_MODE, &getCppuType((table::CellVertJustify*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_SHADOW), ATTR_SHADOW, &getCppuType((table::ShadowFormat*)0), 0, 0 | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_SIZE), 0, &getCppuType((awt::Size*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_TBLBORD), 0, &getCppuType((table::TableBorder*)0), 0, 0 | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_TOPBORDER),ATTR_BORDER, &::getCppuType((const table::BorderLine*)0), 0, TOP_BORDER | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_VALIDAT), 0, &getCppuType((uno::Reference*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_VALILOC), 0, &getCppuType((uno::Reference*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_VALIXML), 0, &getCppuType((uno::Reference*)0), 0 | beans::PropertyAttribute::READONLY, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLVJUS), ATTR_VER_JUSTIFY, &getCppuType((table::CellVertJustify*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLWID), 0, &getCppuType((sal_Int32*)0), 0, 0 }, {0,0,0,0} }; return aColumnPropertyMap_Impl; } const SfxItemPropertyMap* lcl_GetRowPropertyMap() { static SfxItemPropertyMap aRowPropertyMap_Impl[] = { {MAP_CHAR_LEN(SC_UNONAME_BOTTBORDER),ATTR_BORDER, &::getCppuType((const table::BorderLine*)0), 0, BOTTOM_BORDER | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_CELLBACK), ATTR_BACKGROUND, &getCppuType((sal_Int32*)0), 0, MID_BACK_COLOR }, {MAP_CHAR_LEN(SC_UNONAME_CELLPRO), ATTR_PROTECTION, &getCppuType((util::CellProtection*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLSTYL), 0, &getCppuType((rtl::OUString*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CCOLOR), ATTR_FONT_COLOR, &getCppuType((sal_Int32*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_COUTL), ATTR_FONT_CONTOUR, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CCROSS), ATTR_FONT_CROSSEDOUT,&getBooleanCppuType(), 0, MID_CROSSED_OUT }, {MAP_CHAR_LEN(SC_UNONAME_CFONT), ATTR_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_FAMILY }, {MAP_CHAR_LEN(SC_UNONAME_CFCHARS), ATTR_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_CHAR_SET }, {MAP_CHAR_LEN(SC_UNO_CJK_CFCHARS), ATTR_CJK_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_CHAR_SET }, {MAP_CHAR_LEN(SC_UNO_CTL_CFCHARS), ATTR_CTL_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_CHAR_SET }, {MAP_CHAR_LEN(SC_UNONAME_CFFAMIL), ATTR_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_FAMILY }, {MAP_CHAR_LEN(SC_UNO_CJK_CFFAMIL), ATTR_CJK_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_FAMILY }, {MAP_CHAR_LEN(SC_UNO_CTL_CFFAMIL), ATTR_CTL_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_FAMILY }, {MAP_CHAR_LEN(SC_UNONAME_CFNAME), ATTR_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_FAMILY_NAME }, {MAP_CHAR_LEN(SC_UNO_CJK_CFNAME), ATTR_CJK_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_FAMILY_NAME }, {MAP_CHAR_LEN(SC_UNO_CTL_CFNAME), ATTR_CTL_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_FAMILY_NAME }, {MAP_CHAR_LEN(SC_UNONAME_CFPITCH), ATTR_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_PITCH }, {MAP_CHAR_LEN(SC_UNO_CJK_CFPITCH), ATTR_CJK_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_PITCH }, {MAP_CHAR_LEN(SC_UNO_CTL_CFPITCH), ATTR_CTL_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_PITCH }, {MAP_CHAR_LEN(SC_UNONAME_CFSTYLE), ATTR_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_STYLE_NAME }, {MAP_CHAR_LEN(SC_UNO_CJK_CFSTYLE), ATTR_CJK_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_STYLE_NAME }, {MAP_CHAR_LEN(SC_UNO_CTL_CFSTYLE), ATTR_CTL_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_STYLE_NAME }, {MAP_CHAR_LEN(SC_UNONAME_CHEIGHT), ATTR_FONT_HEIGHT, &getCppuType((float*)0), 0, MID_FONTHEIGHT | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNO_CJK_CHEIGHT), ATTR_CJK_FONT_HEIGHT,&getCppuType((float*)0), 0, MID_FONTHEIGHT | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNO_CTL_CHEIGHT), ATTR_CTL_FONT_HEIGHT,&getCppuType((float*)0), 0, MID_FONTHEIGHT | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_CLOCAL), ATTR_FONT_LANGUAGE, &getCppuType((lang::Locale*)0), 0, MID_LANG_LOCALE }, {MAP_CHAR_LEN(SC_UNO_CJK_CLOCAL), ATTR_CJK_FONT_LANGUAGE,&getCppuType((lang::Locale*)0), 0, MID_LANG_LOCALE }, {MAP_CHAR_LEN(SC_UNO_CTL_CLOCAL), ATTR_CTL_FONT_LANGUAGE,&getCppuType((lang::Locale*)0), 0, MID_LANG_LOCALE }, {MAP_CHAR_LEN(SC_UNONAME_CPOST), ATTR_FONT_POSTURE, &getCppuType((awt::FontSlant*)0), 0, MID_POSTURE }, {MAP_CHAR_LEN(SC_UNO_CJK_CPOST), ATTR_CJK_FONT_POSTURE,&getCppuType((awt::FontSlant*)0), 0, MID_POSTURE }, {MAP_CHAR_LEN(SC_UNO_CTL_CPOST), ATTR_CTL_FONT_POSTURE,&getCppuType((awt::FontSlant*)0), 0, MID_POSTURE }, {MAP_CHAR_LEN(SC_UNONAME_CSHADD), ATTR_FONT_SHADOWED, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CSTRIKE), ATTR_FONT_CROSSEDOUT,&getCppuType((sal_Int16*)0), 0, MID_CROSS_OUT }, {MAP_CHAR_LEN(SC_UNONAME_CUNDER), ATTR_FONT_UNDERLINE,&getCppuType((sal_Int16*)0), 0, MID_UNDERLINE }, {MAP_CHAR_LEN(SC_UNONAME_CWEIGHT), ATTR_FONT_WEIGHT, &getCppuType((float*)0), 0, MID_WEIGHT }, {MAP_CHAR_LEN(SC_UNO_CJK_CWEIGHT), ATTR_CJK_FONT_WEIGHT,&getCppuType((float*)0), 0, MID_WEIGHT }, {MAP_CHAR_LEN(SC_UNO_CTL_CWEIGHT), ATTR_CTL_FONT_WEIGHT,&getCppuType((float*)0), 0, MID_WEIGHT }, {MAP_CHAR_LEN(SC_UNONAME_CHCOLHDR), 0, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CHROWHDR), 0, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CONDFMT), 0, &getCppuType((uno::Reference*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CONDLOC), 0, &getCppuType((uno::Reference*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CONDXML), 0, &getCppuType((uno::Reference*)0), 0 | beans::PropertyAttribute::READONLY, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLHGT), 0, &getCppuType((sal_Int32*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLHJUS), ATTR_HOR_JUSTIFY, &getCppuType((table::CellHoriJustify*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLTRAN), ATTR_BACKGROUND, &getBooleanCppuType(), 0, MID_GRAPHIC_TRANSPARENT }, {MAP_CHAR_LEN(SC_UNONAME_CELLFILT), 0, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_MANPAGE), 0, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_NEWPAGE), 0, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_WRAP), ATTR_LINEBREAK, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLVIS), 0, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_LEFTBORDER),ATTR_BORDER, &::getCppuType((const table::BorderLine*)0), 0, LEFT_BORDER | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_NUMFMT), ATTR_VALUE_FORMAT, &getCppuType((sal_Int32*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_OHEIGHT), 0, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLORI), ATTR_ORIENTATION, &getCppuType((table::CellOrientation*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_PBMARGIN), ATTR_MARGIN, &getCppuType((sal_Int32*)0), 0, MID_MARGIN_LO_MARGIN | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_PINDENT), ATTR_INDENT, &getCppuType((sal_Int16*)0), 0, 0 }, //! CONVERT_TWIPS {MAP_CHAR_LEN(SC_UNONAME_PISCHDIST),ATTR_SCRIPTSPACE, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_PISFORBID),ATTR_FORBIDDEN_RULES,&getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_PISHANG), ATTR_HANGPUNCTUATION,&getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_PLMARGIN), ATTR_MARGIN, &getCppuType((sal_Int32*)0), 0, MID_MARGIN_L_MARGIN | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_PRMARGIN), ATTR_MARGIN, &getCppuType((sal_Int32*)0), 0, MID_MARGIN_R_MARGIN | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_PTMARGIN), ATTR_MARGIN, &getCppuType((sal_Int32*)0), 0, MID_MARGIN_UP_MARGIN | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_POS), 0, &getCppuType((awt::Point*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_RIGHTBORDER),ATTR_BORDER, &::getCppuType((const table::BorderLine*)0), 0, RIGHT_BORDER | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_ROTANG), ATTR_ROTATE_VALUE, &getCppuType((sal_Int32*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_ROTREF), ATTR_ROTATE_MODE, &getCppuType((table::CellVertJustify*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_SHADOW), ATTR_SHADOW, &getCppuType((table::ShadowFormat*)0), 0, 0 | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_SIZE), 0, &getCppuType((awt::Size*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_TBLBORD), 0, &getCppuType((table::TableBorder*)0), 0, 0 | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_TOPBORDER),ATTR_BORDER, &::getCppuType((const table::BorderLine*)0), 0, TOP_BORDER | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_VALIDAT), 0, &getCppuType((uno::Reference*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_VALILOC), 0, &getCppuType((uno::Reference*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_VALIXML), 0, &getCppuType((uno::Reference*)0), 0 | beans::PropertyAttribute::READONLY, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLVJUS), ATTR_VER_JUSTIFY, &getCppuType((table::CellVertJustify*)0), 0, 0 }, {0,0,0,0} }; return aRowPropertyMap_Impl; } const SfxItemPropertyMap* lcl_GetSheetPropertyMap() { static SfxItemPropertyMap aSheetPropertyMap_Impl[] = { {MAP_CHAR_LEN(SC_UNONAME_BOTTBORDER),ATTR_BORDER, &::getCppuType((const table::BorderLine*)0), 0, BOTTOM_BORDER | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_CELLBACK), ATTR_BACKGROUND, &getCppuType((sal_Int32*)0), 0, MID_BACK_COLOR }, {MAP_CHAR_LEN(SC_UNONAME_CELLPRO), ATTR_PROTECTION, &getCppuType((util::CellProtection*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLSTYL), 0, &getCppuType((rtl::OUString*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CCOLOR), ATTR_FONT_COLOR, &getCppuType((sal_Int32*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_COUTL), ATTR_FONT_CONTOUR, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CCROSS), ATTR_FONT_CROSSEDOUT,&getBooleanCppuType(), 0, MID_CROSSED_OUT }, {MAP_CHAR_LEN(SC_UNONAME_CFONT), ATTR_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_FAMILY }, {MAP_CHAR_LEN(SC_UNONAME_CFCHARS), ATTR_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_CHAR_SET }, {MAP_CHAR_LEN(SC_UNO_CJK_CFCHARS), ATTR_CJK_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_CHAR_SET }, {MAP_CHAR_LEN(SC_UNO_CTL_CFCHARS), ATTR_CTL_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_CHAR_SET }, {MAP_CHAR_LEN(SC_UNONAME_CFFAMIL), ATTR_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_FAMILY }, {MAP_CHAR_LEN(SC_UNO_CJK_CFFAMIL), ATTR_CJK_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_FAMILY }, {MAP_CHAR_LEN(SC_UNO_CTL_CFFAMIL), ATTR_CTL_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_FAMILY }, {MAP_CHAR_LEN(SC_UNONAME_CFNAME), ATTR_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_FAMILY_NAME }, {MAP_CHAR_LEN(SC_UNO_CJK_CFNAME), ATTR_CJK_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_FAMILY_NAME }, {MAP_CHAR_LEN(SC_UNO_CTL_CFNAME), ATTR_CTL_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_FAMILY_NAME }, {MAP_CHAR_LEN(SC_UNONAME_CFPITCH), ATTR_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_PITCH }, {MAP_CHAR_LEN(SC_UNO_CJK_CFPITCH), ATTR_CJK_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_PITCH }, {MAP_CHAR_LEN(SC_UNO_CTL_CFPITCH), ATTR_CTL_FONT, &getCppuType((sal_Int16*)0), 0, MID_FONT_PITCH }, {MAP_CHAR_LEN(SC_UNONAME_CFSTYLE), ATTR_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_STYLE_NAME }, {MAP_CHAR_LEN(SC_UNO_CJK_CFSTYLE), ATTR_CJK_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_STYLE_NAME }, {MAP_CHAR_LEN(SC_UNO_CTL_CFSTYLE), ATTR_CTL_FONT, &getCppuType((rtl::OUString*)0), 0, MID_FONT_STYLE_NAME }, {MAP_CHAR_LEN(SC_UNONAME_CHEIGHT), ATTR_FONT_HEIGHT, &getCppuType((float*)0), 0, MID_FONTHEIGHT | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNO_CJK_CHEIGHT), ATTR_CJK_FONT_HEIGHT,&getCppuType((float*)0), 0, MID_FONTHEIGHT | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNO_CTL_CHEIGHT), ATTR_CTL_FONT_HEIGHT,&getCppuType((float*)0), 0, MID_FONTHEIGHT | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_CLOCAL), ATTR_FONT_LANGUAGE, &getCppuType((lang::Locale*)0), 0, MID_LANG_LOCALE }, {MAP_CHAR_LEN(SC_UNO_CJK_CLOCAL), ATTR_CJK_FONT_LANGUAGE,&getCppuType((lang::Locale*)0), 0, MID_LANG_LOCALE }, {MAP_CHAR_LEN(SC_UNO_CTL_CLOCAL), ATTR_CTL_FONT_LANGUAGE,&getCppuType((lang::Locale*)0), 0, MID_LANG_LOCALE }, {MAP_CHAR_LEN(SC_UNONAME_CPOST), ATTR_FONT_POSTURE, &getCppuType((awt::FontSlant*)0), 0, MID_POSTURE }, {MAP_CHAR_LEN(SC_UNO_CJK_CPOST), ATTR_CJK_FONT_POSTURE,&getCppuType((awt::FontSlant*)0), 0, MID_POSTURE }, {MAP_CHAR_LEN(SC_UNO_CTL_CPOST), ATTR_CTL_FONT_POSTURE,&getCppuType((awt::FontSlant*)0), 0, MID_POSTURE }, {MAP_CHAR_LEN(SC_UNONAME_CSHADD), ATTR_FONT_SHADOWED, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CSTRIKE), ATTR_FONT_CROSSEDOUT,&getCppuType((sal_Int16*)0), 0, MID_CROSS_OUT }, {MAP_CHAR_LEN(SC_UNONAME_CUNDER), ATTR_FONT_UNDERLINE,&getCppuType((sal_Int16*)0), 0, MID_UNDERLINE }, {MAP_CHAR_LEN(SC_UNONAME_CWEIGHT), ATTR_FONT_WEIGHT, &getCppuType((float*)0), 0, MID_WEIGHT }, {MAP_CHAR_LEN(SC_UNO_CJK_CWEIGHT), ATTR_CJK_FONT_WEIGHT,&getCppuType((float*)0), 0, MID_WEIGHT }, {MAP_CHAR_LEN(SC_UNO_CTL_CWEIGHT), ATTR_CTL_FONT_WEIGHT,&getCppuType((float*)0), 0, MID_WEIGHT }, {MAP_CHAR_LEN(SC_UNONAME_CHCOLHDR), 0, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CHROWHDR), 0, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CONDFMT), 0, &getCppuType((uno::Reference*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CONDLOC), 0, &getCppuType((uno::Reference*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CONDXML), 0, &getCppuType((uno::Reference*)0), 0 | beans::PropertyAttribute::READONLY, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLHJUS), ATTR_HOR_JUSTIFY, &getCppuType((table::CellHoriJustify*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLTRAN), ATTR_BACKGROUND, &getBooleanCppuType(), 0, MID_GRAPHIC_TRANSPARENT }, {MAP_CHAR_LEN(SC_UNONAME_WRAP), ATTR_LINEBREAK, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLVIS), 0, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_LEFTBORDER),ATTR_BORDER, &::getCppuType((const table::BorderLine*)0), 0, LEFT_BORDER | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNO_LINKDISPBIT), 0, &getCppuType((uno::Reference*)0), 0 | beans::PropertyAttribute::READONLY, 0 }, {MAP_CHAR_LEN(SC_UNO_LINKDISPNAME), 0, &getCppuType((rtl::OUString*)0), 0 | beans::PropertyAttribute::READONLY, 0 }, {MAP_CHAR_LEN(SC_UNONAME_NUMFMT), ATTR_VALUE_FORMAT, &getCppuType((sal_Int32*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLORI), ATTR_ORIENTATION, &getCppuType((table::CellOrientation*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_PAGESTL), 0, &getCppuType((rtl::OUString*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_PBMARGIN), ATTR_MARGIN, &getCppuType((sal_Int32*)0), 0, MID_MARGIN_LO_MARGIN | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_PINDENT), ATTR_INDENT, &getCppuType((sal_Int16*)0), 0, 0 }, //! CONVERT_TWIPS {MAP_CHAR_LEN(SC_UNONAME_PISCHDIST),ATTR_SCRIPTSPACE, &getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_PISFORBID),ATTR_FORBIDDEN_RULES,&getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_PISHANG), ATTR_HANGPUNCTUATION,&getBooleanCppuType(), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_PLMARGIN), ATTR_MARGIN, &getCppuType((sal_Int32*)0), 0, MID_MARGIN_L_MARGIN | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_PRMARGIN), ATTR_MARGIN, &getCppuType((sal_Int32*)0), 0, MID_MARGIN_R_MARGIN | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_PTMARGIN), ATTR_MARGIN, &getCppuType((sal_Int32*)0), 0, MID_MARGIN_UP_MARGIN | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_POS), 0, &getCppuType((awt::Point*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_RIGHTBORDER),ATTR_BORDER, &::getCppuType((const table::BorderLine*)0), 0, RIGHT_BORDER | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_ROTANG), ATTR_ROTATE_VALUE, &getCppuType((sal_Int32*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_ROTREF), ATTR_ROTATE_MODE, &getCppuType((table::CellVertJustify*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_SHADOW), ATTR_SHADOW, &getCppuType((table::ShadowFormat*)0), 0, 0 | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_SIZE), 0, &getCppuType((awt::Size*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_TBLBORD), 0, &getCppuType((table::TableBorder*)0), 0, 0 | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_TOPBORDER),ATTR_BORDER, &::getCppuType((const table::BorderLine*)0), 0, TOP_BORDER | CONVERT_TWIPS }, {MAP_CHAR_LEN(SC_UNONAME_VALIDAT), 0, &getCppuType((uno::Reference*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_VALILOC), 0, &getCppuType((uno::Reference*)0), 0, 0 }, {MAP_CHAR_LEN(SC_UNONAME_VALIXML), 0, &getCppuType((uno::Reference*)0), 0 | beans::PropertyAttribute::READONLY, 0 }, {MAP_CHAR_LEN(SC_UNONAME_CELLVJUS), ATTR_VER_JUSTIFY, &getCppuType((table::CellVertJustify*)0), 0, 0 }, {0,0,0,0} }; return aSheetPropertyMap_Impl; } const SfxItemPropertyMap* lcl_GetEditPropertyMap() { static SfxItemPropertyMap aEditPropertyMap_Impl[] = { SVX_UNOEDIT_CHAR_PROPERTIES, SVX_UNOEDIT_FONT_PROPERTIES, SVX_UNOEDIT_PARA_PROPERTIES, {0,0,0,0} }; return aEditPropertyMap_Impl; } //------------------------------------------------------------------------ //! diese Funktionen in einen allgemeinen Header verschieben inline long TwipsToHMM(long nTwips) { return (nTwips * 127 + 36) / 72; } inline long HMMToTwips(long nHMM) { return (nHMM * 72 + 63) / 127; } //------------------------------------------------------------------------ #define SCCHARPROPERTIES_SERVICE "com.sun.star.style.CharacterProperties" #define SCCELLPROPERTIES_SERVICE "com.sun.star.table.CellProperties" #define SCCELLRANGE_SERVICE "com.sun.star.table.CellRange" #define SCCELL_SERVICE "com.sun.star.table.Cell" #define SCSHEETCELLRANGES_SERVICE "com.sun.star.sheet.SheetCellRanges" #define SCSHEETCELLRANGE_SERVICE "com.sun.star.sheet.SheetCellRange" #define SCSPREADSHEET_SERVICE "com.sun.star.sheet.Spreadsheet" #define SCSHEETCELL_SERVICE "com.sun.star.sheet.SheetCell" SC_SIMPLE_SERVICE_INFO( ScCellFormatsEnumeration, "ScCellFormatsEnumeration", "com.sun.star.sheet.CellFormatRangesEnumeration" ) SC_SIMPLE_SERVICE_INFO( ScCellFormatsObj, "ScCellFormatsObj", "com.sun.star.sheet.CellFormatRanges" ) SC_SIMPLE_SERVICE_INFO( ScCellRangesBase, "ScCellRangesBase", "stardiv.unknown" ) SC_SIMPLE_SERVICE_INFO( ScCellsEnumeration, "ScCellsEnumeration", "com.sun.star.sheet.CellsEnumeration" ) SC_SIMPLE_SERVICE_INFO( ScCellsObj, "ScCellsObj", "com.sun.star.sheet.Cells" ) SC_SIMPLE_SERVICE_INFO( ScTableColumnObj, "ScTableColumnObj", "com.sun.star.table.TableColumn" ) SC_SIMPLE_SERVICE_INFO( ScTableRowObj, "ScTableRowObj", "com.sun.star.table.TableRow" ) //------------------------------------------------------------------------ SV_IMPL_PTRARR( XPropertyChangeListenerArr_Impl, XPropertyChangeListenerPtr ); SV_IMPL_PTRARR( ScNamedEntryArr_Impl, ScNamedEntryPtr ); //------------------------------------------------------------------------ #ifdef DBG_UTIL #define TEST_PROPERTY_MAPS #endif #ifdef TEST_PROPERTY_MAPS void lcl_TestMap( const SfxItemPropertyMap* pMap ) { while ( pMap->pName ) { const SfxItemPropertyMap* pNext = pMap + 1; if ( pNext->pName ) { int nDiff = strcmp( pMap->pName, pNext->pName ); if ( nDiff >= 0 ) { ByteString aErr("Reihenfolge: "); aErr += pMap->pName; aErr += '/'; aErr += pNext->pName; DBG_ERROR( aErr.GetBuffer() ); } } pMap = pNext; } } struct ScPropertyTester { ScPropertyTester(); }; //extern const SfxItemPropertyMap* lcl_GetCellStyleMap(); //extern const SfxItemPropertyMap* lcl_GetPageStyleMap(); //extern const SfxItemPropertyMap* lcl_GetHeaderStyleMap(); //extern const SfxItemPropertyMap* lcl_GetFooterStyleMap(); ScPropertyTester::ScPropertyTester() { lcl_TestMap( lcl_GetCellsPropertyMap() ); lcl_TestMap( lcl_GetRangePropertyMap() ); lcl_TestMap( lcl_GetCellPropertyMap() ); lcl_TestMap( lcl_GetColumnPropertyMap() ); lcl_TestMap( lcl_GetRowPropertyMap() ); lcl_TestMap( lcl_GetSheetPropertyMap() ); // lcl_TestMap( lcl_GetCellStyleMap() ); // lcl_TestMap( lcl_GetPageStyleMap() ); // lcl_TestMap( lcl_GetHeaderStyleMap() ); // lcl_TestMap( lcl_GetFooterStyleMap() ); } ScPropertyTester aPropertyTester; #endif //------------------------------------------------------------------------ //! ScLinkListener in anderes File verschieben !!! ScLinkListener::~ScLinkListener() { } void ScLinkListener::Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) { aLink.Call( (SfxHint*)&rHint ); } //------------------------------------------------------------------------ void lcl_CopyProperties( beans::XPropertySet& rDest, beans::XPropertySet& rSource ) { uno::Reference xInfo = rSource.getPropertySetInfo(); if (xInfo.is()) { uno::Sequence aSeq = xInfo->getProperties(); const beans::Property* pAry = aSeq.getConstArray(); ULONG nCount = aSeq.getLength(); for (ULONG i=0; i= 1, "was fuer Ranges ?!?!"); const ScRange* pFirst = rRanges.GetObject(0); if (pFirst) return pFirst->aStart.Tab(); return 0; // soll nicht sein } BOOL lcl_WholeSheet( const ScRangeList& rRanges ) { if ( rRanges.Count() == 1 ) { ScRange* pRange = rRanges.GetObject(0); if ( pRange && pRange->aStart.Col() == 0 && pRange->aEnd.Col() == MAXCOL && pRange->aStart.Row() == 0 && pRange->aEnd.Row() == MAXROW ) return TRUE; } return FALSE; } //------------------------------------------------------------------------ ScSubTotalFunc lcl_SummaryToSubTotal( sheet::GeneralFunction eSummary ) { ScSubTotalFunc eSubTotal; switch (eSummary) { case sheet::GeneralFunction_SUM: eSubTotal = SUBTOTAL_FUNC_SUM; break; case sheet::GeneralFunction_COUNT: eSubTotal = SUBTOTAL_FUNC_CNT2; break; case sheet::GeneralFunction_AVERAGE: eSubTotal = SUBTOTAL_FUNC_AVE; break; case sheet::GeneralFunction_MAX: eSubTotal = SUBTOTAL_FUNC_MAX; break; case sheet::GeneralFunction_MIN: eSubTotal = SUBTOTAL_FUNC_MIN; break; case sheet::GeneralFunction_PRODUCT: eSubTotal = SUBTOTAL_FUNC_PROD; break; case sheet::GeneralFunction_COUNTNUMS: eSubTotal = SUBTOTAL_FUNC_CNT; break; case sheet::GeneralFunction_STDEV: eSubTotal = SUBTOTAL_FUNC_STD; break; case sheet::GeneralFunction_STDEVP: eSubTotal = SUBTOTAL_FUNC_STDP; break; case sheet::GeneralFunction_VAR: eSubTotal = SUBTOTAL_FUNC_VAR; break; case sheet::GeneralFunction_VARP: eSubTotal = SUBTOTAL_FUNC_VARP; break; case sheet::GeneralFunction_NONE: case sheet::GeneralFunction_AUTO: default: eSubTotal = SUBTOTAL_FUNC_NONE; break; } return eSubTotal; } //------------------------------------------------------------------------ const SvxBorderLine* lcl_GetBorderLine( SvxBorderLine& rLine, const table::BorderLine& rStruct ) { // Calc braucht Twips, im Uno-Struct sind 1/100mm rLine.SetOutWidth( (USHORT)HMMToTwips( rStruct.OuterLineWidth ) ); rLine.SetInWidth( (USHORT)HMMToTwips( rStruct.InnerLineWidth ) ); rLine.SetDistance( (USHORT)HMMToTwips( rStruct.LineDistance ) ); rLine.SetColor( ColorData( rStruct.Color ) ); if ( rLine.GetOutWidth() || rLine.GetInWidth() || rLine.GetDistance() ) return &rLine; else return NULL; } void lcl_FillBoxItems( SvxBoxItem& rOuter, SvxBoxInfoItem& rInner, const table::TableBorder& rBorder ) { SvxBorderLine aLine; rOuter.SetDistance( (USHORT)HMMToTwips( rBorder.Distance ) ); rOuter.SetLine( lcl_GetBorderLine( aLine, rBorder.TopLine ), BOX_LINE_TOP ); rOuter.SetLine( lcl_GetBorderLine( aLine, rBorder.BottomLine ), BOX_LINE_BOTTOM ); rOuter.SetLine( lcl_GetBorderLine( aLine, rBorder.LeftLine ), BOX_LINE_LEFT ); rOuter.SetLine( lcl_GetBorderLine( aLine, rBorder.RightLine ), BOX_LINE_RIGHT ); rInner.SetLine( lcl_GetBorderLine( aLine, rBorder.HorizontalLine ), BOXINFO_LINE_HORI ); rInner.SetLine( lcl_GetBorderLine( aLine, rBorder.VerticalLine ), BOXINFO_LINE_VERT ); rInner.SetValid( VALID_TOP, rBorder.IsTopLineValid ); rInner.SetValid( VALID_BOTTOM, rBorder.IsBottomLineValid ); rInner.SetValid( VALID_LEFT, rBorder.IsLeftLineValid ); rInner.SetValid( VALID_RIGHT, rBorder.IsRightLineValid ); rInner.SetValid( VALID_HORI, rBorder.IsHorizontalLineValid ); rInner.SetValid( VALID_VERT, rBorder.IsVerticalLineValid ); rInner.SetValid( VALID_DISTANCE, rBorder.IsDistanceValid ); rInner.SetTable( TRUE ); } void lcl_FillBorderLine( table::BorderLine& rStruct, const SvxBorderLine* pLine ) { if (pLine) { rStruct.Color = pLine->GetColor().GetColor(); rStruct.InnerLineWidth = (sal_Int16)TwipsToHMM( pLine->GetInWidth() ); rStruct.OuterLineWidth = (sal_Int16)TwipsToHMM( pLine->GetOutWidth() ); rStruct.LineDistance = (sal_Int16)TwipsToHMM( pLine->GetDistance() ); } else rStruct.Color = rStruct.InnerLineWidth = rStruct.OuterLineWidth = rStruct.LineDistance = 0; } void lcl_FillTableBorder( table::TableBorder& rBorder, const SvxBoxItem& rOuter, const SvxBoxInfoItem& rInner ) { lcl_FillBorderLine( rBorder.TopLine, rOuter.GetTop() ); lcl_FillBorderLine( rBorder.BottomLine, rOuter.GetBottom() ); lcl_FillBorderLine( rBorder.LeftLine, rOuter.GetLeft() ); lcl_FillBorderLine( rBorder.RightLine, rOuter.GetRight() ); lcl_FillBorderLine( rBorder.HorizontalLine, rInner.GetHori() ); lcl_FillBorderLine( rBorder.VerticalLine, rInner.GetVert() ); rBorder.Distance = rOuter.GetDistance(); rBorder.IsTopLineValid = rInner.IsValid(VALID_TOP); rBorder.IsBottomLineValid = rInner.IsValid(VALID_BOTTOM); rBorder.IsLeftLineValid = rInner.IsValid(VALID_LEFT); rBorder.IsRightLineValid = rInner.IsValid(VALID_RIGHT); rBorder.IsHorizontalLineValid = rInner.IsValid(VALID_HORI); rBorder.IsVerticalLineValid = rInner.IsValid(VALID_VERT); rBorder.IsDistanceValid = rInner.IsValid(VALID_DISTANCE); } //------------------------------------------------------------------------ //! lcl_ApplyBorder nach docfunc verschieben! void lcl_ApplyBorder( ScDocShell* pDocShell, const ScRangeList& rRanges, const SvxBoxItem& rOuter, const SvxBoxInfoItem& rInner ) { ScDocument* pDoc = pDocShell->GetDocument(); BOOL bUndo(pDoc->IsUndoEnabled()); ScDocument* pUndoDoc = NULL; if (bUndo) pUndoDoc = new ScDocument( SCDOCMODE_UNDO ); ULONG nCount = rRanges.Count(); ULONG i; for (i=0; iInitUndo( pDoc, nTab, nTab ); else pUndoDoc->AddUndoTab( nTab, nTab ); pDoc->CopyToDocument( aRange, IDF_ATTRIB, FALSE, pUndoDoc ); } ScMarkData aMark; aMark.SetMarkArea( aRange ); aMark.SelectTable( nTab, TRUE ); pDoc->ApplySelectionFrame( aMark, &rOuter, &rInner ); // RowHeight bei Umrandung alleine nicht noetig } if (bUndo) { pDocShell->GetUndoManager()->AddUndoAction( new ScUndoBorder( pDocShell, rRanges, pUndoDoc, rOuter, rInner ) ); } for (i=0; iPostPaint( *rRanges.GetObject(i), PAINT_GRID, SC_PF_LINES | SC_PF_TESTMERGE ); pDocShell->SetDocumentModified(); } //! move lcl_PutDataArray to docfunc? //! merge loop with ScFunctionAccess::callFunction BOOL lcl_PutDataArray( ScDocShell& rDocShell, const ScRange& rRange, const uno::Sequence< uno::Sequence >& aData ) { // BOOL bApi = TRUE; ScDocument* pDoc = rDocShell.GetDocument(); USHORT nTab = rRange.aStart.Tab(); USHORT nStartCol = rRange.aStart.Col(); USHORT nStartRow = rRange.aStart.Row(); USHORT nEndCol = rRange.aEnd.Col(); USHORT nEndRow = rRange.aEnd.Row(); BOOL bUndo(pDoc->IsUndoEnabled()); if ( !pDoc->IsBlockEditable( nTab, nStartCol,nStartRow, nEndCol,nEndRow ) ) { //! error message return FALSE; } long nCols = 0; long nRows = aData.getLength(); const uno::Sequence* pArray = aData.getConstArray(); if ( nRows ) nCols = pArray[0].getLength(); if ( nCols != nEndCol-nStartCol+1 || nRows != nEndRow-nStartRow+1 ) { //! error message? return FALSE; } ScDocument* pUndoDoc = NULL; if ( bUndo ) { pUndoDoc = new ScDocument( SCDOCMODE_UNDO ); pUndoDoc->InitUndo( pDoc, nTab, nTab ); pDoc->CopyToDocument( rRange, IDF_CONTENTS, FALSE, pUndoDoc ); } pDoc->DeleteAreaTab( nStartCol, nStartRow, nEndCol, nEndRow, nTab, IDF_CONTENTS ); BOOL bError = FALSE; USHORT nDocRow = nStartRow; for (long nRow=0; nRow& rColSeq = pArray[nRow]; if ( rColSeq.getLength() == nCols ) { USHORT nDocCol = nStartCol; const uno::Any* pColArr = rColSeq.getConstArray(); for (long nCol=0; nColSetError( nDocCol, nDocRow, nTab, NOVALUE ); } else if ( eElemClass == uno::TypeClass_SHORT || eElemClass == uno::TypeClass_LONG || eElemClass == uno::TypeClass_DOUBLE ) { double fVal; rElement >>= fVal; pDoc->SetValue( nDocCol, nDocRow, nTab, fVal ); } else if ( eElemClass == uno::TypeClass_STRING ) { rtl::OUString aUStr; rElement >>= aUStr; if ( aUStr.getLength() ) pDoc->PutCell( nDocCol, nDocRow, nTab, new ScStringCell( aUStr ) ); } else bError = TRUE; // invalid type ++nDocCol; } } else bError = TRUE; // wrong size ++nDocRow; } BOOL bHeight = rDocShell.AdjustRowHeight( nStartRow, nEndRow, nTab ); if ( pUndoDoc ) { ScMarkData aDestMark; aDestMark.SelectOneTable( nTab ); rDocShell.GetUndoManager()->AddUndoAction( new ScUndoPaste( &rDocShell, nStartCol, nStartRow, nTab, nEndCol, nEndRow, nTab, aDestMark, pUndoDoc, NULL, IDF_CONTENTS, NULL,NULL,NULL,NULL, FALSE ) ); } if (!bHeight) rDocShell.PostPaint( rRange, PAINT_GRID ); // AdjustRowHeight may have painted already rDocShell.SetDocumentModified(); return !bError; } //------------------------------------------------------------------------ // Default-ctor fuer SMART_REFLECTION Krempel ScCellRangesBase::ScCellRangesBase() : pDocShell( NULL ), aPropSet(lcl_GetCellsPropertyMap()), bChartColAsHdr( FALSE ), bChartRowAsHdr( FALSE ), pCurrentFlat( NULL ), pCurrentDeep( NULL ), pValueListener( NULL ), bValueChangePosted( FALSE ) { } ScCellRangesBase::ScCellRangesBase(ScDocShell* pDocSh, const ScRange& rR) : pDocShell( pDocSh ), aPropSet(lcl_GetCellsPropertyMap()), bChartColAsHdr( FALSE ), bChartRowAsHdr( FALSE ), pCurrentFlat( NULL ), pCurrentDeep( NULL ), pValueListener( NULL ), bValueChangePosted( FALSE ) { ScRange aCellRange = rR; aCellRange.Justify(); aRanges.Append( aCellRange ); if (pDocShell) // Null, wenn per createInstance erzeugt... pDocShell->GetDocument()->AddUnoObject(*this); } ScCellRangesBase::ScCellRangesBase(ScDocShell* pDocSh, const ScRangeList& rR) : pDocShell( pDocSh ), aRanges( rR ), aPropSet(lcl_GetCellsPropertyMap()), bChartColAsHdr( FALSE ), bChartRowAsHdr( FALSE ), pCurrentFlat( NULL ), pCurrentDeep( NULL ), pValueListener( NULL ), bValueChangePosted( FALSE ) { if (pDocShell) // Null, wenn per createInstance erzeugt... pDocShell->GetDocument()->AddUnoObject(*this); } ScCellRangesBase::~ScCellRangesBase() { ForgetCurrentAttrs(); if (pDocShell) pDocShell->GetDocument()->RemoveUnoObject(*this); delete pValueListener; //! XChartDataChangeEventListener abmelden ?? //! (ChartCollection haelt dann auch dieses Objekt fest!) } void ScCellRangesBase::ForgetCurrentAttrs() { delete pCurrentFlat; delete pCurrentDeep; pCurrentFlat = NULL; pCurrentDeep = NULL; } const ScPatternAttr* ScCellRangesBase::GetCurrentAttrsFlat() { // get and cache direct cell attributes for this object's range if ( !pCurrentFlat && pDocShell ) { ScMarkData aMark; aMark.MarkFromRangeList( aRanges, FALSE ); ScDocument* pDoc = pDocShell->GetDocument(); pCurrentFlat = pDoc->CreateSelectionPattern( aMark, FALSE ); } return pCurrentFlat; } const ScPatternAttr* ScCellRangesBase::GetCurrentAttrsDeep() { // get and cache cell attributes (incl. styles) for this object's range if ( !pCurrentDeep && pDocShell ) { ScMarkData aMark; aMark.MarkFromRangeList( aRanges, FALSE ); ScDocument* pDoc = pDocShell->GetDocument(); pCurrentDeep = pDoc->CreateSelectionPattern( aMark, TRUE ); } return pCurrentDeep; } void ScCellRangesBase::Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) { if ( rHint.ISA( ScUpdateRefHint ) ) { const ScUpdateRefHint& rRef = (const ScUpdateRefHint&)rHint; if ( aRanges.UpdateReference( rRef.GetMode(), pDocShell->GetDocument(), rRef.GetRange(), rRef.GetDx(), rRef.GetDy(), rRef.GetDz() ) ) RefChanged(); } else if ( rHint.ISA( SfxSimpleHint ) ) { ULONG nId = ((const SfxSimpleHint&)rHint).GetId(); if ( nId == SFX_HINT_DYING ) { ForgetCurrentAttrs(); pDocShell = NULL; // invalid } else if ( nId == SFX_HINT_DATACHANGED ) { // document content changed -> forget cached attributes ForgetCurrentAttrs(); } } } void ScCellRangesBase::RefChanged() { //! XChartDataChangeEventListener anpassen //! Test !!! if ( pValueListener && aValueListeners.Count() != 0 ) { pValueListener->EndListeningAll(); ScDocument* pDoc = pDocShell->GetDocument(); ULONG nCount = aRanges.Count(); for (ULONG i=0; iStartListeningArea( *aRanges.GetObject(i), pValueListener ); } //! Test !!! } ScDocument* ScCellRangesBase::GetDocument() const { if (pDocShell) return pDocShell->GetDocument(); else return NULL; } void ScCellRangesBase::InitInsertRange(ScDocShell* pDocSh, const ScRange& rR) { if ( !pDocShell && pDocSh ) { pDocShell = pDocSh; ScRange aCellRange = rR; aCellRange.Justify(); aRanges.RemoveAll(); aRanges.Append( aCellRange ); pDocShell->GetDocument()->AddUnoObject(*this); RefChanged(); // Range im Range-Objekt anpassen } } void ScCellRangesBase::SetNewRange(const ScRange& rNew) { ScRange aCellRange = rNew; aCellRange.Justify(); aRanges.RemoveAll(); aRanges.Append( aCellRange ); RefChanged(); } void ScCellRangesBase::SetNewRanges(const ScRangeList& rNew) { aRanges = rNew; RefChanged(); } uno::Any SAL_CALL ScCellRangesBase::queryInterface( const uno::Type& rType ) throw(uno::RuntimeException) { SC_QUERYINTERFACE( beans::XPropertySet ) SC_QUERYINTERFACE( beans::XPropertyState ) SC_QUERYINTERFACE( sheet::XSheetOperation ) SC_QUERYINTERFACE( chart::XChartDataArray ) SC_QUERYINTERFACE( chart::XChartData ) SC_QUERYINTERFACE( util::XIndent ) SC_QUERYINTERFACE( sheet::XCellRangesQuery ) SC_QUERYINTERFACE( sheet::XFormulaQuery ) SC_QUERYINTERFACE( util::XReplaceable ) SC_QUERYINTERFACE( util::XSearchable ) SC_QUERYINTERFACE( lang::XServiceInfo ) SC_QUERYINTERFACE( lang::XUnoTunnel ) SC_QUERYINTERFACE( lang::XTypeProvider ) return OWeakObject::queryInterface( rType ); } void SAL_CALL ScCellRangesBase::acquire() throw(uno::RuntimeException) { OWeakObject::acquire(); } void SAL_CALL ScCellRangesBase::release() throw(uno::RuntimeException) { OWeakObject::release(); } uno::Sequence SAL_CALL ScCellRangesBase::getTypes() throw(uno::RuntimeException) { static uno::Sequence aTypes; if ( aTypes.getLength() == 0 ) { aTypes.realloc(11); uno::Type* pPtr = aTypes.getArray(); pPtr[0] = getCppuType((const uno::Reference*)0); pPtr[1] = getCppuType((const uno::Reference*)0); pPtr[2] = getCppuType((const uno::Reference*)0); pPtr[3] = getCppuType((const uno::Reference*)0); pPtr[4] = getCppuType((const uno::Reference*)0); pPtr[5] = getCppuType((const uno::Reference*)0); pPtr[6] = getCppuType((const uno::Reference*)0); pPtr[7] = getCppuType((const uno::Reference*)0); pPtr[8] = getCppuType((const uno::Reference*)0); pPtr[9] = getCppuType((const uno::Reference*)0); pPtr[10]= getCppuType((const uno::Reference*)0); } return aTypes; } uno::Sequence SAL_CALL ScCellRangesBase::getImplementationId() throw(uno::RuntimeException) { static uno::Sequence< sal_Int8 > aId; if( aId.getLength() == 0 ) { aId.realloc( 16 ); rtl_createUuid( (sal_uInt8 *)aId.getArray(), 0, sal_True ); } return aId; } // --- void ScCellRangesBase::PaintRanges_Impl( USHORT nPart ) { ULONG nCount = aRanges.Count(); for (ULONG i=0; iPostPaint( *aRanges.GetObject(i), nPart ); } // XSheetOperation double SAL_CALL ScCellRangesBase::computeFunction( sheet::GeneralFunction nFunction ) throw(uno::Exception, uno::RuntimeException) { ScUnoGuard aGuard; ScMarkData aMark; aMark.MarkFromRangeList( aRanges, FALSE ); aMark.MarkToSimple(); if (!aMark.IsMarked()) aMark.SetMarkNegative(TRUE); // um Dummy Position angeben zu koennen ScAddress aDummy; // wenn nicht Marked, ignoriert wegen Negative double fVal; ScSubTotalFunc eFunc = lcl_SummaryToSubTotal( nFunction ); ScDocument* pDoc = pDocShell->GetDocument(); if ( !pDoc->GetSelectionFunction( eFunc, aDummy, aMark, fVal ) ) { throw uno::RuntimeException(); //! own exception? } return fVal; } void SAL_CALL ScCellRangesBase::clearContents( sal_Int32 nContentFlags ) throw(uno::RuntimeException) { ScUnoGuard aGuard; if ( aRanges.Count() ) { ScMarkData aMark; aMark.MarkFromRangeList( aRanges, FALSE ); // only for clearContents: EDITATTR is only used if no contents are deleted USHORT nDelFlags = nContentFlags & IDF_ALL; if ( ( nContentFlags & IDF_EDITATTR ) && ( nContentFlags & IDF_CONTENTS ) == 0 ) nDelFlags |= IDF_EDITATTR; ScDocFunc aFunc(*pDocShell); aFunc.DeleteContents( aMark, nDelFlags, TRUE, TRUE ); } // sonst ist nichts zu tun } // XPropertyState USHORT lcl_GetPropertyWhich( const String& rName ) { // Which-ID des betroffenen Items, auch wenn das Item die Property // nicht alleine behandeln kann USHORT nWhich = 0; const SfxItemPropertyMap* pMap = SfxItemPropertyMap::GetByName( lcl_GetCellsPropertyMap(), rName ); if ( pMap && pMap->nWID ) nWhich = pMap->nWID; else if ( rName.EqualsAscii( SC_UNONAME_TBLBORD ) ) nWhich = ATTR_BORDER; else if ( rName.EqualsAscii( SC_UNONAME_CONDFMT ) || rName.EqualsAscii( SC_UNONAME_CONDLOC ) || rName.EqualsAscii( SC_UNONAME_CONDXML ) ) nWhich = ATTR_CONDITIONAL; else if ( rName.EqualsAscii( SC_UNONAME_VALIDAT ) || rName.EqualsAscii( SC_UNONAME_VALILOC ) || rName.EqualsAscii( SC_UNONAME_VALIXML ) ) nWhich = ATTR_VALIDDATA; return nWhich; } beans::PropertyState SAL_CALL ScCellRangesBase::getPropertyState( const rtl::OUString& aPropertyName ) throw(beans::UnknownPropertyException, uno::RuntimeException) { ScUnoGuard aGuard; if ( aRanges.Count() == 0 ) throw uno::RuntimeException(); beans::PropertyState eRet = beans::PropertyState_DIRECT_VALUE; if ( pDocShell ) { String aNameString = aPropertyName; USHORT nWhich = lcl_GetPropertyWhich( aNameString ); if ( nWhich ) // irgendwie zustandegekommene Which-ID { //! Bei Items, die mehrere Properties enthalten (z.B. Hintergrund) //! wird hier evtl. zu oft "Ambiguous" zurueckgegeben // for PropertyState, don't look at styles const ScPatternAttr* pPattern = GetCurrentAttrsFlat(); if ( pPattern ) { SfxItemState eState = pPattern->GetItemSet().GetItemState( nWhich, FALSE ); // if no rotate value is set, look at orientation //! also for a fixed value of 0 (in case orientation is ambiguous)? if ( nWhich == ATTR_ROTATE_VALUE && eState == SFX_ITEM_DEFAULT ) eState = pPattern->GetItemSet().GetItemState( ATTR_ORIENTATION, FALSE ); if ( eState == SFX_ITEM_SET ) eRet = beans::PropertyState_DIRECT_VALUE; else if ( eState == SFX_ITEM_DEFAULT ) eRet = beans::PropertyState_DEFAULT_VALUE; else if ( eState == SFX_ITEM_DONTCARE ) eRet = beans::PropertyState_AMBIGUOUS_VALUE; else DBG_ERROR("unbekannter ItemState"); } } else if ( aNameString.EqualsAscii( SC_UNONAME_CHCOLHDR ) || aNameString.EqualsAscii( SC_UNONAME_CHROWHDR ) ) eRet = beans::PropertyState_DIRECT_VALUE; else if ( aNameString.EqualsAscii( SC_UNONAME_CELLSTYL ) ) { // a style is always set, there's no default state ScMarkData aMark; aMark.MarkFromRangeList( aRanges, FALSE ); const ScStyleSheet* pStyle = pDocShell->GetDocument()->GetSelectionStyle(aMark); if (pStyle) eRet = beans::PropertyState_DIRECT_VALUE; else eRet = beans::PropertyState_AMBIGUOUS_VALUE; } } return eRet; } uno::Sequence SAL_CALL ScCellRangesBase::getPropertyStates( const uno::Sequence& aPropertyNames ) throw(beans::UnknownPropertyException, uno::RuntimeException) { // duemmliche Default-Implementierung: alles einzeln per getPropertyState holen //! sollte optimiert werden! ScUnoGuard aGuard; const rtl::OUString* pNames = aPropertyNames.getConstArray(); uno::Sequence aRet(aPropertyNames.getLength()); beans::PropertyState* pStates = aRet.getArray(); for(INT32 i = 0; i < aPropertyNames.getLength(); i++) pStates[i] = getPropertyState(pNames[i]); return aRet; } void SAL_CALL ScCellRangesBase::setPropertyToDefault( const rtl::OUString& aPropertyName ) throw(beans::UnknownPropertyException, uno::RuntimeException) { ScUnoGuard aGuard; if ( pDocShell ) { String aNameString = aPropertyName; USHORT nWhich = lcl_GetPropertyWhich( aNameString ); if ( nWhich ) // irgendwie zustandegekommene Which-ID { if ( aRanges.Count() ) // leer = nichts zu tun { ScMarkData aMark; aMark.MarkFromRangeList( aRanges, FALSE ); ScDocument* pDoc = pDocShell->GetDocument(); ScDocFunc aFunc(*pDocShell); //! Bei Items, die mehrere Properties enthalten (z.B. Hintergrund) //! wird hier zuviel zurueckgesetzt //! for ATTR_ROTATE_VALUE, also reset ATTR_ORIENTATION? USHORT aWIDs[3]; aWIDs[0] = nWhich; if ( nWhich == ATTR_VALUE_FORMAT ) { aWIDs[1] = ATTR_LANGUAGE_FORMAT; // #67847# language for number formats aWIDs[2] = 0; } else aWIDs[1] = 0; aFunc.ClearItems( aMark, aWIDs, TRUE ); } } else if ( aNameString.EqualsAscii( SC_UNONAME_CHCOLHDR ) ) bChartColAsHdr = FALSE; else if ( aNameString.EqualsAscii( SC_UNONAME_CHROWHDR ) ) bChartRowAsHdr = FALSE; else if ( aNameString.EqualsAscii( SC_UNONAME_CELLSTYL ) ) { ScMarkData aMark; aMark.MarkFromRangeList( aRanges, FALSE ); ScDocFunc aFunc(*pDocShell); aFunc.ApplyStyle( aMark, ScGlobal::GetRscString(STR_STYLENAME_STANDARD), TRUE, TRUE ); } } } uno::Any SAL_CALL ScCellRangesBase::getPropertyDefault( const rtl::OUString& aPropertyName ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) { //! mit getPropertyValue zusammenfassen ScUnoGuard aGuard; uno::Any aAny; if ( pDocShell ) { ScDocument* pDoc = pDocShell->GetDocument(); String aNameString = aPropertyName; const SfxItemPropertyMap* pMap = SfxItemPropertyMap::GetByName( lcl_GetCellsPropertyMap(), aNameString ); if ( pMap && pMap->nWID ) { const ScPatternAttr* pPattern = pDoc->GetDefPattern(); if ( pPattern ) { const SfxItemSet& rSet = pPattern->GetItemSet(); switch ( pMap->nWID ) // fuer Item-Spezial-Behandlungen { case ATTR_VALUE_FORMAT: // default has no language set aAny <<= (sal_Int32)( ((const SfxUInt32Item&)rSet.Get(pMap->nWID)).GetValue() ); break; case ATTR_INDENT: aAny <<= (sal_Int16)( TwipsToHMM(((const SfxUInt16Item&) rSet.Get(pMap->nWID)).GetValue()) ); break; default: aAny = aPropSet.getPropertyValue(aNameString, rSet); } } } else // hier direkt implementierte { if ( aNameString.EqualsAscii( SC_UNONAME_CHCOLHDR ) || aNameString.EqualsAscii( SC_UNONAME_CHROWHDR ) ) ScUnoHelpFunctions::SetBoolInAny( aAny, FALSE ); else if ( aNameString.EqualsAscii( SC_UNONAME_CELLSTYL ) ) aAny <<= rtl::OUString( ScStyleNameConversion::DisplayToProgrammaticName( ScGlobal::GetRscString(STR_STYLENAME_STANDARD), SFX_STYLE_FAMILY_PARA ) ); else if ( aNameString.EqualsAscii( SC_UNONAME_TBLBORD ) ) { const ScPatternAttr* pPattern = pDoc->GetDefPattern(); if ( pPattern ) { table::TableBorder aBorder; lcl_FillTableBorder( aBorder, (const SvxBoxItem&)pPattern->GetItem(ATTR_BORDER), (const SvxBoxInfoItem&)pPattern->GetItem(ATTR_BORDER_INNER) ); aAny <<= aBorder; } } else if ( aNameString.EqualsAscii( SC_UNONAME_CONDFMT ) || aNameString.EqualsAscii( SC_UNONAME_CONDLOC ) || aNameString.EqualsAscii( SC_UNONAME_CONDXML ) ) { BOOL bEnglish = !aNameString.EqualsAscii( SC_UNONAME_CONDLOC ); BOOL bXML = aNameString.EqualsAscii( SC_UNONAME_CONDXML ); uno::Reference xObj = new ScTableConditionalFormat( pDoc, 0, bEnglish, bXML ); aAny <<= xObj; } else if ( aNameString.EqualsAscii( SC_UNONAME_VALIDAT ) || aNameString.EqualsAscii( SC_UNONAME_VALILOC ) || aNameString.EqualsAscii( SC_UNONAME_VALIXML ) ) { BOOL bEnglish = !aNameString.EqualsAscii( SC_UNONAME_VALILOC ); BOOL bXML = aNameString.EqualsAscii( SC_UNONAME_VALIXML ); uno::Reference xObj = new ScTableValidationObj( pDoc, 0, bEnglish, bXML ); aAny <<= xObj; } } } return aAny; } // XPropertySet uno::Reference SAL_CALL ScCellRangesBase::getPropertySetInfo() throw(uno::RuntimeException) { ScUnoGuard aGuard; static uno::Reference aRef = new SfxItemPropertySetInfo( aPropSet.getPropertyMap() ); return aRef; } void SAL_CALL ScCellRangesBase::setPropertyValue( const rtl::OUString& aPropertyName, const uno::Any& aValue ) throw(beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; if ( pDocShell ) { String aNameString = aPropertyName; const SfxItemPropertyMap* pMap = SfxItemPropertyMap::GetByName( lcl_GetCellsPropertyMap(), aNameString ); if ( pMap && pMap->nWID ) { if ( aRanges.Count() ) // leer = nichts zu tun { ScMarkData aMark; aMark.MarkFromRangeList( aRanges, FALSE ); ScDocument* pDoc = pDocShell->GetDocument(); ScDocFunc aFunc(*pDocShell); // Fuer Teile von zusammengesetzten Items mit mehreren Properties (z.B. Hintergrund) // muss vorher das alte Item aus dem Dokument geholt werden //! Das kann hier aber nicht erkannt werden //! -> eigenes Flag im PropertyMap-Eintrag, oder was ??? //! Item direkt von einzelner Position im Bereich holen? // ClearInvalidItems, damit auf jeden Fall ein Item vom richtigen Typ da ist ScPatternAttr aPattern( *GetCurrentAttrsDeep() ); SfxItemSet& rSet = aPattern.GetItemSet(); rSet.ClearInvalidItems(); USHORT nDontClear = 0; switch ( pMap->nWID ) // fuer Item-Spezial-Behandlungen { case ATTR_VALUE_FORMAT: { // #67847# language for number formats SvNumberFormatter* pFormatter = pDoc->GetFormatTable(); ULONG nOldFormat = ((const SfxUInt32Item&) rSet.Get( ATTR_VALUE_FORMAT )).GetValue(); LanguageType eOldLang = ((const SvxLanguageItem&) rSet.Get( ATTR_LANGUAGE_FORMAT )).GetLanguage(); nOldFormat = pFormatter-> GetFormatForLanguageIfBuiltIn( nOldFormat, eOldLang ); sal_Int32 nIntVal; if ( aValue >>= nIntVal ) { ULONG nNewFormat = (ULONG)nIntVal; rSet.Put( SfxUInt32Item( ATTR_VALUE_FORMAT, nNewFormat ) ); const SvNumberformat* pNewEntry = pFormatter->GetEntry( nNewFormat ); LanguageType eNewLang = pNewEntry ? pNewEntry->GetLanguage() : LANGUAGE_DONTKNOW; if ( eNewLang != eOldLang && eNewLang != LANGUAGE_DONTKNOW ) { rSet.Put( SvxLanguageItem( eNewLang, ATTR_LANGUAGE_FORMAT ) ); // #40606# if only language is changed, // don't touch number format attribute ULONG nNewMod = nNewFormat % SV_COUNTRY_LANGUAGE_OFFSET; if ( nNewMod == ( nOldFormat % SV_COUNTRY_LANGUAGE_OFFSET ) && nNewMod <= SV_MAX_ANZ_STANDARD_FORMATE ) rSet.ClearItem( ATTR_VALUE_FORMAT ); nDontClear = ATTR_LANGUAGE_FORMAT; } } } break; case ATTR_INDENT: { sal_Int16 nIntVal; if ( aValue >>= nIntVal ) rSet.Put( SfxUInt16Item( pMap->nWID, (USHORT)HMMToTwips(nIntVal) ) ); } break; case ATTR_ROTATE_VALUE: { sal_Int32 nRotVal; if ( aValue >>= nRotVal ) { // stored value is always between 0 and 360 deg. nRotVal %= 36000; if ( nRotVal < 0 ) nRotVal += 36000; // always set rotation value and orientation SvxCellOrientation eOrient = SVX_ORIENTATION_STANDARD; BOOL bSetOrient = TRUE; if ( nRotVal == 9000 ) eOrient = SVX_ORIENTATION_BOTTOMTOP; else if ( nRotVal == 27000 ) eOrient = SVX_ORIENTATION_TOPBOTTOM; else if ( nRotVal == 0 ) { // don't overwrite stacked orientation by setting // rotation to 0 SvxCellOrientation eOld = (SvxCellOrientation) ((const SvxOrientationItem&)rSet.Get(ATTR_ORIENTATION)). GetValue(); if ( eOld == SVX_ORIENTATION_STACKED ) bSetOrient = FALSE; } rSet.Put( SfxInt32Item( ATTR_ROTATE_VALUE, nRotVal ) ); if (bSetOrient) { rSet.Put( SvxOrientationItem( eOrient, ATTR_ORIENTATION ) ); nDontClear = ATTR_ORIENTATION; } } } break; default: aPropSet.setPropertyValue(aNameString, aValue, rSet); } // alle anderen Items muessen aber wieder raus... //! oder neues Pattern, nur das betroffene Item putten? for (USHORT nWhich = ATTR_PATTERN_START; nWhich <= ATTR_PATTERN_END; nWhich++) if ( nWhich != pMap->nWID && nWhich != nDontClear ) rSet.ClearItem(nWhich); aFunc.ApplyAttributes( aMark, aPattern, TRUE, TRUE ); } } else // hier direkt implementierte { // Chart-Header Flags werden nur an diesem Objekt gesetzt, // nicht im Dokument gespeichert if ( aNameString.EqualsAscii( SC_UNONAME_CHCOLHDR ) ) bChartColAsHdr = ScUnoHelpFunctions::GetBoolFromAny( aValue ); else if ( aNameString.EqualsAscii( SC_UNONAME_CHROWHDR ) ) bChartRowAsHdr = ScUnoHelpFunctions::GetBoolFromAny( aValue ); else if ( aNameString.EqualsAscii( SC_UNONAME_CELLSTYL ) ) { rtl::OUString aStrVal; aValue >>= aStrVal; String aString = ScStyleNameConversion::ProgrammaticToDisplayName( aStrVal, SFX_STYLE_FAMILY_PARA ); ScMarkData aMark; aMark.MarkFromRangeList( aRanges, FALSE ); ScDocFunc aFunc(*pDocShell); aFunc.ApplyStyle( aMark, aString, TRUE, TRUE ); } else if ( aNameString.EqualsAscii( SC_UNONAME_TBLBORD ) ) { table::TableBorder aBorder; if ( aRanges.Count() && ( aValue >>= aBorder ) ) // leer = nichts zu tun { SvxBoxItem aOuter(ATTR_BORDER); SvxBoxInfoItem aInner(ATTR_BORDER_INNER); lcl_FillBoxItems( aOuter, aInner, aBorder ); lcl_ApplyBorder( pDocShell, aRanges, aOuter, aInner ); //! docfunc } } else if ( aNameString.EqualsAscii( SC_UNONAME_CONDFMT ) || aNameString.EqualsAscii( SC_UNONAME_CONDLOC ) || aNameString.EqualsAscii( SC_UNONAME_CONDXML ) ) { BOOL bEnglish = !aNameString.EqualsAscii( SC_UNONAME_CONDLOC ); BOOL bXML = aNameString.EqualsAscii( SC_UNONAME_CONDXML ); uno::Reference xInterface; if ( aRanges.Count() && ( aValue >>= xInterface ) ) // leer = nichts zu tun { ScTableConditionalFormat* pFormat = ScTableConditionalFormat::getImplementation( xInterface ); if (pFormat) { ScDocument* pDoc = pDocShell->GetDocument(); ScConditionalFormat aNew( 0, pDoc ); // Index wird beim Einfuegen gesetzt pFormat->FillFormat( aNew, pDoc, bEnglish, bXML ); ULONG nIndex = pDoc->AddCondFormat( aNew ); ScMarkData aMark; aMark.MarkFromRangeList( aRanges, FALSE ); ScDocFunc aFunc(*pDocShell); ScPatternAttr aPattern( pDoc->GetPool() ); aPattern.GetItemSet().Put( SfxUInt32Item( ATTR_CONDITIONAL, nIndex ) ); aFunc.ApplyAttributes( aMark, aPattern, TRUE, TRUE ); } } } else if ( aNameString.EqualsAscii( SC_UNONAME_VALIDAT ) || aNameString.EqualsAscii( SC_UNONAME_VALILOC ) || aNameString.EqualsAscii( SC_UNONAME_VALIXML ) ) { BOOL bEnglish = !aNameString.EqualsAscii( SC_UNONAME_VALILOC ); BOOL bXML = aNameString.EqualsAscii( SC_UNONAME_VALIXML ); uno::Reference xInterface; if ( aRanges.Count() && ( aValue >>= xInterface ) ) // leer = nichts zu tun { ScTableValidationObj* pValidObj = ScTableValidationObj::getImplementation( xInterface ); if (pValidObj) { ScDocument* pDoc = pDocShell->GetDocument(); ScValidationData* pNewData = pValidObj->CreateValidationData( pDoc, bEnglish, bXML ); ULONG nIndex = pDoc->AddValidationEntry( *pNewData ); delete pNewData; ScMarkData aMark; aMark.MarkFromRangeList( aRanges, FALSE ); ScDocFunc aFunc(*pDocShell); ScPatternAttr aPattern( pDoc->GetPool() ); aPattern.GetItemSet().Put( SfxUInt32Item( ATTR_VALIDDATA, nIndex ) ); aFunc.ApplyAttributes( aMark, aPattern, TRUE, TRUE ); } } } } } } uno::Any SAL_CALL ScCellRangesBase::getPropertyValue( const rtl::OUString& aPropertyName ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; if ( aRanges.Count() == 0 ) throw uno::RuntimeException(); uno::Any aAny; if ( pDocShell ) { String aNameString = aPropertyName; const SfxItemPropertyMap* pMap = SfxItemPropertyMap::GetByName( lcl_GetCellsPropertyMap(), aNameString ); if ( pMap && pMap->nWID ) { const ScPatternAttr* pPattern = GetCurrentAttrsDeep(); if ( pPattern ) { // Dontcare durch Default ersetzen, damit man immer eine Reflection hat SfxItemSet aDataSet( pPattern->GetItemSet() ); aDataSet.ClearInvalidItems(); switch ( pMap->nWID ) // fuer Item-Spezial-Behandlungen { case ATTR_VALUE_FORMAT: { ScDocument* pDoc = pDocShell->GetDocument(); ULONG nOldFormat = ((const SfxUInt32Item&) aDataSet.Get( ATTR_VALUE_FORMAT )).GetValue(); LanguageType eOldLang = ((const SvxLanguageItem&) aDataSet.Get( ATTR_LANGUAGE_FORMAT )).GetLanguage(); nOldFormat = pDoc->GetFormatTable()-> GetFormatForLanguageIfBuiltIn( nOldFormat, eOldLang ); aAny <<= (sal_Int32)( nOldFormat ); } break; case ATTR_INDENT: aAny <<= (sal_Int16)( TwipsToHMM(((const SfxUInt16Item&) aDataSet.Get(pMap->nWID)).GetValue()) ); break; case ATTR_ROTATE_VALUE: { // if value is 0 and orientation topbottom or bottomtop, // adjust value sal_Int32 nRotVal = ((const SfxInt32Item&) aDataSet.Get(ATTR_ROTATE_VALUE)).GetValue(); if ( nRotVal == 0 ) { SvxCellOrientation eOrient = (SvxCellOrientation) ((const SvxOrientationItem&)aDataSet.Get(ATTR_ORIENTATION)). GetValue(); if ( eOrient == SVX_ORIENTATION_BOTTOMTOP ) nRotVal = 9000; else if ( eOrient == SVX_ORIENTATION_TOPBOTTOM ) nRotVal = 27000; } aAny <<= nRotVal; } break; default: aAny = aPropSet.getPropertyValue(aNameString, aDataSet); } } } else // hier direkt implementierte { if ( aNameString.EqualsAscii( SC_UNONAME_CHCOLHDR ) ) ScUnoHelpFunctions::SetBoolInAny( aAny, bChartColAsHdr ); else if ( aNameString.EqualsAscii( SC_UNONAME_CHROWHDR ) ) ScUnoHelpFunctions::SetBoolInAny( aAny, bChartRowAsHdr ); else if ( aNameString.EqualsAscii( SC_UNONAME_CELLSTYL ) ) { ScMarkData aMark; aMark.MarkFromRangeList( aRanges, FALSE ); String aStyleName; const ScStyleSheet* pStyle = pDocShell->GetDocument()->GetSelectionStyle(aMark); if (pStyle) aStyleName = pStyle->GetName(); aAny <<= rtl::OUString( ScStyleNameConversion::DisplayToProgrammaticName( aStyleName, SFX_STYLE_FAMILY_PARA ) ); } else if ( aNameString.EqualsAscii( SC_UNONAME_TBLBORD ) ) { //! alle Ranges durchgehen const ScRange* pFirst = aRanges.GetObject(0); if (pFirst) { SvxBoxItem aOuter(ATTR_BORDER); SvxBoxInfoItem aInner(ATTR_BORDER_INNER); ScDocument* pDoc = pDocShell->GetDocument(); ScMarkData aMark; aMark.SetMarkArea( *pFirst ); aMark.SelectTable( pFirst->aStart.Tab(), TRUE ); pDoc->GetSelectionFrame( aMark, aOuter, aInner ); table::TableBorder aBorder; lcl_FillTableBorder( aBorder, aOuter, aInner ); aAny <<= aBorder; } } else if ( aNameString.EqualsAscii( SC_UNONAME_CONDFMT ) || aNameString.EqualsAscii( SC_UNONAME_CONDLOC ) || aNameString.EqualsAscii( SC_UNONAME_CONDXML ) ) { BOOL bEnglish = !aNameString.EqualsAscii( SC_UNONAME_CONDLOC ); BOOL bXML = aNameString.EqualsAscii( SC_UNONAME_CONDXML ); const ScPatternAttr* pPattern = GetCurrentAttrsDeep(); if ( pPattern ) { ScDocument* pDoc = pDocShell->GetDocument(); ULONG nIndex = ((const SfxUInt32Item&) pPattern->GetItem(ATTR_CONDITIONAL)).GetValue(); uno::Reference xObj = new ScTableConditionalFormat( pDoc, nIndex, bEnglish, bXML ); aAny <<= xObj; } } else if ( aNameString.EqualsAscii( SC_UNONAME_VALIDAT ) || aNameString.EqualsAscii( SC_UNONAME_VALILOC ) || aNameString.EqualsAscii( SC_UNONAME_VALIXML ) ) { BOOL bEnglish = !aNameString.EqualsAscii( SC_UNONAME_VALILOC ); BOOL bXML = aNameString.EqualsAscii( SC_UNONAME_VALIXML ); const ScPatternAttr* pPattern = GetCurrentAttrsDeep(); if ( pPattern ) { ScDocument* pDoc = pDocShell->GetDocument(); ULONG nIndex = ((const SfxUInt32Item&) pPattern->GetItem(ATTR_VALIDDATA)).GetValue(); uno::Reference xObj = new ScTableValidationObj( pDoc, nIndex, bEnglish, bXML ); aAny <<= xObj; } } } } return aAny; } void SAL_CALL ScCellRangesBase::addPropertyChangeListener( const rtl::OUString& aPropertyName, const uno::Reference& aListener) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; if ( aRanges.Count() == 0 ) throw uno::RuntimeException(); //! Test !!!!! if (String(aPropertyName).EqualsAscii( "Test" )) { uno::Reference *pObj = new uno::Reference( aListener ); aValueListeners.Insert( pObj, aValueListeners.Count() ); if ( aValueListeners.Count() == 1 ) { if (!pValueListener) pValueListener = new ScLinkListener( LINK( this, ScCellRangesBase, ValueListenerHdl ) ); ScDocument* pDoc = pDocShell->GetDocument(); ULONG nCount = aRanges.Count(); for (ULONG i=0; iStartListeningArea( *aRanges.GetObject(i), pValueListener ); acquire(); // nicht verlieren (eine Ref fuer alle Listener) } return; } //! Test !!!!! DBG_ERROR("not implemented"); } void SAL_CALL ScCellRangesBase::removePropertyChangeListener( const rtl::OUString& aPropertyName, const uno::Reference& aListener) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; if ( aRanges.Count() == 0 ) throw uno::RuntimeException(); //! Test !!!!! if (String(aPropertyName).EqualsAscii( "Test" )) { acquire(); // falls fuer Listener die letzte Ref existiert - wird unten freigegeben USHORT nCount = aValueListeners.Count(); for ( USHORT n=nCount; n--; ) { uno::Reference *pObj = aValueListeners[n]; if ( *pObj == aListener ) { aValueListeners.DeleteAndDestroy( n ); if ( aValueListeners.Count() == 0 ) { if (pValueListener) pValueListener->EndListeningAll(); release(); // Listener-Ref freigeben } break; } } release(); // damit kann dieses Objekt geloescht werden return; } //! Test !!!!! DBG_ERROR("not implemented"); } void SAL_CALL ScCellRangesBase::addVetoableChangeListener( const rtl::OUString&, const uno::Reference&) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) { DBG_ERROR("not implemented"); } void SAL_CALL ScCellRangesBase::removeVetoableChangeListener( const rtl::OUString&, const uno::Reference&) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) { DBG_ERROR("not implemented"); } //! Test !!! IMPL_LINK( ScCellRangesBase, ValueListenerHdl, SfxHint*, pHint ) { if ( pDocShell && pHint && pHint->ISA( SfxSimpleHint ) && ((const SfxSimpleHint*)pHint)->GetId() & (SC_HINT_DATACHANGED | SC_HINT_DYING) ) { // nicht doppelt notifien, wenn sich mehrere Formeln im Bereich aendern... if ( aValueListeners.Count() && !bValueChangePosted ) { // Die Listener koennen nur asynchron benachrichtigt werden, weil im // Formel-Broadcast auf keinen Fall Reschedule gerufen werden darf beans::PropertyChangeEvent* pEvent = new beans::PropertyChangeEvent; pEvent->Source = (cppu::OWeakObject*)this; pEvent->PropertyName = rtl::OUString::createFromAscii( "Test" ); pEvent->Further = FALSE; pEvent->PropertyHandle = -1; pEvent->OldValue = uno::Any(); pEvent->NewValue = uno::Any(); // Die Ref im Event-Objekt haelt dieses Objekt fest // Das Event-Objekt wird im Link-Handler geloescht bValueChangePosted = TRUE; Application::PostUserEvent( LINK( this, ScCellRangesBase, ValueChanged ), pEvent ); } } return 0; } // ValueChanged wird asynchron gerufen IMPL_LINK( ScCellRangesBase, ValueChanged, beans::PropertyChangeEvent*, pEvent ) { if ( pEvent ) { if ( pDocShell ) for ( USHORT n=0; npropertyChange( *pEvent ); bValueChangePosted = FALSE; delete pEvent; // damit kann auch dieses Objekt geloescht werden } return 0; } //! Test !!!!! // XIndent void SAL_CALL ScCellRangesBase::decrementIndent() throw(::com::sun::star::uno::RuntimeException) { ScUnoGuard aGuard; if ( pDocShell && aRanges.Count() ) // leer = nichts zu tun { ScMarkData aMark; aMark.MarkFromRangeList( aRanges, FALSE ); ScDocFunc aFunc(*pDocShell); aFunc.ChangeIndent( aMark, FALSE, TRUE ); } } void SAL_CALL ScCellRangesBase::incrementIndent() throw(::com::sun::star::uno::RuntimeException) { ScUnoGuard aGuard; if ( pDocShell && aRanges.Count() ) // leer = nichts zu tun { ScMarkData aMark; aMark.MarkFromRangeList( aRanges, FALSE ); ScDocFunc aFunc(*pDocShell); aFunc.ChangeIndent( aMark, TRUE, TRUE ); } } // XChartData SchMemChart* ScCellRangesBase::CreateMemChart_Impl() const { if ( pDocShell && aRanges.Count() ) { ScRangeListRef xChartRanges; if ( aRanges.Count() == 1 ) { // ganze Tabelle sinnvoll begrenzen (auf belegten Datenbereich) // (nur hier, Listener werden auf den ganzen Bereich angemeldet) //! direkt testen, ob es ein ScTableSheetObj ist? ScRange* pRange = aRanges.GetObject(0); if ( pRange->aStart.Col() == 0 && pRange->aEnd.Col() == MAXCOL && pRange->aStart.Row() == 0 && pRange->aEnd.Row() == MAXROW ) { USHORT nTab = pRange->aStart.Tab(); USHORT nStartX, nStartY; // Anfang holen if (!pDocShell->GetDocument()->GetDataStart( nTab, nStartX, nStartY )) nStartX = nStartY = 0; USHORT nEndX, nEndY; // Ende holen if (!pDocShell->GetDocument()->GetTableArea( nTab, nEndX, nEndY )) nEndX = nEndY = 0; xChartRanges = new ScRangeList; xChartRanges->Append( ScRange( nStartX, nStartY, nTab, nEndX, nEndY, nTab ) ); } } if (!xChartRanges.Is()) // sonst Ranges direkt uebernehmen xChartRanges = new ScRangeList(aRanges); ScChartArray aArr( pDocShell->GetDocument(), xChartRanges, String() ); // RowAsHdr = ColHeaders und umgekehrt aArr.SetHeaders( bChartRowAsHdr, bChartColAsHdr ); return aArr.CreateMemChart(); } return NULL; } uno::Sequence< uno::Sequence > SAL_CALL ScCellRangesBase::getData() throw(uno::RuntimeException) { ScUnoGuard aGuard; SchMemChart* pMemChart = CreateMemChart_Impl(); if ( pMemChart ) { short nColCount = pMemChart->GetColCount(); short nRowCount = pMemChart->GetRowCount(); uno::Sequence< uno::Sequence > aRowSeq( nRowCount ); uno::Sequence* pRowAry = aRowSeq.getArray(); for (short nRow = 0; nRow < nRowCount; nRow++) { uno::Sequence aColSeq( nColCount ); double* pColAry = aColSeq.getArray(); for (short nCol = 0; nCol < nColCount; nCol++) pColAry[nCol] = pMemChart->GetData( nCol, nRow ); pRowAry[nRow] = aColSeq; } delete pMemChart; return aRowSeq; } return uno::Sequence< uno::Sequence >(0); } void SAL_CALL ScCellRangesBase::setData( const uno::Sequence< uno::Sequence >& aData ) throw(uno::RuntimeException) { //! ist das ernst gemeint? DBG_ERROR("not implemented"); } uno::Sequence SAL_CALL ScCellRangesBase::getRowDescriptions() throw(uno::RuntimeException) { ScUnoGuard aGuard; SchMemChart* pMemChart = CreateMemChart_Impl(); if ( pMemChart ) { short nRowCount = pMemChart->GetRowCount(); uno::Sequence aSeq( nRowCount ); rtl::OUString* pAry = aSeq.getArray(); for (short nRow = 0; nRow < nRowCount; nRow++) pAry[nRow] = pMemChart->GetRowText(nRow); delete pMemChart; return aSeq; } return uno::Sequence(0); } void SAL_CALL ScCellRangesBase::setRowDescriptions( const uno::Sequence& aRowDescriptions ) throw(uno::RuntimeException) { //! ist das ernst gemeint? DBG_ERROR("not implemented"); } uno::Sequence SAL_CALL ScCellRangesBase::getColumnDescriptions() throw(uno::RuntimeException) { ScUnoGuard aGuard; SchMemChart* pMemChart = CreateMemChart_Impl(); if ( pMemChart ) { short nColCount = pMemChart->GetColCount(); uno::Sequence aSeq( nColCount ); rtl::OUString* pAry = aSeq.getArray(); for (short nCol = 0; nCol < nColCount; nCol++) pAry[nCol] = pMemChart->GetColText(nCol); delete pMemChart; return aSeq; } return uno::Sequence(0); } void SAL_CALL ScCellRangesBase::setColumnDescriptions( const uno::Sequence& aColumnDescriptions ) throw(uno::RuntimeException) { //! ist das ernst gemeint? DBG_ERROR("not implemented"); } String lcl_UniqueName( StrCollection& rColl, const String& rPrefix ) { long nNumber = 1; USHORT nCollCount = rColl.GetCount(); while (TRUE) { String aName = rPrefix; aName += String::CreateFromInt32( nNumber ); BOOL bFound = FALSE; for (USHORT i=0; iGetString() == aName ) { bFound = TRUE; break; } if (!bFound) return aName; ++nNumber; } } void SAL_CALL ScCellRangesBase::addChartDataChangeEventListener( const uno::Reference< chart::XChartDataChangeEventListener >& aListener ) throw(uno::RuntimeException) { ScUnoGuard aGuard; if ( pDocShell && aRanges.Count() ) { //! auf doppelte testen? ScDocument* pDoc = pDocShell->GetDocument(); ScRangeListRef aRangesRef( new ScRangeList(aRanges) ); ScChartListenerCollection* pColl = pDoc->GetChartListenerCollection(); String aName = lcl_UniqueName( *pColl, String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM("__Uno")) ); ScChartListener* pListener = new ScChartListener( aName, pDoc, aRangesRef ); pListener->SetUno( aListener, this ); pColl->Insert( pListener ); pListener->StartListeningTo(); } } void SAL_CALL ScCellRangesBase::removeChartDataChangeEventListener( const uno::Reference< chart::XChartDataChangeEventListener >& aListener ) throw(uno::RuntimeException) { ScUnoGuard aGuard; if ( pDocShell && aRanges.Count() ) { ScDocument* pDoc = pDocShell->GetDocument(); ScChartListenerCollection* pColl = pDoc->GetChartListenerCollection(); pColl->FreeUno( aListener, this ); } } double SAL_CALL ScCellRangesBase::getNotANumber() throw(::com::sun::star::uno::RuntimeException) { // im ScChartArray wird DBL_MIN verwendet, weil das Chart es so will return DBL_MIN; } sal_Bool SAL_CALL ScCellRangesBase::isNotANumber( double nNumber ) throw(uno::RuntimeException) { // im ScChartArray wird DBL_MIN verwendet, weil das Chart es so will return (nNumber == DBL_MIN); } // XCellRangesQuery uno::Reference SAL_CALL ScCellRangesBase::queryVisibleCells() throw(uno::RuntimeException) { ScUnoGuard aGuard; if (pDocShell) { //! fuer alle Tabellen getrennt, wenn Markierungen pro Tabelle getrennt sind! USHORT nTab = lcl_FirstTab(aRanges); ScMarkData aMarkData; aMarkData.MarkFromRangeList( aRanges, FALSE ); ScDocument* pDoc = pDocShell->GetDocument(); for (USHORT nCol=0; nCol<=MAXCOL; nCol++) if (pDoc->GetColFlags(nCol,nTab) & CR_HIDDEN) aMarkData.SetMultiMarkArea( ScRange( nCol,0,nTab, nCol,MAXROW,nTab ), FALSE ); //! nur bis zur letzten selektierten Zeile testen? for (USHORT nRow=0; nRow<=MAXROW; nRow++) if (pDoc->GetRowFlags(nRow,nTab) & CR_HIDDEN) { USHORT nHiddenCount = pDoc->GetHiddenRowCount( nRow, nTab ); DBG_ASSERT(nHiddenCount, "huch?"); USHORT nLast = nRow + nHiddenCount - 1; aMarkData.SetMultiMarkArea( ScRange( 0,nRow,nTab, MAXCOL,nLast,nTab ), FALSE ); nRow = nLast; // +1 wird hinterher addiert } ScRangeList aNewRanges; aMarkData.FillRangeListWithMarks( &aNewRanges, FALSE ); return new ScCellRangesObj( pDocShell, aNewRanges ); } return NULL; } uno::Reference SAL_CALL ScCellRangesBase::queryEmptyCells() throw(uno::RuntimeException) { ScUnoGuard aGuard; if (pDocShell) { ScDocument* pDoc = pDocShell->GetDocument(); ScMarkData aMarkData; aMarkData.MarkFromRangeList( aRanges, FALSE ); // belegte Zellen wegmarkieren ULONG nCount = aRanges.Count(); for (ULONG i=0; iGetCellType() != CELLTYPE_NOTE || pCell->GetNotePtr() ) aMarkData.SetMultiMarkArea( ScRange( aIter.GetCol(), aIter.GetRow(), aIter.GetTab() ), FALSE ); pCell = aIter.GetNext(); } } ScRangeList aNewRanges; // IsMultiMarked reicht hier nicht (wird beim deselektieren nicht zurueckgesetzt) if (aMarkData.HasAnyMultiMarks()) aMarkData.FillRangeListWithMarks( &aNewRanges, FALSE ); return new ScCellRangesObj( pDocShell, aNewRanges ); // aNewRanges kann leer sein } return NULL; } uno::Reference SAL_CALL ScCellRangesBase::queryContentCells( sal_Int16 nContentFlags ) throw(uno::RuntimeException) { ScUnoGuard aGuard; if (pDocShell) { ScDocument* pDoc = pDocShell->GetDocument(); ScMarkData aMarkData; // passende Zellen selektieren ULONG nCount = aRanges.Count(); for (ULONG i=0; iGetNotePtr() && ( nContentFlags & sheet::CellFlags::ANNOTATION ) ) bAdd = TRUE; else switch ( pCell->GetCellType() ) { case CELLTYPE_STRING: case CELLTYPE_EDIT: if ( nContentFlags & sheet::CellFlags::STRING ) bAdd = TRUE; break; case CELLTYPE_FORMULA: if ( nContentFlags & sheet::CellFlags::FORMULA ) bAdd = TRUE; break; case CELLTYPE_VALUE: if ( (nContentFlags & (sheet::CellFlags::VALUE|sheet::CellFlags::DATETIME)) == (sheet::CellFlags::VALUE|sheet::CellFlags::DATETIME) ) bAdd = TRUE; else { // Date/Time Erkennung ULONG nIndex = (ULONG)((SfxUInt32Item*)pDoc->GetAttr( aIter.GetCol(), aIter.GetRow(), aIter.GetTab(), ATTR_VALUE_FORMAT ))->GetValue(); short nTyp = pDoc->GetFormatTable()->GetType(nIndex); if ((nTyp == NUMBERFORMAT_DATE) || (nTyp == NUMBERFORMAT_TIME) || (nTyp == NUMBERFORMAT_DATETIME)) { if ( nContentFlags & sheet::CellFlags::DATETIME ) bAdd = TRUE; } else { if ( nContentFlags & sheet::CellFlags::VALUE ) bAdd = TRUE; } } break; } if (bAdd) aMarkData.SetMultiMarkArea( ScRange( aIter.GetCol(), aIter.GetRow(), aIter.GetTab() ), TRUE ); pCell = aIter.GetNext(); } } ScRangeList aNewRanges; if (aMarkData.IsMultiMarked()) aMarkData.FillRangeListWithMarks( &aNewRanges, FALSE ); return new ScCellRangesObj( pDocShell, aNewRanges ); // aNewRanges kann leer sein } return NULL; } uno::Reference SAL_CALL ScCellRangesBase::queryFormulaCells( sal_Int32 nResultFlags ) throw(uno::RuntimeException) { ScUnoGuard aGuard; if (pDocShell) { ScDocument* pDoc = pDocShell->GetDocument(); ScMarkData aMarkData; // passende Zellen selektieren ULONG nCount = aRanges.Count(); for (ULONG i=0; iGetCellType() == CELLTYPE_FORMULA) { ScFormulaCell* pFCell = (ScFormulaCell*)pCell; BOOL bAdd = FALSE; if (pFCell->GetErrCode()) { if ( nResultFlags & sheet::FormulaResult::ERROR ) bAdd = TRUE; } else if (pFCell->IsValue()) { if ( nResultFlags & sheet::FormulaResult::VALUE ) bAdd = TRUE; } else // String { if ( nResultFlags & sheet::FormulaResult::STRING ) bAdd = TRUE; } if (bAdd) aMarkData.SetMultiMarkArea( ScRange( aIter.GetCol(), aIter.GetRow(), aIter.GetTab() ), TRUE ); } pCell = aIter.GetNext(); } } ScRangeList aNewRanges; if (aMarkData.IsMultiMarked()) aMarkData.FillRangeListWithMarks( &aNewRanges, FALSE ); return new ScCellRangesObj( pDocShell, aNewRanges ); // aNewRanges kann leer sein } return NULL; } uno::Reference ScCellRangesBase::QueryDifferences_Impl( const table::CellAddress& aCompare, BOOL bColumnDiff) { if (pDocShell) { ULONG nRangeCount = aRanges.Count(); ULONG i; ScDocument* pDoc = pDocShell->GetDocument(); ScMarkData aMarkData; USHORT nCmpPos = bColumnDiff ? (USHORT)aCompare.Row : (USHORT)aCompare.Column; // zuerst alles selektieren, wo ueberhaupt etwas in der Vergleichsspalte steht // (fuer gleiche Zellen wird die Selektion im zweiten Schritt aufgehoben) USHORT nTab = lcl_FirstTab(aRanges); //! fuer alle Tabellen, wenn Markierungen pro Tabelle! ScRange aCmpRange, aCellRange; if (bColumnDiff) aCmpRange = ScRange( 0,nCmpPos,nTab, MAXCOL,nCmpPos,nTab ); else aCmpRange = ScRange( nCmpPos,0,nTab, nCmpPos,MAXROW,nTab ); ScCellIterator aCmpIter( pDoc, aCmpRange ); ScBaseCell* pCmpCell = aCmpIter.GetFirst(); while (pCmpCell) { if (pCmpCell->GetCellType() != CELLTYPE_NOTE) { USHORT nCellPos = bColumnDiff ? aCmpIter.GetCol() : aCmpIter.GetRow(); if (bColumnDiff) aCellRange = ScRange( nCellPos,0,nTab, nCellPos,MAXROW,nTab ); else aCellRange = ScRange( 0,nCellPos,nTab, MAXCOL,nCellPos,nTab ); for (i=0; iGetCell( aCmpAddr ); ScRange aCellRange( aIter.GetCol(), aIter.GetRow(), aIter.GetTab() ); if ( !ScBaseCell::CellEqual( pCell, pCmpCell ) ) aMarkData.SetMultiMarkArea( aCellRange ); else aMarkData.SetMultiMarkArea( aCellRange, FALSE ); // aufheben pCell = aIter.GetNext(); } } ScRangeList aNewRanges; if (aMarkData.IsMultiMarked()) aMarkData.FillRangeListWithMarks( &aNewRanges, FALSE ); return new ScCellRangesObj( pDocShell, aNewRanges ); // aNewRanges kann leer sein } return NULL; } uno::Reference SAL_CALL ScCellRangesBase::queryColumnDifferences( const table::CellAddress& aCompare ) throw(uno::RuntimeException) { ScUnoGuard aGuard; return QueryDifferences_Impl( aCompare, TRUE ); } uno::Reference SAL_CALL ScCellRangesBase::queryRowDifferences( const table::CellAddress& aCompare ) throw(uno::RuntimeException) { ScUnoGuard aGuard; return QueryDifferences_Impl( aCompare, FALSE ); } uno::Reference SAL_CALL ScCellRangesBase::queryIntersection( const table::CellRangeAddress& aRange ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScRange aMask( (USHORT)aRange.StartColumn, (USHORT)aRange.StartRow, aRange.Sheet, (USHORT)aRange.EndColumn, (USHORT)aRange.EndRow, aRange.Sheet ); ScRangeList aNew; ULONG nCount = aRanges.Count(); for (ULONG i=0; i SAL_CALL ScCellRangesBase::queryPrecedents( sal_Bool bRecursive ) throw(uno::RuntimeException) { ScUnoGuard aGuard; if ( pDocShell ) { ScDocument* pDoc = pDocShell->GetDocument(); ScRangeList aNewRanges = aRanges; BOOL bFound; do { bFound = FALSE; ScMarkData aMarkData; aMarkData.MarkFromRangeList( aNewRanges, FALSE ); aMarkData.MarkToMulti(); // needed for IsAllMarked ULONG nCount = aNewRanges.Count(); for (USHORT nR=0; nRGetCellType() == CELLTYPE_FORMULA ) { ScFormulaCell* pFCell = (ScFormulaCell*) pCell; ScDetectiveRefIter aIter( pFCell ); ScTripel aRefStart; ScTripel aRefEnd; while ( aIter.GetNextRef( aRefStart, aRefEnd ) ) { ScRange aRefRange( aRefStart, aRefEnd ); if ( bRecursive && !bFound && !aMarkData.IsAllMarked( aRefRange ) ) bFound = TRUE; aMarkData.SetMultiMarkArea( aRefRange, TRUE ); } } pCell = aIter.GetNext(); } } aMarkData.FillRangeListWithMarks( &aNewRanges, TRUE ); } while ( bRecursive && bFound ); return new ScCellRangesObj( pDocShell, aNewRanges ); } return NULL; } uno::Reference SAL_CALL ScCellRangesBase::queryDependents( sal_Bool bRecursive ) throw(uno::RuntimeException) { ScUnoGuard aGuard; if ( pDocShell ) { ScDocument* pDoc = pDocShell->GetDocument(); ScRangeList aNewRanges = aRanges; BOOL bFound; do { bFound = FALSE; ULONG nRangesCount = aNewRanges.Count(); ScMarkData aMarkData; aMarkData.MarkFromRangeList( aNewRanges, FALSE ); aMarkData.MarkToMulti(); // needed for IsAllMarked USHORT nTab = lcl_FirstTab(aNewRanges); //! alle Tabellen ScCellIterator aCellIter( pDoc, 0,0, nTab, MAXCOL,MAXROW, nTab ); ScBaseCell* pCell = aCellIter.GetFirst(); while (pCell) { if (pCell->GetCellType() == CELLTYPE_FORMULA) { BOOL bMark = FALSE; ScDetectiveRefIter aIter( (ScFormulaCell*) pCell ); ScTripel aRefStart; ScTripel aRefEnd; while ( aIter.GetNextRef( aRefStart, aRefEnd ) ) { ScRange aRefRange( aRefStart, aRefEnd ); for (USHORT nR=0; nR SAL_CALL ScCellRangesBase::createSearchDescriptor() throw(uno::RuntimeException) { ScUnoGuard aGuard; return new ScCellSearchObj; } uno::Reference SAL_CALL ScCellRangesBase::findAll( const uno::Reference& xDesc ) throw(uno::RuntimeException) { // Wenn nichts gefunden wird, soll Null zurueckgegeben werden (?) uno::Reference xRet; if ( pDocShell && xDesc.is() ) { ScCellSearchObj* pSearch = ScCellSearchObj::getImplementation( xDesc ); if (pSearch) { SvxSearchItem* pSearchItem = pSearch->GetSearchItem(); if (pSearchItem) { ScDocument* pDoc = pDocShell->GetDocument(); pSearchItem->SetCommand( SVX_SEARCHCMD_FIND_ALL ); // immer nur innerhalb dieses Objekts pSearchItem->SetSelection( !lcl_WholeSheet(aRanges) ); ScMarkData aMark; aMark.MarkFromRangeList( aRanges, FALSE ); String aDummyUndo; USHORT nCol = 0, nRow = 0, nTab = 0; BOOL bFound = pDoc->SearchAndReplace( *pSearchItem, nCol, nRow, nTab, aMark, aDummyUndo, NULL ); if (bFound) { ScRangeList aNewRanges; aMark.FillRangeListWithMarks( &aNewRanges, TRUE ); // bei findAll immer CellRanges, egal wieviel gefunden wurde xRet = new ScCellRangesObj( pDocShell, aNewRanges ); } } } } return xRet; } uno::Reference ScCellRangesBase::Find_Impl( const uno::Reference& xDesc, const ScAddress* pLastPos ) { uno::Reference xRet; if ( pDocShell && xDesc.is() ) { ScCellSearchObj* pSearch = ScCellSearchObj::getImplementation( xDesc ); if (pSearch) { SvxSearchItem* pSearchItem = pSearch->GetSearchItem(); if (pSearchItem) { ScDocument* pDoc = pDocShell->GetDocument(); pSearchItem->SetCommand( SVX_SEARCHCMD_FIND ); // immer nur innerhalb dieses Objekts pSearchItem->SetSelection( !lcl_WholeSheet(aRanges) ); ScMarkData aMark; aMark.MarkFromRangeList( aRanges, FALSE ); USHORT nCol, nRow, nTab; if (pLastPos) pLastPos->GetVars( nCol, nRow, nTab ); else { nTab = lcl_FirstTab(aRanges); //! mehrere Tabellen? ScDocument::GetSearchAndReplaceStart( *pSearchItem, nCol, nRow ); } String aDummyUndo; BOOL bFound = pDoc->SearchAndReplace( *pSearchItem, nCol, nRow, nTab, aMark, aDummyUndo, NULL ); if (bFound) { ScAddress aFoundPos( nCol, nRow, nTab ); xRet = (cppu::OWeakObject*) new ScCellObj( pDocShell, aFoundPos ); } } } } return xRet; } uno::Reference SAL_CALL ScCellRangesBase::findFirst( const uno::Reference& xDesc ) throw(uno::RuntimeException) { ScUnoGuard aGuard; return Find_Impl( xDesc, NULL ); } uno::Reference SAL_CALL ScCellRangesBase::findNext( const uno::Reference& xStartAt, const uno::Reference& xDesc ) throw(uno::RuntimeException) { ScUnoGuard aGuard; if ( xStartAt.is() ) { ScCellRangesBase* pRangesImp = ScCellRangesBase::getImplementation( xStartAt ); if ( pRangesImp && pRangesImp->GetDocShell() == pDocShell ) { const ScRangeList& rStartRanges = pRangesImp->GetRangeList(); if ( rStartRanges.Count() == 1 ) { ScAddress aStartPos = rStartRanges.GetObject(0)->aStart; return Find_Impl( xDesc, &aStartPos ); } } } return NULL; } // XReplaceable uno::Reference SAL_CALL ScCellRangesBase::createReplaceDescriptor() throw(uno::RuntimeException) { ScUnoGuard aGuard; return new ScCellSearchObj; } sal_Int32 SAL_CALL ScCellRangesBase::replaceAll( const uno::Reference& xDesc ) throw(uno::RuntimeException) { ScUnoGuard aGuard; INT32 nReplaced = 0; if ( pDocShell && xDesc.is() ) { ScCellSearchObj* pSearch = ScCellSearchObj::getImplementation( xDesc ); if (pSearch) { SvxSearchItem* pSearchItem = pSearch->GetSearchItem(); if (pSearchItem) { ScDocument* pDoc = pDocShell->GetDocument(); BOOL bUndo(pDoc->IsUndoEnabled()); pSearchItem->SetCommand( SVX_SEARCHCMD_REPLACE_ALL ); // immer nur innerhalb dieses Objekts pSearchItem->SetSelection( !lcl_WholeSheet(aRanges) ); ScMarkData aMark; aMark.MarkFromRangeList( aRanges, FALSE ); USHORT i; USHORT nTabCount = pDoc->GetTableCount(); BOOL bProtected = !pDocShell->IsEditable(); for (i=0; iIsTabProtected(i) ) bProtected = TRUE; if (bProtected) { //! Exception, oder was? } else { USHORT nTab = aMark.GetFirstSelected(); // bei SearchAndReplace nicht benutzt USHORT nCol = 0, nRow = 0; String aUndoStr; ScDocument* pUndoDoc = NULL; if (bUndo) { pUndoDoc = new ScDocument( SCDOCMODE_UNDO ); pUndoDoc->InitUndo( pDoc, nTab, nTab ); } for (i=0; iAddUndoTab( i, i ); ScMarkData* pUndoMark = NULL; if (bUndo) pUndoMark = new ScMarkData(aMark); BOOL bFound(FALSE); if (bUndo) bFound = pDoc->SearchAndReplace( *pSearchItem, nCol, nRow, nTab, aMark, aUndoStr, pUndoDoc ); if (bFound) { nReplaced = pUndoDoc->GetCellCount(); pDocShell->GetUndoManager()->AddUndoAction( new ScUndoReplace( pDocShell, *pUndoMark, nCol, nRow, nTab, aUndoStr, pUndoDoc, pSearchItem ) ); pDocShell->PostPaintGridAll(); pDocShell->SetDocumentModified(); } else { delete pUndoDoc; delete pUndoMark; // nReplaced bleibt 0 } } } } } return nReplaced; } // XUnoTunnel sal_Int64 SAL_CALL ScCellRangesBase::getSomething( const uno::Sequence& rId ) throw(uno::RuntimeException) { if ( rId.getLength() == 16 && 0 == rtl_compareMemory( getUnoTunnelId().getConstArray(), rId.getConstArray(), 16 ) ) { return (sal_Int64)this; } return 0; } // static const uno::Sequence& ScCellRangesBase::getUnoTunnelId() { static uno::Sequence * pSeq = 0; if( !pSeq ) { osl::Guard< osl::Mutex > aGuard( osl::Mutex::getGlobalMutex() ); if( !pSeq ) { static uno::Sequence< sal_Int8 > aSeq( 16 ); rtl_createUuid( (sal_uInt8*)aSeq.getArray(), 0, sal_True ); pSeq = &aSeq; } } return *pSeq; } // static ScCellRangesBase* ScCellRangesBase::getImplementation( const uno::Reference xObj ) { ScCellRangesBase* pRet = NULL; uno::Reference xUT( xObj, uno::UNO_QUERY ); if (xUT.is()) pRet = (ScCellRangesBase*) xUT->getSomething( getUnoTunnelId() ); return pRet; } //------------------------------------------------------------------------ ScCellRangesObj::ScCellRangesObj(ScDocShell* pDocSh, const ScRangeList& rR) : ScCellRangesBase( pDocSh, rR ) { } ScCellRangesObj::~ScCellRangesObj() { List aNamedEntries; } void ScCellRangesObj::RefChanged() { ScCellRangesBase::RefChanged(); // nix weiter... } uno::Any SAL_CALL ScCellRangesObj::queryInterface( const uno::Type& rType ) throw(uno::RuntimeException) { SC_QUERYINTERFACE( sheet::XSheetCellRanges ) SC_QUERYINTERFACE( container::XIndexAccess ) SC_QUERY_MULTIPLE( container::XElementAccess, container::XIndexAccess ) SC_QUERYINTERFACE( container::XEnumerationAccess ) SC_QUERYINTERFACE( container::XNameContainer ) SC_QUERYINTERFACE( container::XNameReplace ) SC_QUERYINTERFACE( container::XNameAccess ) return ScCellRangesBase::queryInterface( rType ); } void SAL_CALL ScCellRangesObj::acquire() throw(uno::RuntimeException) { ScCellRangesBase::acquire(); } void SAL_CALL ScCellRangesObj::release() throw(uno::RuntimeException) { ScCellRangesBase::release(); } uno::Sequence SAL_CALL ScCellRangesObj::getTypes() throw(uno::RuntimeException) { static uno::Sequence aTypes; if ( aTypes.getLength() == 0 ) { uno::Sequence aParentTypes = ScCellRangesBase::getTypes(); long nParentLen = aParentTypes.getLength(); const uno::Type* pParentPtr = aParentTypes.getConstArray(); aTypes.realloc( nParentLen + 3 ); uno::Type* pPtr = aTypes.getArray(); pPtr[nParentLen + 0] = getCppuType((const uno::Reference*)0); pPtr[nParentLen + 1] = getCppuType((const uno::Reference*)0); pPtr[nParentLen + 2] = getCppuType((const uno::Reference*)0); for (long i=0; i SAL_CALL ScCellRangesObj::getImplementationId() throw(uno::RuntimeException) { static uno::Sequence< sal_Int8 > aId; if( aId.getLength() == 0 ) { aId.realloc( 16 ); rtl_createUuid( (sal_uInt8 *)aId.getArray(), 0, sal_True ); } return aId; } // XCellRanges ScCellRangeObj* ScCellRangesObj::GetObjectByIndex_Impl(USHORT nIndex) const { ScDocShell* pDocSh = GetDocShell(); const ScRangeList& rRanges = GetRangeList(); if ( pDocSh && nIndex < rRanges.Count() ) { ScRange aRange = *rRanges.GetObject(nIndex); if ( aRange.aStart == aRange.aEnd ) return new ScCellObj( pDocSh, aRange.aStart ); else return new ScCellRangeObj( pDocSh, aRange ); } return NULL; // keine DocShell oder falscher Index } uno::Sequence SAL_CALL ScCellRangesObj::getRangeAddresses() throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); const ScRangeList& rRanges = GetRangeList(); ULONG nCount = rRanges.Count(); if ( pDocSh && nCount ) { table::CellRangeAddress aRangeAddress; uno::Sequence aSeq(nCount); table::CellRangeAddress* pAry = aSeq.getArray(); for (USHORT i=0; i(0); // leer ist moeglich } uno::Reference SAL_CALL ScCellRangesObj::getCells() throw(uno::RuntimeException) { ScUnoGuard aGuard; // getCells with empty range list is possible (no exception), // the resulting enumeration just has no elements // (same behaviour as a valid range with no cells) // This is handled in ScCellsEnumeration ctor. const ScRangeList& rRanges = GetRangeList(); ScDocShell* pDocSh = GetDocShell(); if (pDocSh) return new ScCellsObj( pDocSh, rRanges ); return NULL; } rtl::OUString SAL_CALL ScCellRangesObj::getRangeAddressesAsString() throw(uno::RuntimeException) { ScUnoGuard aGuard; String aString; ScDocShell* pDocSh = GetDocShell(); const ScRangeList& rRanges = GetRangeList(); if (pDocSh) rRanges.Format( aString, SCA_VALID | SCA_TAB_3D, pDocSh->GetDocument() ); return aString; } // XNameContainer void lcl_RemoveNamedEntry( ScNamedEntryArr_Impl& rNamedEntries, const String& rName ) { USHORT nCount = rNamedEntries.Count(); for ( USHORT n=nCount; n--; ) if ( rNamedEntries[n]->GetName() == rName ) rNamedEntries.DeleteAndDestroy( n ); } void SAL_CALL ScCellRangesObj::insertByName( const rtl::OUString& aName, const uno::Any& aElement ) throw(lang::IllegalArgumentException, container::ElementExistException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); BOOL bDone = FALSE; //! Type of aElement can be some specific interface instead of XInterface uno::Reference xInterface; if ( pDocSh && ( aElement >>= xInterface ) ) { ScCellRangesBase* pRangesImp = ScCellRangesBase::getImplementation( xInterface ); if ( pRangesImp && pRangesImp->GetDocShell() == pDocSh ) { ScRangeList aNew = GetRangeList(); const ScRangeList& rAddRanges = pRangesImp->GetRangeList(); ULONG nAddCount = rAddRanges.Count(); for (ULONG i=0; iGetDocument(); ULONG nCount = rRanges.Count(); for (ULONG i=0; iFormat( aRangeStr, SCA_VALID | SCA_TAB_3D, pDoc ); if ( aRangeStr == rName ) { rIndex = i; return TRUE; } } } return FALSE; // nicht gefunden } BOOL lcl_FindRangeOrEntry( const ScNamedEntryArr_Impl& rNamedEntries, const ScRangeList& rRanges, ScDocShell* pDocSh, const String& rName, ScRange& rFound ) { // exact range in list? ULONG nIndex = 0; if ( lcl_FindRangeByName( rRanges, pDocSh, rName, nIndex ) ) { rFound = *rRanges.GetObject(nIndex); return TRUE; } // range contained in selection? (sheet must be specified) ScRange aCellRange; USHORT nParse = aCellRange.ParseAny( rName, pDocSh->GetDocument() ); if ( ( nParse & ( SCA_VALID | SCA_TAB_3D ) ) == ( SCA_VALID | SCA_TAB_3D ) ) { ScMarkData aMarkData; aMarkData.MarkFromRangeList( rRanges, FALSE ); aMarkData.MarkToMulti(); // needed for IsAllMarked if ( aMarkData.IsAllMarked( aCellRange ) ) { rFound = aCellRange; return TRUE; } } // named entry in this object? if ( rNamedEntries.Count() ) { for ( USHORT n=0; nGetName() == rName ) { // test if named entry is contained in rRanges const ScRange& rComp = rNamedEntries[n]->GetRange(); ScMarkData aMarkData; aMarkData.MarkFromRangeList( rRanges, FALSE ); aMarkData.MarkToMulti(); // needed for IsAllMarked if ( aMarkData.IsAllMarked( rComp ) ) { rFound = rComp; return TRUE; } } } return FALSE; // not found } void SAL_CALL ScCellRangesObj::removeByName( const rtl::OUString& aName ) throw(container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; BOOL bDone = FALSE; String aNameStr = aName; ScDocShell* pDocSh = GetDocShell(); const ScRangeList& rRanges = GetRangeList(); ULONG nIndex = 0; if ( lcl_FindRangeByName( rRanges, pDocSh, aNameStr, nIndex ) ) { // einzelnen Range weglassen ScRangeList aNew; ULONG nCount = rRanges.Count(); for (ULONG i=0; iGetDocument() ) & SCA_VALID ) != 0; if ( !bValid && aNamedEntries.Count() ) { USHORT nCount = aNamedEntries.Count(); for (USHORT n=0; nGetName() == aNameStr) { aDiff.RemoveAll(); aDiff.Append( aNamedEntries[n]->GetRange() ); bValid = TRUE; } } if ( bValid ) { ScMarkData aMarkData; aMarkData.MarkFromRangeList( rRanges, FALSE ); ULONG nDiffCount = aDiff.Count(); for (ULONG i=0; iaStart.Tab() )) aMarkData.SetMultiMarkArea( *pDiffRange, FALSE ); } ScRangeList aNew; aMarkData.FillRangeListWithMarks( &aNew, FALSE ); SetNewRanges(aNew); bDone = TRUE; //! error if range was not selected before? } } if (aNamedEntries.Count()) lcl_RemoveNamedEntry( aNamedEntries, aNameStr ); // remove named entry if (!bDone) throw container::NoSuchElementException(); // not found } // XNameReplace void SAL_CALL ScCellRangesObj::replaceByName( const rtl::OUString& aName, const uno::Any& aElement ) throw(lang::IllegalArgumentException, container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; //! zusammenfassen? removeByName( aName ); insertByName( aName, aElement ); } // XNameAccess uno::Any SAL_CALL ScCellRangesObj::getByName( const rtl::OUString& aName ) throw(container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; uno::Any aRet; String aNameStr = aName; ScDocShell* pDocSh = GetDocShell(); const ScRangeList& rRanges = GetRangeList(); ScRange aRange; if ( lcl_FindRangeOrEntry( aNamedEntries, rRanges, pDocSh, aNameStr, aRange ) ) { uno::Reference xRange; if ( aRange.aStart == aRange.aEnd ) xRange = new ScCellObj( pDocSh, aRange.aStart ); else xRange = new ScCellRangeObj( pDocSh, aRange ); aRet <<= xRange; } else throw container::NoSuchElementException(); return aRet; } BOOL lcl_FindEntryName( const ScNamedEntryArr_Impl& rNamedEntries, const ScRange& rRange, String& rName ) { USHORT nCount = rNamedEntries.Count(); for (USHORT i=0; iGetRange() == rRange) { rName = rNamedEntries[i]->GetName(); return TRUE; } return FALSE; } uno::Sequence SAL_CALL ScCellRangesObj::getElementNames() throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); const ScRangeList& rRanges = GetRangeList(); if (pDocSh) { String aRangeStr; ScDocument* pDoc = pDocSh->GetDocument(); ULONG nCount = rRanges.Count(); uno::Sequence aSeq(nCount); rtl::OUString* pAry = aSeq.getArray(); for (ULONG i=0; i(0); } sal_Bool SAL_CALL ScCellRangesObj::hasByName( const rtl::OUString& aName ) throw(uno::RuntimeException) { ScUnoGuard aGuard; String aNameStr = aName; ScDocShell* pDocSh = GetDocShell(); const ScRangeList& rRanges = GetRangeList(); ScRange aRange; return lcl_FindRangeOrEntry( aNamedEntries, rRanges, pDocSh, aNameStr, aRange ); } // XEnumerationAccess uno::Reference SAL_CALL ScCellRangesObj::createEnumeration() throw(uno::RuntimeException) { ScUnoGuard aGuard; return new ScIndexEnumeration(this); } // XIndexAccess sal_Int32 SAL_CALL ScCellRangesObj::getCount() throw(uno::RuntimeException) { ScUnoGuard aGuard; const ScRangeList& rRanges = GetRangeList(); return rRanges.Count(); } uno::Any SAL_CALL ScCellRangesObj::getByIndex( sal_Int32 nIndex ) throw(lang::IndexOutOfBoundsException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; uno::Reference xRange = GetObjectByIndex_Impl((USHORT)nIndex); uno::Any aAny; if (xRange.is()) aAny <<= xRange; else throw lang::IndexOutOfBoundsException(); return aAny; } uno::Type SAL_CALL ScCellRangesObj::getElementType() throw(uno::RuntimeException) { ScUnoGuard aGuard; return getCppuType((uno::Reference*)0); } sal_Bool SAL_CALL ScCellRangesObj::hasElements() throw(uno::RuntimeException) { ScUnoGuard aGuard; const ScRangeList& rRanges = GetRangeList(); return rRanges.Count() != 0; } // XServiceInfo rtl::OUString SAL_CALL ScCellRangesObj::getImplementationName() throw(uno::RuntimeException) { return rtl::OUString::createFromAscii( "ScCellRangesObj" ); } sal_Bool SAL_CALL ScCellRangesObj::supportsService( const rtl::OUString& rServiceName ) throw(uno::RuntimeException) { String aServiceStr(rServiceName); return aServiceStr.EqualsAscii( SCSHEETCELLRANGES_SERVICE ) || aServiceStr.EqualsAscii( SCCELLPROPERTIES_SERVICE ) || aServiceStr.EqualsAscii( SCCHARPROPERTIES_SERVICE ); } uno::Sequence SAL_CALL ScCellRangesObj::getSupportedServiceNames() throw(uno::RuntimeException) { uno::Sequence aRet(3); rtl::OUString* pArray = aRet.getArray(); pArray[0] = rtl::OUString::createFromAscii( SCSHEETCELLRANGES_SERVICE ); pArray[1] = rtl::OUString::createFromAscii( SCCELLPROPERTIES_SERVICE ); pArray[2] = rtl::OUString::createFromAscii( SCCHARPROPERTIES_SERVICE ); return aRet; } //------------------------------------------------------------------------ // static uno::Reference ScCellRangeObj::CreateRangeFromDoc( ScDocument* pDoc, const ScRange& rR ) { SfxObjectShell* pObjSh = pDoc->GetDocumentShell(); if ( pObjSh && pObjSh->ISA(ScDocShell) ) return new ScCellRangeObj( (ScDocShell*) pObjSh, rR ); return NULL; } //------------------------------------------------------------------------ ScCellRangeObj::ScCellRangeObj(ScDocShell* pDocSh, const ScRange& rR) : ScCellRangesBase( pDocSh, rR ), aRangePropSet( lcl_GetRangePropertyMap() ), aRange( rR ) { aRange.Justify(); // Anfang / Ende richtig } ScCellRangeObj::~ScCellRangeObj() { } void ScCellRangeObj::RefChanged() { ScCellRangesBase::RefChanged(); const ScRangeList& rRanges = GetRangeList(); DBG_ASSERT(rRanges.Count() == 1, "was fuer Ranges ?!?!"); const ScRange* pFirst = rRanges.GetObject(0); if (pFirst) { aRange = *pFirst; aRange.Justify(); } } uno::Any SAL_CALL ScCellRangeObj::queryInterface( const uno::Type& rType ) throw(uno::RuntimeException) { SC_QUERYINTERFACE( sheet::XCellRangeAddressable ) SC_QUERYINTERFACE( table::XCellRange ) SC_QUERYINTERFACE( sheet::XSheetCellRange ) SC_QUERYINTERFACE( sheet::XArrayFormulaRange ) SC_QUERYINTERFACE( sheet::XCellRangeData ) SC_QUERYINTERFACE( sheet::XMultipleOperation ) SC_QUERYINTERFACE( util::XMergeable ) SC_QUERYINTERFACE( sheet::XCellSeries ) SC_QUERYINTERFACE( table::XAutoFormattable ) SC_QUERYINTERFACE( util::XSortable ) SC_QUERYINTERFACE( sheet::XSheetFilterableEx ) SC_QUERYINTERFACE( sheet::XSheetFilterable ) SC_QUERYINTERFACE( sheet::XSubTotalCalculatable ) SC_QUERYINTERFACE( table::XColumnRowRange ) SC_QUERYINTERFACE( util::XImportable ) SC_QUERYINTERFACE( sheet::XCellFormatRangesSupplier ) return ScCellRangesBase::queryInterface( rType ); } void SAL_CALL ScCellRangeObj::acquire() throw(uno::RuntimeException) { ScCellRangesBase::acquire(); } void SAL_CALL ScCellRangeObj::release() throw(uno::RuntimeException) { ScCellRangesBase::release(); } uno::Sequence SAL_CALL ScCellRangeObj::getTypes() throw(uno::RuntimeException) { static uno::Sequence aTypes; if ( aTypes.getLength() == 0 ) { uno::Sequence aParentTypes = ScCellRangesBase::getTypes(); long nParentLen = aParentTypes.getLength(); const uno::Type* pParentPtr = aParentTypes.getConstArray(); aTypes.realloc( nParentLen + 14 ); uno::Type* pPtr = aTypes.getArray(); pPtr[nParentLen + 0] = getCppuType((const uno::Reference*)0); pPtr[nParentLen + 1] = getCppuType((const uno::Reference*)0); pPtr[nParentLen + 2] = getCppuType((const uno::Reference*)0); pPtr[nParentLen + 3] = getCppuType((const uno::Reference*)0); pPtr[nParentLen + 4] = getCppuType((const uno::Reference*)0); pPtr[nParentLen + 5] = getCppuType((const uno::Reference*)0); pPtr[nParentLen + 6] = getCppuType((const uno::Reference*)0); pPtr[nParentLen + 7] = getCppuType((const uno::Reference*)0); pPtr[nParentLen + 8] = getCppuType((const uno::Reference*)0); pPtr[nParentLen + 9] = getCppuType((const uno::Reference*)0); pPtr[nParentLen +10] = getCppuType((const uno::Reference*)0); pPtr[nParentLen +11] = getCppuType((const uno::Reference*)0); pPtr[nParentLen +12] = getCppuType((const uno::Reference*)0); pPtr[nParentLen +13] = getCppuType((const uno::Reference*)0); for (long i=0; i SAL_CALL ScCellRangeObj::getImplementationId() throw(uno::RuntimeException) { static uno::Sequence< sal_Int8 > aId; if( aId.getLength() == 0 ) { aId.realloc( 16 ); rtl_createUuid( (sal_uInt8 *)aId.getArray(), 0, sal_True ); } return aId; } // XCellRange // ColumnCount / RowCount sind weggefallen //! werden im Writer fuer Tabellen noch gebraucht ??? uno::Reference SAL_CALL ScCellRangeObj::getCellByPosition( sal_Int32 nColumn, sal_Int32 nRow ) throw(uno::RuntimeException) { ScUnoGuard aGuard; if ( nColumn >= 0 && nRow >= 0 ) { ScDocShell* pDocSh = GetDocShell(); sal_Int32 nPosX = aRange.aStart.Col() + nColumn; sal_Int32 nPosY = aRange.aStart.Row() + nRow; if ( pDocSh && nPosX <= aRange.aEnd.Col() && nPosY <= aRange.aEnd.Row() ) { ScAddress aNew( (USHORT)nPosX, (USHORT)nPosY, aRange.aStart.Tab() ); return new ScCellObj( pDocSh, aNew ); } } throw uno::RuntimeException(); return NULL; } uno::Reference SAL_CALL ScCellRangeObj::getCellRangeByPosition( sal_Int32 nLeft, sal_Int32 nTop, sal_Int32 nRight, sal_Int32 nBottom ) throw(uno::RuntimeException) { ScUnoGuard aGuard; if ( nLeft >= 0 && nTop >= 0 && nRight >= 0 && nBottom >= 0 ) { ScDocShell* pDocSh = GetDocShell(); sal_Int32 nStartX = aRange.aStart.Col() + nLeft; sal_Int32 nStartY = aRange.aStart.Row() + nTop; sal_Int32 nEndX = aRange.aStart.Col() + nRight; sal_Int32 nEndY = aRange.aStart.Row() + nBottom; if ( pDocSh && nStartX <= nEndX && nEndX <= aRange.aEnd.Col() && nStartY <= nEndY && nEndY <= aRange.aEnd.Row() ) { ScRange aNew( (USHORT)nStartX, (USHORT)nStartY, aRange.aStart.Tab(), (USHORT)nEndX, (USHORT)nEndY, aRange.aEnd.Tab() ); return new ScCellRangeObj( pDocSh, aNew ); } } throw uno::RuntimeException(); return NULL; } uno::Reference SAL_CALL ScCellRangeObj::getCellRangeByName( const rtl::OUString& aName ) throw(uno::RuntimeException) { // name refers to the whole document (with the range's table as default), // valid only if the range is within this range ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { ScDocument* pDoc = pDocSh->GetDocument(); USHORT nTab = aRange.aStart.Tab(); ScRange aCellRange; BOOL bFound = FALSE; String aString = aName; USHORT nParse = aCellRange.ParseAny( aString, pDoc ); if ( nParse & SCA_VALID ) { if ( !(nParse & SCA_TAB_3D) ) // keine Tabelle angegeben -> auf dieser Tabelle { aCellRange.aStart.SetTab(nTab); aCellRange.aEnd.SetTab(nTab); } bFound = TRUE; } else { ScRangeUtil aRangeUtil; if ( aRangeUtil.MakeRangeFromName( aString, pDoc, nTab, aCellRange, RUTL_NAMES ) || aRangeUtil.MakeRangeFromName( aString, pDoc, nTab, aCellRange, RUTL_DBASE ) ) bFound = TRUE; } if (bFound) // valid only if within this object's range { if (!aRange.In(aCellRange)) bFound = FALSE; } if (bFound) { if ( aCellRange.aStart == aCellRange.aEnd ) return new ScCellObj( pDocSh, aCellRange.aStart ); else return new ScCellRangeObj( pDocSh, aCellRange ); } } throw uno::RuntimeException(); return NULL; } // XColumnRowRange uno::Reference SAL_CALL ScCellRangeObj::getColumns() throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if (pDocSh) return new ScTableColumnsObj( pDocSh, aRange.aStart.Tab(), aRange.aStart.Col(), aRange.aEnd.Col() ); DBG_ERROR("Dokument ungueltig"); return NULL; } uno::Reference SAL_CALL ScCellRangeObj::getRows() throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if (pDocSh) return new ScTableRowsObj( pDocSh, aRange.aStart.Tab(), aRange.aStart.Row(), aRange.aEnd.Row() ); DBG_ERROR("Dokument ungueltig"); return NULL; } // XAddressableCellRange table::CellRangeAddress SAL_CALL ScCellRangeObj::getRangeAddress() throw(uno::RuntimeException) { ScUnoGuard aGuard; table::CellRangeAddress aRet; ScUnoConversion::FillApiRange( aRet, aRange ); return aRet; } // XSheetCellRange uno::Reference SAL_CALL ScCellRangeObj::getSpreadsheet() throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if (pDocSh) return new ScTableSheetObj( pDocSh, aRange.aStart.Tab() ); DBG_ERROR("Dokument ungueltig"); return NULL; } // XArrayFormulaRange rtl::OUString SAL_CALL ScCellRangeObj::getArrayFormula() throw(uno::RuntimeException) { ScUnoGuard aGuard; // Matrix-Formel, wenn eindeutig Teil einer Matrix, // also wenn Anfang und Ende des Blocks zur selben Matrix gehoeren. // Sonst Leerstring. String aFormula; ScDocShell* pDocSh = GetDocShell(); if (pDocSh) { ScDocument* pDoc = pDocSh->GetDocument(); const ScBaseCell* pCell1 = pDoc->GetCell( aRange.aStart ); const ScBaseCell* pCell2 = pDoc->GetCell( aRange.aEnd ); if ( pCell1 && pCell2 && pCell1->GetCellType() == CELLTYPE_FORMULA && pCell2->GetCellType() == CELLTYPE_FORMULA ) { const ScFormulaCell* pFCell1 = (const ScFormulaCell*)pCell1; const ScFormulaCell* pFCell2 = (const ScFormulaCell*)pCell2; ScAddress aStart1; ScAddress aStart2; if ( pFCell1->GetMatrixOrigin( aStart1 ) && pFCell2->GetMatrixOrigin( aStart2 ) ) { if ( aStart1 == aStart2 ) // beides dieselbe Matrix pFCell1->GetFormula( aFormula ); // egal, von welcher Zelle } } } return aFormula; } void SAL_CALL ScCellRangeObj::setArrayFormula( const rtl::OUString& aFormula ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if (pDocSh) { String aString = aFormula; ScDocFunc aFunc(*pDocSh); if ( aString.Len() ) { if ( ScTableSheetObj::getImplementation( (cppu::OWeakObject*)this ) ) { // #74681# don't set array formula for sheet object throw uno::RuntimeException(); } aFunc.EnterMatrix( aRange, NULL, aString, TRUE ); } else { // empty string -> erase array formula ScMarkData aMark; aMark.SetMarkArea( aRange ); aMark.SelectTable( aRange.aStart.Tab(), TRUE ); aFunc.DeleteContents( aMark, IDF_CONTENTS, TRUE, TRUE ); } } } // XCellRangeData uno::Sequence< uno::Sequence > SAL_CALL ScCellRangeObj::getDataArray() throw(uno::RuntimeException) { ScUnoGuard aGuard; if ( ScTableSheetObj::getImplementation( (cppu::OWeakObject*)this ) ) { // don't create a data array for the sheet throw uno::RuntimeException(); } ScDocShell* pDocSh = GetDocShell(); if (pDocSh) { uno::Any aAny; // bAllowNV = TRUE: errors as void if ( ScRangeToSequence::FillMixedArray( aAny, pDocSh->GetDocument(), aRange, TRUE ) ) { uno::Sequence< uno::Sequence > aSeq; if ( aAny >>= aSeq ) return aSeq; // success } } throw uno::RuntimeException(); // no other exceptions specified return uno::Sequence< uno::Sequence >(0); } void SAL_CALL ScCellRangeObj::setDataArray( const uno::Sequence< uno::Sequence >& aArray ) throw(uno::RuntimeException) { ScUnoGuard aGuard; BOOL bDone = FALSE; ScDocShell* pDocSh = GetDocShell(); if (pDocSh) { //! move lcl_PutDataArray to docfunc? bDone = lcl_PutDataArray( *pDocSh, aRange, aArray ); } if (!bDone) throw uno::RuntimeException(); // no other exceptions specified } // XMultipleOperation void SAL_CALL ScCellRangeObj::setTableOperation( const table::CellRangeAddress& aFormulaRange, sheet::TableOperationMode nMode, const table::CellAddress& aColumnCell, const table::CellAddress& aRowCell ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if (pDocSh) { BOOL bError = FALSE; ScTabOpParam aParam; aParam.aRefFormulaCell = ScRefTripel( (USHORT)aFormulaRange.StartColumn, (USHORT)aFormulaRange.StartRow, aFormulaRange.Sheet, FALSE, FALSE, FALSE ); aParam.aRefFormulaEnd = ScRefTripel( (USHORT)aFormulaRange.EndColumn, (USHORT)aFormulaRange.EndRow, aFormulaRange.Sheet, FALSE, FALSE, FALSE ); aParam.aRefRowCell = ScRefTripel( (USHORT)aRowCell.Column, (USHORT)aRowCell.Row, aRowCell.Sheet, FALSE, FALSE, FALSE ); aParam.aRefColCell = ScRefTripel( (USHORT)aColumnCell.Column, (USHORT)aColumnCell.Row, aColumnCell.Sheet, FALSE, FALSE, FALSE ); switch (nMode) { case sheet::TableOperationMode_COLUMN: aParam.nMode = 0; break; case sheet::TableOperationMode_ROW: aParam.nMode = 1; break; case sheet::TableOperationMode_BOTH: aParam.nMode = 2; break; default: bError = TRUE; } if (!bError) { ScDocFunc aFunc(*pDocSh); aFunc.TabOp( aRange, NULL, aParam, TRUE, TRUE ); } } } // XMergeable void SAL_CALL ScCellRangeObj::merge( sal_Bool bMerge ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { ScDocFunc aFunc(*pDocSh); if ( bMerge ) aFunc.MergeCells( aRange, FALSE, TRUE, TRUE ); else aFunc.UnmergeCells( aRange, TRUE, TRUE ); //! Fehler abfangen? } } sal_Bool SAL_CALL ScCellRangeObj::getIsMerged() throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); return pDocSh && pDocSh->GetDocument()->HasAttrib( aRange, HASATTR_MERGED ); } // XCellSeries void SAL_CALL ScCellRangeObj::fillSeries( sheet::FillDirection nFillDirection, sheet::FillMode nFillMode, sheet::FillDateMode nFillDateMode, double fStep, double fEndValue ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { BOOL bError = FALSE; FillDir eDir; switch (nFillDirection) { case sheet::FillDirection_TO_BOTTOM: eDir = FILL_TO_BOTTOM; break; case sheet::FillDirection_TO_RIGHT: eDir = FILL_TO_RIGHT; break; case sheet::FillDirection_TO_TOP: eDir = FILL_TO_TOP; break; case sheet::FillDirection_TO_LEFT: eDir = FILL_TO_LEFT; break; default: bError = TRUE; } FillCmd eCmd; switch ( nFillMode ) { case sheet::FillMode_SIMPLE: eCmd = FILL_SIMPLE; break; case sheet::FillMode_LINEAR: eCmd = FILL_LINEAR; break; case sheet::FillMode_GROWTH: eCmd = FILL_GROWTH; break; case sheet::FillMode_DATE: eCmd = FILL_DATE; break; case sheet::FillMode_AUTO: eCmd = FILL_AUTO; break; default: bError = TRUE; } FillDateCmd eDateCmd; switch ( nFillDateMode ) { case sheet::FillDateMode_FILL_DATE_DAY: eDateCmd = FILL_DAY; break; case sheet::FillDateMode_FILL_DATE_WEEKDAY: eDateCmd = FILL_WEEKDAY; break; case sheet::FillDateMode_FILL_DATE_MONTH: eDateCmd = FILL_MONTH; break; case sheet::FillDateMode_FILL_DATE_YEAR: eDateCmd = FILL_YEAR; break; default: bError = TRUE; } if (!bError) { ScDocFunc aFunc(*pDocSh); aFunc.FillSeries( aRange, NULL, eDir, eCmd, eDateCmd, MAXDOUBLE, fStep, fEndValue, TRUE, TRUE ); } } } void SAL_CALL ScCellRangeObj::fillAuto( sheet::FillDirection nFillDirection, sal_Int32 nSourceCount ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh && nSourceCount ) { ScRange aSourceRange = aRange; USHORT nCount; // "Dest-Count" FillDir eDir; BOOL bError = FALSE; switch (nFillDirection) { case sheet::FillDirection_TO_BOTTOM: aSourceRange.aEnd.SetRow( aSourceRange.aStart.Row() + nSourceCount - 1 ); nCount = aRange.aEnd.Row() - aSourceRange.aEnd.Row(); eDir = FILL_TO_BOTTOM; break; case sheet::FillDirection_TO_RIGHT: aSourceRange.aEnd.SetCol( aSourceRange.aStart.Col() + nSourceCount - 1 ); nCount = aRange.aEnd.Col() - aSourceRange.aEnd.Col(); eDir = FILL_TO_RIGHT; break; case sheet::FillDirection_TO_TOP: aSourceRange.aStart.SetRow( aSourceRange.aEnd.Row() - nSourceCount + 1 ); nCount = aSourceRange.aStart.Row() - aRange.aStart.Row(); eDir = FILL_TO_TOP; break; case sheet::FillDirection_TO_LEFT: aSourceRange.aStart.SetCol( aSourceRange.aEnd.Col() - nSourceCount + 1 ); nCount = aSourceRange.aStart.Col() - aRange.aStart.Col(); eDir = FILL_TO_LEFT; break; default: bError = TRUE; } if (nCount > MAXROW) // Ueberlauf bError = TRUE; if (!bError) { ScDocFunc aFunc(*pDocSh); aFunc.FillAuto( aSourceRange, NULL, eDir, nCount, TRUE, TRUE ); } } } // XAutoFormattable void SAL_CALL ScCellRangeObj::autoFormat( const rtl::OUString& aName ) throw(lang::IllegalArgumentException, uno::RuntimeException) { ScUnoGuard aGuard; ScAutoFormat* pAutoFormat = ScGlobal::GetAutoFormat(); ScDocShell* pDocSh = GetDocShell(); if ( pDocSh && pAutoFormat ) { String aNameString = aName; USHORT nCount = pAutoFormat->GetCount(); USHORT nIndex; String aCompare; for (nIndex=0; nIndexGetName(aCompare); if ( aCompare == aNameString ) //! Case-insensitiv ??? break; } if (nIndex SAL_CALL ScCellRangeObj::createSortDescriptor() throw(uno::RuntimeException) { ScUnoGuard aGuard; ScSortParam aParam; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { // DB-Bereich anlegen erst beim Ausfuehren, per API immer genau den Bereich ScDBData* pData = pDocSh->GetDBData( aRange, SC_DB_OLD, TRUE ); if (pData) { pData->GetSortParam(aParam); // im SortDescriptor sind die Fields innerhalb des Bereichs gezaehlt ScRange aDBRange; pData->GetArea(aDBRange); USHORT nFieldStart = aParam.bByRow ? aDBRange.aStart.Col() : aDBRange.aStart.Row(); for (USHORT i=0; i= nFieldStart ) aParam.nField[i] -= nFieldStart; } } uno::Sequence aSeq( ScSortDescriptor::GetPropertyCount() ); ScSortDescriptor::FillProperties( aSeq, aParam ); return aSeq; } void SAL_CALL ScCellRangeObj::sort( const uno::Sequence& aDescriptor ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if (pDocSh) { USHORT i; ScSortParam aParam; ScDBData* pData = pDocSh->GetDBData( aRange, SC_DB_MAKE, TRUE ); // ggf. Bereich anlegen if (pData) { // alten Einstellungen holen, falls nicht alles neu gesetzt wird pData->GetSortParam(aParam); USHORT nOldStart = aParam.bByRow ? aRange.aStart.Col() : aRange.aStart.Row(); for (i=0; i= nOldStart ) aParam.nField[i] -= nOldStart; } ScSortDescriptor::FillSortParam( aParam, aDescriptor ); // im SortDescriptor sind die Fields innerhalb des Bereichs gezaehlt // ByRow kann bei FillSortParam umgesetzt worden sein USHORT nFieldStart = aParam.bByRow ? aRange.aStart.Col() : aRange.aStart.Row(); for (i=0; iGetDBData( aRange, SC_DB_MAKE, TRUE ); // ggf. Bereich anlegen ScDBDocFunc aFunc(*pDocSh); // Bereich muss angelegt sein aFunc.Sort( nTab, aParam, TRUE, TRUE, TRUE ); } } // XFilterable uno::Reference SAL_CALL ScCellRangeObj::createFilterDescriptor( sal_Bool bEmpty ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScFilterDescriptor* pNew = new ScFilterDescriptor; ScDocShell* pDocSh = GetDocShell(); if ( !bEmpty && pDocSh ) { // DB-Bereich anlegen erst beim Ausfuehren, per API immer genau den Bereich ScDBData* pData = pDocSh->GetDBData( aRange, SC_DB_OLD, TRUE ); if (pData) { ScQueryParam aParam; pData->GetQueryParam(aParam); // im FilterDescriptor sind die Fields innerhalb des Bereichs gezaehlt ScRange aDBRange; pData->GetArea(aDBRange); USHORT nFieldStart = aParam.bByRow ? aDBRange.aStart.Col() : aDBRange.aStart.Row(); USHORT nCount = aParam.GetEntryCount(); for (USHORT i=0; i= nFieldStart) rEntry.nField -= nFieldStart; } pNew->SetParam(aParam); } } return pNew; } void SAL_CALL ScCellRangeObj::filter( const uno::Reference& xDescriptor ) throw(uno::RuntimeException) { ScUnoGuard aGuard; // das koennte theoretisch ein fremdes Objekt sein, also nur das // oeffentliche XSheetFilterDescriptor Interface benutzen, um // die Daten in ein ScFilterDescriptor Objekt zu kopieren: //! wenn es schon ein ScFilterDescriptor ist, direkt per getImplementation? ScFilterDescriptor aImpl; aImpl.setFilterFields( xDescriptor->getFilterFields() ); // Rest sind jetzt Properties... uno::Reference xPropSet( xDescriptor, uno::UNO_QUERY ); if (xPropSet.is()) lcl_CopyProperties( aImpl, *(beans::XPropertySet*)xPropSet.get() ); // // ausfuehren... // ScDocShell* pDocSh = GetDocShell(); if (pDocSh) { ScQueryParam aParam = aImpl.GetParam(); // im FilterDescriptor sind die Fields innerhalb des Bereichs gezaehlt USHORT nFieldStart = aParam.bByRow ? aRange.aStart.Col() : aRange.aStart.Row(); USHORT nCount = aParam.GetEntryCount(); for (USHORT i=0; i muss zum Wert passen if ( !rEntry.bQueryByString ) pDocSh->GetDocument()->GetFormatTable()-> GetInputLineString( rEntry.nVal, 0, *rEntry.pStr ); } } USHORT nTab = aRange.aStart.Tab(); aParam.nCol1 = aRange.aStart.Col(); aParam.nRow1 = aRange.aStart.Row(); aParam.nCol2 = aRange.aEnd.Col(); aParam.nRow2 = aRange.aEnd.Row(); pDocSh->GetDBData( aRange, SC_DB_MAKE, TRUE ); // ggf. Bereich anlegen //! keep source range in filter descriptor //! if created by createFilterDescriptorByObject ??? ScDBDocFunc aFunc(*pDocSh); aFunc.Query( nTab, aParam, NULL, TRUE, TRUE ); // Bereich muss angelegt sein } } //! get/setAutoFilter als Properties!!! // XAdvancedFilterSource uno::Reference SAL_CALL ScCellRangeObj::createFilterDescriptorByObject( const uno::Reference& xObject ) throw(uno::RuntimeException) { ScUnoGuard aGuard; // this ist hier nicht der Bereich, der gefiltert wird, sondern der // Bereich mit der Abfrage... uno::Reference xAddr( xObject, uno::UNO_QUERY ); ScDocShell* pDocSh = GetDocShell(); if ( pDocSh && xAddr.is() ) { //! Test, ob xObject im selben Dokument ist ScFilterDescriptor* pNew = new ScFilterDescriptor; //! stattdessen vom Objekt? //XSheetFilterDescriptorRef xNew = xObject->createFilterDescriptor(TRUE); ScQueryParam aParam = pNew->GetParam(); aParam.bHasHeader = TRUE; table::CellRangeAddress aDataAddress = xAddr->getRangeAddress(); aParam.nCol1 = (USHORT)aDataAddress.StartColumn; aParam.nRow1 = (USHORT)aDataAddress.StartRow; aParam.nCol2 = (USHORT)aDataAddress.EndColumn; aParam.nRow2 = (USHORT)aDataAddress.EndRow; aParam.nTab = aDataAddress.Sheet; ScDocument* pDoc = pDocSh->GetDocument(); BOOL bOk = pDoc->CreateQueryParam( aRange.aStart.Col(), aRange.aStart.Row(), aRange.aEnd.Col(), aRange.aEnd.Row(), aRange.aStart.Tab(), aParam ); if ( bOk ) { // im FilterDescriptor sind die Fields innerhalb des Bereichs gezaehlt USHORT nFieldStart = aParam.bByRow ? (USHORT)aDataAddress.StartColumn : (USHORT)aDataAddress.StartRow; USHORT nCount = aParam.GetEntryCount(); for (USHORT i=0; i= nFieldStart) rEntry.nField -= nFieldStart; } pNew->SetParam( aParam ); return pNew; } else { delete pNew; return NULL; // ungueltig -> null } } DBG_ERROR("kein Dokument oder kein Bereich"); return NULL; } // XSubTotalSource uno::Reference SAL_CALL ScCellRangeObj::createSubTotalDescriptor( sal_Bool bEmpty ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScSubTotalDescriptor* pNew = new ScSubTotalDescriptor; ScDocShell* pDocSh = GetDocShell(); if ( !bEmpty && pDocSh ) { // DB-Bereich anlegen erst beim Ausfuehren, per API immer genau den Bereich ScDBData* pData = pDocSh->GetDBData( aRange, SC_DB_OLD, TRUE ); if (pData) { ScSubTotalParam aParam; pData->GetSubTotalParam(aParam); // im SubTotalDescriptor sind die Fields innerhalb des Bereichs gezaehlt ScRange aDBRange; pData->GetArea(aDBRange); USHORT nFieldStart = aDBRange.aStart.Col(); for (USHORT i=0; i= nFieldStart ) aParam.nField[i] -= nFieldStart; for (USHORT j=0; j= nFieldStart ) aParam.pSubTotals[i][j] -= nFieldStart; } } pNew->SetParam(aParam); } } return pNew; } void SAL_CALL ScCellRangeObj::applySubTotals( const uno::Reference& xDescriptor, sal_Bool bReplace ) throw(uno::RuntimeException) { ScUnoGuard aGuard; if (!xDescriptor.is()) return; ScDocShell* pDocSh = GetDocShell(); ScSubTotalDescriptorBase* pImp = ScSubTotalDescriptorBase::getImplementation( xDescriptor ); if (pDocSh && pImp) { ScSubTotalParam aParam; pImp->GetData(aParam); // virtuelle Methode der Basisklasse // im SubTotalDescriptor sind die Fields innerhalb des Bereichs gezaehlt USHORT nFieldStart = aRange.aStart.Col(); for (USHORT i=0; iGetDBData( aRange, SC_DB_MAKE, TRUE ); // ggf. Bereich anlegen ScDBDocFunc aFunc(*pDocSh); aFunc.DoSubTotals( nTab, aParam, NULL, TRUE, TRUE ); // Bereich muss angelegt sein } } void SAL_CALL ScCellRangeObj::removeSubTotals() throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if (pDocSh) { ScSubTotalParam aParam; ScDBData* pData = pDocSh->GetDBData( aRange, SC_DB_OLD, TRUE ); if (pData) pData->GetSubTotalParam(aParam); // auch bei Remove die Feld-Eintraege behalten aParam.bRemoveOnly = TRUE; USHORT nTab = aRange.aStart.Tab(); aParam.nCol1 = aRange.aStart.Col(); aParam.nRow1 = aRange.aStart.Row(); aParam.nCol2 = aRange.aEnd.Col(); aParam.nRow2 = aRange.aEnd.Row(); pDocSh->GetDBData( aRange, SC_DB_MAKE, TRUE ); // ggf. Bereich anlegen ScDBDocFunc aFunc(*pDocSh); aFunc.DoSubTotals( nTab, aParam, NULL, TRUE, TRUE ); // Bereich muss angelegt sein } } uno::Sequence SAL_CALL ScCellRangeObj::createImportDescriptor( sal_Bool bEmpty ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScImportParam aParam; ScDocShell* pDocSh = GetDocShell(); if ( !bEmpty && pDocSh ) { // DB-Bereich anlegen erst beim Ausfuehren, per API immer genau den Bereich ScDBData* pData = pDocSh->GetDBData( aRange, SC_DB_OLD, TRUE ); if (pData) pData->GetImportParam(aParam); } uno::Sequence aSeq( ScImportDescriptor::GetPropertyCount() ); ScImportDescriptor::FillProperties( aSeq, aParam ); return aSeq; } void SAL_CALL ScCellRangeObj::doImport( const uno::Sequence& aDescriptor ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if (pDocSh) { ScImportParam aParam; ScImportDescriptor::FillImportParam( aParam, aDescriptor ); USHORT nTab = aRange.aStart.Tab(); aParam.nCol1 = aRange.aStart.Col(); aParam.nRow1 = aRange.aStart.Row(); aParam.nCol2 = aRange.aEnd.Col(); aParam.nRow2 = aRange.aEnd.Row(); pDocSh->GetDBData( aRange, SC_DB_MAKE, TRUE ); // ggf. Bereich anlegen ScDBDocFunc aFunc(*pDocSh); // Bereich muss angelegt sein aFunc.DoImport( nTab, aParam, NULL, TRUE, FALSE ); //! Api-Flag als Parameter } } // XCellFormatsSupplier uno::Reference SAL_CALL ScCellRangeObj::getCellFormatRanges() throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) return new ScCellFormatsObj( pDocSh, aRange ); return NULL; } // XPropertySet erweitert fuer Range-Properties uno::Reference SAL_CALL ScCellRangeObj::getPropertySetInfo() throw(uno::RuntimeException) { ScUnoGuard aGuard; static uno::Reference aRef = new SfxItemPropertySetInfo( aRangePropSet.getPropertyMap() ); return aRef; } void SAL_CALL ScCellRangeObj::setPropertyValue( const rtl::OUString& aPropertyName, const uno::Any& aValue ) throw(beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; // Range hat nur Position und Size zusaetzlich zu ScCellRangesBase, beide sind ReadOnly // -> hier muss nichts passieren ScCellRangesBase::setPropertyValue(aPropertyName, aValue); } uno::Any SAL_CALL ScCellRangeObj::getPropertyValue( const rtl::OUString& aPropertyName ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; String aNameString = aPropertyName; // eigene Properties uno::Any aAny; if ( aNameString.EqualsAscii( SC_UNONAME_POS ) ) { ScDocShell* pDocSh = GetDocShell(); if (pDocSh) { // GetMMRect rechnet per HMM_PER_TWIPS, also passend zum DrawingLayer Rectangle aMMRect = pDocSh->GetDocument()->GetMMRect( aRange.aStart.Col(), aRange.aStart.Row(), aRange.aEnd.Col(), aRange.aEnd.Row(), aRange.aStart.Tab() ); awt::Point aPos( aMMRect.Left(), aMMRect.Top() ); aAny <<= aPos; } } else if ( aNameString.EqualsAscii( SC_UNONAME_SIZE ) ) { ScDocShell* pDocSh = GetDocShell(); if (pDocSh) { // GetMMRect rechnet per HMM_PER_TWIPS, also passend zum DrawingLayer Rectangle aMMRect = pDocSh->GetDocument()->GetMMRect( aRange.aStart.Col(), aRange.aStart.Row(), aRange.aEnd.Col(), aRange.aEnd.Row(), aRange.aStart.Tab() ); Size aSize = aMMRect.GetSize(); awt::Size aAwtSize( aSize.Width(), aSize.Height() ); aAny <<= aAwtSize; } } else aAny = ScCellRangesBase::getPropertyValue(aPropertyName); // geerbte mit oder ohne WID return aAny; } // XServiceInfo rtl::OUString SAL_CALL ScCellRangeObj::getImplementationName() throw(uno::RuntimeException) { return rtl::OUString::createFromAscii( "ScCellRangeObj" ); } sal_Bool SAL_CALL ScCellRangeObj::supportsService( const rtl::OUString& rServiceName ) throw(uno::RuntimeException) { String aServiceStr( rServiceName ); return aServiceStr.EqualsAscii( SCSHEETCELLRANGE_SERVICE ) || aServiceStr.EqualsAscii( SCCELLRANGE_SERVICE ) || aServiceStr.EqualsAscii( SCCELLPROPERTIES_SERVICE ) || aServiceStr.EqualsAscii( SCCHARPROPERTIES_SERVICE ); } uno::Sequence SAL_CALL ScCellRangeObj::getSupportedServiceNames() throw(uno::RuntimeException) { uno::Sequence aRet(4); rtl::OUString* pArray = aRet.getArray(); pArray[0] = rtl::OUString::createFromAscii( SCSHEETCELLRANGE_SERVICE ); pArray[1] = rtl::OUString::createFromAscii( SCCELLRANGE_SERVICE ); pArray[2] = rtl::OUString::createFromAscii( SCCELLPROPERTIES_SERVICE ); pArray[3] = rtl::OUString::createFromAscii( SCCHARPROPERTIES_SERVICE ); return aRet; } //------------------------------------------------------------------------ const SfxItemPropertyMap* ScCellObj::GetEditPropertyMap() // static { return lcl_GetEditPropertyMap(); } ScCellObj::ScCellObj(ScDocShell* pDocSh, const ScAddress& rP) : ScCellRangeObj( pDocSh, ScRange(rP,rP) ), aCellPropSet( lcl_GetCellPropertyMap() ), aCellPos( rP ), pUnoText( NULL ) { // pUnoText is allocated on demand (GetUnoText) // can't be aggregated because getString/setString is handled here } SvxUnoText& ScCellObj::GetUnoText() { if (!pUnoText) { ScCellEditSource aEditSource( GetDocShell(), aCellPos ); pUnoText = new SvxUnoText( &aEditSource, lcl_GetEditPropertyMap(), uno::Reference() ); pUnoText->acquire(); } return *pUnoText; } ScCellObj::~ScCellObj() { if (pUnoText) pUnoText->release(); } void ScCellObj::RefChanged() { ScCellRangeObj::RefChanged(); const ScRangeList& rRanges = GetRangeList(); DBG_ASSERT(rRanges.Count() == 1, "was fuer Ranges ?!?!"); const ScRange* pFirst = rRanges.GetObject(0); if (pFirst) aCellPos = pFirst->aStart; } uno::Any SAL_CALL ScCellObj::queryInterface( const uno::Type& rType ) throw(uno::RuntimeException) { SC_QUERYINTERFACE( table::XCell ) SC_QUERYINTERFACE( sheet::XCellAddressable ) SC_QUERYINTERFACE( text::XText ) SC_QUERYINTERFACE( text::XSimpleText ) SC_QUERYINTERFACE( text::XTextRange ) SC_QUERYINTERFACE( container::XEnumerationAccess ) SC_QUERYINTERFACE( container::XElementAccess ) SC_QUERYINTERFACE( sheet::XSheetAnnotationAnchor ) SC_QUERYINTERFACE( text::XTextFieldsSupplier ) return ScCellRangeObj::queryInterface( rType ); } void SAL_CALL ScCellObj::acquire() throw(uno::RuntimeException) { ScCellRangeObj::acquire(); } void SAL_CALL ScCellObj::release() throw(uno::RuntimeException) { ScCellRangeObj::release(); } uno::Sequence SAL_CALL ScCellObj::getTypes() throw(uno::RuntimeException) { static uno::Sequence aTypes; if ( aTypes.getLength() == 0 ) { uno::Sequence aParentTypes = ScCellRangeObj::getTypes(); long nParentLen = aParentTypes.getLength(); const uno::Type* pParentPtr = aParentTypes.getConstArray(); aTypes.realloc( nParentLen + 6 ); uno::Type* pPtr = aTypes.getArray(); pPtr[nParentLen + 0] = getCppuType((const uno::Reference*)0); pPtr[nParentLen + 1] = getCppuType((const uno::Reference*)0); pPtr[nParentLen + 2] = getCppuType((const uno::Reference*)0); pPtr[nParentLen + 3] = getCppuType((const uno::Reference*)0); pPtr[nParentLen + 4] = getCppuType((const uno::Reference*)0); pPtr[nParentLen + 5] = getCppuType((const uno::Reference*)0); for (long i=0; i SAL_CALL ScCellObj::getImplementationId() throw(uno::RuntimeException) { static uno::Sequence< sal_Int8 > aId; if( aId.getLength() == 0 ) { aId.realloc( 16 ); rtl_createUuid( (sal_uInt8 *)aId.getArray(), 0, sal_True ); } return aId; } // Hilfsfunktionen String ScCellObj::GetInputString_Impl(BOOL bEnglish) const // fuer getFormula / FormulaLocal { ScDocShell* pDocSh = GetDocShell(); String aVal; if ( pDocSh ) { ScDocument* pDoc = pDocSh->GetDocument(); ScBaseCell* pCell = pDoc->GetCell( aCellPos ); if ( pCell && pCell->GetCellType() != CELLTYPE_NOTE ) { CellType eType = pCell->GetCellType(); if ( eType == CELLTYPE_FORMULA ) { ScFormulaCell* pForm = (ScFormulaCell*)pCell; if (bEnglish) pForm->GetEnglishFormula( aVal ); else pForm->GetFormula( aVal ); } else { SvNumberFormatter* pFormatter = pDoc->GetFormatTable(); ULONG nNumFmt = bEnglish ? pFormatter->GetStandardIndex(LANGUAGE_ENGLISH_US) : pDoc->GetNumberFormat( aCellPos ); if ( eType == CELLTYPE_EDIT ) { // GetString an der EditCell macht Leerzeichen aus Umbruechen, // hier werden die Umbrueche aber gebraucht const EditTextObject* pData = ((ScEditCell*)pCell)->GetData(); if (pData) { EditEngine& rEngine = pDoc->GetEditEngine(); rEngine.SetText( *pData ); aVal = rEngine.GetText( LINEEND_LF ); } } else ScCellFormat::GetInputString( pCell, nNumFmt, aVal, *pFormatter ); // ggf. ein ' davorhaengen wie in ScTabViewShell::UpdateInputHandler if ( eType == CELLTYPE_STRING || eType == CELLTYPE_EDIT ) { double fDummy; if ( pFormatter->IsNumberFormat(aVal, nNumFmt, fDummy) ) aVal.Insert('\'',0); } } } } return aVal; } String ScCellObj::GetOutputString_Impl() const { ScDocShell* pDocSh = GetDocShell(); String aVal; if ( pDocSh ) { ScDocument* pDoc = pDocSh->GetDocument(); ScBaseCell* pCell = pDoc->GetCell( aCellPos ); if ( pCell && pCell->GetCellType() != CELLTYPE_NOTE ) { if ( pCell->GetCellType() == CELLTYPE_EDIT ) { // GetString an der EditCell macht Leerzeichen aus Umbruechen, // hier werden die Umbrueche aber gebraucht const EditTextObject* pData = ((ScEditCell*)pCell)->GetData(); if (pData) { EditEngine& rEngine = pDoc->GetEditEngine(); rEngine.SetText( *pData ); aVal = rEngine.GetText( LINEEND_LF ); } // Edit-Zellen auch nicht per NumberFormatter formatieren // (passend zur Ausgabe) } else { // wie in GetString am Dokument (column) Color* pColor; ULONG nNumFmt = pDoc->GetNumberFormat( aCellPos ); ScCellFormat::GetString( pCell, nNumFmt, aVal, &pColor, *pDoc->GetFormatTable() ); } } } return aVal; } void ScCellObj::SetString_Impl(const String& rString, BOOL bInterpret, BOOL bEnglish) { ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { ScDocFunc aFunc(*pDocSh); BOOL bOk = aFunc.SetCellText( aCellPos, rString, bInterpret, bEnglish, TRUE ); } } double ScCellObj::GetValue_Impl() const { ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) return pDocSh->GetDocument()->GetValue( aCellPos ); return 0.0; } void ScCellObj::SetValue_Impl(double fValue) { ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { ScDocFunc aFunc(*pDocSh); BOOL bOk = aFunc.PutCell( aCellPos, new ScValueCell(fValue), TRUE ); } } // only for XML import void ScCellObj::SetFormulaResultString( const ::rtl::OUString& rResult ) { ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { ScBaseCell* pCell = pDocSh->GetDocument()->GetCell( aCellPos ); if ( pCell && pCell->GetCellType() == CELLTYPE_FORMULA ) ((ScFormulaCell*)pCell)->SetString( rResult ); } } void ScCellObj::SetFormulaResultDouble( double fResult ) { ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { ScBaseCell* pCell = pDocSh->GetDocument()->GetCell( aCellPos ); if ( pCell && pCell->GetCellType() == CELLTYPE_FORMULA ) ((ScFormulaCell*)pCell)->SetDouble( fResult ); } } // XText uno::Reference SAL_CALL ScCellObj::createTextCursor() throw(uno::RuntimeException) { ScUnoGuard aGuard; return new ScCellTextCursor( *this ); } uno::Reference SAL_CALL ScCellObj::createTextCursorByRange( const uno::Reference& aTextPosition ) throw(uno::RuntimeException) { ScUnoGuard aGuard; SvxUnoTextCursor* pCursor = new ScCellTextCursor( *this ); uno::Reference xCursor = pCursor; SvxUnoTextRangeBase* pRange = SvxUnoTextRangeBase::getImplementation( aTextPosition ); if(pRange) pCursor->SetSelection( pRange->GetSelection() ); else { ScCellTextCursor* pOther = ScCellTextCursor::getImplementation( aTextPosition ); if(pOther) pCursor->SetSelection( pOther->GetSelection() ); else throw uno::RuntimeException(); } return xCursor; } rtl::OUString SAL_CALL ScCellObj::getString() throw(uno::RuntimeException) { ScUnoGuard aGuard; return GetOutputString_Impl(); } void SAL_CALL ScCellObj::setString( const rtl::OUString& aText ) throw(uno::RuntimeException) { ScUnoGuard aGuard; String aString = aText; SetString_Impl(aString, FALSE, FALSE); // immer Text // don't create pUnoText here if not there if (pUnoText) pUnoText->SetSelection(ESelection( 0,0, 0,aString.Len() )); } void SAL_CALL ScCellObj::insertString( const uno::Reference& xRange, const rtl::OUString& aString, sal_Bool bAbsorb ) throw(uno::RuntimeException) { ScUnoGuard aGuard; // der SvxUnoText kennt den ScCellTextCursor nicht, darum muss der Fall hier abgefangen werden if ( xRange.is() ) { ScCellTextCursor* pCursor = ScCellTextCursor::getImplementation( xRange ); if ( pCursor ) { // setString am Cursor statt selber QuickInsertText und UpdateData, // damit die Selektion am Cursor angepasst wird. //! Eigentlich muessten alle Cursor-Objekte dieses Textes angepasst werden! if (!bAbsorb) // nicht ersetzen -> hinten anhaengen pCursor->CollapseToEnd(); pCursor->setString( aString ); return; } } GetUnoText().insertString(xRange, aString, bAbsorb); } void SAL_CALL ScCellObj::insertControlCharacter( const uno::Reference& xRange, sal_Int16 nControlCharacter, sal_Bool bAbsorb ) throw(lang::IllegalArgumentException, uno::RuntimeException) { ScUnoGuard aGuard; GetUnoText().insertControlCharacter(xRange, nControlCharacter, bAbsorb); } void SAL_CALL ScCellObj::insertTextContent( const uno::Reference& xRange, const uno::Reference& xContent, sal_Bool bAbsorb ) throw(lang::IllegalArgumentException, uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh && xContent.is() ) { ScCellFieldObj* pCellField = ScCellFieldObj::getImplementation( xContent ); SvxUnoTextRangeBase* pTextRange = ScCellTextCursor::getImplementation( xRange ); #if 0 if (!pTextRange) pTextRange = SvxUnoTextRangeBase::getImplementation( xRange ); //! bei SvxUnoTextRange testen, ob in passendem Objekt !!! #endif if ( pCellField && !pCellField->IsInserted() && pTextRange ) { SvxEditSource* pEditSource = pTextRange->GetEditSource(); ESelection aSelection = pTextRange->GetSelection(); if (!bAbsorb) { // nicht ersetzen -> hinten anhaengen aSelection.Adjust(); aSelection.nStartPara = aSelection.nEndPara; aSelection.nStartPos = aSelection.nEndPos; } SvxFieldItem aItem = pCellField->CreateFieldItem(); SvxTextForwarder* pForwarder = pEditSource->GetTextForwarder(); pForwarder->QuickInsertField( aItem, aSelection ); pEditSource->UpdateData(); // neue Selektion: ein Zeichen aSelection.Adjust(); aSelection.nEndPara = aSelection.nStartPara; aSelection.nEndPos = aSelection.nStartPos + 1; pCellField->InitDoc( pDocSh, aCellPos, aSelection ); pTextRange->SetSelection( aSelection ); return; } } GetUnoText().insertTextContent(xRange, xContent, bAbsorb); } void SAL_CALL ScCellObj::removeTextContent( const uno::Reference& xContent ) throw(container::NoSuchElementException, uno::RuntimeException) { ScUnoGuard aGuard; if ( xContent.is() ) { ScCellFieldObj* pCellField = ScCellFieldObj::getImplementation( xContent ); if ( pCellField && pCellField->IsInserted() ) { //! Testen, ob das Feld in dieser Zelle ist pCellField->DeleteField(); return; } } GetUnoText().removeTextContent(xContent); } uno::Reference SAL_CALL ScCellObj::getText() throw(uno::RuntimeException) { ScUnoGuard aGuard; return GetUnoText().getText(); } uno::Reference SAL_CALL ScCellObj::getStart() throw(uno::RuntimeException) { ScUnoGuard aGuard; return GetUnoText().getStart(); } uno::Reference SAL_CALL ScCellObj::getEnd() throw(uno::RuntimeException) { ScUnoGuard aGuard; return GetUnoText().getEnd(); } uno::Reference SAL_CALL ScCellObj::createEnumeration() throw(uno::RuntimeException) { ScUnoGuard aGuard; return GetUnoText().createEnumeration(); } uno::Type SAL_CALL ScCellObj::getElementType() throw(uno::RuntimeException) { ScUnoGuard aGuard; return GetUnoText().getElementType(); } sal_Bool SAL_CALL ScCellObj::hasElements() throw(uno::RuntimeException) { ScUnoGuard aGuard; return GetUnoText().hasElements(); } // XCell rtl::OUString SAL_CALL ScCellObj::getFormula() throw(uno::RuntimeException) { ScUnoGuard aGuard; // TRUE = englisch return GetInputString_Impl(TRUE); } void SAL_CALL ScCellObj::setFormula( const rtl::OUString& aFormula ) throw(uno::RuntimeException) { ScUnoGuard aGuard; String aString = aFormula; SetString_Impl(aString, TRUE, TRUE); // englisch interpretieren } double SAL_CALL ScCellObj::getValue() throw(uno::RuntimeException) { ScUnoGuard aGuard; return GetValue_Impl(); } void SAL_CALL ScCellObj::setValue( double nValue ) throw(uno::RuntimeException) { ScUnoGuard aGuard; SetValue_Impl(nValue); } table::CellContentType SAL_CALL ScCellObj::getType() throw(uno::RuntimeException) { ScUnoGuard aGuard; table::CellContentType eRet = table::CellContentType_EMPTY; ScDocShell* pDocSh = GetDocShell(); if (pDocSh) { CellType eCalcType = pDocSh->GetDocument()->GetCellType( aCellPos ); switch (eCalcType) { case CELLTYPE_VALUE: eRet = table::CellContentType_VALUE; break; case CELLTYPE_STRING: case CELLTYPE_EDIT: eRet = table::CellContentType_TEXT; break; case CELLTYPE_FORMULA: eRet = table::CellContentType_FORMULA; break; default: eRet = table::CellContentType_EMPTY; } } else DBG_ERROR("keine DocShell"); //! Exception oder so? return eRet; } table::CellContentType ScCellObj::GetResultType_Impl() { ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { ScBaseCell* pCell = pDocSh->GetDocument()->GetCell(aCellPos); if ( pCell && pCell->GetCellType() == CELLTYPE_FORMULA ) { BOOL bValue = ((ScFormulaCell*)pCell)->IsValue(); return bValue ? table::CellContentType_VALUE : table::CellContentType_TEXT; } } return getType(); // wenn keine Formel } sal_Int32 SAL_CALL ScCellObj::getError() throw(uno::RuntimeException) { ScUnoGuard aGuard; USHORT nError = 0; ScDocShell* pDocSh = GetDocShell(); if (pDocSh) { ScBaseCell* pCell = pDocSh->GetDocument()->GetCell( aCellPos ); if ( pCell && pCell->GetCellType() == CELLTYPE_FORMULA ) nError = ((ScFormulaCell*)pCell)->GetErrCode(); // sonst bleibt's bei 0 } else DBG_ERROR("keine DocShell"); //! Exception oder so? return nError; } // XCellAddressable table::CellAddress SAL_CALL ScCellObj::getCellAddress() throw(uno::RuntimeException) { ScUnoGuard aGuard; table::CellAddress aAdr; aAdr.Sheet = aCellPos.Tab(); aAdr.Column = aCellPos.Col(); aAdr.Row = aCellPos.Row(); return aAdr; } // XSheetAnnotationAnchor uno::Reference SAL_CALL ScCellObj::getAnnotation() throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) return new ScAnnotationObj( pDocSh, aCellPos ); DBG_ERROR("getAnnotation ohne DocShell"); return NULL; } // XFieldTypesSupplier uno::Reference SAL_CALL ScCellObj::getTextFields() throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) return new ScCellFieldsObj( pDocSh, aCellPos ); return NULL; } uno::Reference SAL_CALL ScCellObj::getTextFieldMasters() throw(uno::RuntimeException) { // sowas gibts nicht im Calc (?) return NULL; } // XPropertySet erweitert fuer Zell-Properties uno::Reference SAL_CALL ScCellObj::getPropertySetInfo() throw(uno::RuntimeException) { ScUnoGuard aGuard; static uno::Reference aRef = new SfxItemPropertySetInfo( aCellPropSet.getPropertyMap() ); return aRef; } void SAL_CALL ScCellObj::setPropertyValue( const rtl::OUString& aPropertyName, const uno::Any& aValue ) throw(beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; String aNameString = aPropertyName; // Abkuerzung, um Attributs-Properties relativ schnell zu setzen const SfxItemPropertyMap* pMap = SfxItemPropertyMap::GetByName( lcl_GetCellsPropertyMap(), aNameString ); if ( pMap && pMap->nWID ) { ScCellRangesBase::setPropertyValue(aPropertyName, aValue); return; } // eigene Properties if ( aNameString.EqualsAscii( SC_UNONAME_FORMLOC ) ) { rtl::OUString aStrVal; aValue >>= aStrVal; String aString = aStrVal; SetString_Impl(aString, TRUE, FALSE); // lokal interpretieren } else if ( aNameString.EqualsAscii( SC_UNONAME_FORMRT ) ) { // Read-Only //! Exception oder so... } else ScCellRangeObj::setPropertyValue(aPropertyName, aValue); // geerbte ohne WID } uno::Any SAL_CALL ScCellObj::getPropertyValue( const rtl::OUString& aPropertyName ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; String aNameString = aPropertyName; // Abkuerzung, um Attributs-Properties relativ schnell zu bekommen const SfxItemPropertyMap* pMap = SfxItemPropertyMap::GetByName( lcl_GetCellsPropertyMap(), aNameString ); if ( pMap && pMap->nWID ) return ScCellRangesBase::getPropertyValue(aPropertyName); // eigene Properties uno::Any aAny; if ( aNameString.EqualsAscii( SC_UNONAME_FORMLOC ) ) { // FALSE = lokal String aFormStr = GetInputString_Impl(FALSE); aAny <<= rtl::OUString( aFormStr ); } else if ( aNameString.EqualsAscii( SC_UNONAME_FORMRT ) ) { table::CellContentType eType = GetResultType_Impl(); aAny <<= eType; } else aAny = ScCellRangeObj::getPropertyValue(aPropertyName); // geerbte ohne WID return aAny; } // XServiceInfo rtl::OUString SAL_CALL ScCellObj::getImplementationName() throw(uno::RuntimeException) { return rtl::OUString::createFromAscii( "ScCellObj" ); } sal_Bool SAL_CALL ScCellObj::supportsService( const rtl::OUString& rServiceName ) throw(uno::RuntimeException) { // CellRange/SheetCellRange are not in SheetCell service description, // but ScCellObj is used instead of ScCellRangeObj in CellRanges collections, // so it must support them String aServiceStr(rServiceName); return aServiceStr.EqualsAscii( SCSHEETCELL_SERVICE ) || aServiceStr.EqualsAscii( SCCELL_SERVICE ) || aServiceStr.EqualsAscii( SCCELLPROPERTIES_SERVICE ) || aServiceStr.EqualsAscii( SCCHARPROPERTIES_SERVICE ) || aServiceStr.EqualsAscii( SCSHEETCELLRANGE_SERVICE ) || aServiceStr.EqualsAscii( SCCELLRANGE_SERVICE ); } uno::Sequence SAL_CALL ScCellObj::getSupportedServiceNames() throw(uno::RuntimeException) { uno::Sequence aRet(6); rtl::OUString* pArray = aRet.getArray(); pArray[0] = rtl::OUString::createFromAscii( SCSHEETCELL_SERVICE ); pArray[1] = rtl::OUString::createFromAscii( SCCELL_SERVICE ); pArray[2] = rtl::OUString::createFromAscii( SCCELLPROPERTIES_SERVICE ); pArray[3] = rtl::OUString::createFromAscii( SCCHARPROPERTIES_SERVICE ); pArray[4] = rtl::OUString::createFromAscii( SCSHEETCELLRANGE_SERVICE ); pArray[5] = rtl::OUString::createFromAscii( SCCELLRANGE_SERVICE ); return aRet; } //------------------------------------------------------------------------ ScTableSheetObj::ScTableSheetObj( ScDocShell* pDocSh, USHORT nTab ) : ScCellRangeObj( pDocSh, ScRange(0,0,nTab, MAXCOL,MAXROW,nTab) ), aSheetPropSet(lcl_GetSheetPropertyMap()) { } ScTableSheetObj::~ScTableSheetObj() { } void ScTableSheetObj::InitInsertSheet(ScDocShell* pDocSh, USHORT nTab) { InitInsertRange( pDocSh, ScRange(0,0,nTab, MAXCOL,MAXROW,nTab) ); } uno::Any SAL_CALL ScTableSheetObj::queryInterface( const uno::Type& rType ) throw(uno::RuntimeException) { SC_QUERYINTERFACE( sheet::XSpreadsheet ) SC_QUERYINTERFACE( container::XNamed ) SC_QUERYINTERFACE( sheet::XSheetPageBreak ) SC_QUERYINTERFACE( sheet::XCellRangeMovement ) SC_QUERYINTERFACE( table::XTableChartsSupplier ) SC_QUERYINTERFACE( sheet::XDataPilotTablesSupplier ) SC_QUERYINTERFACE( sheet::XScenariosSupplier ) SC_QUERYINTERFACE( sheet::XSheetAnnotationsSupplier ) SC_QUERYINTERFACE( drawing::XDrawPageSupplier ) SC_QUERYINTERFACE( sheet::XPrintAreas ) SC_QUERYINTERFACE( sheet::XSheetAuditing ) SC_QUERYINTERFACE( sheet::XSheetOutline ) SC_QUERYINTERFACE( util::XProtectable ) SC_QUERYINTERFACE( sheet::XScenario ) SC_QUERYINTERFACE( sheet::XSheetLinkable ) return ScCellRangeObj::queryInterface( rType ); } void SAL_CALL ScTableSheetObj::acquire() throw(uno::RuntimeException) { ScCellRangeObj::acquire(); } void SAL_CALL ScTableSheetObj::release() throw(uno::RuntimeException) { ScCellRangeObj::release(); } uno::Sequence SAL_CALL ScTableSheetObj::getTypes() throw(uno::RuntimeException) { static uno::Sequence aTypes; if ( aTypes.getLength() == 0 ) { uno::Sequence aParentTypes = ScCellRangeObj::getTypes(); long nParentLen = aParentTypes.getLength(); const uno::Type* pParentPtr = aParentTypes.getConstArray(); aTypes.realloc( nParentLen + 15 ); uno::Type* pPtr = aTypes.getArray(); pPtr[nParentLen + 0] = getCppuType((const uno::Reference*)0); pPtr[nParentLen + 1] = getCppuType((const uno::Reference*)0); pPtr[nParentLen + 2] = getCppuType((const uno::Reference*)0); pPtr[nParentLen + 3] = getCppuType((const uno::Reference*)0); pPtr[nParentLen + 4] = getCppuType((const uno::Reference*)0); pPtr[nParentLen + 5] = getCppuType((const uno::Reference*)0); pPtr[nParentLen + 6] = getCppuType((const uno::Reference*)0); pPtr[nParentLen + 7] = getCppuType((const uno::Reference*)0); pPtr[nParentLen + 8] = getCppuType((const uno::Reference*)0); pPtr[nParentLen + 9] = getCppuType((const uno::Reference*)0); pPtr[nParentLen +10] = getCppuType((const uno::Reference*)0); pPtr[nParentLen +11] = getCppuType((const uno::Reference*)0); pPtr[nParentLen +12] = getCppuType((const uno::Reference*)0); pPtr[nParentLen +13] = getCppuType((const uno::Reference*)0); pPtr[nParentLen +14] = getCppuType((const uno::Reference*)0); for (long i=0; i SAL_CALL ScTableSheetObj::getImplementationId() throw(uno::RuntimeException) { static uno::Sequence< sal_Int8 > aId; if( aId.getLength() == 0 ) { aId.realloc( 16 ); rtl_createUuid( (sal_uInt8 *)aId.getArray(), 0, sal_True ); } return aId; } // Hilfsfunktionen USHORT ScTableSheetObj::GetTab_Impl() const { const ScRangeList& rRanges = GetRangeList(); DBG_ASSERT(rRanges.Count() == 1, "was fuer Ranges ?!?!"); const ScRange* pFirst = rRanges.GetObject(0); if (pFirst) return pFirst->aStart.Tab(); return 0; // soll nicht sein } // former XSheet uno::Reference SAL_CALL ScTableSheetObj::getCharts() throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) return new ScChartsObj( pDocSh, GetTab_Impl() ); DBG_ERROR("kein Dokument"); return NULL; } uno::Reference SAL_CALL ScTableSheetObj::getDataPilotTables() throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) return new ScDataPilotTablesObj( pDocSh, GetTab_Impl() ); DBG_ERROR("kein Dokument"); return NULL; } uno::Reference SAL_CALL ScTableSheetObj::getScenarios() throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) return new ScScenariosObj( pDocSh, GetTab_Impl() ); DBG_ERROR("kein Dokument"); return NULL; } uno::Reference SAL_CALL ScTableSheetObj::getAnnotations() throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) return new ScAnnotationsObj( pDocSh, GetTab_Impl() ); DBG_ERROR("kein Dokument"); return NULL; } uno::Reference SAL_CALL ScTableSheetObj::getCellRangeByName( const rtl::OUString& aRange ) throw(uno::RuntimeException) { ScUnoGuard aGuard; return ScCellRangeObj::getCellRangeByName( aRange ); } uno::Reference SAL_CALL ScTableSheetObj::createCursor() throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { //! einzelne Zelle oder ganze Tabelle??????? USHORT nTab = GetTab_Impl(); return new ScCellCursorObj( pDocSh, ScRange( 0,0,nTab, MAXCOL,MAXROW,nTab ) ); } return NULL; } uno::Reference SAL_CALL ScTableSheetObj::createCursorByRange( const uno::Reference& aRange ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh && aRange.is() ) { ScCellRangesBase* pRangesImp = ScCellRangesBase::getImplementation( aRange ); if (pRangesImp) { const ScRangeList& rRanges = pRangesImp->GetRangeList(); DBG_ASSERT( rRanges.Count() == 1, "Range? Ranges?" ); return new ScCellCursorObj( pDocSh, *rRanges.GetObject(0) ); } } return NULL; } // XSheetCellRange uno::Reference SAL_CALL ScTableSheetObj::getSpreadsheet() throw(uno::RuntimeException) { ScUnoGuard aGuard; return this; //!??? } // XCellRange uno::Reference SAL_CALL ScTableSheetObj::getCellByPosition( sal_Int32 nColumn, sal_Int32 nRow ) throw(uno::RuntimeException) { ScUnoGuard aGuard; return ScCellRangeObj::getCellByPosition(nColumn, nRow); } uno::Reference SAL_CALL ScTableSheetObj::getCellRangeByPosition( sal_Int32 nLeft, sal_Int32 nTop, sal_Int32 nRight, sal_Int32 nBottom ) throw(uno::RuntimeException) { ScUnoGuard aGuard; return ScCellRangeObj::getCellRangeByPosition(nLeft,nTop,nRight,nBottom); } uno::Sequence SAL_CALL ScTableSheetObj::getColumnPageBreaks() throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { ScDocument* pDoc = pDocSh->GetDocument(); USHORT nTab = GetTab_Impl(); Size aSize = pDoc->GetPageSize( nTab ); if (aSize.Width() && aSize.Height()) // effektive Groesse schon gesetzt? pDoc->UpdatePageBreaks( nTab ); else { // Umbrueche updaten wie in ScDocShell::PageStyleModified: ScPrintFunc aPrintFunc( pDocSh, pDocSh->GetPrinter(), nTab ); aPrintFunc.UpdatePages(); } USHORT nCount = 0; USHORT nCol; for (nCol=0; nCol<=MAXCOL; nCol++) if (pDoc->GetColFlags( nCol, nTab ) & ( CR_PAGEBREAK | CR_MANUALBREAK )) ++nCount; sheet::TablePageBreakData aData; uno::Sequence aSeq(nCount); sheet::TablePageBreakData* pAry = aSeq.getArray(); USHORT nPos = 0; for (nCol=0; nCol<=MAXCOL; nCol++) { BYTE nFlags = pDoc->GetColFlags( nCol, nTab ); if (nFlags & ( CR_PAGEBREAK | CR_MANUALBREAK )) { aData.Position = nCol; aData.ManualBreak = ( nFlags & CR_MANUALBREAK ) != 0; pAry[nPos] = aData; ++nPos; } } return aSeq; } return uno::Sequence(0); } uno::Sequence SAL_CALL ScTableSheetObj::getRowPageBreaks() throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { ScDocument* pDoc = pDocSh->GetDocument(); USHORT nTab = GetTab_Impl(); Size aSize = pDoc->GetPageSize( nTab ); if (aSize.Width() && aSize.Height()) // effektive Groesse schon gesetzt? pDoc->UpdatePageBreaks( nTab ); else { // Umbrueche updaten wie in ScDocShell::PageStyleModified: ScPrintFunc aPrintFunc( pDocSh, pDocSh->GetPrinter(), nTab ); aPrintFunc.UpdatePages(); } USHORT nCount = 0; USHORT nRow; for (nRow=0; nRow<=MAXROW; nRow++) if (pDoc->GetRowFlags( nRow, nTab ) & ( CR_PAGEBREAK | CR_MANUALBREAK )) ++nCount; sheet::TablePageBreakData aData; uno::Sequence aSeq(nCount); sheet::TablePageBreakData* pAry = aSeq.getArray(); USHORT nPos = 0; for (nRow=0; nRow<=MAXROW; nRow++) { BYTE nFlags = pDoc->GetRowFlags( nRow, nTab ); if (nFlags & ( CR_PAGEBREAK | CR_MANUALBREAK )) { aData.Position = nRow; aData.ManualBreak = ( nFlags & CR_MANUALBREAK ) != 0; pAry[nPos] = aData; ++nPos; } } return aSeq; } return uno::Sequence(0); } void SAL_CALL ScTableSheetObj::removeAllManualPageBreaks() throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { //! docfunc Funktion, auch fuer ScViewFunc::RemoveManualBreaks ScDocument* pDoc = pDocSh->GetDocument(); BOOL bUndo (pDoc->IsUndoEnabled()); USHORT nTab = GetTab_Impl(); if (bUndo) { ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO ); pUndoDoc->InitUndo( pDoc, nTab, nTab, TRUE, TRUE ); pDoc->CopyToDocument( 0,0,nTab, MAXCOL,MAXROW,nTab, IDF_NONE, FALSE, pUndoDoc ); pDocSh->GetUndoManager()->AddUndoAction( new ScUndoRemoveBreaks( pDocSh, nTab, pUndoDoc ) ); } pDoc->RemoveManualBreaks(nTab); pDoc->UpdatePageBreaks(nTab); //? UpdatePageBreakData( TRUE ); pDocSh->SetDocumentModified(); pDocSh->PostPaint( 0,0,nTab, MAXCOL,MAXROW,nTab, PAINT_GRID ); } } // XNamed rtl::OUString SAL_CALL ScTableSheetObj::getName() throw(uno::RuntimeException) { ScUnoGuard aGuard; String aName; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) pDocSh->GetDocument()->GetName( GetTab_Impl(), aName ); return aName; } void SAL_CALL ScTableSheetObj::setName( const rtl::OUString& aNewName ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { String aString = aNewName; ScDocFunc aFunc( *pDocSh ); aFunc.RenameTable( GetTab_Impl(), aString, TRUE, TRUE ); } } // XDrawPageSupplier uno::Reference SAL_CALL ScTableSheetObj::getDrawPage() throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { ScDrawLayer* pDrawLayer = pDocSh->MakeDrawLayer(); DBG_ASSERT(pDrawLayer,"kann Draw-Layer nicht anlegen"); USHORT nTab = GetTab_Impl(); SdrPage* pPage = pDrawLayer->GetPage(nTab); DBG_ASSERT(pPage,"Draw-Page nicht gefunden"); if (pPage) return uno::Reference (pPage->getUnoPage(), uno::UNO_QUERY); // Das DrawPage-Objekt meldet sich als Listener am SdrModel an // und sollte von dort alle Aktionen mitbekommen } return NULL; } // XCellMovement void SAL_CALL ScTableSheetObj::insertCells( const table::CellRangeAddress& aRange, sheet::CellInsertMode nMode ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { BOOL bDo = TRUE; InsCellCmd eCmd; switch (nMode) { case sheet::CellInsertMode_NONE: bDo = FALSE; break; case sheet::CellInsertMode_DOWN: eCmd = INS_CELLSDOWN; break; case sheet::CellInsertMode_RIGHT: eCmd = INS_CELLSRIGHT; break; case sheet::CellInsertMode_ROWS: eCmd = INS_INSROWS; break; case sheet::CellInsertMode_COLUMNS: eCmd = INS_INSCOLS; break; default: DBG_ERROR("insertCells: falscher Mode"); bDo = FALSE; } if (bDo) { DBG_ASSERT( aRange.Sheet == GetTab_Impl(), "falsche Tabelle in CellRangeAddress" ); ScRange aScRange; ScUnoConversion::FillScRange( aScRange, aRange ); ScDocFunc aFunc(*pDocSh); aFunc.InsertCells( aScRange, eCmd, TRUE, TRUE ); } } } void SAL_CALL ScTableSheetObj::removeRange( const table::CellRangeAddress& aRange, sheet::CellDeleteMode nMode ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { BOOL bDo = TRUE; DelCellCmd eCmd; switch (nMode) { case sheet::CellDeleteMode_NONE: bDo = FALSE; break; case sheet::CellDeleteMode_UP: eCmd = DEL_CELLSUP; break; case sheet::CellDeleteMode_LEFT: eCmd = DEL_CELLSLEFT; break; case sheet::CellDeleteMode_ROWS: eCmd = DEL_DELROWS; break; case sheet::CellDeleteMode_COLUMNS: eCmd = DEL_DELCOLS; break; default: DBG_ERROR("deleteCells: falscher Mode"); bDo = FALSE; } if (bDo) { DBG_ASSERT( aRange.Sheet == GetTab_Impl(), "falsche Tabelle in CellRangeAddress" ); ScRange aScRange; ScUnoConversion::FillScRange( aScRange, aRange ); ScDocFunc aFunc(*pDocSh); aFunc.DeleteCells( aScRange, eCmd, TRUE, TRUE ); } } } void SAL_CALL ScTableSheetObj::moveRange( const table::CellAddress& aDestination, const table::CellRangeAddress& aSource ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { DBG_ASSERT( aSource.Sheet == GetTab_Impl(), "falsche Tabelle in CellRangeAddress" ); ScRange aRange; ScUnoConversion::FillScRange( aRange, aSource ); ScAddress aDestPos( (USHORT)aDestination.Column, (USHORT)aDestination.Row, aDestination.Sheet ); ScDocFunc aFunc(*pDocSh); aFunc.MoveBlock( aRange, aDestPos, TRUE, TRUE, TRUE, TRUE ); } } void SAL_CALL ScTableSheetObj::copyRange( const table::CellAddress& aDestination, const table::CellRangeAddress& aSource ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { DBG_ASSERT( aSource.Sheet == GetTab_Impl(), "falsche Tabelle in CellRangeAddress" ); ScRange aRange; ScUnoConversion::FillScRange( aRange, aSource ); ScAddress aDestPos( (USHORT)aDestination.Column, (USHORT)aDestination.Row, aDestination.Sheet ); ScDocFunc aFunc(*pDocSh); aFunc.MoveBlock( aRange, aDestPos, FALSE, TRUE, TRUE, TRUE ); } } // XPrintAreas void ScTableSheetObj::PrintAreaUndo_Impl( ScPrintRangeSaver* pOldRanges ) { // Umbrueche und Undo ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { ScDocument* pDoc = pDocSh->GetDocument(); BOOL bUndo(pDoc->IsUndoEnabled()); USHORT nTab = GetTab_Impl(); ScPrintRangeSaver* pNewRanges = pDoc->CreatePrintRangeSaver(); if (bUndo) { pDocSh->GetUndoManager()->AddUndoAction( new ScUndoPrintRange( pDocSh, nTab, pOldRanges, pNewRanges ) ); } ScPrintFunc( pDocSh, pDocSh->GetPrinter(), nTab ).UpdatePages(); SfxBindings* pBindings = pDocSh->GetViewBindings(); if (pBindings) pBindings->Invalidate( SID_DELETE_PRINTAREA ); pDocSh->SetDocumentModified(); } else delete pOldRanges; } uno::Sequence SAL_CALL ScTableSheetObj::getPrintAreas() throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { ScDocument* pDoc = pDocSh->GetDocument(); USHORT nTab = GetTab_Impl(); USHORT nCount = pDoc->GetPrintRangeCount( nTab ); table::CellRangeAddress aRangeAddress; uno::Sequence aSeq(nCount); table::CellRangeAddress* pAry = aSeq.getArray(); for (USHORT i=0; iGetPrintRange( nTab, i ); DBG_ASSERT(pRange,"wo ist der Druckbereich"); if (pRange) { ScUnoConversion::FillApiRange( aRangeAddress, *pRange ); pAry[i] = aRangeAddress; } } return aSeq; } return uno::Sequence(); } void SAL_CALL ScTableSheetObj::setPrintAreas( const uno::Sequence& aPrintAreas ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { ScDocument* pDoc = pDocSh->GetDocument(); USHORT nTab = GetTab_Impl(); ScPrintRangeSaver* pOldRanges = pDoc->CreatePrintRangeSaver(); USHORT nCount = (USHORT) aPrintAreas.getLength(); pDoc->SetPrintRangeCount( nTab, nCount ); if (nCount) { ScRange aRange; const table::CellRangeAddress* pAry = aPrintAreas.getConstArray(); for (USHORT i=0; iSetPrintRange( nTab, i, aRange ); } } PrintAreaUndo_Impl( pOldRanges ); // Undo, Umbrueche, Modified etc. } } sal_Bool SAL_CALL ScTableSheetObj::getPrintTitleColumns() throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { ScDocument* pDoc = pDocSh->GetDocument(); USHORT nTab = GetTab_Impl(); return ( pDoc->GetRepeatColRange(nTab) != NULL ); } return FALSE; } void SAL_CALL ScTableSheetObj::setPrintTitleColumns( sal_Bool bPrintTitleColumns ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { ScDocument* pDoc = pDocSh->GetDocument(); USHORT nTab = GetTab_Impl(); ScPrintRangeSaver* pOldRanges = pDoc->CreatePrintRangeSaver(); if ( bPrintTitleColumns ) { if ( !pDoc->GetRepeatColRange( nTab ) ) // keinen bestehenden Bereich veraendern { ScRange aNew( 0, 0, nTab, 0, 0, nTab ); // Default pDoc->SetRepeatColRange( nTab, &aNew ); // einschalten } } else pDoc->SetRepeatColRange( nTab, NULL ); // abschalten PrintAreaUndo_Impl( pOldRanges ); // Undo, Umbrueche, Modified etc. //! zuletzt gesetzten Bereich beim Abschalten merken und beim Einschalten wiederherstellen ??? } } table::CellRangeAddress SAL_CALL ScTableSheetObj::getTitleColumns() throw(uno::RuntimeException) { ScUnoGuard aGuard; table::CellRangeAddress aRet; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { ScDocument* pDoc = pDocSh->GetDocument(); USHORT nTab = GetTab_Impl(); const ScRange* pRange = pDoc->GetRepeatColRange(nTab); if (pRange) ScUnoConversion::FillApiRange( aRet, *pRange ); } return aRet; } void SAL_CALL ScTableSheetObj::setTitleColumns( const table::CellRangeAddress& aTitleColumns ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { ScDocument* pDoc = pDocSh->GetDocument(); USHORT nTab = GetTab_Impl(); ScPrintRangeSaver* pOldRanges = pDoc->CreatePrintRangeSaver(); ScRange aNew; ScUnoConversion::FillScRange( aNew, aTitleColumns ); pDoc->SetRepeatColRange( nTab, &aNew ); // immer auch einschalten PrintAreaUndo_Impl( pOldRanges ); // Undo, Umbrueche, Modified etc. } } sal_Bool SAL_CALL ScTableSheetObj::getPrintTitleRows() throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { ScDocument* pDoc = pDocSh->GetDocument(); USHORT nTab = GetTab_Impl(); return ( pDoc->GetRepeatRowRange(nTab) != NULL ); } return FALSE; } void SAL_CALL ScTableSheetObj::setPrintTitleRows( sal_Bool bPrintTitleRows ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { ScDocument* pDoc = pDocSh->GetDocument(); USHORT nTab = GetTab_Impl(); ScPrintRangeSaver* pOldRanges = pDoc->CreatePrintRangeSaver(); if ( bPrintTitleRows ) { if ( !pDoc->GetRepeatRowRange( nTab ) ) // keinen bestehenden Bereich veraendern { ScRange aNew( 0, 0, nTab, 0, 0, nTab ); // Default pDoc->SetRepeatRowRange( nTab, &aNew ); // einschalten } } else pDoc->SetRepeatRowRange( nTab, NULL ); // abschalten PrintAreaUndo_Impl( pOldRanges ); // Undo, Umbrueche, Modified etc. //! zuletzt gesetzten Bereich beim Abschalten merken und beim Einschalten wiederherstellen ??? } } table::CellRangeAddress SAL_CALL ScTableSheetObj::getTitleRows() throw(uno::RuntimeException) { ScUnoGuard aGuard; table::CellRangeAddress aRet; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { ScDocument* pDoc = pDocSh->GetDocument(); USHORT nTab = GetTab_Impl(); const ScRange* pRange = pDoc->GetRepeatRowRange(nTab); if (pRange) ScUnoConversion::FillApiRange( aRet, *pRange ); } return aRet; } void SAL_CALL ScTableSheetObj::setTitleRows( const table::CellRangeAddress& aTitleRows ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { ScDocument* pDoc = pDocSh->GetDocument(); USHORT nTab = GetTab_Impl(); ScPrintRangeSaver* pOldRanges = pDoc->CreatePrintRangeSaver(); ScRange aNew; ScUnoConversion::FillScRange( aNew, aTitleRows ); pDoc->SetRepeatRowRange( nTab, &aNew ); // immer auch einschalten PrintAreaUndo_Impl( pOldRanges ); // Undo, Umbrueche, Modified etc. } } // XSheetLinkable sheet::SheetLinkMode SAL_CALL ScTableSheetObj::getLinkMode() throw(uno::RuntimeException) { ScUnoGuard aGuard; sheet::SheetLinkMode eRet = sheet::SheetLinkMode_NONE; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { BYTE nMode = pDocSh->GetDocument()->GetLinkMode( GetTab_Impl() ); if ( nMode == SC_LINK_NORMAL ) eRet = sheet::SheetLinkMode_NORMAL; else if ( nMode == SC_LINK_VALUE ) eRet = sheet::SheetLinkMode_VALUE; } return eRet; } void SAL_CALL ScTableSheetObj::setLinkMode( sheet::SheetLinkMode nLinkMode ) throw(uno::RuntimeException) { ScUnoGuard aGuard; //! Filter und Options aus altem Link suchen rtl::OUString aUrl = getLinkUrl(); rtl::OUString aSheet = getLinkSheetName(); rtl::OUString aEmpty; link( aUrl, aSheet, aEmpty, aEmpty, nLinkMode ); } rtl::OUString SAL_CALL ScTableSheetObj::getLinkUrl() throw(uno::RuntimeException) { ScUnoGuard aGuard; String aFile; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) aFile = pDocSh->GetDocument()->GetLinkDoc( GetTab_Impl() ); return aFile; } void SAL_CALL ScTableSheetObj::setLinkUrl( const rtl::OUString& aLinkUrl ) throw(uno::RuntimeException) { ScUnoGuard aGuard; //! Filter und Options aus altem Link suchen sheet::SheetLinkMode eMode = getLinkMode(); rtl::OUString aSheet = getLinkSheetName(); rtl::OUString aEmpty; link( aLinkUrl, aSheet, aEmpty, aEmpty, eMode ); } rtl::OUString SAL_CALL ScTableSheetObj::getLinkSheetName() throw(uno::RuntimeException) { ScUnoGuard aGuard; String aSheet; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) aSheet = pDocSh->GetDocument()->GetLinkTab( GetTab_Impl() ); return aSheet; } void SAL_CALL ScTableSheetObj::setLinkSheetName( const rtl::OUString& aLinkSheetName ) throw(uno::RuntimeException) { ScUnoGuard aGuard; //! Filter und Options aus altem Link suchen sheet::SheetLinkMode eMode = getLinkMode(); rtl::OUString aUrl = getLinkUrl(); rtl::OUString aEmpty; link( aUrl, aLinkSheetName, aEmpty, aEmpty, eMode ); } void SAL_CALL ScTableSheetObj::link( const rtl::OUString& aUrl, const rtl::OUString& aSheetName, const rtl::OUString& aFilterName, const rtl::OUString& aFilterOptions, sheet::SheetLinkMode nMode ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { ScDocument* pDoc = pDocSh->GetDocument(); USHORT nTab = GetTab_Impl(); String aFileString = aUrl; String aFilterString = aFilterName; String aOptString = aFilterOptions; String aSheetString = aSheetName; aFileString = ScGlobal::GetAbsDocName( aFileString, pDocSh ); if ( !aFilterString.Len() ) ScDocumentLoader::GetFilterName( aFileString, aFilterString, aOptString ); BYTE nLinkMode = SC_LINK_NONE; if ( nMode == sheet::SheetLinkMode_NORMAL ) nLinkMode = SC_LINK_NORMAL; else if ( nMode == sheet::SheetLinkMode_VALUE ) nLinkMode = SC_LINK_VALUE; pDoc->SetLink( nTab, nLinkMode, aFileString, aFilterString, aOptString, aSheetString ); pDocSh->UpdateLinks(); // ggf. Link eintragen oder loeschen SfxBindings* pBindings = pDocSh->GetViewBindings(); if (pBindings) pBindings->Invalidate(SID_LINKS); //! Undo fuer Link-Daten an der Table if ( nLinkMode != SC_LINK_NONE ) // Link updaten { // Update immer, auch wenn der Link schon da war //! Update nur fuer die betroffene Tabelle??? SvxLinkManager* pLinkManager = pDoc->GetLinkManager(); USHORT nCount = pLinkManager->GetLinks().Count(); for ( USHORT i=0; iGetLinks()[i]; if (pBase->ISA(ScTableLink)) { ScTableLink* pTabLink = (ScTableLink*)pBase; if ( pTabLink->GetFileName() == aFileString ) pTabLink->Update(); // inkl. Paint&Undo //! Der Dateiname sollte nur einmal vorkommen (?) } } } //! Notify fuer ScSheetLinkObj Objekte!!! } } // XSheetAuditing sal_Bool SAL_CALL ScTableSheetObj::hideDependents( const table::CellAddress& aPosition ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { USHORT nTab = GetTab_Impl(); DBG_ASSERT( aPosition.Sheet == nTab, "falsche Tabelle in CellAddress" ); ScAddress aPos( (USHORT)aPosition.Column, (USHORT)aPosition.Row, nTab ); ScDocFunc aFunc(*pDocSh); return aFunc.DetectiveDelSucc( aPos ); } return FALSE; } sal_Bool SAL_CALL ScTableSheetObj::hidePrecedents( const table::CellAddress& aPosition ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { USHORT nTab = GetTab_Impl(); DBG_ASSERT( aPosition.Sheet == nTab, "falsche Tabelle in CellAddress" ); ScAddress aPos( (USHORT)aPosition.Column, (USHORT)aPosition.Row, nTab ); ScDocFunc aFunc(*pDocSh); return aFunc.DetectiveDelPred( aPos ); } return FALSE; } sal_Bool SAL_CALL ScTableSheetObj::showDependents( const table::CellAddress& aPosition ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { USHORT nTab = GetTab_Impl(); DBG_ASSERT( aPosition.Sheet == nTab, "falsche Tabelle in CellAddress" ); ScAddress aPos( (USHORT)aPosition.Column, (USHORT)aPosition.Row, nTab ); ScDocFunc aFunc(*pDocSh); return aFunc.DetectiveAddSucc( aPos ); } return FALSE; } sal_Bool SAL_CALL ScTableSheetObj::showPrecedents( const table::CellAddress& aPosition ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { USHORT nTab = GetTab_Impl(); DBG_ASSERT( aPosition.Sheet == nTab, "falsche Tabelle in CellAddress" ); ScAddress aPos( (USHORT)aPosition.Column, (USHORT)aPosition.Row, nTab ); ScDocFunc aFunc(*pDocSh); return aFunc.DetectiveAddPred( aPos ); } return FALSE; } sal_Bool SAL_CALL ScTableSheetObj::showErrors( const table::CellAddress& aPosition ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { USHORT nTab = GetTab_Impl(); DBG_ASSERT( aPosition.Sheet == nTab, "falsche Tabelle in CellAddress" ); ScAddress aPos( (USHORT)aPosition.Column, (USHORT)aPosition.Row, nTab ); ScDocFunc aFunc(*pDocSh); return aFunc.DetectiveAddError( aPos ); } return FALSE; } sal_Bool SAL_CALL ScTableSheetObj::showInvalid() throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { ScDocFunc aFunc(*pDocSh); return aFunc.DetectiveMarkInvalid( GetTab_Impl() ); } return FALSE; } void SAL_CALL ScTableSheetObj::clearArrows() throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { ScDocFunc aFunc(*pDocSh); aFunc.DetectiveDelAll( GetTab_Impl() ); } } // XSheetOutline void SAL_CALL ScTableSheetObj::group( const table::CellRangeAddress& aRange, table::TableOrientation nOrientation ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { BOOL bColumns = ( nOrientation == table::TableOrientation_COLUMNS ); ScRange aGroupRange; ScUnoConversion::FillScRange( aGroupRange, aRange ); ScOutlineDocFunc aFunc(*pDocSh); aFunc.MakeOutline( aGroupRange, bColumns, TRUE, TRUE ); } } void SAL_CALL ScTableSheetObj::ungroup( const table::CellRangeAddress& aRange, table::TableOrientation nOrientation ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { BOOL bColumns = ( nOrientation == table::TableOrientation_COLUMNS ); ScRange aGroupRange; ScUnoConversion::FillScRange( aGroupRange, aRange ); ScOutlineDocFunc aFunc(*pDocSh); aFunc.RemoveOutline( aGroupRange, bColumns, TRUE, TRUE ); } } void SAL_CALL ScTableSheetObj::autoOutline( const table::CellRangeAddress& aRange ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { ScRange aFormulaRange; ScUnoConversion::FillScRange( aFormulaRange, aRange ); ScOutlineDocFunc aFunc(*pDocSh); aFunc.AutoOutline( aFormulaRange, TRUE, TRUE ); } } void SAL_CALL ScTableSheetObj::clearOutline() throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { USHORT nTab = GetTab_Impl(); ScOutlineDocFunc aFunc(*pDocSh); aFunc.RemoveAllOutlines( nTab, TRUE, TRUE ); } } void SAL_CALL ScTableSheetObj::hideDetail( const table::CellRangeAddress& aRange ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { ScRange aMarkRange; ScUnoConversion::FillScRange( aMarkRange, aRange ); ScOutlineDocFunc aFunc(*pDocSh); aFunc.HideMarkedOutlines( aMarkRange, TRUE, TRUE ); } } void SAL_CALL ScTableSheetObj::showDetail( const table::CellRangeAddress& aRange ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { ScRange aMarkRange; ScUnoConversion::FillScRange( aMarkRange, aRange ); ScOutlineDocFunc aFunc(*pDocSh); aFunc.ShowMarkedOutlines( aMarkRange, TRUE, TRUE ); } } void SAL_CALL ScTableSheetObj::showLevel( sal_Int16 nLevel, table::TableOrientation nOrientation ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { BOOL bColumns = ( nOrientation == table::TableOrientation_COLUMNS ); USHORT nTab = GetTab_Impl(); ScOutlineDocFunc aFunc(*pDocSh); aFunc.SelectLevel( nTab, bColumns, nLevel, TRUE, TRUE, TRUE ); } } // XProtectable void SAL_CALL ScTableSheetObj::protect( const rtl::OUString& aPassword ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { String aString = aPassword; ScDocFunc aFunc(*pDocSh); aFunc.Protect( GetTab_Impl(), aString, TRUE ); } } void SAL_CALL ScTableSheetObj::unprotect( const rtl::OUString& aPassword ) throw(lang::IllegalArgumentException, uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { String aString = aPassword; ScDocFunc aFunc(*pDocSh); aFunc.Unprotect( GetTab_Impl(), aString, TRUE ); //! Rueckgabewert auswerten, Exception oder so } } sal_Bool SAL_CALL ScTableSheetObj::isProtected() throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) return pDocSh->GetDocument()->IsTabProtected( GetTab_Impl() ); DBG_ERROR("keine DocShell"); //! Exception oder so? return FALSE; } // XScenario sal_Bool SAL_CALL ScTableSheetObj::getIsScenario() throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) return pDocSh->GetDocument()->IsScenario( GetTab_Impl() ); return FALSE; } rtl::OUString SAL_CALL ScTableSheetObj::getScenarioComment() throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { String aComment; Color aColor; USHORT nFlags; pDocSh->GetDocument()->GetScenarioData( GetTab_Impl(), aComment, aColor, nFlags ); return aComment; } return rtl::OUString(); } void SAL_CALL ScTableSheetObj::setScenarioComment( const rtl::OUString& aScenarioComment ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { ScDocument* pDoc = pDocSh->GetDocument(); USHORT nTab = GetTab_Impl(); String aName; String aComment; Color aColor; USHORT nFlags; pDoc->GetName( nTab, aName ); pDoc->GetScenarioData( nTab, aComment, aColor, nFlags ); aComment = String( aScenarioComment ); pDocSh->ModifyScenario( nTab, aName, aComment, aColor, nFlags ); } } void SAL_CALL ScTableSheetObj::addRanges( const uno::Sequence& aRanges ) throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { ScDocument* pDoc = pDocSh->GetDocument(); USHORT nTab = GetTab_Impl(); ScMarkData aMarkData; aMarkData.SelectTable( nTab, TRUE ); USHORT nRangeCount = (USHORT)aRanges.getLength(); if (nRangeCount) { const table::CellRangeAddress* pAry = aRanges.getConstArray(); for (USHORT i=0; iGetPool() ); aPattern.GetItemSet().Put( ScMergeFlagAttr( SC_MF_SCENARIO ) ); aPattern.GetItemSet().Put( ScProtectionAttr( TRUE ) ); ScDocFunc aFunc(*pDocSh); aFunc.ApplyAttributes( aMarkData, aPattern, TRUE, TRUE ); } } void SAL_CALL ScTableSheetObj::apply() throw(uno::RuntimeException) { ScUnoGuard aGuard; ScDocShell* pDocSh = GetDocShell(); if ( pDocSh ) { ScDocument* pDoc = pDocSh->GetDocument(); USHORT nTab = GetTab_Impl(); String aName; pDoc->GetName( nTab, aName ); // Name dieses Szenarios USHORT nDestTab = nTab; while ( nDestTab > 0 && pDoc->IsScenario(nDestTab) ) --nDestTab; if ( !pDoc->IsScenario(nDestTab) ) pDocSh->UseScenario( nDestTab, aName ); //! sonst Fehler oder so } } // XPropertySet erweitert fuer Sheet-Properties uno::Reference SAL_CALL ScTableSheetObj::getPropertySetInfo() throw(uno::RuntimeException) { ScUnoGuard aGuard; static uno::Reference aRef = new SfxItemPropertySetInfo( aSheetPropSet.getPropertyMap() ); return aRef; } void SAL_CALL ScTableSheetObj::setPropertyValue( const rtl::OUString& aPropertyName, const uno::Any& aValue ) throw(beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; String aNameString = aPropertyName; // Abkuerzung, um Attributs-Properties relativ schnell zu setzen const SfxItemPropertyMap* pMap = SfxItemPropertyMap::GetByName( lcl_GetCellsPropertyMap(), aNameString ); if ( pMap && pMap->nWID ) { ScCellRangesBase::setPropertyValue(aPropertyName, aValue); return; } // eigene Properties ScDocShell* pDocSh = GetDocShell(); if (!pDocSh) return; //! Exception oder so? ScDocument* pDoc = pDocSh->GetDocument(); USHORT nTab = GetTab_Impl(); ScDocFunc aFunc(*pDocSh); if ( aNameString.EqualsAscii( SC_UNONAME_PAGESTL ) ) { rtl::OUString aStrVal; aValue >>= aStrVal; String aNewStr = ScStyleNameConversion::ProgrammaticToDisplayName( aStrVal, SFX_STYLE_FAMILY_PAGE ); //! Undo? (auch bei SID_STYLE_APPLY an der View) if ( pDoc->GetPageStyle( nTab ) != aNewStr ) { pDoc->SetPageStyle( nTab, aNewStr ); ScPrintFunc( pDocSh, pDocSh->GetPrinter(), nTab ).UpdatePages(); pDocSh->SetDocumentModified(); SfxBindings* pBindings = pDocSh->GetViewBindings(); if (pBindings) { pBindings->Invalidate( SID_STYLE_FAMILY4 ); pBindings->Invalidate( SID_STATUS_PAGESTYLE ); pBindings->Invalidate( FID_RESET_PRINTZOOM ); } } } else if ( aNameString.EqualsAscii( SC_UNONAME_CELLVIS ) ) { BOOL bVis = ScUnoHelpFunctions::GetBoolFromAny( aValue ); aFunc.SetTableVisible( nTab, bVis, TRUE ); } else ScCellRangeObj::setPropertyValue(aPropertyName, aValue); // geerbte ohne WID } uno::Any SAL_CALL ScTableSheetObj::getPropertyValue( const rtl::OUString& aPropertyName ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; String aNameString = aPropertyName; // Abkuerzung, um Attributs-Properties relativ schnell zu bekommen const SfxItemPropertyMap* pMap = SfxItemPropertyMap::GetByName( lcl_GetCellsPropertyMap(), aNameString ); if ( pMap && pMap->nWID ) return ScCellRangesBase::getPropertyValue(aPropertyName); // eigene Properties ScDocShell* pDocSh = GetDocShell(); if (!pDocSh) return uno::Any(); //! Exception oder so? ScDocument* pDoc = pDocSh->GetDocument(); USHORT nTab = GetTab_Impl(); uno::Any aAny; if ( aNameString.EqualsAscii( SC_UNONAME_PAGESTL ) ) { String aStyle = ScStyleNameConversion::DisplayToProgrammaticName( pDoc->GetPageStyle( nTab ), SFX_STYLE_FAMILY_PAGE ); aAny <<= rtl::OUString( aStyle ); } else if ( aNameString.EqualsAscii( SC_UNONAME_CELLVIS ) ) { BOOL bVis = pDoc->IsVisible( nTab ); ScUnoHelpFunctions::SetBoolInAny( aAny, bVis ); } else if ( aNameString.EqualsAscii( SC_UNO_LINKDISPBIT ) ) { // no target bitmaps for individual entries (would be all equal) // ScLinkTargetTypeObj::SetLinkTargetBitmap( aAny, SC_LINKTARGETTYPE_SHEET ); } else if ( aNameString.EqualsAscii( SC_UNO_LINKDISPNAME ) ) { // LinkDisplayName for hyperlink dialog aAny <<= getName(); // sheet name } else aAny = ScCellRangeObj::getPropertyValue(aPropertyName); // geerbte ohne WID return aAny; } // XServiceInfo rtl::OUString SAL_CALL ScTableSheetObj::getImplementationName() throw(uno::RuntimeException) { return rtl::OUString::createFromAscii( "ScTableSheetObj" ); } sal_Bool SAL_CALL ScTableSheetObj::supportsService( const rtl::OUString& rServiceName ) throw(uno::RuntimeException) { String aServiceStr( rServiceName ); return aServiceStr.EqualsAscii( SCSPREADSHEET_SERVICE ) || aServiceStr.EqualsAscii( SCSHEETCELLRANGE_SERVICE ) || aServiceStr.EqualsAscii( SCCELLRANGE_SERVICE ) || aServiceStr.EqualsAscii( SCCELLPROPERTIES_SERVICE ) || aServiceStr.EqualsAscii( SCCHARPROPERTIES_SERVICE ) || aServiceStr.EqualsAscii( SCLINKTARGET_SERVICE ); } uno::Sequence SAL_CALL ScTableSheetObj::getSupportedServiceNames() throw(uno::RuntimeException) { uno::Sequence aRet(6); rtl::OUString* pArray = aRet.getArray(); pArray[0] = rtl::OUString::createFromAscii( SCSPREADSHEET_SERVICE ); pArray[1] = rtl::OUString::createFromAscii( SCSHEETCELLRANGE_SERVICE ); pArray[2] = rtl::OUString::createFromAscii( SCCELLRANGE_SERVICE ); pArray[3] = rtl::OUString::createFromAscii( SCCELLPROPERTIES_SERVICE ); pArray[4] = rtl::OUString::createFromAscii( SCCHARPROPERTIES_SERVICE ); pArray[5] = rtl::OUString::createFromAscii( SCLINKTARGET_SERVICE ); return aRet; } // XUnoTunnel sal_Int64 SAL_CALL ScTableSheetObj::getSomething( const uno::Sequence& rId ) throw(uno::RuntimeException) { if ( rId.getLength() == 16 && 0 == rtl_compareMemory( getUnoTunnelId().getConstArray(), rId.getConstArray(), 16 ) ) { return (sal_Int64)this; } return ScCellRangeObj::getSomething( rId ); } // static const uno::Sequence& ScTableSheetObj::getUnoTunnelId() { static uno::Sequence * pSeq = 0; if( !pSeq ) { osl::Guard< osl::Mutex > aGuard( osl::Mutex::getGlobalMutex() ); if( !pSeq ) { static uno::Sequence< sal_Int8 > aSeq( 16 ); rtl_createUuid( (sal_uInt8*)aSeq.getArray(), 0, sal_True ); pSeq = &aSeq; } } return *pSeq; } // static ScTableSheetObj* ScTableSheetObj::getImplementation( const uno::Reference xObj ) { ScTableSheetObj* pRet = NULL; uno::Reference xUT( xObj, uno::UNO_QUERY ); if (xUT.is()) pRet = (ScTableSheetObj*) xUT->getSomething( getUnoTunnelId() ); return pRet; } //------------------------------------------------------------------------ ScTableColumnObj::ScTableColumnObj( ScDocShell* pDocSh, USHORT nCol, USHORT nTab ) : ScCellRangeObj( pDocSh, ScRange(nCol,0,nTab, nCol,MAXROW,nTab) ), aColPropSet(lcl_GetColumnPropertyMap()) { } ScTableColumnObj::~ScTableColumnObj() { } uno::Any SAL_CALL ScTableColumnObj::queryInterface( const uno::Type& rType ) throw(uno::RuntimeException) { SC_QUERYINTERFACE( container::XNamed ) return ScCellRangeObj::queryInterface( rType ); } void SAL_CALL ScTableColumnObj::acquire() throw(uno::RuntimeException) { ScCellRangeObj::acquire(); } void SAL_CALL ScTableColumnObj::release() throw(uno::RuntimeException) { ScCellRangeObj::release(); } uno::Sequence SAL_CALL ScTableColumnObj::getTypes() throw(uno::RuntimeException) { static uno::Sequence aTypes; if ( aTypes.getLength() == 0 ) { uno::Sequence aParentTypes = ScCellRangeObj::getTypes(); long nParentLen = aParentTypes.getLength(); const uno::Type* pParentPtr = aParentTypes.getConstArray(); aTypes.realloc( nParentLen + 1 ); uno::Type* pPtr = aTypes.getArray(); pPtr[nParentLen + 0] = getCppuType((const uno::Reference*)0); for (long i=0; i SAL_CALL ScTableColumnObj::getImplementationId() throw(uno::RuntimeException) { static uno::Sequence< sal_Int8 > aId; if( aId.getLength() == 0 ) { aId.realloc( 16 ); rtl_createUuid( (sal_uInt8 *)aId.getArray(), 0, sal_True ); } return aId; } // XNamed rtl::OUString SAL_CALL ScTableColumnObj::getName() throw(uno::RuntimeException) { ScUnoGuard aGuard; const ScRange& rRange = GetRange(); DBG_ASSERT(rRange.aStart.Col() == rRange.aEnd.Col(), "too many columns"); USHORT nCol = rRange.aStart.Col(); return ColToAlpha( nCol ); // from global.hxx } void SAL_CALL ScTableColumnObj::setName( const rtl::OUString& aNewName ) throw(uno::RuntimeException) { ScUnoGuard aGuard; throw uno::RuntimeException(); // read-only } // XPropertySet erweitert fuer Spalten-Properties uno::Reference SAL_CALL ScTableColumnObj::getPropertySetInfo() throw(uno::RuntimeException) { ScUnoGuard aGuard; static uno::Reference aRef = new SfxItemPropertySetInfo( aColPropSet.getPropertyMap() ); return aRef; } void SAL_CALL ScTableColumnObj::setPropertyValue( const rtl::OUString& aPropertyName, const uno::Any& aValue ) throw(beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; String aNameString = aPropertyName; // Abkuerzung, um Attributs-Properties relativ schnell zu setzen const SfxItemPropertyMap* pMap = SfxItemPropertyMap::GetByName( lcl_GetCellsPropertyMap(), aNameString ); if ( pMap && pMap->nWID ) { ScCellRangesBase::setPropertyValue(aPropertyName, aValue); return; } // eigene Properties ScDocShell* pDocSh = GetDocShell(); if (!pDocSh) return; //! Exception oder so? ScDocument* pDoc = pDocSh->GetDocument(); const ScRange& rRange = GetRange(); DBG_ASSERT(rRange.aStart.Col() == rRange.aEnd.Col(), "zuviele Spalten"); USHORT nCol = rRange.aStart.Col(); USHORT nTab = rRange.aStart.Tab(); ScDocFunc aFunc(*pDocSh); USHORT nColArr[2]; nColArr[0] = nColArr[1] = nCol; if ( aNameString.EqualsAscii( SC_UNONAME_CELLWID ) ) { sal_Int32 nNewWidth; if ( aValue >>= nNewWidth ) { // property is 1/100mm, column width is twips nNewWidth = HMMToTwips(nNewWidth); aFunc.SetWidthOrHeight( TRUE, 1, nColArr, nTab, SC_SIZE_DIRECT, (USHORT)nNewWidth, TRUE, TRUE ); } } else if ( aNameString.EqualsAscii( SC_UNONAME_CELLVIS ) ) { BOOL bVis = ScUnoHelpFunctions::GetBoolFromAny( aValue ); ScSizeMode eMode = bVis ? SC_SIZE_SHOW : SC_SIZE_DIRECT; aFunc.SetWidthOrHeight( TRUE, 1, nColArr, nTab, eMode, 0, TRUE, TRUE ); // SC_SIZE_DIRECT mit Groesse 0 blendet aus } else if ( aNameString.EqualsAscii( SC_UNONAME_OWIDTH ) ) { BOOL bOpt = ScUnoHelpFunctions::GetBoolFromAny( aValue ); if (bOpt) aFunc.SetWidthOrHeight( TRUE, 1, nColArr, nTab, SC_SIZE_OPTIMAL, STD_EXTRA_WIDTH, TRUE, TRUE ); // FALSE bei Spalten momentan ohne Auswirkung } else if ( aNameString.EqualsAscii( SC_UNONAME_NEWPAGE ) || aNameString.EqualsAscii( SC_UNONAME_MANPAGE ) ) { BOOL bSet = ScUnoHelpFunctions::GetBoolFromAny( aValue ); if (bSet) aFunc.InsertPageBreak( TRUE, rRange.aStart, TRUE, TRUE, TRUE ); else aFunc.RemovePageBreak( TRUE, rRange.aStart, TRUE, TRUE, TRUE ); } else ScCellRangeObj::setPropertyValue(aPropertyName, aValue); // geerbte ohne WID } uno::Any SAL_CALL ScTableColumnObj::getPropertyValue( const rtl::OUString& aPropertyName ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; String aNameString = aPropertyName; // Abkuerzung, um Attributs-Properties relativ schnell zu bekommen const SfxItemPropertyMap* pMap = SfxItemPropertyMap::GetByName( lcl_GetCellsPropertyMap(), aNameString ); if ( pMap && pMap->nWID ) return ScCellRangesBase::getPropertyValue(aPropertyName); // eigene Properties ScDocShell* pDocSh = GetDocShell(); if (!pDocSh) return uno::Any(); //! Exception oder so? ScDocument* pDoc = pDocSh->GetDocument(); const ScRange& rRange = GetRange(); DBG_ASSERT(rRange.aStart.Col() == rRange.aEnd.Col(), "zuviele Spalten"); USHORT nCol = rRange.aStart.Col(); USHORT nTab = rRange.aStart.Tab(); uno::Any aAny; if ( aNameString.EqualsAscii( SC_UNONAME_CELLWID ) ) { USHORT nWidth = pDoc->GetColWidth( nCol, nTab ); // Property ist 1/100mm, Spaltenbreite in Twips nWidth = (USHORT) TwipsToHMM(nWidth); aAny <<= (sal_Int32)( nWidth ); } else if ( aNameString.EqualsAscii( SC_UNONAME_CELLVIS ) ) { BOOL bVis = !(pDoc->GetColFlags( nCol, nTab ) & CR_HIDDEN); ScUnoHelpFunctions::SetBoolInAny( aAny, bVis ); } else if ( aNameString.EqualsAscii( SC_UNONAME_OWIDTH ) ) { //! momentan immer gesetzt ??!?! BOOL bOpt = !(pDoc->GetColFlags( nCol, nTab ) & CR_MANUALSIZE); ScUnoHelpFunctions::SetBoolInAny( aAny, bOpt ); } else if ( aNameString.EqualsAscii( SC_UNONAME_NEWPAGE ) ) { BOOL bBreak = ( 0 != (pDoc->GetColFlags( nCol, nTab ) & (CR_PAGEBREAK|CR_MANUALBREAK)) ); ScUnoHelpFunctions::SetBoolInAny( aAny, bBreak ); } else if ( aNameString.EqualsAscii( SC_UNONAME_MANPAGE ) ) { BOOL bBreak = ( 0 != (pDoc->GetColFlags( nCol, nTab ) & (CR_MANUALBREAK)) ); ScUnoHelpFunctions::SetBoolInAny( aAny, bBreak ); } else aAny = ScCellRangeObj::getPropertyValue(aPropertyName); // geerbte ohne WID return aAny; } //------------------------------------------------------------------------ ScTableRowObj::ScTableRowObj(ScDocShell* pDocSh, USHORT nRow, USHORT nTab) : ScCellRangeObj( pDocSh, ScRange(0,nRow,nTab, MAXCOL,nRow,nTab) ), aRowPropSet(lcl_GetRowPropertyMap()) { } ScTableRowObj::~ScTableRowObj() { } // XPropertySet erweitert fuer Zeilen-Properties uno::Reference SAL_CALL ScTableRowObj::getPropertySetInfo() throw(uno::RuntimeException) { ScUnoGuard aGuard; static uno::Reference aRef = new SfxItemPropertySetInfo( aRowPropSet.getPropertyMap() ); return aRef; } void SAL_CALL ScTableRowObj::setPropertyValue( const rtl::OUString& aPropertyName, const uno::Any& aValue ) throw(beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; String aNameString = aPropertyName; // Abkuerzung, um Attributs-Properties relativ schnell zu setzen const SfxItemPropertyMap* pMap = SfxItemPropertyMap::GetByName( lcl_GetCellsPropertyMap(), aNameString ); if ( pMap && pMap->nWID ) { ScCellRangesBase::setPropertyValue(aPropertyName, aValue); return; } // eigene Properties ScDocShell* pDocSh = GetDocShell(); if (!pDocSh) return; //! Exception oder so? ScDocument* pDoc = pDocSh->GetDocument(); const ScRange& rRange = GetRange(); DBG_ASSERT(rRange.aStart.Row() == rRange.aEnd.Row(), "zuviele Zeilen"); USHORT nRow = rRange.aStart.Row(); USHORT nTab = rRange.aStart.Tab(); ScDocFunc aFunc(*pDocSh); USHORT nRowArr[2]; nRowArr[0] = nRowArr[1] = nRow; if ( aNameString.EqualsAscii( SC_UNONAME_CELLHGT ) ) { sal_Int32 nNewHeight; if ( aValue >>= nNewHeight ) { // property is 1/100mm, row height is twips nNewHeight = HMMToTwips(nNewHeight); aFunc.SetWidthOrHeight( FALSE, 1, nRowArr, nTab, SC_SIZE_DIRECT, (USHORT)nNewHeight, TRUE, TRUE ); } } else if ( aNameString.EqualsAscii( SC_UNONAME_CELLVIS ) ) { BOOL bVis = ScUnoHelpFunctions::GetBoolFromAny( aValue ); ScSizeMode eMode = bVis ? SC_SIZE_SHOW : SC_SIZE_DIRECT; aFunc.SetWidthOrHeight( FALSE, 1, nRowArr, nTab, eMode, 0, TRUE, TRUE ); // SC_SIZE_DIRECT mit Groesse 0 blendet aus } else if ( aNameString.EqualsAscii( SC_UNONAME_CELLFILT ) ) { BOOL bFil = ScUnoHelpFunctions::GetBoolFromAny( aValue ); // ScSizeMode eMode = bVis ? SC_SIZE_SHOW : SC_SIZE_DIRECT; // aFunc.SetWidthOrHeight( FALSE, 1, nRowArr, nTab, eMode, 0, TRUE, TRUE ); // SC_SIZE_DIRECT mit Groesse 0 blendet aus BYTE nFlags = pDoc->GetRowFlags(nRow, nTab); if (bFil) nFlags |= CR_FILTERED; else nFlags &= ~CR_FILTERED; pDoc->SetRowFlags(nRow, nTab, nFlags); } else if ( aNameString.EqualsAscii( SC_UNONAME_OHEIGHT ) ) { BOOL bOpt = ScUnoHelpFunctions::GetBoolFromAny( aValue ); if (bOpt) aFunc.SetWidthOrHeight( FALSE, 1, nRowArr, nTab, SC_SIZE_OPTIMAL, 0, TRUE, TRUE ); else { // alte Hoehe nochmal manuell setzen USHORT nHeight = pDoc->GetRowHeight( nRow, nTab ); aFunc.SetWidthOrHeight( FALSE, 1, nRowArr, nTab, SC_SIZE_DIRECT, nHeight, TRUE, TRUE ); } } else if ( aNameString.EqualsAscii( SC_UNONAME_NEWPAGE) || aNameString.EqualsAscii( SC_UNONAME_MANPAGE) ) { BOOL bSet = ScUnoHelpFunctions::GetBoolFromAny( aValue ); if (bSet) aFunc.InsertPageBreak( FALSE, rRange.aStart, TRUE, TRUE, TRUE ); else aFunc.RemovePageBreak( FALSE, rRange.aStart, TRUE, TRUE, TRUE ); } else ScCellRangeObj::setPropertyValue(aPropertyName, aValue); // geerbte ohne WID } uno::Any SAL_CALL ScTableRowObj::getPropertyValue( const rtl::OUString& aPropertyName ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; String aNameString = aPropertyName; // Abkuerzung, um Attributs-Properties relativ schnell zu bekommen const SfxItemPropertyMap* pMap = SfxItemPropertyMap::GetByName( lcl_GetCellsPropertyMap(), aNameString ); if ( pMap && pMap->nWID ) return ScCellRangesBase::getPropertyValue(aPropertyName); // eigene Properties ScDocShell* pDocSh = GetDocShell(); if (!pDocSh) return uno::Any(); //! Exception oder so? ScDocument* pDoc = pDocSh->GetDocument(); const ScRange& rRange = GetRange(); DBG_ASSERT(rRange.aStart.Row() == rRange.aEnd.Row(), "zuviele Zeilen"); USHORT nRow = rRange.aStart.Row(); USHORT nTab = rRange.aStart.Tab(); uno::Any aAny; if ( aNameString.EqualsAscii( SC_UNONAME_CELLHGT ) ) { USHORT nHeight = pDoc->GetRowHeight( nRow, nTab ); // Property ist 1/100mm, Zeilenhoehe in Twips nHeight = (USHORT) TwipsToHMM(nHeight); aAny <<= (sal_Int32)( nHeight ); } else if ( aNameString.EqualsAscii( SC_UNONAME_CELLVIS ) ) { BOOL bVis = !(pDoc->GetRowFlags( nRow, nTab ) & CR_HIDDEN); ScUnoHelpFunctions::SetBoolInAny( aAny, bVis ); } else if ( aNameString.EqualsAscii( SC_UNONAME_CELLFILT ) ) { BOOL bVis = ((pDoc->GetRowFlags( nRow, nTab ) & CR_FILTERED) != 0); ScUnoHelpFunctions::SetBoolInAny( aAny, bVis ); } else if ( aNameString.EqualsAscii( SC_UNONAME_OHEIGHT ) ) { BOOL bOpt = !(pDoc->GetRowFlags( nRow, nTab ) & CR_MANUALSIZE); ScUnoHelpFunctions::SetBoolInAny( aAny, bOpt ); } else if ( aNameString.EqualsAscii( SC_UNONAME_NEWPAGE ) ) { BOOL bBreak = ( 0 != (pDoc->GetRowFlags( nRow, nTab ) & (CR_PAGEBREAK|CR_MANUALBREAK)) ); ScUnoHelpFunctions::SetBoolInAny( aAny, bBreak ); } else if ( aNameString.EqualsAscii( SC_UNONAME_MANPAGE ) ) { BOOL bBreak = ( 0 != (pDoc->GetRowFlags( nRow, nTab ) & (CR_MANUALBREAK)) ); ScUnoHelpFunctions::SetBoolInAny( aAny, bBreak ); } else aAny = ScCellRangeObj::getPropertyValue(aPropertyName); // geerbte ohne WID return aAny; } //------------------------------------------------------------------------ ScCellsObj::ScCellsObj(ScDocShell* pDocSh, const ScRangeList& rR) : pDocShell( pDocSh ), aRanges( rR ) { pDocShell->GetDocument()->AddUnoObject(*this); } ScCellsObj::~ScCellsObj() { if (pDocShell) pDocShell->GetDocument()->RemoveUnoObject(*this); } void ScCellsObj::Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) { if ( rHint.ISA( ScUpdateRefHint ) ) { const ScUpdateRefHint& rRef = (const ScUpdateRefHint&)rHint; aRanges.UpdateReference( rRef.GetMode(), pDocShell->GetDocument(), rRef.GetRange(), rRef.GetDx(), rRef.GetDy(), rRef.GetDz() ); } else if ( rHint.ISA( SfxSimpleHint ) && ((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING ) { pDocShell = NULL; // ungueltig geworden } } // XEnumerationAccess uno::Reference SAL_CALL ScCellsObj::createEnumeration() throw(uno::RuntimeException) { ScUnoGuard aGuard; if (pDocShell) return new ScCellsEnumeration( pDocShell, aRanges ); return NULL; } uno::Type SAL_CALL ScCellsObj::getElementType() throw(uno::RuntimeException) { ScUnoGuard aGuard; return getCppuType((uno::Reference*)0); } sal_Bool SAL_CALL ScCellsObj::hasElements() throw(uno::RuntimeException) { ScUnoGuard aGuard; BOOL bHas = FALSE; if ( pDocShell ) { //! schneller selber testen? uno::Reference xEnum = new ScCellsEnumeration( pDocShell, aRanges ); bHas = xEnum->hasMoreElements(); } return bHas; } //------------------------------------------------------------------------ ScCellsEnumeration::ScCellsEnumeration(ScDocShell* pDocSh, const ScRangeList& rR) : pDocShell( pDocSh ), aRanges( rR ), bAtEnd( FALSE ), pMark( NULL ) { ScDocument* pDoc = pDocShell->GetDocument(); pDoc->AddUnoObject(*this); if ( aRanges.Count() == 0 ) bAtEnd = TRUE; else { USHORT nTab = 0; const ScRange* pFirst = aRanges.GetObject(0); if (pFirst) nTab = pFirst->aStart.Tab(); aPos = ScAddress(0,0,nTab); CheckPos_Impl(); // aPos auf erste passende Zelle setzen } } void ScCellsEnumeration::CheckPos_Impl() { if (pDocShell) { BOOL bFound = FALSE; ScDocument* pDoc = pDocShell->GetDocument(); ScBaseCell* pCell = pDoc->GetCell(aPos); if ( pCell && pCell->GetCellType() != CELLTYPE_NOTE ) { if (!pMark) { pMark = new ScMarkData; pMark->MarkFromRangeList( aRanges, FALSE ); pMark->MarkToMulti(); // needed for GetNextMarkedCell } bFound = pMark->IsCellMarked( aPos.Col(), aPos.Row() ); } if (!bFound) Advance_Impl(); } } ScCellsEnumeration::~ScCellsEnumeration() { if (pDocShell) pDocShell->GetDocument()->RemoveUnoObject(*this); delete pMark; } void ScCellsEnumeration::Advance_Impl() { DBG_ASSERT(!bAtEnd,"zuviel Advance_Impl"); if (!pMark) { pMark = new ScMarkData; pMark->MarkFromRangeList( aRanges, FALSE ); pMark->MarkToMulti(); // needed for GetNextMarkedCell } USHORT nCol = aPos.Col(); USHORT nRow = aPos.Row(); USHORT nTab = aPos.Tab(); BOOL bFound = pDocShell->GetDocument()->GetNextMarkedCell( nCol, nRow, nTab, *pMark ); if (bFound) aPos.Set( nCol, nRow, nTab ); else bAtEnd = TRUE; // kommt nix mehr } void ScCellsEnumeration::Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) { if ( rHint.ISA( ScUpdateRefHint ) ) { if (pDocShell) { const ScUpdateRefHint& rRef = (const ScUpdateRefHint&)rHint; aRanges.UpdateReference( rRef.GetMode(), pDocShell->GetDocument(), rRef.GetRange(), rRef.GetDx(), rRef.GetDy(), rRef.GetDz() ); delete pMark; // aus verschobenen Bereichen neu erzeugen pMark = NULL; if (!bAtEnd) // aPos anpassen { ScRangeList aNew; aNew.Append(ScRange(aPos)); aNew.UpdateReference( rRef.GetMode(), pDocShell->GetDocument(), rRef.GetRange(), rRef.GetDx(), rRef.GetDy(), rRef.GetDz() ); if (aNew.Count()==1) { aPos = aNew.GetObject(0)->aStart; CheckPos_Impl(); } } } } else if ( rHint.ISA( SfxSimpleHint ) && ((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING ) { pDocShell = NULL; // ungueltig geworden } } // XEnumeration sal_Bool SAL_CALL ScCellsEnumeration::hasMoreElements() throw(uno::RuntimeException) { ScUnoGuard aGuard; return !bAtEnd; } uno::Any SAL_CALL ScCellsEnumeration::nextElement() throw(container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; if (pDocShell && !bAtEnd) { // Interface-Typ muss zu ScCellsObj::getElementType passen uno::Any aAny; uno::Reference xCell = new ScCellObj( pDocShell, aPos ); aAny <<= xCell; Advance_Impl(); return aAny; } throw container::NoSuchElementException(); // no more elements return uno::Any(); } //------------------------------------------------------------------------ ScCellFormatsObj::ScCellFormatsObj(ScDocShell* pDocSh, const ScRange& rRange) : pDocShell( pDocSh ), aTotalRange( rRange ) { ScDocument* pDoc = pDocShell->GetDocument(); pDoc->AddUnoObject(*this); DBG_ASSERT( aTotalRange.aStart.Tab() == aTotalRange.aEnd.Tab(), "unterschiedliche Tabellen" ); } ScCellFormatsObj::~ScCellFormatsObj() { if (pDocShell) pDocShell->GetDocument()->RemoveUnoObject(*this); } void ScCellFormatsObj::Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) { if ( rHint.ISA( ScUpdateRefHint ) ) { //! aTotalRange... } else if ( rHint.ISA( SfxSimpleHint ) && ((const SfxSimpleHint&)rHint).GetId() == SFX_HINT_DYING ) { pDocShell = NULL; // ungueltig geworden } } ScCellRangeObj* ScCellFormatsObj::GetObjectByIndex_Impl(long nIndex) const { //! direkt auf die AttrArrays zugreifen !!!! ScCellRangeObj* pRet = NULL; if (pDocShell) { ScDocument* pDoc = pDocShell->GetDocument(); long nPos = 0; ScAttrRectIterator aIter( pDoc, aTotalRange.aStart.Tab(), aTotalRange.aStart.Col(), aTotalRange.aStart.Row(), aTotalRange.aEnd.Col(), aTotalRange.aEnd.Row() ); USHORT nCol1, nCol2, nRow1, nRow2; while ( aIter.GetNext( nCol1, nCol2, nRow1, nRow2 ) ) { if ( nPos == nIndex ) { USHORT nTab = aTotalRange.aStart.Tab(); ScRange aNext( nCol1, nRow1, nTab, nCol2, nRow2, nTab ); if ( aNext.aStart == aNext.aEnd ) pRet = new ScCellObj( pDocShell, aNext.aStart ); else pRet = new ScCellRangeObj( pDocShell, aNext ); } ++nPos; } } return pRet; } // XIndexAccess sal_Int32 SAL_CALL ScCellFormatsObj::getCount() throw(uno::RuntimeException) { ScUnoGuard aGuard; //! direkt auf die AttrArrays zugreifen !!!! long nCount = 0; if (pDocShell) { ScDocument* pDoc = pDocShell->GetDocument(); ScAttrRectIterator aIter( pDoc, aTotalRange.aStart.Tab(), aTotalRange.aStart.Col(), aTotalRange.aStart.Row(), aTotalRange.aEnd.Col(), aTotalRange.aEnd.Row() ); USHORT nCol1, nCol2, nRow1, nRow2; while ( aIter.GetNext( nCol1, nCol2, nRow1, nRow2 ) ) ++nCount; } return nCount; } uno::Any SAL_CALL ScCellFormatsObj::getByIndex( sal_Int32 nIndex ) throw(lang::IndexOutOfBoundsException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; uno::Reference xRange = GetObjectByIndex_Impl(nIndex); uno::Any aAny; if (xRange.is()) aAny <<= xRange; else throw lang::IndexOutOfBoundsException(); return aAny; } uno::Type SAL_CALL ScCellFormatsObj::getElementType() throw(uno::RuntimeException) { ScUnoGuard aGuard; return getCppuType((uno::Reference*)0); } sal_Bool SAL_CALL ScCellFormatsObj::hasElements() throw(uno::RuntimeException) { ScUnoGuard aGuard; return ( getCount() != 0 ); //! immer groesser 0 ?? } // XEnumerationAccess uno::Reference SAL_CALL ScCellFormatsObj::createEnumeration() throw(uno::RuntimeException) { ScUnoGuard aGuard; if (pDocShell) return new ScCellFormatsEnumeration( pDocShell, aTotalRange ); return NULL; } //------------------------------------------------------------------------ ScCellFormatsEnumeration::ScCellFormatsEnumeration(ScDocShell* pDocSh, const ScRange& rRange) : pDocShell( pDocSh ), nTab( rRange.aStart.Tab() ), pIter( NULL ), bAtEnd( FALSE ), bDirty( FALSE ) { ScDocument* pDoc = pDocShell->GetDocument(); pDoc->AddUnoObject(*this); DBG_ASSERT( rRange.aStart.Tab() == rRange.aEnd.Tab(), "CellFormatsEnumeration: unterschiedliche Tabellen" ); pIter = new ScAttrRectIterator( pDoc, nTab, rRange.aStart.Col(), rRange.aStart.Row(), rRange.aEnd.Col(), rRange.aEnd.Row() ); Advance_Impl(); } ScCellFormatsEnumeration::~ScCellFormatsEnumeration() { if (pDocShell) pDocShell->GetDocument()->RemoveUnoObject(*this); delete pIter; } void ScCellFormatsEnumeration::Advance_Impl() { DBG_ASSERT(!bAtEnd,"zuviel Advance_Impl"); if ( pIter ) { if ( bDirty ) { pIter->DataChanged(); // AttrArray-Index neu suchen bDirty = FALSE; } USHORT nCol1, nCol2, nRow1, nRow2; if ( pIter->GetNext( nCol1, nCol2, nRow1, nRow2 ) ) aNext = ScRange( nCol1, nRow1, nTab, nCol2, nRow2, nTab ); else bAtEnd = TRUE; // kommt nix mehr } else bAtEnd = TRUE; // Dok weggekommen oder so } ScCellRangeObj* ScCellFormatsEnumeration::NextObject_Impl() { ScCellRangeObj* pRet = NULL; if (pDocShell && !bAtEnd) { if ( aNext.aStart == aNext.aEnd ) pRet = new ScCellObj( pDocShell, aNext.aStart ); else pRet = new ScCellRangeObj( pDocShell, aNext ); Advance_Impl(); } return pRet; } void ScCellFormatsEnumeration::Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) { if ( rHint.ISA( ScUpdateRefHint ) ) { //! und nun ??? } else if ( rHint.ISA( SfxSimpleHint ) ) { ULONG nId = ((const SfxSimpleHint&)rHint).GetId(); if ( nId == SFX_HINT_DYING ) { pDocShell = NULL; // ungueltig geworden delete pIter; pIter = NULL; } else if ( nId == SFX_HINT_DATACHANGED ) { bDirty = TRUE; // AttrArray-Index evtl. ungueltig geworden } } } // XEnumeration sal_Bool SAL_CALL ScCellFormatsEnumeration::hasMoreElements() throw(uno::RuntimeException) { ScUnoGuard aGuard; return !bAtEnd; } uno::Any SAL_CALL ScCellFormatsEnumeration::nextElement() throw(container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException) { ScUnoGuard aGuard; if ( bAtEnd || !pDocShell ) throw container::NoSuchElementException(); // no more elements // Interface-Typ muss zu ScCellFormatsObj::getElementType passen uno::Any aAny; uno::Reference xRange = NextObject_Impl(); aAny <<= xRange; return aAny; }