| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_sc.hxx" |
| |
| |
| #include "scitems.hxx" |
| #include <editeng/eeitem.hxx> |
| #include <svx/svdpool.hxx> |
| |
| #include <svx/algitem.hxx> |
| #include <editeng/boxitem.hxx> |
| #include <editeng/brshitem.hxx> |
| #include <editeng/editeng.hxx> |
| #include <editeng/flditem.hxx> |
| #include <svx/fmdpage.hxx> |
| #include <editeng/langitem.hxx> |
| #include <sfx2/linkmgr.hxx> |
| #include <svl/srchitem.hxx> |
| #include <svx/unomid.hxx> |
| #include <editeng/unoprnms.hxx> |
| #include <editeng/unotext.hxx> |
| #include <svx/svdpage.hxx> |
| #include <sfx2/bindings.hxx> |
| #include <svl/zforlist.hxx> |
| #include <svl/zformat.hxx> |
| #include <rtl/uuid.h> |
| #include <float.h> // DBL_MIN |
| |
| #include <com/sun/star/awt/XBitmap.hpp> |
| #include <com/sun/star/util/CellProtection.hpp> |
| #include <com/sun/star/table/CellHoriJustify.hpp> |
| #include <com/sun/star/table/CellOrientation.hpp> |
| #include <com/sun/star/table/CellVertJustify.hpp> |
| #include <com/sun/star/table/ShadowFormat.hpp> |
| #include <com/sun/star/table/TableBorder.hpp> |
| #include <com/sun/star/sheet/CellFlags.hpp> |
| #include <com/sun/star/sheet/FormulaResult.hpp> |
| #include <com/sun/star/beans/PropertyAttribute.hpp> |
| #include <com/sun/star/lang/Locale.hpp> |
| #include <com/sun/star/beans/TolerantPropertySetResultType.hpp> |
| #include <com/sun/star/beans/SetPropertyTolerantFailed.hpp> |
| #include <com/sun/star/text/WritingMode2.hpp> |
| |
| #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 "tokenuno.hxx" |
| #include "eventuno.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" |
| #include "unowids.hxx" |
| #include "paramisc.hxx" |
| #include "formula/errorcodes.hxx" |
| #include "unoreflist.hxx" |
| #include "formula/grammar.hxx" |
| |
| #include <list> |
| |
| using namespace com::sun::star; |
| |
| //------------------------------------------------------------------------ |
| |
| |
| 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 SfxItemPropertySet* lcl_GetCellsPropertySet() |
| { |
| static SfxItemPropertyMapEntry aCellsPropertyMap_Impl[] = |
| { |
| {MAP_CHAR_LEN(SC_UNONAME_ABSNAME), SC_WID_UNO_ABSNAME, &getCppuType((rtl::OUString*)0), 0 | beans::PropertyAttribute::READONLY, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_ASIANVERT),ATTR_VERTICAL_ASIAN,&getBooleanCppuType(), 0, 0 }, |
| {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), SC_WID_UNO_CELLSTYL,&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_CEMPHAS), ATTR_FONT_EMPHASISMARK,&getCppuType((sal_Int16*)0), 0, MID_EMPHASIS }, |
| {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_COVER), ATTR_FONT_OVERLINE, &getCppuType((sal_Int16*)0), 0, MID_TL_STYLE }, |
| {MAP_CHAR_LEN(SC_UNONAME_COVRLCOL), ATTR_FONT_OVERLINE, &getCppuType((sal_Int32*)0), 0, MID_TL_COLOR }, |
| {MAP_CHAR_LEN(SC_UNONAME_COVRLHAS), ATTR_FONT_OVERLINE, &getBooleanCppuType(), 0, MID_TL_HASCOLOR }, |
| {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_CRELIEF), ATTR_FONT_RELIEF, &getCppuType((sal_Int16*)0), 0, MID_RELIEF }, |
| {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_TL_STYLE }, |
| {MAP_CHAR_LEN(SC_UNONAME_CUNDLCOL), ATTR_FONT_UNDERLINE,&getCppuType((sal_Int32*)0), 0, MID_TL_COLOR }, |
| {MAP_CHAR_LEN(SC_UNONAME_CUNDLHAS), ATTR_FONT_UNDERLINE,&getBooleanCppuType(), 0, MID_TL_HASCOLOR }, |
| {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_CWORDMOD), ATTR_FONT_WORDLINE, &getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CHCOLHDR), SC_WID_UNO_CHCOLHDR,&getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CHROWHDR), SC_WID_UNO_CHROWHDR,&getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CONDFMT), SC_WID_UNO_CONDFMT, &getCppuType((uno::Reference<sheet::XSheetConditionalEntries>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CONDLOC), SC_WID_UNO_CONDLOC, &getCppuType((uno::Reference<sheet::XSheetConditionalEntries>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CONDXML), SC_WID_UNO_CONDXML, &getCppuType((uno::Reference<sheet::XSheetConditionalEntries>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_DIAGONAL_BLTR), ATTR_BORDER_BLTR, &::getCppuType((const table::BorderLine*)0), 0, 0 | CONVERT_TWIPS }, |
| {MAP_CHAR_LEN(SC_UNONAME_DIAGONAL_TLBR), ATTR_BORDER_TLBR, &::getCppuType((const table::BorderLine*)0), 0, 0 | CONVERT_TWIPS }, |
| {MAP_CHAR_LEN(SC_UNONAME_CELLHJUS), ATTR_HOR_JUSTIFY, &getCppuType((table::CellHoriJustify*)0), 0, MID_HORJUST_HORJUST }, |
| {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_NUMRULES), SC_WID_UNO_NUMRULES,&getCppuType((const uno::Reference<container::XIndexReplace>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CELLORI), ATTR_STACKED, &getCppuType((table::CellOrientation*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_PADJUST), ATTR_HOR_JUSTIFY, &::getCppuType((const sal_Int16*)0), 0, MID_HORJUST_ADJUST }, |
| {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_PISHYPHEN),ATTR_HYPHENATE, &getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_PLASTADJ), ATTR_HOR_JUSTIFY, &::getCppuType((const sal_Int16*)0), 0, MID_HORJUST_ADJUST }, |
| {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_SHRINK_TO_FIT), ATTR_SHRINKTOFIT, &getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_TBLBORD), SC_WID_UNO_TBLBORD, &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_USERDEF), ATTR_USERDEF, &getCppuType((uno::Reference<container::XNameContainer>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_VALIDAT), SC_WID_UNO_VALIDAT, &getCppuType((uno::Reference<beans::XPropertySet>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_VALILOC), SC_WID_UNO_VALILOC, &getCppuType((uno::Reference<beans::XPropertySet>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_VALIXML), SC_WID_UNO_VALIXML, &getCppuType((uno::Reference<beans::XPropertySet>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CELLVJUS), ATTR_VER_JUSTIFY, &getCppuType((table::CellVertJustify*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_WRITING), ATTR_WRITINGDIR, &getCppuType((sal_Int16*)0), 0, 0 }, |
| {0,0,0,0,0,0} |
| }; |
| static SfxItemPropertySet aCellsPropertySet( aCellsPropertyMap_Impl ); |
| return &aCellsPropertySet; |
| } |
| |
| // CellRange enthaelt alle Eintraege von Cells, zusaetzlich eigene Eintraege |
| // mit Which-ID 0 (werden nur fuer getPropertySetInfo benoetigt). |
| |
| const SfxItemPropertySet* lcl_GetRangePropertySet() |
| { |
| static SfxItemPropertyMapEntry aRangePropertyMap_Impl[] = |
| { |
| {MAP_CHAR_LEN(SC_UNONAME_ABSNAME), SC_WID_UNO_ABSNAME, &getCppuType((rtl::OUString*)0), 0 | beans::PropertyAttribute::READONLY, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_ASIANVERT),ATTR_VERTICAL_ASIAN,&getBooleanCppuType(), 0, 0 }, |
| {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), SC_WID_UNO_CELLSTYL,&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_CEMPHAS), ATTR_FONT_EMPHASISMARK,&getCppuType((sal_Int16*)0), 0, MID_EMPHASIS }, |
| {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_COVER), ATTR_FONT_OVERLINE, &getCppuType((sal_Int16*)0), 0, MID_TL_STYLE }, |
| {MAP_CHAR_LEN(SC_UNONAME_COVRLCOL), ATTR_FONT_OVERLINE, &getCppuType((sal_Int32*)0), 0, MID_TL_COLOR }, |
| {MAP_CHAR_LEN(SC_UNONAME_COVRLHAS), ATTR_FONT_OVERLINE, &getBooleanCppuType(), 0, MID_TL_HASCOLOR }, |
| {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_CRELIEF), ATTR_FONT_RELIEF, &getCppuType((sal_Int16*)0), 0, MID_RELIEF }, |
| {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_TL_STYLE }, |
| {MAP_CHAR_LEN(SC_UNONAME_CUNDLCOL), ATTR_FONT_UNDERLINE,&getCppuType((sal_Int32*)0), 0, MID_TL_COLOR }, |
| {MAP_CHAR_LEN(SC_UNONAME_CUNDLHAS), ATTR_FONT_UNDERLINE,&getBooleanCppuType(), 0, MID_TL_HASCOLOR }, |
| {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_CWORDMOD), ATTR_FONT_WORDLINE, &getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CHCOLHDR), SC_WID_UNO_CHCOLHDR,&getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CHROWHDR), SC_WID_UNO_CHROWHDR,&getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CONDFMT), SC_WID_UNO_CONDFMT, &getCppuType((uno::Reference<sheet::XSheetConditionalEntries>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CONDLOC), SC_WID_UNO_CONDLOC, &getCppuType((uno::Reference<sheet::XSheetConditionalEntries>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CONDXML), SC_WID_UNO_CONDXML, &getCppuType((uno::Reference<sheet::XSheetConditionalEntries>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_DIAGONAL_BLTR), ATTR_BORDER_BLTR, &::getCppuType((const table::BorderLine*)0), 0, 0 | CONVERT_TWIPS }, |
| {MAP_CHAR_LEN(SC_UNONAME_DIAGONAL_TLBR), ATTR_BORDER_TLBR, &::getCppuType((const table::BorderLine*)0), 0, 0 | CONVERT_TWIPS }, |
| {MAP_CHAR_LEN(SC_UNONAME_CELLHJUS), ATTR_HOR_JUSTIFY, &getCppuType((table::CellHoriJustify*)0), 0, MID_HORJUST_HORJUST }, |
| {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_NUMRULES), SC_WID_UNO_NUMRULES,&getCppuType((const uno::Reference<container::XIndexReplace>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CELLORI), ATTR_STACKED, &getCppuType((table::CellOrientation*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_PADJUST), ATTR_HOR_JUSTIFY, &::getCppuType((const sal_Int16*)0), 0, MID_HORJUST_ADJUST }, |
| {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_PISHYPHEN),ATTR_HYPHENATE, &getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_PLASTADJ), ATTR_HOR_JUSTIFY, &::getCppuType((const sal_Int16*)0), 0, MID_HORJUST_ADJUST }, |
| {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), SC_WID_UNO_POS, &getCppuType((awt::Point*)0), 0 | beans::PropertyAttribute::READONLY, 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_SHRINK_TO_FIT), ATTR_SHRINKTOFIT, &getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_SIZE), SC_WID_UNO_SIZE, &getCppuType((awt::Size*)0), 0 | beans::PropertyAttribute::READONLY, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_TBLBORD), SC_WID_UNO_TBLBORD, &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_USERDEF), ATTR_USERDEF, &getCppuType((uno::Reference<container::XNameContainer>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_VALIDAT), SC_WID_UNO_VALIDAT, &getCppuType((uno::Reference<beans::XPropertySet>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_VALILOC), SC_WID_UNO_VALILOC, &getCppuType((uno::Reference<beans::XPropertySet>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_VALIXML), SC_WID_UNO_VALIXML, &getCppuType((uno::Reference<beans::XPropertySet>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CELLVJUS), ATTR_VER_JUSTIFY, &getCppuType((table::CellVertJustify*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_WRITING), ATTR_WRITINGDIR, &getCppuType((sal_Int16*)0), 0, 0 }, |
| {0,0,0,0,0,0} |
| }; |
| static SfxItemPropertySet aRangePropertySet( aRangePropertyMap_Impl ); |
| return &aRangePropertySet; |
| } |
| |
| // Cell enthaelt alle Eintraege von CellRange, zusaetzlich eigene Eintraege |
| // mit Which-ID 0 (werden nur fuer getPropertySetInfo benoetigt). |
| |
| const SfxItemPropertySet* lcl_GetCellPropertySet() |
| { |
| static SfxItemPropertyMapEntry aCellPropertyMap_Impl[] = |
| { |
| {MAP_CHAR_LEN(SC_UNONAME_ABSNAME), SC_WID_UNO_ABSNAME, &getCppuType((rtl::OUString*)0), 0 | beans::PropertyAttribute::READONLY, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_ASIANVERT),ATTR_VERTICAL_ASIAN,&getBooleanCppuType(), 0, 0 }, |
| {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), SC_WID_UNO_CELLSTYL,&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_CEMPHAS), ATTR_FONT_EMPHASISMARK,&getCppuType((sal_Int16*)0), 0, MID_EMPHASIS }, |
| {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_COVER), ATTR_FONT_OVERLINE, &getCppuType((sal_Int16*)0), 0, MID_TL_STYLE }, |
| {MAP_CHAR_LEN(SC_UNONAME_COVRLCOL), ATTR_FONT_OVERLINE, &getCppuType((sal_Int32*)0), 0, MID_TL_COLOR }, |
| {MAP_CHAR_LEN(SC_UNONAME_COVRLHAS), ATTR_FONT_OVERLINE, &getBooleanCppuType(), 0, MID_TL_HASCOLOR }, |
| {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_CRELIEF), ATTR_FONT_RELIEF, &getCppuType((sal_Int16*)0), 0, MID_RELIEF }, |
| {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_TL_STYLE }, |
| {MAP_CHAR_LEN(SC_UNONAME_CUNDLCOL), ATTR_FONT_UNDERLINE,&getCppuType((sal_Int32*)0), 0, MID_TL_COLOR }, |
| {MAP_CHAR_LEN(SC_UNONAME_CUNDLHAS), ATTR_FONT_UNDERLINE,&getBooleanCppuType(), 0, MID_TL_HASCOLOR }, |
| {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_CWORDMOD), ATTR_FONT_WORDLINE, &getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CHCOLHDR), SC_WID_UNO_CHCOLHDR,&getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CHROWHDR), SC_WID_UNO_CHROWHDR,&getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CONDFMT), SC_WID_UNO_CONDFMT, &getCppuType((uno::Reference<sheet::XSheetConditionalEntries>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CONDLOC), SC_WID_UNO_CONDLOC, &getCppuType((uno::Reference<sheet::XSheetConditionalEntries>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CONDXML), SC_WID_UNO_CONDXML, &getCppuType((uno::Reference<sheet::XSheetConditionalEntries>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_DIAGONAL_BLTR), ATTR_BORDER_BLTR, &::getCppuType((const table::BorderLine*)0), 0, 0 | CONVERT_TWIPS }, |
| {MAP_CHAR_LEN(SC_UNONAME_DIAGONAL_TLBR), ATTR_BORDER_TLBR, &::getCppuType((const table::BorderLine*)0), 0, 0 | CONVERT_TWIPS }, |
| {MAP_CHAR_LEN(SC_UNONAME_FORMLOC), SC_WID_UNO_FORMLOC, &getCppuType((rtl::OUString*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_FORMRT), SC_WID_UNO_FORMRT, &getCppuType((table::CellContentType*)0), 0 | beans::PropertyAttribute::READONLY, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CELLHJUS), ATTR_HOR_JUSTIFY, &getCppuType((table::CellHoriJustify*)0), 0, MID_HORJUST_HORJUST }, |
| {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_NUMRULES), SC_WID_UNO_NUMRULES,&getCppuType((const uno::Reference<container::XIndexReplace>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CELLORI), ATTR_STACKED, &getCppuType((table::CellOrientation*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_PADJUST), ATTR_HOR_JUSTIFY, &::getCppuType((const sal_Int16*)0), 0, MID_HORJUST_ADJUST }, |
| {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_PISHYPHEN),ATTR_HYPHENATE, &getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_PLASTADJ), ATTR_HOR_JUSTIFY, &::getCppuType((const sal_Int16*)0), 0, MID_HORJUST_ADJUST }, |
| {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), SC_WID_UNO_POS, &getCppuType((awt::Point*)0), 0 | beans::PropertyAttribute::READONLY, 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_SHRINK_TO_FIT), ATTR_SHRINKTOFIT, &getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_SIZE), SC_WID_UNO_SIZE, &getCppuType((awt::Size*)0), 0 | beans::PropertyAttribute::READONLY, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_TBLBORD), SC_WID_UNO_TBLBORD, &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_USERDEF), ATTR_USERDEF, &getCppuType((uno::Reference<container::XNameContainer>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_VALIDAT), SC_WID_UNO_VALIDAT, &getCppuType((uno::Reference<beans::XPropertySet>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_VALILOC), SC_WID_UNO_VALILOC, &getCppuType((uno::Reference<beans::XPropertySet>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_VALIXML), SC_WID_UNO_VALIXML, &getCppuType((uno::Reference<beans::XPropertySet>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CELLVJUS), ATTR_VER_JUSTIFY, &getCppuType((table::CellVertJustify*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_WRITING), ATTR_WRITINGDIR, &getCppuType((sal_Int16*)0), 0, 0 }, |
| {0,0,0,0,0,0} |
| }; |
| static SfxItemPropertySet aCellPropertySet( aCellPropertyMap_Impl ); |
| return &aCellPropertySet; |
| } |
| |
| // Column und Row enthalten alle Eintraege von CellRange, zusaetzlich eigene Eintraege |
| // mit Which-ID 0 (werden nur fuer getPropertySetInfo benoetigt). |
| |
| const SfxItemPropertySet* lcl_GetColumnPropertySet() |
| { |
| static SfxItemPropertyMapEntry aColumnPropertyMap_Impl[] = |
| { |
| {MAP_CHAR_LEN(SC_UNONAME_ABSNAME), SC_WID_UNO_ABSNAME, &getCppuType((rtl::OUString*)0), 0 | beans::PropertyAttribute::READONLY, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_ASIANVERT),ATTR_VERTICAL_ASIAN,&getBooleanCppuType(), 0, 0 }, |
| {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), SC_WID_UNO_CELLSTYL,&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_CEMPHAS), ATTR_FONT_EMPHASISMARK,&getCppuType((sal_Int16*)0), 0, MID_EMPHASIS }, |
| {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_COVER), ATTR_FONT_OVERLINE, &getCppuType((sal_Int16*)0), 0, MID_TL_STYLE }, |
| {MAP_CHAR_LEN(SC_UNONAME_COVRLCOL), ATTR_FONT_OVERLINE, &getCppuType((sal_Int32*)0), 0, MID_TL_COLOR }, |
| {MAP_CHAR_LEN(SC_UNONAME_COVRLHAS), ATTR_FONT_OVERLINE, &getBooleanCppuType(), 0, MID_TL_HASCOLOR }, |
| {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_CRELIEF), ATTR_FONT_RELIEF, &getCppuType((sal_Int16*)0), 0, MID_RELIEF }, |
| {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_TL_STYLE }, |
| {MAP_CHAR_LEN(SC_UNONAME_CUNDLCOL), ATTR_FONT_UNDERLINE,&getCppuType((sal_Int32*)0), 0, MID_TL_COLOR }, |
| {MAP_CHAR_LEN(SC_UNONAME_CUNDLHAS), ATTR_FONT_UNDERLINE,&getBooleanCppuType(), 0, MID_TL_HASCOLOR }, |
| {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_CWORDMOD), ATTR_FONT_WORDLINE, &getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CHCOLHDR), SC_WID_UNO_CHCOLHDR,&getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CHROWHDR), SC_WID_UNO_CHROWHDR,&getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CONDFMT), SC_WID_UNO_CONDFMT, &getCppuType((uno::Reference<sheet::XSheetConditionalEntries>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CONDLOC), SC_WID_UNO_CONDLOC, &getCppuType((uno::Reference<sheet::XSheetConditionalEntries>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CONDXML), SC_WID_UNO_CONDXML, &getCppuType((uno::Reference<sheet::XSheetConditionalEntries>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_DIAGONAL_BLTR), ATTR_BORDER_BLTR, &::getCppuType((const table::BorderLine*)0), 0, 0 | CONVERT_TWIPS }, |
| {MAP_CHAR_LEN(SC_UNONAME_DIAGONAL_TLBR), ATTR_BORDER_TLBR, &::getCppuType((const table::BorderLine*)0), 0, 0 | CONVERT_TWIPS }, |
| {MAP_CHAR_LEN(SC_UNONAME_CELLHJUS), ATTR_HOR_JUSTIFY, &getCppuType((table::CellHoriJustify*)0), 0, MID_HORJUST_HORJUST }, |
| {MAP_CHAR_LEN(SC_UNONAME_CELLTRAN), ATTR_BACKGROUND, &getBooleanCppuType(), 0, MID_GRAPHIC_TRANSPARENT }, |
| // {MAP_CHAR_LEN(SC_UNONAME_CELLFILT), SC_WID_UNO_CELLFILT,&getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_MANPAGE), SC_WID_UNO_MANPAGE, &getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_NEWPAGE), SC_WID_UNO_NEWPAGE, &getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_WRAP), ATTR_LINEBREAK, &getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CELLVIS), SC_WID_UNO_CELLVIS, &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_NUMRULES), SC_WID_UNO_NUMRULES,&getCppuType((const uno::Reference<container::XIndexReplace>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_OWIDTH), SC_WID_UNO_OWIDTH, &getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CELLORI), ATTR_STACKED, &getCppuType((table::CellOrientation*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_PADJUST), ATTR_HOR_JUSTIFY, &::getCppuType((const sal_Int16*)0), 0, MID_HORJUST_ADJUST }, |
| {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_PISHYPHEN),ATTR_HYPHENATE, &getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_PLASTADJ), ATTR_HOR_JUSTIFY, &::getCppuType((const sal_Int16*)0), 0, MID_HORJUST_ADJUST }, |
| {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), SC_WID_UNO_POS, &getCppuType((awt::Point*)0), 0 | beans::PropertyAttribute::READONLY, 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_SHRINK_TO_FIT), ATTR_SHRINKTOFIT, &getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_SIZE), SC_WID_UNO_SIZE, &getCppuType((awt::Size*)0), 0 | beans::PropertyAttribute::READONLY, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_TBLBORD), SC_WID_UNO_TBLBORD, &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_USERDEF), ATTR_USERDEF, &getCppuType((uno::Reference<container::XNameContainer>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_VALIDAT), SC_WID_UNO_VALIDAT, &getCppuType((uno::Reference<beans::XPropertySet>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_VALILOC), SC_WID_UNO_VALILOC, &getCppuType((uno::Reference<beans::XPropertySet>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_VALIXML), SC_WID_UNO_VALIXML, &getCppuType((uno::Reference<beans::XPropertySet>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CELLVJUS), ATTR_VER_JUSTIFY, &getCppuType((table::CellVertJustify*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CELLWID), SC_WID_UNO_CELLWID, &getCppuType((sal_Int32*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_WRITING), ATTR_WRITINGDIR, &getCppuType((sal_Int16*)0), 0, 0 }, |
| {0,0,0,0,0,0} |
| }; |
| static SfxItemPropertySet aColumnPropertySet( aColumnPropertyMap_Impl ); |
| return &aColumnPropertySet; |
| } |
| |
| const SfxItemPropertySet* lcl_GetRowPropertySet() |
| { |
| static SfxItemPropertyMapEntry aRowPropertyMap_Impl[] = |
| { |
| {MAP_CHAR_LEN(SC_UNONAME_ABSNAME), SC_WID_UNO_ABSNAME, &getCppuType((rtl::OUString*)0), 0 | beans::PropertyAttribute::READONLY, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_ASIANVERT),ATTR_VERTICAL_ASIAN,&getBooleanCppuType(), 0, 0 }, |
| {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), SC_WID_UNO_CELLSTYL,&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_CEMPHAS), ATTR_FONT_EMPHASISMARK,&getCppuType((sal_Int16*)0), 0, MID_EMPHASIS }, |
| {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_COVER), ATTR_FONT_OVERLINE, &getCppuType((sal_Int16*)0), 0, MID_TL_STYLE }, |
| {MAP_CHAR_LEN(SC_UNONAME_COVRLCOL), ATTR_FONT_OVERLINE, &getCppuType((sal_Int32*)0), 0, MID_TL_COLOR }, |
| {MAP_CHAR_LEN(SC_UNONAME_COVRLHAS), ATTR_FONT_OVERLINE, &getBooleanCppuType(), 0, MID_TL_HASCOLOR }, |
| {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_CRELIEF), ATTR_FONT_RELIEF, &getCppuType((sal_Int16*)0), 0, MID_RELIEF }, |
| {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_TL_STYLE }, |
| {MAP_CHAR_LEN(SC_UNONAME_CUNDLCOL), ATTR_FONT_UNDERLINE,&getCppuType((sal_Int32*)0), 0, MID_TL_COLOR }, |
| {MAP_CHAR_LEN(SC_UNONAME_CUNDLHAS), ATTR_FONT_UNDERLINE,&getBooleanCppuType(), 0, MID_TL_HASCOLOR }, |
| {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_CWORDMOD), ATTR_FONT_WORDLINE, &getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CHCOLHDR), SC_WID_UNO_CHCOLHDR,&getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CHROWHDR), SC_WID_UNO_CHROWHDR,&getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CONDFMT), SC_WID_UNO_CONDFMT, &getCppuType((uno::Reference<sheet::XSheetConditionalEntries>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CONDLOC), SC_WID_UNO_CONDLOC, &getCppuType((uno::Reference<sheet::XSheetConditionalEntries>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CONDXML), SC_WID_UNO_CONDXML, &getCppuType((uno::Reference<sheet::XSheetConditionalEntries>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_DIAGONAL_BLTR), ATTR_BORDER_BLTR, &::getCppuType((const table::BorderLine*)0), 0, 0 | CONVERT_TWIPS }, |
| {MAP_CHAR_LEN(SC_UNONAME_DIAGONAL_TLBR), ATTR_BORDER_TLBR, &::getCppuType((const table::BorderLine*)0), 0, 0 | CONVERT_TWIPS }, |
| {MAP_CHAR_LEN(SC_UNONAME_CELLHGT), SC_WID_UNO_CELLHGT, &getCppuType((sal_Int32*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CELLHJUS), ATTR_HOR_JUSTIFY, &getCppuType((table::CellHoriJustify*)0), 0, MID_HORJUST_HORJUST }, |
| {MAP_CHAR_LEN(SC_UNONAME_CELLTRAN), ATTR_BACKGROUND, &getBooleanCppuType(), 0, MID_GRAPHIC_TRANSPARENT }, |
| {MAP_CHAR_LEN(SC_UNONAME_CELLFILT), SC_WID_UNO_CELLFILT,&getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_MANPAGE), SC_WID_UNO_MANPAGE, &getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_NEWPAGE), SC_WID_UNO_NEWPAGE, &getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_WRAP), ATTR_LINEBREAK, &getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CELLVIS), SC_WID_UNO_CELLVIS, &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_NUMRULES), SC_WID_UNO_NUMRULES,&getCppuType((const uno::Reference<container::XIndexReplace>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_OHEIGHT), SC_WID_UNO_OHEIGHT, &getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CELLORI), ATTR_STACKED, &getCppuType((table::CellOrientation*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_PADJUST), ATTR_HOR_JUSTIFY, &::getCppuType((const sal_Int16*)0), 0, MID_HORJUST_ADJUST }, |
| {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_PISHYPHEN),ATTR_HYPHENATE, &getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_PLASTADJ), ATTR_HOR_JUSTIFY, &::getCppuType((const sal_Int16*)0), 0, MID_HORJUST_ADJUST }, |
| {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), SC_WID_UNO_POS, &getCppuType((awt::Point*)0), 0 | beans::PropertyAttribute::READONLY, 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_SHRINK_TO_FIT), ATTR_SHRINKTOFIT, &getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_SIZE), SC_WID_UNO_SIZE, &getCppuType((awt::Size*)0), 0 | beans::PropertyAttribute::READONLY, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_TBLBORD), SC_WID_UNO_TBLBORD, &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_USERDEF), ATTR_USERDEF, &getCppuType((uno::Reference<container::XNameContainer>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_VALIDAT), SC_WID_UNO_VALIDAT, &getCppuType((uno::Reference<beans::XPropertySet>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_VALILOC), SC_WID_UNO_VALILOC, &getCppuType((uno::Reference<beans::XPropertySet>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_VALIXML), SC_WID_UNO_VALIXML, &getCppuType((uno::Reference<beans::XPropertySet>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CELLVJUS), ATTR_VER_JUSTIFY, &getCppuType((table::CellVertJustify*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_WRITING), ATTR_WRITINGDIR, &getCppuType((sal_Int16*)0), 0, 0 }, |
| {0,0,0,0,0,0} |
| }; |
| static SfxItemPropertySet aRowPropertySet( aRowPropertyMap_Impl ); |
| return &aRowPropertySet; |
| } |
| |
| const SfxItemPropertySet* lcl_GetSheetPropertySet() |
| { |
| static SfxItemPropertyMapEntry aSheetPropertyMap_Impl[] = |
| { |
| {MAP_CHAR_LEN(SC_UNONAME_ABSNAME), SC_WID_UNO_ABSNAME, &getCppuType((rtl::OUString*)0), 0 | beans::PropertyAttribute::READONLY, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_ASIANVERT),ATTR_VERTICAL_ASIAN,&getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_AUTOPRINT),SC_WID_UNO_AUTOPRINT,&getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_BORDCOL), SC_WID_UNO_BORDCOL, &getCppuType((sal_Int32*)0), 0, 0 }, |
| {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), SC_WID_UNO_CELLSTYL,&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_CEMPHAS), ATTR_FONT_EMPHASISMARK,&getCppuType((sal_Int16*)0), 0, MID_EMPHASIS }, |
| {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_COVER), ATTR_FONT_OVERLINE, &getCppuType((sal_Int16*)0), 0, MID_TL_STYLE }, |
| {MAP_CHAR_LEN(SC_UNONAME_COVRLCOL), ATTR_FONT_OVERLINE, &getCppuType((sal_Int32*)0), 0, MID_TL_COLOR }, |
| {MAP_CHAR_LEN(SC_UNONAME_COVRLHAS), ATTR_FONT_OVERLINE, &getBooleanCppuType(), 0, MID_TL_HASCOLOR }, |
| {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_CRELIEF), ATTR_FONT_RELIEF, &getCppuType((sal_Int16*)0), 0, MID_RELIEF }, |
| {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_TL_STYLE }, |
| {MAP_CHAR_LEN(SC_UNONAME_CUNDLCOL), ATTR_FONT_UNDERLINE,&getCppuType((sal_Int32*)0), 0, MID_TL_COLOR }, |
| {MAP_CHAR_LEN(SC_UNONAME_CUNDLHAS), ATTR_FONT_UNDERLINE,&getBooleanCppuType(), 0, MID_TL_HASCOLOR }, |
| {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_CWORDMOD), ATTR_FONT_WORDLINE, &getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CHCOLHDR), SC_WID_UNO_CHCOLHDR,&getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CHROWHDR), SC_WID_UNO_CHROWHDR,&getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CONDFMT), SC_WID_UNO_CONDFMT, &getCppuType((uno::Reference<sheet::XSheetConditionalEntries>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CONDLOC), SC_WID_UNO_CONDLOC, &getCppuType((uno::Reference<sheet::XSheetConditionalEntries>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CONDXML), SC_WID_UNO_CONDXML, &getCppuType((uno::Reference<sheet::XSheetConditionalEntries>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_COPYBACK), SC_WID_UNO_COPYBACK,&getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_COPYFORM), SC_WID_UNO_COPYFORM,&getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_COPYSTYL), SC_WID_UNO_COPYSTYL,&getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_DIAGONAL_BLTR), ATTR_BORDER_BLTR, &::getCppuType((const table::BorderLine*)0), 0, 0 | CONVERT_TWIPS }, |
| {MAP_CHAR_LEN(SC_UNONAME_DIAGONAL_TLBR), ATTR_BORDER_TLBR, &::getCppuType((const table::BorderLine*)0), 0, 0 | CONVERT_TWIPS }, |
| {MAP_CHAR_LEN(SC_UNONAME_CELLHJUS), ATTR_HOR_JUSTIFY, &getCppuType((table::CellHoriJustify*)0), 0, MID_HORJUST_HORJUST }, |
| {MAP_CHAR_LEN(SC_UNONAME_ISACTIVE), SC_WID_UNO_ISACTIVE,&getBooleanCppuType(), 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), SC_WID_UNO_CELLVIS, &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), SC_WID_UNO_LINKDISPBIT,&getCppuType((uno::Reference<awt::XBitmap>*)0), 0 | beans::PropertyAttribute::READONLY, 0 }, |
| {MAP_CHAR_LEN(SC_UNO_LINKDISPNAME), SC_WID_UNO_LINKDISPNAME,&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_NUMRULES), SC_WID_UNO_NUMRULES,&getCppuType((const uno::Reference<container::XIndexReplace>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CELLORI), ATTR_STACKED, &getCppuType((table::CellOrientation*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_PAGESTL), SC_WID_UNO_PAGESTL, &getCppuType((rtl::OUString*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_PADJUST), ATTR_HOR_JUSTIFY, &::getCppuType((const sal_Int16*)0), 0, MID_HORJUST_ADJUST }, |
| {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_PISHYPHEN),ATTR_HYPHENATE, &getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_PLASTADJ), ATTR_HOR_JUSTIFY, &::getCppuType((const sal_Int16*)0), 0, MID_HORJUST_ADJUST }, |
| {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), SC_WID_UNO_POS, &getCppuType((awt::Point*)0), 0 | beans::PropertyAttribute::READONLY, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_PRINTBORD),SC_WID_UNO_PRINTBORD,&getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_PROTECT), SC_WID_UNO_PROTECT, &getBooleanCppuType(), 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_SHOWBORD), SC_WID_UNO_SHOWBORD,&getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_SHRINK_TO_FIT), ATTR_SHRINKTOFIT, &getBooleanCppuType(), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_SIZE), SC_WID_UNO_SIZE, &getCppuType((awt::Size*)0), 0 | beans::PropertyAttribute::READONLY, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_TBLBORD), SC_WID_UNO_TBLBORD, &getCppuType((table::TableBorder*)0), 0, 0 | CONVERT_TWIPS }, |
| {MAP_CHAR_LEN(SC_UNONAME_TABLAYOUT),SC_WID_UNO_TABLAYOUT,&getCppuType((sal_Int16*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_TOPBORDER),ATTR_BORDER, &::getCppuType((const table::BorderLine*)0), 0, TOP_BORDER | CONVERT_TWIPS }, |
| {MAP_CHAR_LEN(SC_UNONAME_USERDEF), ATTR_USERDEF, &getCppuType((uno::Reference<container::XNameContainer>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_VALIDAT), SC_WID_UNO_VALIDAT, &getCppuType((uno::Reference<beans::XPropertySet>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_VALILOC), SC_WID_UNO_VALILOC, &getCppuType((uno::Reference<beans::XPropertySet>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_VALIXML), SC_WID_UNO_VALIXML, &getCppuType((uno::Reference<beans::XPropertySet>*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_CELLVJUS), ATTR_VER_JUSTIFY, &getCppuType((table::CellVertJustify*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_WRITING), ATTR_WRITINGDIR, &getCppuType((sal_Int16*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNONAME_TABCOLOR), SC_WID_UNO_TABCOLOR, &getCppuType((sal_Int32*)0), 0, 0 }, |
| {MAP_CHAR_LEN(SC_UNO_CODENAME), SC_WID_UNO_CODENAME, &getCppuType(static_cast< const rtl::OUString * >(0)), 0, 0}, |
| {0,0,0,0,0,0} |
| }; |
| static SfxItemPropertySet aSheetPropertySet( aSheetPropertyMap_Impl ); |
| return &aSheetPropertySet; |
| } |
| |
| const SfxItemPropertyMapEntry* lcl_GetEditPropertyMap() |
| { |
| static SfxItemPropertyMapEntry aEditPropertyMap_Impl[] = |
| { |
| SVX_UNOEDIT_CHAR_PROPERTIES, |
| SVX_UNOEDIT_FONT_PROPERTIES, |
| SVX_UNOEDIT_PARA_PROPERTIES, |
| SVX_UNOEDIT_NUMBERING_PROPERTIE, // for completeness of service ParagraphProperties |
| {MAP_CHAR_LEN(SC_UNONAME_TEXTUSER), EE_CHAR_XMLATTRIBS, &getCppuType((const uno::Reference< container::XNameContainer >*)0), 0, 0}, |
| {MAP_CHAR_LEN(SC_UNONAME_USERDEF), EE_PARA_XMLATTRIBS, &getCppuType((const uno::Reference< container::XNameContainer >*)0), 0, 0}, |
| {0,0,0,0,0,0} |
| }; |
| return aEditPropertyMap_Impl; |
| } |
| const SvxItemPropertySet* lcl_GetEditPropertySet() |
| { |
| static SvxItemPropertySet aEditPropertySet( lcl_GetEditPropertyMap(), SdrObject::GetGlobalDrawObjectItemPool() ); |
| return &aEditPropertySet; |
| } |
| |
| |
| //------------------------------------------------------------------------ |
| |
| //! 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 SCPARAPROPERTIES_SERVICE "com.sun.star.style.ParagraphProperties" |
| #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( ScUniqueCellFormatsEnumeration, "ScUniqueCellFormatsEnumeration", "com.sun.star.sheet.UniqueCellFormatRangesEnumeration" ) |
| SC_SIMPLE_SERVICE_INFO( ScUniqueCellFormatsObj, "ScUniqueCellFormatsObj", "com.sun.star.sheet.UniqueCellFormatRanges" ) |
| 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( XModifyListenerArr_Impl, XModifyListenerPtr ); |
| SV_IMPL_PTRARR( ScNamedEntryArr_Impl, ScNamedEntryPtr ); |
| |
| //------------------------------------------------------------------------ |
| |
| //! ScLinkListener in anderes File verschieben !!! |
| |
| ScLinkListener::~ScLinkListener() |
| { |
| } |
| |
| void ScLinkListener::Notify( SvtBroadcaster&, const SfxHint& rHint ) |
| { |
| aLink.Call( (SfxHint*)&rHint ); |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| void lcl_CopyProperties( beans::XPropertySet& rDest, beans::XPropertySet& rSource ) |
| { |
| uno::Reference<beans::XPropertySetInfo> xInfo(rSource.getPropertySetInfo()); |
| if (xInfo.is()) |
| { |
| uno::Sequence<beans::Property> aSeq(xInfo->getProperties()); |
| const beans::Property* pAry = aSeq.getConstArray(); |
| sal_uLong nCount = aSeq.getLength(); |
| for (sal_uLong i=0; i<nCount; i++) |
| { |
| rtl::OUString aName(pAry[i].Name); |
| rDest.setPropertyValue( aName, rSource.getPropertyValue( aName ) ); |
| } |
| } |
| } |
| |
| SCTAB lcl_FirstTab( const ScRangeList& rRanges ) |
| { |
| 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 |
| } |
| |
| sal_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 sal_True; |
| } |
| return sal_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* ScHelperFunctions::GetBorderLine( SvxBorderLine& rLine, const table::BorderLine& rStruct ) |
| { |
| // Calc braucht Twips, im Uno-Struct sind 1/100mm |
| |
| rLine.SetOutWidth( (sal_uInt16)HMMToTwips( rStruct.OuterLineWidth ) ); |
| rLine.SetInWidth( (sal_uInt16)HMMToTwips( rStruct.InnerLineWidth ) ); |
| rLine.SetDistance( (sal_uInt16)HMMToTwips( rStruct.LineDistance ) ); |
| rLine.SetColor( ColorData( rStruct.Color ) ); |
| |
| if ( rLine.GetOutWidth() || rLine.GetInWidth() || rLine.GetDistance() ) |
| return &rLine; |
| else |
| return NULL; |
| } |
| |
| void ScHelperFunctions::FillBoxItems( SvxBoxItem& rOuter, SvxBoxInfoItem& rInner, const table::TableBorder& rBorder ) |
| { |
| SvxBorderLine aLine; |
| rOuter.SetDistance( (sal_uInt16)HMMToTwips( rBorder.Distance ) ); |
| rOuter.SetLine( ScHelperFunctions::GetBorderLine( aLine, rBorder.TopLine ), BOX_LINE_TOP ); |
| rOuter.SetLine( ScHelperFunctions::GetBorderLine( aLine, rBorder.BottomLine ), BOX_LINE_BOTTOM ); |
| rOuter.SetLine( ScHelperFunctions::GetBorderLine( aLine, rBorder.LeftLine ), BOX_LINE_LEFT ); |
| rOuter.SetLine( ScHelperFunctions::GetBorderLine( aLine, rBorder.RightLine ), BOX_LINE_RIGHT ); |
| rInner.SetLine( ScHelperFunctions::GetBorderLine( aLine, rBorder.HorizontalLine ), BOXINFO_LINE_HORI ); |
| rInner.SetLine( ScHelperFunctions::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( sal_True ); |
| } |
| |
| void ScHelperFunctions::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 ScHelperFunctions::FillTableBorder( table::TableBorder& rBorder, |
| const SvxBoxItem& rOuter, const SvxBoxInfoItem& rInner ) |
| { |
| ScHelperFunctions::FillBorderLine( rBorder.TopLine, rOuter.GetTop() ); |
| ScHelperFunctions::FillBorderLine( rBorder.BottomLine, rOuter.GetBottom() ); |
| ScHelperFunctions::FillBorderLine( rBorder.LeftLine, rOuter.GetLeft() ); |
| ScHelperFunctions::FillBorderLine( rBorder.RightLine, rOuter.GetRight() ); |
| ScHelperFunctions::FillBorderLine( rBorder.HorizontalLine, rInner.GetHori() ); |
| ScHelperFunctions::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 ScHelperFunctions::ApplyBorder( ScDocShell* pDocShell, const ScRangeList& rRanges, |
| const SvxBoxItem& rOuter, const SvxBoxInfoItem& rInner ) |
| { |
| ScDocument* pDoc = pDocShell->GetDocument(); |
| sal_Bool bUndo(pDoc->IsUndoEnabled()); |
| ScDocument* pUndoDoc = NULL; |
| if (bUndo) |
| pUndoDoc = new ScDocument( SCDOCMODE_UNDO ); |
| sal_uLong nCount = rRanges.Count(); |
| sal_uLong i; |
| for (i=0; i<nCount; i++) |
| { |
| ScRange aRange(*rRanges.GetObject(i)); |
| SCTAB nTab = aRange.aStart.Tab(); |
| |
| if (bUndo) |
| { |
| if ( i==0 ) |
| pUndoDoc->InitUndo( pDoc, nTab, nTab ); |
| else |
| pUndoDoc->AddUndoTab( nTab, nTab ); |
| pDoc->CopyToDocument( aRange, IDF_ATTRIB, sal_False, pUndoDoc ); |
| } |
| |
| ScMarkData aMark; |
| aMark.SetMarkArea( aRange ); |
| aMark.SelectTable( nTab, sal_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; i<nCount; i++) |
| pDocShell->PostPaint( *rRanges.GetObject(i), PAINT_GRID, SC_PF_LINES | SC_PF_TESTMERGE ); |
| |
| pDocShell->SetDocumentModified(); |
| } |
| |
| //! move lcl_PutDataArray to docfunc? |
| //! merge loop with ScFunctionAccess::callFunction |
| |
| sal_Bool lcl_PutDataArray( ScDocShell& rDocShell, const ScRange& rRange, |
| const uno::Sequence< uno::Sequence<uno::Any> >& aData ) |
| { |
| // sal_Bool bApi = sal_True; |
| |
| ScDocument* pDoc = rDocShell.GetDocument(); |
| SCTAB nTab = rRange.aStart.Tab(); |
| SCCOL nStartCol = rRange.aStart.Col(); |
| SCROW nStartRow = rRange.aStart.Row(); |
| SCCOL nEndCol = rRange.aEnd.Col(); |
| SCROW nEndRow = rRange.aEnd.Row(); |
| sal_Bool bUndo(pDoc->IsUndoEnabled()); |
| |
| if ( !pDoc->IsBlockEditable( nTab, nStartCol,nStartRow, nEndCol,nEndRow ) ) |
| { |
| //! error message |
| return sal_False; |
| } |
| |
| long nCols = 0; |
| long nRows = aData.getLength(); |
| const uno::Sequence<uno::Any>* pArray = aData.getConstArray(); |
| if ( nRows ) |
| nCols = pArray[0].getLength(); |
| |
| if ( nCols != nEndCol-nStartCol+1 || nRows != nEndRow-nStartRow+1 ) |
| { |
| //! error message? |
| return sal_False; |
| } |
| |
| ScDocument* pUndoDoc = NULL; |
| if ( bUndo ) |
| { |
| pUndoDoc = new ScDocument( SCDOCMODE_UNDO ); |
| pUndoDoc->InitUndo( pDoc, nTab, nTab ); |
| pDoc->CopyToDocument( rRange, IDF_CONTENTS|IDF_NOCAPTIONS, sal_False, pUndoDoc ); |
| } |
| |
| pDoc->DeleteAreaTab( nStartCol, nStartRow, nEndCol, nEndRow, nTab, IDF_CONTENTS ); |
| |
| /* #164410# Use double allocation, which will speed up import filters |
| using XCellRangeData::setDataArray() significantly. */ |
| bool bDoubleAlloc = ScColumn::bDoubleAlloc; |
| ScColumn::bDoubleAlloc = true; |
| |
| sal_Bool bError = sal_False; |
| SCROW nDocRow = nStartRow; |
| for (long nRow=0; nRow<nRows; nRow++) |
| { |
| const uno::Sequence<uno::Any>& rColSeq = pArray[nRow]; |
| if ( rColSeq.getLength() == nCols ) |
| { |
| SCCOL nDocCol = nStartCol; |
| const uno::Any* pColArr = rColSeq.getConstArray(); |
| for (long nCol=0; nCol<nCols; nCol++) |
| { |
| const uno::Any& rElement = pColArr[nCol]; |
| switch( rElement.getValueTypeClass() ) |
| { |
| case uno::TypeClass_VOID: |
| { |
| // void = "no value" |
| pDoc->SetError( nDocCol, nDocRow, nTab, NOTAVAILABLE ); |
| } |
| break; |
| |
| // #87871# accept integer types because Basic passes a floating point |
| // variable as byte, short or long if it's an integer number. |
| case uno::TypeClass_BYTE: |
| case uno::TypeClass_SHORT: |
| case uno::TypeClass_UNSIGNED_SHORT: |
| case uno::TypeClass_LONG: |
| case uno::TypeClass_UNSIGNED_LONG: |
| case uno::TypeClass_FLOAT: |
| case uno::TypeClass_DOUBLE: |
| { |
| double fVal(0.0); |
| rElement >>= fVal; |
| pDoc->SetValue( nDocCol, nDocRow, nTab, fVal ); |
| } |
| break; |
| |
| case uno::TypeClass_STRING: |
| { |
| rtl::OUString aUStr; |
| rElement >>= aUStr; |
| if ( aUStr.getLength() ) |
| pDoc->PutCell( nDocCol, nDocRow, nTab, new ScStringCell( aUStr ) ); |
| } |
| break; |
| |
| // accept Sequence<FormulaToken> for formula cells |
| case uno::TypeClass_SEQUENCE: |
| { |
| uno::Sequence< sheet::FormulaToken > aTokens; |
| if ( rElement >>= aTokens ) |
| { |
| ScTokenArray aTokenArray; |
| ScTokenConversion::ConvertToTokenArray( *pDoc, aTokenArray, aTokens ); |
| ScAddress aPos( nDocCol, nDocRow, nTab ); |
| ScBaseCell* pNewCell = new ScFormulaCell( pDoc, aPos, &aTokenArray ); |
| pDoc->PutCell( aPos, pNewCell ); |
| } |
| else |
| bError = true; |
| } |
| break; |
| |
| default: |
| bError = true; // invalid type |
| } |
| |
| ++nDocCol; |
| } |
| } |
| else |
| bError = sal_True; // wrong size |
| |
| ++nDocRow; |
| } |
| ScColumn::bDoubleAlloc = bDoubleAlloc; |
| |
| sal_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, sal_False ) ); |
| } |
| |
| if (!bHeight) |
| rDocShell.PostPaint( rRange, PAINT_GRID ); // AdjustRowHeight may have painted already |
| |
| rDocShell.SetDocumentModified(); |
| |
| return !bError; |
| } |
| |
| sal_Bool lcl_PutFormulaArray( ScDocShell& rDocShell, const ScRange& rRange, |
| const uno::Sequence< uno::Sequence<rtl::OUString> >& aData, |
| const ::rtl::OUString& rFormulaNmsp, const formula::FormulaGrammar::Grammar eGrammar ) |
| { |
| // sal_Bool bApi = sal_True; |
| |
| ScDocument* pDoc = rDocShell.GetDocument(); |
| SCTAB nTab = rRange.aStart.Tab(); |
| SCCOL nStartCol = rRange.aStart.Col(); |
| SCROW nStartRow = rRange.aStart.Row(); |
| SCCOL nEndCol = rRange.aEnd.Col(); |
| SCROW nEndRow = rRange.aEnd.Row(); |
| sal_Bool bUndo(pDoc->IsUndoEnabled()); |
| |
| if ( !pDoc->IsBlockEditable( nTab, nStartCol,nStartRow, nEndCol,nEndRow ) ) |
| { |
| //! error message |
| return sal_False; |
| } |
| |
| long nCols = 0; |
| long nRows = aData.getLength(); |
| const uno::Sequence<rtl::OUString>* pArray = aData.getConstArray(); |
| if ( nRows ) |
| nCols = pArray[0].getLength(); |
| |
| if ( nCols != nEndCol-nStartCol+1 || nRows != nEndRow-nStartRow+1 ) |
| { |
| //! error message? |
| return sal_False; |
| } |
| |
| ScDocument* pUndoDoc = NULL; |
| if ( bUndo ) |
| { |
| pUndoDoc = new ScDocument( SCDOCMODE_UNDO ); |
| pUndoDoc->InitUndo( pDoc, nTab, nTab ); |
| pDoc->CopyToDocument( rRange, IDF_CONTENTS, sal_False, pUndoDoc ); |
| } |
| |
| pDoc->DeleteAreaTab( nStartCol, nStartRow, nEndCol, nEndRow, nTab, IDF_CONTENTS ); |
| |
| ScDocFunc aFunc( rDocShell ); // for InterpretEnglishString |
| |
| sal_Bool bError = sal_False; |
| SCROW nDocRow = nStartRow; |
| for (long nRow=0; nRow<nRows; nRow++) |
| { |
| const uno::Sequence<rtl::OUString>& rColSeq = pArray[nRow]; |
| if ( rColSeq.getLength() == nCols ) |
| { |
| SCCOL nDocCol = nStartCol; |
| const rtl::OUString* pColArr = rColSeq.getConstArray(); |
| for (long nCol=0; nCol<nCols; nCol++) |
| { |
| String aText(pColArr[nCol]); |
| ScAddress aPos( nDocCol, nDocRow, nTab ); |
| ScBaseCell* pNewCell = aFunc.InterpretEnglishString( aPos, aText, rFormulaNmsp, eGrammar ); |
| pDoc->PutCell( aPos, pNewCell ); |
| |
| ++nDocCol; |
| } |
| } |
| else |
| bError = sal_True; // wrong size |
| |
| ++nDocRow; |
| } |
| |
| sal_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, sal_False ) ); |
| } |
| |
| if (!bHeight) |
| rDocShell.PostPaint( rRange, PAINT_GRID ); // AdjustRowHeight may have painted already |
| |
| rDocShell.SetDocumentModified(); |
| |
| return !bError; |
| } |
| |
| // used in ScCellRangeObj::getFormulaArray and ScCellObj::GetInputString_Impl |
| String lcl_GetInputString( ScDocument* pDoc, const ScAddress& rPosition, sal_Bool bEnglish ) |
| { |
| String aVal; |
| if ( pDoc ) |
| { |
| ScBaseCell* pCell = pDoc->GetCell( rPosition ); |
| if ( pCell && pCell->GetCellType() != CELLTYPE_NOTE ) |
| { |
| CellType eType = pCell->GetCellType(); |
| if ( eType == CELLTYPE_FORMULA ) |
| { |
| ScFormulaCell* pForm = (ScFormulaCell*)pCell; |
| pForm->GetFormula( aVal,formula::FormulaGrammar::mapAPItoGrammar( bEnglish, false)); |
| } |
| else |
| { |
| SvNumberFormatter* pFormatter = bEnglish ? ScGlobal::GetEnglishFormatter() : |
| pDoc->GetFormatTable(); |
| // Since the English formatter was constructed with |
| // LANGUAGE_ENGLISH_US the "General" format has index key 0, |
| // we don't have to query. |
| sal_uInt32 nNumFmt = bEnglish ? |
| // pFormatter->GetStandardIndex(LANGUAGE_ENGLISH_US) : |
| 0 : |
| pDoc->GetNumberFormat( rPosition ); |
| |
| 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; |
| sal_Bool bIsNumberFormat(pFormatter->IsNumberFormat(aVal, nNumFmt, fDummy)); |
| if ( bIsNumberFormat ) |
| aVal.Insert('\'',0); |
| else if ( aVal.Len() && aVal.GetChar(0) == '\'' ) |
| { |
| // if the string starts with a "'", add another one because setFormula |
| // strips one (like text input, except for "text" number formats) |
| if ( bEnglish || ( pFormatter->GetType(nNumFmt) != NUMBERFORMAT_TEXT ) ) |
| aVal.Insert('\'',0); |
| } |
| } |
| } |
| } |
| } |
| return aVal; |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| // Default-ctor fuer SMART_REFLECTION Krempel |
| ScCellRangesBase::ScCellRangesBase() : |
| pPropSet(lcl_GetCellsPropertySet()), |
| pDocShell( NULL ), |
| pValueListener( NULL ), |
| pCurrentFlat( NULL ), |
| pCurrentDeep( NULL ), |
| pCurrentDataSet( NULL ), |
| pNoDfltCurrentDataSet( NULL ), |
| pMarkData( NULL ), |
| nObjectId( 0 ), |
| bChartColAsHdr( sal_False ), |
| bChartRowAsHdr( sal_False ), |
| bCursorOnly( sal_False ), |
| bGotDataChangedHint( sal_False ), |
| aValueListeners( 0 ) |
| { |
| } |
| |
| ScCellRangesBase::ScCellRangesBase(ScDocShell* pDocSh, const ScRange& rR) : |
| pPropSet(lcl_GetCellsPropertySet()), |
| pDocShell( pDocSh ), |
| pValueListener( NULL ), |
| pCurrentFlat( NULL ), |
| pCurrentDeep( NULL ), |
| pCurrentDataSet( NULL ), |
| pNoDfltCurrentDataSet( NULL ), |
| pMarkData( NULL ), |
| nObjectId( 0 ), |
| bChartColAsHdr( sal_False ), |
| bChartRowAsHdr( sal_False ), |
| bCursorOnly( sal_False ), |
| bGotDataChangedHint( sal_False ), |
| aValueListeners( 0 ) |
| { |
| ScRange aCellRange(rR); |
| aCellRange.Justify(); |
| aRanges.Append( aCellRange ); |
| |
| if (pDocShell) // Null if created with createInstance |
| { |
| ScDocument* pDoc = pDocShell->GetDocument(); |
| pDoc->AddUnoObject(*this); |
| nObjectId = pDoc->GetNewUnoId(); |
| } |
| } |
| |
| ScCellRangesBase::ScCellRangesBase(ScDocShell* pDocSh, const ScRangeList& rR) : |
| pPropSet(lcl_GetCellsPropertySet()), |
| pDocShell( pDocSh ), |
| pValueListener( NULL ), |
| pCurrentFlat( NULL ), |
| pCurrentDeep( NULL ), |
| pCurrentDataSet( NULL ), |
| pNoDfltCurrentDataSet( NULL ), |
| pMarkData( NULL ), |
| aRanges( rR ), |
| nObjectId( 0 ), |
| bChartColAsHdr( sal_False ), |
| bChartRowAsHdr( sal_False ), |
| bCursorOnly( sal_False ), |
| bGotDataChangedHint( sal_False ), |
| aValueListeners( 0 ) |
| { |
| if (pDocShell) // Null if created with createInstance |
| { |
| ScDocument* pDoc = pDocShell->GetDocument(); |
| pDoc->AddUnoObject(*this); |
| nObjectId = pDoc->GetNewUnoId(); |
| } |
| } |
| |
| ScCellRangesBase::~ScCellRangesBase() |
| { |
| // #107294# call RemoveUnoObject first, so no notification can happen |
| // during ForgetCurrentAttrs |
| |
| if (pDocShell) |
| pDocShell->GetDocument()->RemoveUnoObject(*this); |
| |
| ForgetCurrentAttrs(); |
| ForgetMarkData(); |
| |
| delete pValueListener; |
| |
| //! XChartDataChangeEventListener abmelden ?? |
| //! (ChartCollection haelt dann auch dieses Objekt fest!) |
| } |
| |
| void ScCellRangesBase::ForgetCurrentAttrs() |
| { |
| delete pCurrentFlat; |
| delete pCurrentDeep; |
| delete pCurrentDataSet; |
| delete pNoDfltCurrentDataSet; |
| pCurrentFlat = NULL; |
| pCurrentDeep = NULL; |
| pCurrentDataSet = NULL; |
| pNoDfltCurrentDataSet = NULL; |
| |
| // #i62483# pMarkData can remain unchanged, is deleted only if the range changes (RefChanged) |
| } |
| |
| void ScCellRangesBase::ForgetMarkData() |
| { |
| delete pMarkData; |
| pMarkData = NULL; |
| } |
| |
| const ScPatternAttr* ScCellRangesBase::GetCurrentAttrsFlat() |
| { |
| // get and cache direct cell attributes for this object's range |
| |
| if ( !pCurrentFlat && pDocShell ) |
| { |
| ScDocument* pDoc = pDocShell->GetDocument(); |
| pCurrentFlat = pDoc->CreateSelectionPattern( *GetMarkData(), sal_False ); |
| } |
| return pCurrentFlat; |
| } |
| |
| const ScPatternAttr* ScCellRangesBase::GetCurrentAttrsDeep() |
| { |
| // get and cache cell attributes (incl. styles) for this object's range |
| |
| if ( !pCurrentDeep && pDocShell ) |
| { |
| ScDocument* pDoc = pDocShell->GetDocument(); |
| pCurrentDeep = pDoc->CreateSelectionPattern( *GetMarkData(), sal_True ); |
| } |
| return pCurrentDeep; |
| } |
| |
| SfxItemSet* ScCellRangesBase::GetCurrentDataSet(bool bNoDflt) |
| { |
| if(!pCurrentDataSet) |
| { |
| const ScPatternAttr* pPattern = GetCurrentAttrsDeep(); |
| if ( pPattern ) |
| { |
| // Dontcare durch Default ersetzen, damit man immer eine Reflection hat |
| pCurrentDataSet = new SfxItemSet( pPattern->GetItemSet() ); |
| pNoDfltCurrentDataSet = new SfxItemSet( pPattern->GetItemSet() ); |
| pCurrentDataSet->ClearInvalidItems(); |
| } |
| } |
| return bNoDflt ? pNoDfltCurrentDataSet : pCurrentDataSet; |
| } |
| |
| const ScMarkData* ScCellRangesBase::GetMarkData() |
| { |
| if (!pMarkData) |
| { |
| pMarkData = new ScMarkData(); |
| pMarkData->MarkFromRangeList( aRanges, sal_False ); |
| } |
| return pMarkData; |
| } |
| |
| void ScCellRangesBase::Notify( SfxBroadcaster&, const SfxHint& rHint ) |
| { |
| if ( rHint.ISA( ScUpdateRefHint ) ) |
| { |
| const ScUpdateRefHint& rRef = (const ScUpdateRefHint&)rHint; |
| |
| ScDocument* pDoc = pDocShell->GetDocument(); |
| ScRangeList* pUndoRanges = NULL; |
| if ( pDoc->HasUnoRefUndo() ) |
| pUndoRanges = new ScRangeList( aRanges ); |
| |
| if ( aRanges.UpdateReference( rRef.GetMode(), pDoc, rRef.GetRange(), |
| rRef.GetDx(), rRef.GetDy(), rRef.GetDz() ) ) |
| { |
| if (rRef.GetMode() == URM_INSDEL && |
| aRanges.Count() == 1 && |
| ScTableSheetObj::getImplementation( (cppu::OWeakObject*)this )) |
| { |
| // #101755#; the range size of a sheet does not change |
| ScRange* pR = aRanges.First(); |
| if (pR) |
| { |
| pR->aStart.SetCol(0); |
| pR->aStart.SetRow(0); |
| pR->aEnd.SetCol(MAXCOL); |
| pR->aEnd.SetRow(MAXROW); |
| } |
| } |
| RefChanged(); |
| |
| // #129050# any change of the range address is broadcast to value (modify) listeners |
| if ( aValueListeners.Count() ) |
| bGotDataChangedHint = sal_True; |
| |
| if ( pUndoRanges ) |
| pDoc->AddUnoRefChange( nObjectId, *pUndoRanges ); |
| } |
| |
| delete pUndoRanges; |
| } |
| else if ( rHint.ISA( SfxSimpleHint ) ) |
| { |
| sal_uLong nId = ((const SfxSimpleHint&)rHint).GetId(); |
| if ( nId == SFX_HINT_DYING ) |
| { |
| ForgetCurrentAttrs(); |
| pDocShell = NULL; // invalid |
| |
| if ( aValueListeners.Count() != 0 ) |
| { |
| // dispose listeners |
| |
| lang::EventObject aEvent; |
| aEvent.Source.set(static_cast<cppu::OWeakObject*>(this)); |
| for ( sal_uInt16 n=0; n<aValueListeners.Count(); n++ ) |
| (*aValueListeners[n])->disposing( aEvent ); |
| |
| aValueListeners.DeleteAndDestroy( 0, aValueListeners.Count() ); |
| |
| // The listeners can't have the last ref to this, as it's still held |
| // by the DocShell. |
| } |
| } |
| else if ( nId == SFX_HINT_DATACHANGED ) |
| { |
| // document content changed -> forget cached attributes |
| ForgetCurrentAttrs(); |
| |
| if ( bGotDataChangedHint && pDocShell ) |
| { |
| // This object was notified of content changes, so one call |
| // for each listener is generated now. |
| // The calls can't be executed directly because the document's |
| // UNO broadcaster list must not be modified. |
| // Instead, add to the document's list of listener calls, |
| // which will be executed directly after the broadcast of |
| // SFX_HINT_DATACHANGED. |
| |
| lang::EventObject aEvent; |
| aEvent.Source.set((cppu::OWeakObject*)this); |
| |
| // the EventObject holds a Ref to this object until after the listener calls |
| |
| ScDocument* pDoc = pDocShell->GetDocument(); |
| for ( sal_uInt16 n=0; n<aValueListeners.Count(); n++ ) |
| pDoc->AddUnoListenerCall( *aValueListeners[n], aEvent ); |
| |
| bGotDataChangedHint = sal_False; |
| } |
| } |
| else if ( nId == SC_HINT_CALCALL ) |
| { |
| // broadcast from DoHardRecalc - set bGotDataChangedHint |
| // (SFX_HINT_DATACHANGED follows separately) |
| |
| if ( aValueListeners.Count() ) |
| bGotDataChangedHint = sal_True; |
| } |
| } |
| else if ( rHint.ISA( ScUnoRefUndoHint ) ) |
| { |
| const ScUnoRefUndoHint& rUndoHint = static_cast<const ScUnoRefUndoHint&>(rHint); |
| if ( rUndoHint.GetObjectId() == nObjectId ) |
| { |
| // restore ranges from hint |
| |
| aRanges = rUndoHint.GetRanges(); |
| |
| RefChanged(); |
| if ( aValueListeners.Count() ) |
| bGotDataChangedHint = sal_True; // need to broadcast the undo, too |
| } |
| } |
| } |
| |
| void ScCellRangesBase::RefChanged() |
| { |
| //! adjust XChartDataChangeEventListener |
| |
| if ( pValueListener && aValueListeners.Count() != 0 ) |
| { |
| pValueListener->EndListeningAll(); |
| |
| ScDocument* pDoc = pDocShell->GetDocument(); |
| sal_uLong nCount = aRanges.Count(); |
| for (sal_uLong i=0; i<nCount; i++) |
| pDoc->StartListeningArea( *aRanges.GetObject(i), pValueListener ); |
| } |
| |
| ForgetCurrentAttrs(); |
| ForgetMarkData(); |
| } |
| |
| 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::AddRange(const ScRange& rRange, const sal_Bool bMergeRanges) |
| { |
| if (bMergeRanges) |
| aRanges.Join(rRange); |
| else |
| aRanges.Append(rRange); |
| RefChanged(); |
| } |
| |
| 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(); |
| } |
| |
| void ScCellRangesBase::SetCursorOnly( sal_Bool bSet ) |
| { |
| // set for a selection object that is created from the cursor position |
| // without anything selected (may contain several sheets) |
| |
| bCursorOnly = bSet; |
| } |
| |
| uno::Any SAL_CALL ScCellRangesBase::queryInterface( const uno::Type& rType ) |
| throw(uno::RuntimeException) |
| { |
| SC_QUERYINTERFACE( beans::XPropertySet ) |
| SC_QUERYINTERFACE( beans::XMultiPropertySet ) |
| SC_QUERYINTERFACE( beans::XTolerantMultiPropertySet ) |
| 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( util::XModifyBroadcaster ) |
| SC_QUERYINTERFACE( lang::XServiceInfo ) |
| SC_QUERYINTERFACE( lang::XUnoTunnel ) |
| SC_QUERYINTERFACE( lang::XTypeProvider ) |
| |
| return OWeakObject::queryInterface( rType ); |
| } |
| |
| void SAL_CALL ScCellRangesBase::acquire() throw() |
| { |
| OWeakObject::acquire(); |
| } |
| |
| void SAL_CALL ScCellRangesBase::release() throw() |
| { |
| OWeakObject::release(); |
| } |
| |
| uno::Sequence<uno::Type> SAL_CALL ScCellRangesBase::getTypes() throw(uno::RuntimeException) |
| { |
| static uno::Sequence<uno::Type> aTypes; |
| if ( aTypes.getLength() == 0 ) |
| { |
| aTypes.realloc(13); |
| uno::Type* pPtr = aTypes.getArray(); |
| pPtr[0] = getCppuType((const uno::Reference<beans::XPropertySet>*)0); |
| pPtr[1] = getCppuType((const uno::Reference<beans::XMultiPropertySet>*)0); |
| pPtr[2] = getCppuType((const uno::Reference<beans::XPropertyState>*)0); |
| pPtr[3] = getCppuType((const uno::Reference<sheet::XSheetOperation>*)0); |
| pPtr[4] = getCppuType((const uno::Reference<chart::XChartDataArray>*)0); |
| pPtr[5] = getCppuType((const uno::Reference<util::XIndent>*)0); |
| pPtr[6] = getCppuType((const uno::Reference<sheet::XCellRangesQuery>*)0); |
| pPtr[7] = getCppuType((const uno::Reference<sheet::XFormulaQuery>*)0); |
| pPtr[8] = getCppuType((const uno::Reference<util::XReplaceable>*)0); |
| pPtr[9] = getCppuType((const uno::Reference<util::XModifyBroadcaster>*)0); |
| pPtr[10]= getCppuType((const uno::Reference<lang::XServiceInfo>*)0); |
| pPtr[11]= getCppuType((const uno::Reference<lang::XUnoTunnel>*)0); |
| pPtr[12]= getCppuType((const uno::Reference<lang::XTypeProvider>*)0); |
| } |
| return aTypes; |
| } |
| |
| uno::Sequence<sal_Int8> 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( sal_uInt16 nPart ) |
| { |
| sal_uLong nCount = aRanges.Count(); |
| for (sal_uLong i=0; i<nCount; i++) |
| pDocShell->PostPaint( *aRanges.GetObject(i), nPart ); |
| } |
| |
| // XSheetOperation |
| |
| double SAL_CALL ScCellRangesBase::computeFunction( sheet::GeneralFunction nFunction ) |
| throw(uno::Exception, uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScMarkData aMark(*GetMarkData()); |
| aMark.MarkToSimple(); |
| if (!aMark.IsMarked()) |
| aMark.SetMarkNegative(sal_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() ) |
| { |
| // only for clearContents: EDITATTR is only used if no contents are deleted |
| sal_uInt16 nDelFlags = static_cast< sal_uInt16 >( nContentFlags & IDF_ALL ); |
| if ( ( nContentFlags & IDF_EDITATTR ) && ( nContentFlags & IDF_CONTENTS ) == 0 ) |
| nDelFlags |= IDF_EDITATTR; |
| |
| ScDocFunc aFunc(*pDocShell); |
| aFunc.DeleteContents( *GetMarkData(), nDelFlags, sal_True, sal_True ); |
| } |
| // sonst ist nichts zu tun |
| } |
| |
| // XPropertyState |
| |
| const SfxItemPropertyMap* ScCellRangesBase::GetItemPropertyMap() |
| { |
| return pPropSet->getPropertyMap(); |
| } |
| |
| void lcl_GetPropertyWhich( const SfxItemPropertySimpleEntry* pEntry, |
| sal_uInt16& rItemWhich ) |
| { |
| // Which-ID des betroffenen Items, auch wenn das Item die Property |
| // nicht alleine behandeln kann |
| if ( pEntry ) |
| { |
| if ( IsScItemWid( pEntry->nWID ) ) |
| rItemWhich = pEntry->nWID; |
| else |
| switch ( pEntry->nWID ) |
| { |
| case SC_WID_UNO_TBLBORD: |
| rItemWhich = ATTR_BORDER; |
| break; |
| case SC_WID_UNO_CONDFMT: |
| case SC_WID_UNO_CONDLOC: |
| case SC_WID_UNO_CONDXML: |
| rItemWhich = ATTR_CONDITIONAL; |
| break; |
| case SC_WID_UNO_VALIDAT: |
| case SC_WID_UNO_VALILOC: |
| case SC_WID_UNO_VALIXML: |
| rItemWhich = ATTR_VALIDDATA; |
| break; |
| } |
| } |
| |
| } |
| |
| beans::PropertyState ScCellRangesBase::GetOnePropertyState( sal_uInt16 nItemWhich, const SfxItemPropertySimpleEntry* pEntry ) |
| { |
| beans::PropertyState eRet = beans::PropertyState_DIRECT_VALUE; |
| if ( nItemWhich ) // item wid (from map or special case) |
| { |
| // For items that contain several properties (like background), |
| // "ambiguous" is returned too often here |
| |
| // for PropertyState, don't look at styles |
| const ScPatternAttr* pPattern = GetCurrentAttrsFlat(); |
| if ( pPattern ) |
| { |
| SfxItemState eState = pPattern->GetItemSet().GetItemState( nItemWhich, sal_False ); |
| |
| // // if no rotate value is set, look at orientation |
| // //! also for a fixed value of 0 (in case orientation is ambiguous)? |
| // if ( nItemWhich == ATTR_ROTATE_VALUE && eState == SFX_ITEM_DEFAULT ) |
| // eState = pPattern->GetItemSet().GetItemState( ATTR_ORIENTATION, sal_False ); |
| |
| if ( nItemWhich == ATTR_VALUE_FORMAT && eState == SFX_ITEM_DEFAULT ) |
| eState = pPattern->GetItemSet().GetItemState( ATTR_LANGUAGE_FORMAT, sal_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 ( pEntry ) |
| { |
| if ( pEntry->nWID == SC_WID_UNO_CHCOLHDR || pEntry->nWID == SC_WID_UNO_CHROWHDR || pEntry->nWID == SC_WID_UNO_ABSNAME ) |
| eRet = beans::PropertyState_DIRECT_VALUE; |
| else if ( pEntry->nWID == SC_WID_UNO_CELLSTYL ) |
| { |
| // a style is always set, there's no default state |
| const ScStyleSheet* pStyle = pDocShell->GetDocument()->GetSelectionStyle(*GetMarkData()); |
| if (pStyle) |
| eRet = beans::PropertyState_DIRECT_VALUE; |
| else |
| eRet = beans::PropertyState_AMBIGUOUS_VALUE; |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_NUMRULES ) |
| eRet = beans::PropertyState_DEFAULT_VALUE; // numbering rules are always default |
| } |
| return eRet; |
| } |
| |
| beans::PropertyState SAL_CALL ScCellRangesBase::getPropertyState( const rtl::OUString& aPropertyName ) |
| throw(beans::UnknownPropertyException, uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| if ( aRanges.Count() == 0 ) |
| throw uno::RuntimeException(); |
| |
| const SfxItemPropertyMap* pMap = GetItemPropertyMap(); // from derived class |
| sal_uInt16 nItemWhich = 0; |
| const SfxItemPropertySimpleEntry* pEntry = pMap->getByName( aPropertyName ); |
| lcl_GetPropertyWhich( pEntry, nItemWhich ); |
| return GetOnePropertyState( nItemWhich, pEntry ); |
| } |
| |
| uno::Sequence<beans::PropertyState> SAL_CALL ScCellRangesBase::getPropertyStates( |
| const uno::Sequence<rtl::OUString>& aPropertyNames ) |
| throw(beans::UnknownPropertyException, uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| |
| const SfxItemPropertyMap* pPropertyMap = GetItemPropertyMap(); // from derived class |
| |
| uno::Sequence<beans::PropertyState> aRet(aPropertyNames.getLength()); |
| beans::PropertyState* pStates = aRet.getArray(); |
| for(sal_Int32 i = 0; i < aPropertyNames.getLength(); i++) |
| { |
| sal_uInt16 nItemWhich = 0; |
| const SfxItemPropertySimpleEntry* pEntry = pPropertyMap->getByName( aPropertyNames[i] ); |
| lcl_GetPropertyWhich( pEntry, nItemWhich ); |
| pStates[i] = GetOnePropertyState(nItemWhich, pEntry); |
| } |
| return aRet; |
| } |
| |
| void SAL_CALL ScCellRangesBase::setPropertyToDefault( const rtl::OUString& aPropertyName ) |
| throw(beans::UnknownPropertyException, uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| if ( pDocShell ) |
| { |
| const SfxItemPropertyMap* pPropertyMap = GetItemPropertyMap(); // from derived class |
| sal_uInt16 nItemWhich = 0; |
| const SfxItemPropertySimpleEntry* pEntry = pPropertyMap->getByName( aPropertyName ); |
| lcl_GetPropertyWhich( pEntry, nItemWhich ); |
| if ( nItemWhich ) // item wid (from map or special case) |
| { |
| if ( aRanges.Count() ) // leer = nichts zu tun |
| { |
| ScDocFunc aFunc(*pDocShell); |
| |
| //! Bei Items, die mehrere Properties enthalten (z.B. Hintergrund) |
| //! wird hier zuviel zurueckgesetzt |
| |
| // //! for ATTR_ROTATE_VALUE, also reset ATTR_ORIENTATION? |
| |
| sal_uInt16 aWIDs[3]; |
| aWIDs[0] = nItemWhich; |
| if ( nItemWhich == ATTR_VALUE_FORMAT ) |
| { |
| aWIDs[1] = ATTR_LANGUAGE_FORMAT; // #67847# language for number formats |
| aWIDs[2] = 0; |
| } |
| else |
| aWIDs[1] = 0; |
| aFunc.ClearItems( *GetMarkData(), aWIDs, sal_True ); |
| } |
| } |
| else if ( pEntry ) |
| { |
| if ( pEntry->nWID == SC_WID_UNO_CHCOLHDR ) |
| bChartColAsHdr = sal_False; |
| else if ( pEntry->nWID == SC_WID_UNO_CHROWHDR ) |
| bChartRowAsHdr = sal_False; |
| else if ( pEntry->nWID == SC_WID_UNO_CELLSTYL ) |
| { |
| ScDocFunc aFunc(*pDocShell); |
| aFunc.ApplyStyle( *GetMarkData(), ScGlobal::GetRscString(STR_STYLENAME_STANDARD), sal_True, sal_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(); |
| const SfxItemPropertyMap* pPropertyMap = GetItemPropertyMap(); // from derived class |
| const SfxItemPropertySimpleEntry* pEntry = pPropertyMap->getByName( aPropertyName ); |
| if ( pEntry ) |
| { |
| if ( IsScItemWid( pEntry->nWID ) ) |
| { |
| const ScPatternAttr* pPattern = pDoc->GetDefPattern(); |
| if ( pPattern ) |
| { |
| const SfxItemSet& rSet = pPattern->GetItemSet(); |
| |
| switch ( pEntry->nWID ) // fuer Item-Spezial-Behandlungen |
| { |
| case ATTR_VALUE_FORMAT: |
| // default has no language set |
| aAny <<= (sal_Int32)( ((const SfxUInt32Item&)rSet.Get(pEntry->nWID)).GetValue() ); |
| break; |
| case ATTR_INDENT: |
| aAny <<= (sal_Int16)( TwipsToHMM(((const SfxUInt16Item&) |
| rSet.Get(pEntry->nWID)).GetValue()) ); |
| break; |
| default: |
| pPropSet->getPropertyValue(aPropertyName, rSet, aAny); |
| } |
| } |
| } |
| else |
| switch ( pEntry->nWID ) |
| { |
| case SC_WID_UNO_CHCOLHDR: |
| case SC_WID_UNO_CHROWHDR: |
| ScUnoHelpFunctions::SetBoolInAny( aAny, sal_False ); |
| break; |
| case SC_WID_UNO_CELLSTYL: |
| aAny <<= rtl::OUString( ScStyleNameConversion::DisplayToProgrammaticName( |
| ScGlobal::GetRscString(STR_STYLENAME_STANDARD), SFX_STYLE_FAMILY_PARA ) ); |
| break; |
| case SC_WID_UNO_TBLBORD: |
| { |
| const ScPatternAttr* pPattern = pDoc->GetDefPattern(); |
| if ( pPattern ) |
| { |
| table::TableBorder aBorder; |
| ScHelperFunctions::FillTableBorder( aBorder, |
| (const SvxBoxItem&)pPattern->GetItem(ATTR_BORDER), |
| (const SvxBoxInfoItem&)pPattern->GetItem(ATTR_BORDER_INNER) ); |
| aAny <<= aBorder; |
| } |
| } |
| break; |
| case SC_WID_UNO_CONDFMT: |
| case SC_WID_UNO_CONDLOC: |
| case SC_WID_UNO_CONDXML: |
| { |
| sal_Bool bEnglish = ( pEntry->nWID != SC_WID_UNO_CONDLOC ); |
| sal_Bool bXML = ( pEntry->nWID == SC_WID_UNO_CONDXML ); |
| formula::FormulaGrammar::Grammar eGrammar = (bXML ? |
| pDoc->GetStorageGrammar() : |
| formula::FormulaGrammar::mapAPItoGrammar( bEnglish, bXML)); |
| |
| aAny <<= uno::Reference<sheet::XSheetConditionalEntries>( |
| new ScTableConditionalFormat( pDoc, 0, eGrammar )); |
| } |
| break; |
| case SC_WID_UNO_VALIDAT: |
| case SC_WID_UNO_VALILOC: |
| case SC_WID_UNO_VALIXML: |
| { |
| sal_Bool bEnglish = ( pEntry->nWID != SC_WID_UNO_VALILOC ); |
| sal_Bool bXML = ( pEntry->nWID == SC_WID_UNO_VALIXML ); |
| formula::FormulaGrammar::Grammar eGrammar = (bXML ? |
| pDoc->GetStorageGrammar() : |
| formula::FormulaGrammar::mapAPItoGrammar( bEnglish, bXML)); |
| |
| aAny <<= uno::Reference<beans::XPropertySet>( |
| new ScTableValidationObj( pDoc, 0, eGrammar )); |
| } |
| break; |
| case SC_WID_UNO_NUMRULES: |
| { |
| aAny <<= uno::Reference<container::XIndexReplace>(ScStyleObj::CreateEmptyNumberingRules()); |
| } |
| break; |
| } |
| } |
| } |
| |
| return aAny; |
| } |
| |
| // XPropertySet |
| |
| uno::Reference<beans::XPropertySetInfo> SAL_CALL ScCellRangesBase::getPropertySetInfo() |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| static uno::Reference<beans::XPropertySetInfo> aRef( |
| new SfxItemPropertySetInfo( pPropSet->getPropertyMap() )); |
| return aRef; |
| } |
| |
| |
| void lcl_SetCellProperty( const SfxItemPropertySimpleEntry& rEntry, const uno::Any& rValue, |
| ScPatternAttr& rPattern, ScDocument* pDoc, |
| sal_uInt16& rFirstItemId, sal_uInt16& rSecondItemId ) |
| { |
| rFirstItemId = rEntry.nWID; |
| rSecondItemId = 0; |
| |
| SfxItemSet& rSet = rPattern.GetItemSet(); |
| switch ( rEntry.nWID ) |
| { |
| case ATTR_VALUE_FORMAT: |
| { |
| // #67847# language for number formats |
| SvNumberFormatter* pFormatter = pDoc->GetFormatTable(); |
| sal_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 = 0; |
| if ( rValue >>= nIntVal ) |
| { |
| sal_uLong nNewFormat = (sal_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 |
| sal_uLong nNewMod = nNewFormat % SV_COUNTRY_LANGUAGE_OFFSET; |
| if ( nNewMod == ( nOldFormat % SV_COUNTRY_LANGUAGE_OFFSET ) && |
| nNewMod <= SV_MAX_ANZ_STANDARD_FORMATE ) |
| { |
| rFirstItemId = 0; // don't use ATTR_VALUE_FORMAT value |
| } |
| |
| rSecondItemId = ATTR_LANGUAGE_FORMAT; |
| } |
| } |
| else |
| throw lang::IllegalArgumentException(); |
| } |
| break; |
| case ATTR_INDENT: |
| { |
| sal_Int16 nIntVal = 0; |
| if ( rValue >>= nIntVal ) |
| rSet.Put( SfxUInt16Item( rEntry.nWID, (sal_uInt16)HMMToTwips(nIntVal) ) ); |
| else |
| throw lang::IllegalArgumentException(); |
| } |
| break; |
| case ATTR_ROTATE_VALUE: |
| { |
| sal_Int32 nRotVal = 0; |
| if ( rValue >>= nRotVal ) |
| { |
| // stored value is always between 0 and 360 deg. |
| nRotVal %= 36000; |
| if ( nRotVal < 0 ) |
| nRotVal += 36000; |
| |
| rSet.Put( SfxInt32Item( ATTR_ROTATE_VALUE, nRotVal ) ); |
| } |
| else |
| throw lang::IllegalArgumentException(); |
| } |
| break; |
| case ATTR_STACKED: |
| { |
| table::CellOrientation eOrient; |
| if( rValue >>= eOrient ) |
| { |
| switch( eOrient ) |
| { |
| case table::CellOrientation_STANDARD: |
| rSet.Put( SfxBoolItem( ATTR_STACKED, sal_False ) ); |
| break; |
| case table::CellOrientation_TOPBOTTOM: |
| rSet.Put( SfxBoolItem( ATTR_STACKED, sal_False ) ); |
| rSet.Put( SfxInt32Item( ATTR_ROTATE_VALUE, 27000 ) ); |
| rSecondItemId = ATTR_ROTATE_VALUE; |
| break; |
| case table::CellOrientation_BOTTOMTOP: |
| rSet.Put( SfxBoolItem( ATTR_STACKED, sal_False ) ); |
| rSet.Put( SfxInt32Item( ATTR_ROTATE_VALUE, 9000 ) ); |
| rSecondItemId = ATTR_ROTATE_VALUE; |
| break; |
| case table::CellOrientation_STACKED: |
| rSet.Put( SfxBoolItem( ATTR_STACKED, sal_True ) ); |
| break; |
| default: |
| { |
| // added to avoid warnings |
| } |
| } |
| } |
| } |
| break; |
| default: |
| { |
| lcl_GetCellsPropertySet()->setPropertyValue(rEntry, rValue, rSet); |
| } |
| } |
| } |
| |
| 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 || aRanges.Count() == 0 ) |
| throw uno::RuntimeException(); |
| |
| const SfxItemPropertyMap* pPropertyMap = GetItemPropertyMap(); // from derived class |
| const SfxItemPropertySimpleEntry* pEntry = pPropertyMap->getByName( aPropertyName ); |
| if ( !pEntry ) |
| throw beans::UnknownPropertyException(); |
| |
| SetOnePropertyValue( pEntry, aValue ); |
| } |
| |
| void ScCellRangesBase::SetOnePropertyValue( const SfxItemPropertySimpleEntry* pEntry, const uno::Any& aValue ) |
| throw(lang::IllegalArgumentException, uno::RuntimeException) |
| { |
| if ( pEntry ) |
| { |
| if ( IsScItemWid( pEntry->nWID ) ) |
| { |
| if ( aRanges.Count() ) // leer = nichts zu tun |
| { |
| 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(); |
| |
| sal_uInt16 nFirstItem, nSecondItem; |
| lcl_SetCellProperty( *pEntry, aValue, aPattern, pDoc, nFirstItem, nSecondItem ); |
| |
| for (sal_uInt16 nWhich = ATTR_PATTERN_START; nWhich <= ATTR_PATTERN_END; nWhich++) |
| if ( nWhich != nFirstItem && nWhich != nSecondItem ) |
| rSet.ClearItem(nWhich); |
| |
| aFunc.ApplyAttributes( *GetMarkData(), aPattern, sal_True, sal_True ); |
| } |
| } |
| else // implemented here |
| switch ( pEntry->nWID ) |
| { |
| case SC_WID_UNO_CHCOLHDR: |
| // chart header flags are set for this object, not stored with document |
| bChartColAsHdr = ScUnoHelpFunctions::GetBoolFromAny( aValue ); |
| break; |
| case SC_WID_UNO_CHROWHDR: |
| bChartRowAsHdr = ScUnoHelpFunctions::GetBoolFromAny( aValue ); |
| break; |
| case SC_WID_UNO_CELLSTYL: |
| { |
| rtl::OUString aStrVal; |
| aValue >>= aStrVal; |
| String aString(ScStyleNameConversion::ProgrammaticToDisplayName( |
| aStrVal, SFX_STYLE_FAMILY_PARA )); |
| ScDocFunc aFunc(*pDocShell); |
| aFunc.ApplyStyle( *GetMarkData(), aString, sal_True, sal_True ); |
| } |
| break; |
| case SC_WID_UNO_TBLBORD: |
| { |
| table::TableBorder aBorder; |
| if ( aRanges.Count() && ( aValue >>= aBorder ) ) // empty = nothing to do |
| { |
| SvxBoxItem aOuter(ATTR_BORDER); |
| SvxBoxInfoItem aInner(ATTR_BORDER_INNER); |
| ScHelperFunctions::FillBoxItems( aOuter, aInner, aBorder ); |
| |
| ScHelperFunctions::ApplyBorder( pDocShell, aRanges, aOuter, aInner ); //! docfunc |
| } |
| } |
| break; |
| case SC_WID_UNO_CONDFMT: |
| case SC_WID_UNO_CONDLOC: |
| case SC_WID_UNO_CONDXML: |
| { |
| uno::Reference<sheet::XSheetConditionalEntries> xInterface(aValue, uno::UNO_QUERY); |
| if ( aRanges.Count() && xInterface.is() ) // leer = nichts zu tun |
| { |
| ScTableConditionalFormat* pFormat = |
| ScTableConditionalFormat::getImplementation( xInterface ); |
| if (pFormat) |
| { |
| ScDocument* pDoc = pDocShell->GetDocument(); |
| sal_Bool bEnglish = ( pEntry->nWID != SC_WID_UNO_CONDLOC ); |
| sal_Bool bXML = ( pEntry->nWID == SC_WID_UNO_CONDXML ); |
| formula::FormulaGrammar::Grammar eGrammar = (bXML ? |
| formula::FormulaGrammar::GRAM_UNSPECIFIED : |
| formula::FormulaGrammar::mapAPItoGrammar( bEnglish, bXML)); |
| |
| ScConditionalFormat aNew( 0, pDoc ); // Index wird beim Einfuegen gesetzt |
| pFormat->FillFormat( aNew, pDoc, eGrammar ); |
| sal_uLong nIndex = pDoc->AddCondFormat( aNew ); |
| |
| ScDocFunc aFunc(*pDocShell); |
| |
| ScPatternAttr aPattern( pDoc->GetPool() ); |
| aPattern.GetItemSet().Put( SfxUInt32Item( ATTR_CONDITIONAL, nIndex ) ); |
| aFunc.ApplyAttributes( *GetMarkData(), aPattern, sal_True, sal_True ); |
| } |
| } |
| } |
| break; |
| case SC_WID_UNO_VALIDAT: |
| case SC_WID_UNO_VALILOC: |
| case SC_WID_UNO_VALIXML: |
| { |
| uno::Reference<beans::XPropertySet> xInterface(aValue, uno::UNO_QUERY); |
| if ( aRanges.Count() && xInterface.is() ) // leer = nichts zu tun |
| { |
| ScTableValidationObj* pValidObj = |
| ScTableValidationObj::getImplementation( xInterface ); |
| if (pValidObj) |
| { |
| ScDocument* pDoc = pDocShell->GetDocument(); |
| sal_Bool bEnglish = ( pEntry->nWID != SC_WID_UNO_VALILOC ); |
| sal_Bool bXML = ( pEntry->nWID == SC_WID_UNO_VALIXML ); |
| formula::FormulaGrammar::Grammar eGrammar = (bXML ? |
| formula::FormulaGrammar::GRAM_UNSPECIFIED : |
| formula::FormulaGrammar::mapAPItoGrammar( bEnglish, bXML)); |
| |
| ScValidationData* pNewData = |
| pValidObj->CreateValidationData( pDoc, eGrammar ); |
| sal_uLong nIndex = pDoc->AddValidationEntry( *pNewData ); |
| delete pNewData; |
| |
| ScDocFunc aFunc(*pDocShell); |
| |
| ScPatternAttr aPattern( pDoc->GetPool() ); |
| aPattern.GetItemSet().Put( SfxUInt32Item( ATTR_VALIDDATA, nIndex ) ); |
| aFunc.ApplyAttributes( *GetMarkData(), aPattern, sal_True, sal_True ); |
| } |
| } |
| } |
| break; |
| // SC_WID_UNO_NUMRULES is ignored... |
| } |
| } |
| } |
| |
| uno::Any SAL_CALL ScCellRangesBase::getPropertyValue( const rtl::OUString& aPropertyName ) |
| throw(beans::UnknownPropertyException, lang::WrappedTargetException, |
| uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| |
| if ( !pDocShell || aRanges.Count() == 0 ) |
| throw uno::RuntimeException(); |
| |
| const SfxItemPropertyMap* pPropertyMap = GetItemPropertyMap(); // from derived class |
| const SfxItemPropertySimpleEntry* pEntry = pPropertyMap->getByName( aPropertyName ); |
| if ( !pEntry ) |
| throw beans::UnknownPropertyException(); |
| |
| uno::Any aAny; |
| GetOnePropertyValue( pEntry, aAny ); |
| return aAny; |
| } |
| |
| void ScCellRangesBase::GetOnePropertyValue( const SfxItemPropertySimpleEntry* pEntry, |
| uno::Any& rAny ) |
| throw(uno::RuntimeException) |
| { |
| if ( pEntry ) |
| { |
| if ( IsScItemWid( pEntry->nWID ) ) |
| { |
| SfxItemSet* pDataSet = GetCurrentDataSet(); |
| if ( pDataSet ) |
| { |
| switch ( pEntry->nWID ) // fuer Item-Spezial-Behandlungen |
| { |
| case ATTR_VALUE_FORMAT: |
| { |
| ScDocument* pDoc = pDocShell->GetDocument(); |
| |
| sal_uLong nOldFormat = ((const SfxUInt32Item&) |
| pDataSet->Get( ATTR_VALUE_FORMAT )).GetValue(); |
| LanguageType eOldLang = ((const SvxLanguageItem&) |
| pDataSet->Get( ATTR_LANGUAGE_FORMAT )).GetLanguage(); |
| nOldFormat = pDoc->GetFormatTable()-> |
| GetFormatForLanguageIfBuiltIn( nOldFormat, eOldLang ); |
| rAny <<= (sal_Int32)( nOldFormat ); |
| } |
| break; |
| case ATTR_INDENT: |
| rAny <<= (sal_Int16)( TwipsToHMM(((const SfxUInt16Item&) |
| pDataSet->Get(pEntry->nWID)).GetValue()) ); |
| break; |
| case ATTR_STACKED: |
| { |
| sal_Int32 nRot = ((const SfxInt32Item&)pDataSet->Get(ATTR_ROTATE_VALUE)).GetValue(); |
| sal_Bool bStacked = ((const SfxBoolItem&)pDataSet->Get(pEntry->nWID)).GetValue(); |
| SvxOrientationItem( nRot, bStacked, 0 ).QueryValue( rAny ); |
| } |
| break; |
| default: |
| pPropSet->getPropertyValue(*pEntry, *pDataSet, rAny); |
| } |
| } |
| } |
| else // implemented here |
| switch ( pEntry->nWID ) |
| { |
| case SC_WID_UNO_CHCOLHDR: |
| ScUnoHelpFunctions::SetBoolInAny( rAny, bChartColAsHdr ); |
| break; |
| case SC_WID_UNO_CHROWHDR: |
| ScUnoHelpFunctions::SetBoolInAny( rAny, bChartRowAsHdr ); |
| break; |
| case SC_WID_UNO_CELLSTYL: |
| { |
| String aStyleName; |
| const ScStyleSheet* pStyle = pDocShell->GetDocument()->GetSelectionStyle(*GetMarkData()); |
| if (pStyle) |
| aStyleName = pStyle->GetName(); |
| rAny <<= rtl::OUString( ScStyleNameConversion::DisplayToProgrammaticName( |
| aStyleName, SFX_STYLE_FAMILY_PARA ) ); |
| } |
| break; |
| case SC_WID_UNO_TBLBORD: |
| { |
| //! loop throgh all ranges |
| 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(), sal_True ); |
| pDoc->GetSelectionFrame( aMark, aOuter, aInner ); |
| |
| table::TableBorder aBorder; |
| ScHelperFunctions::FillTableBorder( aBorder, aOuter, aInner ); |
| rAny <<= aBorder; |
| } |
| } |
| break; |
| case SC_WID_UNO_CONDFMT: |
| case SC_WID_UNO_CONDLOC: |
| case SC_WID_UNO_CONDXML: |
| { |
| const ScPatternAttr* pPattern = GetCurrentAttrsDeep(); |
| if ( pPattern ) |
| { |
| ScDocument* pDoc = pDocShell->GetDocument(); |
| sal_Bool bEnglish = ( pEntry->nWID != SC_WID_UNO_CONDLOC ); |
| sal_Bool bXML = ( pEntry->nWID == SC_WID_UNO_CONDXML ); |
| formula::FormulaGrammar::Grammar eGrammar = (bXML ? |
| pDoc->GetStorageGrammar() : |
| formula::FormulaGrammar::mapAPItoGrammar( bEnglish, bXML)); |
| sal_uLong nIndex = ((const SfxUInt32Item&) |
| pPattern->GetItem(ATTR_CONDITIONAL)).GetValue(); |
| rAny <<= uno::Reference<sheet::XSheetConditionalEntries>( |
| new ScTableConditionalFormat( pDoc, nIndex, eGrammar )); |
| } |
| } |
| break; |
| case SC_WID_UNO_VALIDAT: |
| case SC_WID_UNO_VALILOC: |
| case SC_WID_UNO_VALIXML: |
| { |
| const ScPatternAttr* pPattern = GetCurrentAttrsDeep(); |
| if ( pPattern ) |
| { |
| ScDocument* pDoc = pDocShell->GetDocument(); |
| sal_Bool bEnglish = ( pEntry->nWID != SC_WID_UNO_VALILOC ); |
| sal_Bool bXML = ( pEntry->nWID == SC_WID_UNO_VALIXML ); |
| formula::FormulaGrammar::Grammar eGrammar = (bXML ? |
| pDoc->GetStorageGrammar() : |
| formula::FormulaGrammar::mapAPItoGrammar( bEnglish, bXML)); |
| sal_uLong nIndex = ((const SfxUInt32Item&) |
| pPattern->GetItem(ATTR_VALIDDATA)).GetValue(); |
| rAny <<= uno::Reference<beans::XPropertySet>( |
| new ScTableValidationObj( pDoc, nIndex, eGrammar )); |
| } |
| } |
| break; |
| case SC_WID_UNO_NUMRULES: |
| { |
| // always return empty numbering rules object |
| rAny <<= uno::Reference<container::XIndexReplace>(ScStyleObj::CreateEmptyNumberingRules()); |
| } |
| break; |
| case SC_WID_UNO_ABSNAME: |
| { |
| String sRet; |
| aRanges.Format(sRet, SCR_ABS_3D, pDocShell->GetDocument()); |
| rAny <<= rtl::OUString(sRet); |
| } |
| } |
| } |
| } |
| |
| void SAL_CALL ScCellRangesBase::addPropertyChangeListener( const rtl::OUString& /* aPropertyName */, |
| const uno::Reference<beans::XPropertyChangeListener>& /* aListener */) |
| throw(beans::UnknownPropertyException, |
| lang::WrappedTargetException, uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| if ( aRanges.Count() == 0 ) |
| throw uno::RuntimeException(); |
| |
| DBG_ERROR("not implemented"); |
| } |
| |
| void SAL_CALL ScCellRangesBase::removePropertyChangeListener( const rtl::OUString& /* aPropertyName */, |
| const uno::Reference<beans::XPropertyChangeListener>& /* aListener */) |
| throw(beans::UnknownPropertyException, |
| lang::WrappedTargetException, uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| if ( aRanges.Count() == 0 ) |
| throw uno::RuntimeException(); |
| |
| DBG_ERROR("not implemented"); |
| } |
| |
| void SAL_CALL ScCellRangesBase::addVetoableChangeListener( const rtl::OUString&, |
| const uno::Reference<beans::XVetoableChangeListener>&) |
| throw(beans::UnknownPropertyException, |
| lang::WrappedTargetException, uno::RuntimeException) |
| { |
| DBG_ERROR("not implemented"); |
| } |
| |
| void SAL_CALL ScCellRangesBase::removeVetoableChangeListener( const rtl::OUString&, |
| const uno::Reference<beans::XVetoableChangeListener>&) |
| throw(beans::UnknownPropertyException, |
| lang::WrappedTargetException, uno::RuntimeException) |
| { |
| DBG_ERROR("not implemented"); |
| } |
| |
| // XMultiPropertySet |
| |
| void SAL_CALL ScCellRangesBase::setPropertyValues( const uno::Sequence< rtl::OUString >& aPropertyNames, |
| const uno::Sequence< uno::Any >& aValues ) |
| throw (beans::PropertyVetoException, |
| lang::IllegalArgumentException, |
| lang::WrappedTargetException, |
| uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| |
| sal_Int32 nCount(aPropertyNames.getLength()); |
| sal_Int32 nValues(aValues.getLength()); |
| if (nCount != nValues) |
| throw lang::IllegalArgumentException(); |
| |
| if ( pDocShell && nCount ) |
| { |
| const SfxItemPropertyMap* pPropertyMap = GetItemPropertyMap(); // from derived class |
| const rtl::OUString* pNames = aPropertyNames.getConstArray(); |
| const uno::Any* pValues = aValues.getConstArray(); |
| |
| const SfxItemPropertySimpleEntry** pEntryArray = new const SfxItemPropertySimpleEntry*[nCount]; |
| |
| sal_Int32 i; |
| for(i = 0; i < nCount; i++) |
| { |
| // first loop: find all properties in map, but handle only CellStyle |
| // (CellStyle must be set before any other cell properties) |
| |
| const SfxItemPropertySimpleEntry* pEntry = pPropertyMap->getByName( pNames[i] ); |
| pEntryArray[i] = pEntry; |
| if (pEntry) |
| { |
| if ( pEntry->nWID == SC_WID_UNO_CELLSTYL ) |
| { |
| try |
| { |
| SetOnePropertyValue( pEntry, pValues[i] ); |
| } |
| catch ( lang::IllegalArgumentException& ) |
| { |
| DBG_ERROR("exception when setting cell style"); // not supposed to happen |
| } |
| } |
| } |
| } |
| |
| ScDocument* pDoc = pDocShell->GetDocument(); |
| ScPatternAttr* pOldPattern = NULL; |
| ScPatternAttr* pNewPattern = NULL; |
| |
| for(i = 0; i < nCount; i++) |
| { |
| // second loop: handle other properties |
| |
| const SfxItemPropertySimpleEntry* pEntry = pEntryArray[i]; |
| if ( pEntry ) |
| { |
| if ( IsScItemWid( pEntry->nWID ) ) // can be handled by SfxItemPropertySet |
| { |
| if ( !pOldPattern ) |
| { |
| pOldPattern = new ScPatternAttr( *GetCurrentAttrsDeep() ); |
| pOldPattern->GetItemSet().ClearInvalidItems(); |
| pNewPattern = new ScPatternAttr( pDoc->GetPool() ); |
| } |
| |
| // collect items in pNewPattern, apply with one call after the loop |
| |
| sal_uInt16 nFirstItem, nSecondItem; |
| lcl_SetCellProperty( *pEntry, pValues[i], *pOldPattern, pDoc, nFirstItem, nSecondItem ); |
| |
| // put only affected items into new set |
| if ( nFirstItem ) |
| pNewPattern->GetItemSet().Put( pOldPattern->GetItemSet().Get( nFirstItem ) ); |
| if ( nSecondItem ) |
| pNewPattern->GetItemSet().Put( pOldPattern->GetItemSet().Get( nSecondItem ) ); |
| } |
| else if ( pEntry->nWID != SC_WID_UNO_CELLSTYL ) // CellStyle is handled above |
| { |
| // call virtual method to set a single property |
| SetOnePropertyValue( pEntry, pValues[i] ); |
| } |
| } |
| } |
| |
| if ( pNewPattern && aRanges.Count() ) |
| { |
| ScDocFunc aFunc(*pDocShell); |
| aFunc.ApplyAttributes( *GetMarkData(), *pNewPattern, sal_True, sal_True ); |
| } |
| |
| delete pNewPattern; |
| delete pOldPattern; |
| delete[] pEntryArray; |
| } |
| } |
| |
| uno::Sequence<uno::Any> SAL_CALL ScCellRangesBase::getPropertyValues( |
| const uno::Sequence< rtl::OUString >& aPropertyNames ) |
| throw (uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| |
| const SfxItemPropertyMap* pPropertyMap = GetItemPropertyMap(); // from derived class |
| |
| uno::Sequence<uno::Any> aRet(aPropertyNames.getLength()); |
| uno::Any* pProperties = aRet.getArray(); |
| for(sal_Int32 i = 0; i < aPropertyNames.getLength(); i++) |
| { |
| const SfxItemPropertySimpleEntry* pEntry = pPropertyMap->getByName( aPropertyNames[i] ); |
| GetOnePropertyValue( pEntry, pProperties[i] ); |
| } |
| return aRet; |
| } |
| |
| void SAL_CALL ScCellRangesBase::addPropertiesChangeListener( const uno::Sequence< rtl::OUString >& /* aPropertyNames */, |
| const uno::Reference< beans::XPropertiesChangeListener >& /* xListener */ ) |
| throw (uno::RuntimeException) |
| { |
| DBG_ERROR("not implemented"); |
| } |
| |
| void SAL_CALL ScCellRangesBase::removePropertiesChangeListener( const uno::Reference< beans::XPropertiesChangeListener >& /* xListener */ ) |
| throw (uno::RuntimeException) |
| { |
| DBG_ERROR("not implemented"); |
| } |
| |
| void SAL_CALL ScCellRangesBase::firePropertiesChangeEvent( const uno::Sequence< rtl::OUString >& /* aPropertyNames */, |
| const uno::Reference< beans::XPropertiesChangeListener >& /* xListener */ ) |
| throw (uno::RuntimeException) |
| { |
| DBG_ERROR("not implemented"); |
| } |
| |
| IMPL_LINK( ScCellRangesBase, ValueListenerHdl, SfxHint*, pHint ) |
| { |
| if ( pDocShell && pHint && pHint->ISA( SfxSimpleHint ) && |
| ((const SfxSimpleHint*)pHint)->GetId() & (SC_HINT_DATACHANGED | SC_HINT_DYING) ) |
| { |
| // This may be called several times for a single change, if several formulas |
| // in the range are notified. So only a flag is set that is checked when |
| // SFX_HINT_DATACHANGED is received. |
| |
| bGotDataChangedHint = sal_True; |
| } |
| return 0; |
| } |
| |
| // XTolerantMultiPropertySet |
| uno::Sequence< beans::SetPropertyTolerantFailed > SAL_CALL ScCellRangesBase::setPropertyValuesTolerant( const uno::Sequence< ::rtl::OUString >& aPropertyNames, |
| const uno::Sequence< uno::Any >& aValues ) |
| throw (lang::IllegalArgumentException, uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| |
| sal_Int32 nCount(aPropertyNames.getLength()); |
| sal_Int32 nValues(aValues.getLength()); |
| if (nCount != nValues) |
| throw lang::IllegalArgumentException(); |
| |
| if ( pDocShell && nCount ) |
| { |
| uno::Sequence < beans::SetPropertyTolerantFailed > aReturns(nCount); |
| beans::SetPropertyTolerantFailed* pReturns = aReturns.getArray(); |
| |
| const SfxItemPropertyMap* pPropertyMap = GetItemPropertyMap(); // from derived class |
| const rtl::OUString* pNames = aPropertyNames.getConstArray(); |
| const uno::Any* pValues = aValues.getConstArray(); |
| |
| const SfxItemPropertySimpleEntry** pMapArray = new const SfxItemPropertySimpleEntry*[nCount]; |
| |
| sal_Int32 i; |
| for(i = 0; i < nCount; i++) |
| { |
| // first loop: find all properties in map, but handle only CellStyle |
| // (CellStyle must be set before any other cell properties) |
| |
| const SfxItemPropertySimpleEntry* pEntry = pPropertyMap->getByName( pNames[i] ); |
| pMapArray[i] = pEntry; |
| if (pEntry) |
| { |
| if ( pEntry->nWID == SC_WID_UNO_CELLSTYL ) |
| { |
| try |
| { |
| SetOnePropertyValue( pEntry, pValues[i] ); |
| } |
| catch ( lang::IllegalArgumentException& ) |
| { |
| DBG_ERROR("exception when setting cell style"); // not supposed to happen |
| } |
| } |
| } |
| } |
| |
| ScDocument* pDoc = pDocShell->GetDocument(); |
| ScPatternAttr* pOldPattern = NULL; |
| ScPatternAttr* pNewPattern = NULL; |
| |
| sal_Int32 nFailed(0); |
| for(i = 0; i < nCount; i++) |
| { |
| // second loop: handle other properties |
| |
| const SfxItemPropertySimpleEntry* pEntry = pMapArray[i]; |
| if ( pEntry && ((pEntry->nFlags & beans::PropertyAttribute::READONLY) == 0)) |
| { |
| if ( IsScItemWid( pEntry->nWID ) ) // can be handled by SfxItemPropertySet |
| { |
| if ( !pOldPattern ) |
| { |
| pOldPattern = new ScPatternAttr( *GetCurrentAttrsDeep() ); |
| pOldPattern->GetItemSet().ClearInvalidItems(); |
| pNewPattern = new ScPatternAttr( pDoc->GetPool() ); |
| } |
| |
| // collect items in pNewPattern, apply with one call after the loop |
| |
| sal_uInt16 nFirstItem, nSecondItem; |
| try |
| { |
| lcl_SetCellProperty( *pEntry, pValues[i], *pOldPattern, pDoc, nFirstItem, nSecondItem ); |
| |
| // put only affected items into new set |
| if ( nFirstItem ) |
| pNewPattern->GetItemSet().Put( pOldPattern->GetItemSet().Get( nFirstItem ) ); |
| if ( nSecondItem ) |
| pNewPattern->GetItemSet().Put( pOldPattern->GetItemSet().Get( nSecondItem ) ); |
| } |
| catch ( lang::IllegalArgumentException& ) |
| { |
| pReturns[nFailed].Name = pNames[i]; |
| pReturns[nFailed++].Result = beans::TolerantPropertySetResultType::ILLEGAL_ARGUMENT; |
| } |
| } |
| else if ( pEntry->nWID != SC_WID_UNO_CELLSTYL ) // CellStyle is handled above |
| { |
| // call virtual method to set a single property |
| try |
| { |
| SetOnePropertyValue( pEntry, pValues[i] ); |
| } |
| catch ( lang::IllegalArgumentException& ) |
| { |
| pReturns[nFailed].Name = pNames[i]; |
| pReturns[nFailed++].Result = beans::TolerantPropertySetResultType::ILLEGAL_ARGUMENT; |
| } |
| } |
| } |
| else |
| { |
| pReturns[nFailed].Name = pNames[i]; |
| if (pEntry) |
| pReturns[nFailed++].Result = beans::TolerantPropertySetResultType::PROPERTY_VETO; |
| else |
| pReturns[nFailed++].Result = beans::TolerantPropertySetResultType::UNKNOWN_PROPERTY; |
| } |
| } |
| |
| if ( pNewPattern && aRanges.Count() ) |
| { |
| ScDocFunc aFunc(*pDocShell); |
| aFunc.ApplyAttributes( *GetMarkData(), *pNewPattern, sal_True, sal_True ); |
| } |
| |
| delete pNewPattern; |
| delete pOldPattern; |
| delete[] pMapArray; |
| |
| aReturns.realloc(nFailed); |
| |
| return aReturns; |
| } |
| return uno::Sequence < beans::SetPropertyTolerantFailed >(); |
| } |
| |
| uno::Sequence< beans::GetPropertyTolerantResult > SAL_CALL ScCellRangesBase::getPropertyValuesTolerant( const uno::Sequence< ::rtl::OUString >& aPropertyNames ) |
| throw (uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| |
| sal_Int32 nCount(aPropertyNames.getLength()); |
| uno::Sequence < beans::GetPropertyTolerantResult > aReturns(nCount); |
| beans::GetPropertyTolerantResult* pReturns = aReturns.getArray(); |
| |
| const SfxItemPropertyMap* pPropertyMap = GetItemPropertyMap(); // from derived class |
| |
| for(sal_Int32 i = 0; i < nCount; i++) |
| { |
| const SfxItemPropertySimpleEntry* pEntry = pPropertyMap->getByName( aPropertyNames[i] ); |
| if (!pEntry) |
| { |
| pReturns[i].Result = beans::TolerantPropertySetResultType::UNKNOWN_PROPERTY; |
| } |
| else |
| { |
| sal_uInt16 nItemWhich = 0; |
| lcl_GetPropertyWhich( pEntry, nItemWhich ); |
| pReturns[i].State = GetOnePropertyState( nItemWhich, pEntry ); |
| GetOnePropertyValue( pEntry, pReturns[i].Value ); |
| pReturns[i].Result = beans::TolerantPropertySetResultType::SUCCESS; |
| } |
| } |
| return aReturns; |
| } |
| |
| uno::Sequence< beans::GetDirectPropertyTolerantResult > SAL_CALL ScCellRangesBase::getDirectPropertyValuesTolerant( const uno::Sequence< ::rtl::OUString >& aPropertyNames ) |
| throw (uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| |
| sal_Int32 nCount(aPropertyNames.getLength()); |
| uno::Sequence < beans::GetDirectPropertyTolerantResult > aReturns(nCount); |
| beans::GetDirectPropertyTolerantResult* pReturns = aReturns.getArray(); |
| |
| const SfxItemPropertyMap* pPropertyMap = GetItemPropertyMap(); // from derived class |
| |
| sal_Int32 j = 0; |
| for(sal_Int32 i = 0; i < nCount; i++) |
| { |
| const SfxItemPropertySimpleEntry* pEntry = pPropertyMap->getByName( aPropertyNames[i] ); |
| if (!pEntry) |
| { |
| pReturns[i].Result = beans::TolerantPropertySetResultType::UNKNOWN_PROPERTY; |
| } |
| else |
| { |
| sal_uInt16 nItemWhich = 0; |
| lcl_GetPropertyWhich( pEntry, nItemWhich ); |
| pReturns[j].State = GetOnePropertyState( nItemWhich, pEntry ); |
| if (pReturns[j].State == beans::PropertyState_DIRECT_VALUE) |
| { |
| GetOnePropertyValue( pEntry, pReturns[j].Value ); |
| pReturns[j].Result = beans::TolerantPropertySetResultType::SUCCESS; |
| pReturns[j].Name = aPropertyNames[i]; |
| ++j; |
| } |
| } |
| } |
| if (j < nCount) |
| aReturns.realloc(j); |
| return aReturns; |
| } |
| |
| // XIndent |
| |
| void SAL_CALL ScCellRangesBase::decrementIndent() throw(::com::sun::star::uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| if ( pDocShell && aRanges.Count() ) // leer = nichts zu tun |
| { |
| ScDocFunc aFunc(*pDocShell); |
| //#97041#; put only MultiMarked ScMarkData in ChangeIndent |
| ScMarkData aMarkData(*GetMarkData()); |
| aMarkData.MarkToMulti(); |
| aFunc.ChangeIndent( aMarkData, sal_False, sal_True ); |
| } |
| } |
| |
| void SAL_CALL ScCellRangesBase::incrementIndent() throw(::com::sun::star::uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| if ( pDocShell && aRanges.Count() ) // leer = nichts zu tun |
| { |
| ScDocFunc aFunc(*pDocShell); |
| //#97041#; put only MultiMarked ScMarkData in ChangeIndent |
| ScMarkData aMarkData(*GetMarkData()); |
| aMarkData.MarkToMulti(); |
| aFunc.ChangeIndent( aMarkData, sal_True, sal_True ); |
| } |
| } |
| |
| // XChartData |
| |
| ScMemChart* 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 ) |
| { |
| SCTAB nTab = pRange->aStart.Tab(); |
| |
| SCCOL nStartX; |
| SCROW nStartY; // Anfang holen |
| if (!pDocShell->GetDocument()->GetDataStart( nTab, nStartX, nStartY )) |
| { |
| nStartX = 0; |
| nStartY = 0; |
| } |
| |
| SCCOL nEndX; |
| SCROW nEndY; // Ende holen |
| if (!pDocShell->GetDocument()->GetTableArea( nTab, nEndX, nEndY )) |
| { |
| nEndX = 0; |
| 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<double> > SAL_CALL ScCellRangesBase::getData() |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScMemChart* pMemChart = CreateMemChart_Impl(); |
| if ( pMemChart ) |
| { |
| sal_Int32 nColCount = pMemChart->GetColCount(); |
| sal_Int32 nRowCount = static_cast<sal_Int32>(pMemChart->GetRowCount()); |
| |
| uno::Sequence< uno::Sequence<double> > aRowSeq( nRowCount ); |
| uno::Sequence<double>* pRowAry = aRowSeq.getArray(); |
| for (sal_Int32 nRow = 0; nRow < nRowCount; nRow++) |
| { |
| uno::Sequence<double> aColSeq( nColCount ); |
| double* pColAry = aColSeq.getArray(); |
| for (sal_Int32 nCol = 0; nCol < nColCount; nCol++) |
| pColAry[nCol] = pMemChart->GetData( static_cast<short>(nCol), static_cast<short>(nRow) ); |
| |
| pRowAry[nRow] = aColSeq; |
| } |
| |
| delete pMemChart; |
| return aRowSeq; |
| } |
| |
| return uno::Sequence< uno::Sequence<double> >(0); |
| } |
| |
| ScRangeListRef ScCellRangesBase::GetLimitedChartRanges_Impl( long nDataColumns, long nDataRows ) const |
| { |
| if ( aRanges.Count() == 1 ) |
| { |
| ScRange* pRange = aRanges.GetObject(0); |
| if ( pRange->aStart.Col() == 0 && pRange->aEnd.Col() == MAXCOL && |
| pRange->aStart.Row() == 0 && pRange->aEnd.Row() == MAXROW ) |
| { |
| // if aRanges is a complete sheet, limit to given size |
| |
| SCTAB nTab = pRange->aStart.Tab(); |
| |
| long nEndColumn = nDataColumns - 1 + ( bChartColAsHdr ? 1 : 0 ); |
| if ( nEndColumn < 0 ) |
| nEndColumn = 0; |
| if ( nEndColumn > MAXCOL ) |
| nEndColumn = MAXCOL; |
| |
| long nEndRow = nDataRows - 1 + ( bChartRowAsHdr ? 1 : 0 ); |
| if ( nEndRow < 0 ) |
| nEndRow = 0; |
| if ( nEndRow > MAXROW ) |
| nEndRow = MAXROW; |
| |
| ScRangeListRef xChartRanges = new ScRangeList; |
| xChartRanges->Append( ScRange( 0, 0, nTab, (SCCOL)nEndColumn, (SCROW)nEndRow, nTab ) ); |
| return xChartRanges; |
| } |
| } |
| |
| return new ScRangeList(aRanges); // as-is |
| } |
| |
| void SAL_CALL ScCellRangesBase::setData( const uno::Sequence< uno::Sequence<double> >& aData ) |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| sal_Bool bDone = sal_False; |
| long nRowCount = aData.getLength(); |
| long nColCount = nRowCount ? aData[0].getLength() : 0; |
| ScRangeListRef xChartRanges = GetLimitedChartRanges_Impl( nColCount, nRowCount ); |
| if ( pDocShell && xChartRanges.Is() ) |
| { |
| ScDocument* pDoc = pDocShell->GetDocument(); |
| ScChartArray aArr( pDoc, xChartRanges, String() ); |
| aArr.SetHeaders( bChartRowAsHdr, bChartColAsHdr ); // RowAsHdr = ColHeaders |
| const ScChartPositionMap* pPosMap = aArr.GetPositionMap(); |
| if (pPosMap) |
| { |
| if ( pPosMap->GetColCount() == static_cast<SCCOL>(nColCount) && |
| pPosMap->GetRowCount() == static_cast<SCROW>(nRowCount) ) |
| { |
| for (long nRow=0; nRow<nRowCount; nRow++) |
| { |
| const uno::Sequence<double>& rRowSeq = aData[nRow]; |
| const double* pArray = rRowSeq.getConstArray(); |
| nColCount = rRowSeq.getLength(); |
| for (long nCol=0; nCol<nColCount; nCol++) |
| { |
| const ScAddress* pPos = pPosMap->GetPosition( |
| sal::static_int_cast<SCCOL>(nCol), |
| sal::static_int_cast<SCROW>(nRow) ); |
| if (pPos) |
| { |
| double fVal = pArray[nCol]; |
| if ( fVal == DBL_MIN ) |
| pDoc->PutCell( *pPos, NULL ); // empty cell |
| else |
| pDoc->SetValue( pPos->Col(), pPos->Row(), pPos->Tab(), pArray[nCol] ); |
| } |
| } |
| } |
| |
| //! undo |
| PaintRanges_Impl( PAINT_GRID ); |
| pDocShell->SetDocumentModified(); |
| ForceChartListener_Impl(); // call listeners for this object synchronously |
| bDone = sal_True; |
| } |
| } |
| } |
| |
| if (!bDone) |
| throw uno::RuntimeException(); |
| } |
| |
| uno::Sequence<rtl::OUString> SAL_CALL ScCellRangesBase::getRowDescriptions() |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScMemChart* pMemChart = CreateMemChart_Impl(); |
| if ( pMemChart ) |
| { |
| sal_Int32 nRowCount = static_cast<sal_Int32>(pMemChart->GetRowCount()); |
| uno::Sequence<rtl::OUString> aSeq( nRowCount ); |
| rtl::OUString* pAry = aSeq.getArray(); |
| for (sal_Int32 nRow = 0; nRow < nRowCount; nRow++) |
| pAry[nRow] = pMemChart->GetRowText(static_cast<short>(nRow)); |
| |
| delete pMemChart; |
| return aSeq; |
| } |
| return uno::Sequence<rtl::OUString>(0); |
| } |
| |
| void SAL_CALL ScCellRangesBase::setRowDescriptions( |
| const uno::Sequence<rtl::OUString>& aRowDescriptions ) |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| sal_Bool bDone = sal_False; |
| if ( bChartColAsHdr ) |
| { |
| long nRowCount = aRowDescriptions.getLength(); |
| ScRangeListRef xChartRanges = GetLimitedChartRanges_Impl( 1, nRowCount ); |
| if ( pDocShell && xChartRanges.Is() ) |
| { |
| ScDocument* pDoc = pDocShell->GetDocument(); |
| ScChartArray aArr( pDoc, xChartRanges, String() ); |
| aArr.SetHeaders( bChartRowAsHdr, bChartColAsHdr ); // RowAsHdr = ColHeaders |
| const ScChartPositionMap* pPosMap = aArr.GetPositionMap(); |
| if (pPosMap) |
| { |
| if ( pPosMap->GetRowCount() == static_cast<SCROW>(nRowCount) ) |
| { |
| const rtl::OUString* pArray = aRowDescriptions.getConstArray(); |
| for (long nRow=0; nRow<nRowCount; nRow++) |
| { |
| const ScAddress* pPos = pPosMap->GetRowHeaderPosition( |
| static_cast<SCSIZE>(nRow) ); |
| if (pPos) |
| { |
| String aStr = pArray[nRow]; |
| if ( aStr.Len() ) |
| pDoc->PutCell( *pPos, new ScStringCell( aStr ) ); |
| else |
| pDoc->PutCell( *pPos, NULL ); // empty cell |
| } |
| } |
| |
| //! undo |
| PaintRanges_Impl( PAINT_GRID ); |
| pDocShell->SetDocumentModified(); |
| ForceChartListener_Impl(); // call listeners for this object synchronously |
| bDone = sal_True; |
| } |
| } |
| } |
| } |
| |
| if (!bDone) |
| throw uno::RuntimeException(); |
| } |
| |
| uno::Sequence<rtl::OUString> SAL_CALL ScCellRangesBase::getColumnDescriptions() |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScMemChart* pMemChart = CreateMemChart_Impl(); |
| if ( pMemChart ) |
| { |
| sal_Int32 nColCount = pMemChart->GetColCount(); |
| uno::Sequence<rtl::OUString> aSeq( nColCount ); |
| rtl::OUString* pAry = aSeq.getArray(); |
| for (sal_Int32 nCol = 0; nCol < nColCount; nCol++) |
| pAry[nCol] = pMemChart->GetColText(static_cast<short>(nCol)); |
| |
| delete pMemChart; |
| return aSeq; |
| } |
| return uno::Sequence<rtl::OUString>(0); |
| } |
| |
| void SAL_CALL ScCellRangesBase::setColumnDescriptions( |
| const uno::Sequence<rtl::OUString>& aColumnDescriptions ) |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| sal_Bool bDone = sal_False; |
| if ( bChartRowAsHdr ) |
| { |
| long nColCount = aColumnDescriptions.getLength(); |
| ScRangeListRef xChartRanges = GetLimitedChartRanges_Impl( nColCount, 1 ); |
| if ( pDocShell && xChartRanges.Is() ) |
| { |
| ScDocument* pDoc = pDocShell->GetDocument(); |
| ScChartArray aArr( pDoc, xChartRanges, String() ); |
| aArr.SetHeaders( bChartRowAsHdr, bChartColAsHdr ); // RowAsHdr = ColHeaders |
| const ScChartPositionMap* pPosMap = aArr.GetPositionMap(); |
| if (pPosMap) |
| { |
| if ( pPosMap->GetColCount() == static_cast<SCCOL>(nColCount) ) |
| { |
| const rtl::OUString* pArray = aColumnDescriptions.getConstArray(); |
| for (long nCol=0; nCol<nColCount; nCol++) |
| { |
| const ScAddress* pPos = pPosMap->GetColHeaderPosition( |
| sal::static_int_cast<SCCOL>(nCol) ); |
| if (pPos) |
| { |
| String aStr(pArray[nCol]); |
| if ( aStr.Len() ) |
| pDoc->PutCell( *pPos, new ScStringCell( aStr ) ); |
| else |
| pDoc->PutCell( *pPos, NULL ); // empty cell |
| } |
| } |
| |
| //! undo |
| PaintRanges_Impl( PAINT_GRID ); |
| pDocShell->SetDocumentModified(); |
| ForceChartListener_Impl(); // call listeners for this object synchronously |
| bDone = sal_True; |
| } |
| } |
| } |
| } |
| |
| if (!bDone) |
| throw uno::RuntimeException(); |
| } |
| |
| void ScCellRangesBase::ForceChartListener_Impl() |
| { |
| // call Update immediately so the caller to setData etc. can |
| // regognize the listener call |
| |
| if ( pDocShell ) |
| { |
| ScChartListenerCollection* pColl = pDocShell->GetDocument()->GetChartListenerCollection(); |
| if ( pColl ) |
| { |
| sal_uInt16 nCollCount = pColl->GetCount(); |
| for ( sal_uInt16 nIndex = 0; nIndex < nCollCount; nIndex++ ) |
| { |
| ScChartListener* pChartListener = (ScChartListener*)pColl->At(nIndex); |
| if ( pChartListener && |
| pChartListener->GetUnoSource() == static_cast<chart::XChartData*>(this) && |
| pChartListener->IsDirty() ) |
| pChartListener->Update(); |
| } |
| } |
| } |
| } |
| |
| String lcl_UniqueName( ScStrCollection& rColl, const String& rPrefix ) |
| { |
| long nNumber = 1; |
| sal_uInt16 nCollCount = rColl.GetCount(); |
| while (sal_True) |
| { |
| String aName(rPrefix); |
| aName += String::CreateFromInt32( nNumber ); |
| sal_Bool bFound = sal_False; |
| for (sal_uInt16 i=0; i<nCollCount; i++) |
| if ( rColl[i]->GetString() == aName ) |
| { |
| bFound = sal_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); |
| } |
| |
| // XModifyBroadcaster |
| |
| void SAL_CALL ScCellRangesBase::addModifyListener( const uno::Reference<util::XModifyListener>& aListener ) |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| if ( aRanges.Count() == 0 ) |
| throw uno::RuntimeException(); |
| |
| uno::Reference<util::XModifyListener> *pObj = |
| new uno::Reference<util::XModifyListener>( aListener ); |
| aValueListeners.Insert( pObj, aValueListeners.Count() ); |
| |
| if ( aValueListeners.Count() == 1 ) |
| { |
| if (!pValueListener) |
| pValueListener = new ScLinkListener( LINK( this, ScCellRangesBase, ValueListenerHdl ) ); |
| |
| ScDocument* pDoc = pDocShell->GetDocument(); |
| sal_uLong nCount = aRanges.Count(); |
| for (sal_uLong i=0; i<nCount; i++) |
| pDoc->StartListeningArea( *aRanges.GetObject(i), pValueListener ); |
| |
| acquire(); // don't lose this object (one ref for all listeners) |
| } |
| } |
| |
| void SAL_CALL ScCellRangesBase::removeModifyListener( const uno::Reference<util::XModifyListener>& aListener ) |
| throw(uno::RuntimeException) |
| { |
| |
| ScUnoGuard aGuard; |
| if ( aRanges.Count() == 0 ) |
| throw uno::RuntimeException(); |
| |
| acquire(); // in case the listeners have the last ref - released below |
| |
| sal_uInt16 nCount = aValueListeners.Count(); |
| for ( sal_uInt16 n=nCount; n--; ) |
| { |
| uno::Reference<util::XModifyListener> *pObj = aValueListeners[n]; |
| if ( *pObj == aListener ) |
| { |
| aValueListeners.DeleteAndDestroy( n ); |
| |
| if ( aValueListeners.Count() == 0 ) |
| { |
| if (pValueListener) |
| pValueListener->EndListeningAll(); |
| |
| release(); // release the ref for the listeners |
| } |
| |
| break; |
| } |
| } |
| |
| release(); // might delete this object |
| } |
| |
| // XCellRangesQuery |
| |
| uno::Reference<sheet::XSheetCellRanges> SAL_CALL ScCellRangesBase::queryVisibleCells() |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| if (pDocShell) |
| { |
| //! fuer alle Tabellen getrennt, wenn Markierungen pro Tabelle getrennt sind! |
| SCTAB nTab = lcl_FirstTab(aRanges); |
| |
| ScMarkData aMarkData(*GetMarkData()); |
| |
| ScDocument* pDoc = pDocShell->GetDocument(); |
| SCCOL nCol = 0, nLastCol; |
| while (nCol <= MAXCOL) |
| { |
| if (pDoc->ColHidden(nCol, nTab, nLastCol)) |
| // hidden columns. Unselect them. |
| aMarkData.SetMultiMarkArea(ScRange(nCol, 0, nTab, nLastCol, MAXROW, nTab), false); |
| |
| nCol = nLastCol + 1; |
| } |
| |
| SCROW nRow = 0, nLastRow; |
| while (nRow <= MAXROW) |
| { |
| if (pDoc->RowHidden(nRow, nTab, nLastRow)) |
| // These rows are hidden. Unselect them. |
| aMarkData.SetMultiMarkArea(ScRange(0, nRow, nTab, MAXCOL, nLastRow, nTab), false); |
| |
| nRow = nLastRow + 1; |
| } |
| |
| ScRangeList aNewRanges; |
| aMarkData.FillRangeListWithMarks( &aNewRanges, sal_False ); |
| return new ScCellRangesObj( pDocShell, aNewRanges ); |
| } |
| |
| return NULL; |
| } |
| |
| uno::Reference<sheet::XSheetCellRanges> SAL_CALL ScCellRangesBase::queryEmptyCells() |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| if (pDocShell) |
| { |
| ScDocument* pDoc = pDocShell->GetDocument(); |
| |
| ScMarkData aMarkData(*GetMarkData()); |
| |
| // belegte Zellen wegmarkieren |
| sal_uLong nCount = aRanges.Count(); |
| for (sal_uLong i=0; i<nCount; i++) |
| { |
| ScRange aRange = *aRanges.GetObject(i); |
| |
| ScCellIterator aIter( pDoc, aRange ); |
| ScBaseCell* pCell = aIter.GetFirst(); |
| while (pCell) |
| { |
| // Notizen zaehlen als nicht-leer |
| if ( !pCell->IsBlank() ) |
| aMarkData.SetMultiMarkArea( |
| ScRange( aIter.GetCol(), aIter.GetRow(), aIter.GetTab() ), |
| sal_False ); |
| |
| pCell = aIter.GetNext(); |
| } |
| } |
| |
| ScRangeList aNewRanges; |
| // IsMultiMarked reicht hier nicht (wird beim deselektieren nicht zurueckgesetzt) |
| //if (aMarkData.HasAnyMultiMarks()) // #20044# should be set for all empty range |
| aMarkData.FillRangeListWithMarks( &aNewRanges, sal_False ); |
| |
| return new ScCellRangesObj( pDocShell, aNewRanges ); // aNewRanges kann leer sein |
| } |
| |
| return NULL; |
| } |
| |
| uno::Reference<sheet::XSheetCellRanges> SAL_CALL ScCellRangesBase::queryContentCells( |
| sal_Int16 nContentFlags ) |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| if (pDocShell) |
| { |
| ScDocument* pDoc = pDocShell->GetDocument(); |
| |
| ScMarkData aMarkData; |
| |
| // passende Zellen selektieren |
| sal_uLong nCount = aRanges.Count(); |
| for (sal_uLong i=0; i<nCount; i++) |
| { |
| ScRange aRange = *aRanges.GetObject(i); |
| |
| ScCellIterator aIter( pDoc, aRange ); |
| ScBaseCell* pCell = aIter.GetFirst(); |
| while (pCell) |
| { |
| sal_Bool bAdd = sal_False; |
| if ( pCell->HasNote() && ( nContentFlags & sheet::CellFlags::ANNOTATION ) ) |
| bAdd = sal_True; |
| else |
| switch ( pCell->GetCellType() ) |
| { |
| case CELLTYPE_STRING: |
| if ( nContentFlags & sheet::CellFlags::STRING ) |
| bAdd = sal_True; |
| break; |
| case CELLTYPE_EDIT: |
| if ( (nContentFlags & sheet::CellFlags::STRING) || (nContentFlags & sheet::CellFlags::FORMATTED) ) |
| bAdd = sal_True; |
| break; |
| case CELLTYPE_FORMULA: |
| if ( nContentFlags & sheet::CellFlags::FORMULA ) |
| bAdd = sal_True; |
| break; |
| case CELLTYPE_VALUE: |
| if ( (nContentFlags & (sheet::CellFlags::VALUE|sheet::CellFlags::DATETIME)) |
| == (sheet::CellFlags::VALUE|sheet::CellFlags::DATETIME) ) |
| bAdd = sal_True; |
| else |
| { |
| // Date/Time Erkennung |
| |
| sal_uLong nIndex = (sal_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 = sal_True; |
| } |
| else |
| { |
| if ( nContentFlags & sheet::CellFlags::VALUE ) |
| bAdd = sal_True; |
| } |
| } |
| break; |
| default: |
| { |
| // added to avoid warnings |
| } |
| } |
| |
| if (bAdd) |
| aMarkData.SetMultiMarkArea( |
| ScRange( aIter.GetCol(), aIter.GetRow(), aIter.GetTab() ), |
| sal_True ); |
| |
| pCell = aIter.GetNext(); |
| } |
| } |
| |
| ScRangeList aNewRanges; |
| if (aMarkData.IsMultiMarked()) |
| aMarkData.FillRangeListWithMarks( &aNewRanges, sal_False ); |
| |
| return new ScCellRangesObj( pDocShell, aNewRanges ); // aNewRanges kann leer sein |
| } |
| |
| return NULL; |
| } |
| |
| uno::Reference<sheet::XSheetCellRanges> SAL_CALL ScCellRangesBase::queryFormulaCells( |
| sal_Int32 nResultFlags ) |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| if (pDocShell) |
| { |
| ScDocument* pDoc = pDocShell->GetDocument(); |
| |
| ScMarkData aMarkData; |
| |
| // passende Zellen selektieren |
| sal_uLong nCount = aRanges.Count(); |
| for (sal_uLong i=0; i<nCount; i++) |
| { |
| ScRange aRange = *aRanges.GetObject(i); |
| |
| ScCellIterator aIter( pDoc, aRange ); |
| ScBaseCell* pCell = aIter.GetFirst(); |
| while (pCell) |
| { |
| if (pCell->GetCellType() == CELLTYPE_FORMULA) |
| { |
| ScFormulaCell* pFCell = (ScFormulaCell*)pCell; |
| sal_Bool bAdd = sal_False; |
| if (pFCell->GetErrCode()) |
| { |
| if ( nResultFlags & sheet::FormulaResult::ERROR ) |
| bAdd = sal_True; |
| } |
| else if (pFCell->IsValue()) |
| { |
| if ( nResultFlags & sheet::FormulaResult::VALUE ) |
| bAdd = sal_True; |
| } |
| else // String |
| { |
| if ( nResultFlags & sheet::FormulaResult::STRING ) |
| bAdd = sal_True; |
| } |
| |
| if (bAdd) |
| aMarkData.SetMultiMarkArea( |
| ScRange( aIter.GetCol(), aIter.GetRow(), aIter.GetTab() ), |
| sal_True ); |
| } |
| |
| pCell = aIter.GetNext(); |
| } |
| } |
| |
| ScRangeList aNewRanges; |
| if (aMarkData.IsMultiMarked()) |
| aMarkData.FillRangeListWithMarks( &aNewRanges, sal_False ); |
| |
| return new ScCellRangesObj( pDocShell, aNewRanges ); // aNewRanges kann leer sein |
| } |
| |
| return NULL; |
| } |
| |
| uno::Reference<sheet::XSheetCellRanges> ScCellRangesBase::QueryDifferences_Impl( |
| const table::CellAddress& aCompare, sal_Bool bColumnDiff) |
| { |
| if (pDocShell) |
| { |
| sal_uLong nRangeCount = aRanges.Count(); |
| sal_uLong i; |
| ScDocument* pDoc = pDocShell->GetDocument(); |
| ScMarkData aMarkData; |
| |
| SCCOLROW nCmpPos = bColumnDiff ? (SCCOLROW)aCompare.Row : (SCCOLROW)aCompare.Column; |
| |
| // zuerst alles selektieren, wo ueberhaupt etwas in der Vergleichsspalte steht |
| // (fuer gleiche Zellen wird die Selektion im zweiten Schritt aufgehoben) |
| |
| SCTAB 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( static_cast<SCCOL>(nCmpPos),0,nTab, static_cast<SCCOL>(nCmpPos),MAXROW,nTab ); |
| ScCellIterator aCmpIter( pDoc, aCmpRange ); |
| ScBaseCell* pCmpCell = aCmpIter.GetFirst(); |
| while (pCmpCell) |
| { |
| if (pCmpCell->GetCellType() != CELLTYPE_NOTE) |
| { |
| SCCOLROW nCellPos = bColumnDiff ? static_cast<SCCOLROW>(aCmpIter.GetCol()) : static_cast<SCCOLROW>(aCmpIter.GetRow()); |
| if (bColumnDiff) |
| aCellRange = ScRange( static_cast<SCCOL>(nCellPos),0,nTab, |
| static_cast<SCCOL>(nCellPos),MAXROW,nTab ); |
| else |
| aCellRange = ScRange( 0,nCellPos,nTab, MAXCOL,nCellPos,nTab ); |
| |
| for (i=0; i<nRangeCount; i++) |
| { |
| ScRange aRange(*aRanges.GetObject(i)); |
| if ( aRange.Intersects( aCellRange ) ) |
| { |
| if (bColumnDiff) |
| { |
| aRange.aStart.SetCol(static_cast<SCCOL>(nCellPos)); |
| aRange.aEnd.SetCol(static_cast<SCCOL>(nCellPos)); |
| } |
| else |
| { |
| aRange.aStart.SetRow(nCellPos); |
| aRange.aEnd.SetRow(nCellPos); |
| } |
| aMarkData.SetMultiMarkArea( aRange ); |
| } |
| } |
| } |
| pCmpCell = aCmpIter.GetNext(); |
| } |
| |
| // alle nichtleeren Zellen mit der Vergleichsspalte vergleichen und entsprechend |
| // selektieren oder aufheben |
| |
| ScAddress aCmpAddr; |
| for (i=0; i<nRangeCount; i++) |
| { |
| ScRange aRange(*aRanges.GetObject(i)); |
| |
| ScCellIterator aIter( pDoc, aRange ); |
| ScBaseCell* pCell = aIter.GetFirst(); |
| while (pCell) |
| { |
| if (bColumnDiff) |
| aCmpAddr = ScAddress( aIter.GetCol(), nCmpPos, aIter.GetTab() ); |
| else |
| aCmpAddr = ScAddress( static_cast<SCCOL>(nCmpPos), aIter.GetRow(), aIter.GetTab() ); |
| const ScBaseCell* pOtherCell = pDoc->GetCell( aCmpAddr ); |
| |
| ScRange aOneRange( aIter.GetCol(), aIter.GetRow(), aIter.GetTab() ); |
| if ( !ScBaseCell::CellEqual( pCell, pOtherCell ) ) |
| aMarkData.SetMultiMarkArea( aOneRange ); |
| else |
| aMarkData.SetMultiMarkArea( aOneRange, sal_False ); // deselect |
| |
| pCell = aIter.GetNext(); |
| } |
| } |
| |
| ScRangeList aNewRanges; |
| if (aMarkData.IsMultiMarked()) |
| aMarkData.FillRangeListWithMarks( &aNewRanges, sal_False ); |
| |
| return new ScCellRangesObj( pDocShell, aNewRanges ); // aNewRanges kann leer sein |
| } |
| return NULL; |
| } |
| |
| uno::Reference<sheet::XSheetCellRanges > SAL_CALL ScCellRangesBase::queryColumnDifferences( |
| const table::CellAddress& aCompare ) throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| return QueryDifferences_Impl( aCompare, sal_True ); |
| } |
| |
| uno::Reference<sheet::XSheetCellRanges> SAL_CALL ScCellRangesBase::queryRowDifferences( |
| const table::CellAddress& aCompare ) throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| return QueryDifferences_Impl( aCompare, sal_False ); |
| } |
| |
| uno::Reference<sheet::XSheetCellRanges> SAL_CALL ScCellRangesBase::queryIntersection( |
| const table::CellRangeAddress& aRange ) throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScRange aMask( (SCCOL)aRange.StartColumn, (SCROW)aRange.StartRow, aRange.Sheet, |
| (SCCOL)aRange.EndColumn, (SCROW)aRange.EndRow, aRange.Sheet ); |
| |
| ScRangeList aNew; |
| sal_uLong nCount = aRanges.Count(); |
| for (sal_uLong i=0; i<nCount; i++) |
| { |
| ScRange aTemp(*aRanges.GetObject(i)); |
| if ( aTemp.Intersects( aMask ) ) |
| aNew.Join( ScRange( Max( aTemp.aStart.Col(), aMask.aStart.Col() ), |
| Max( aTemp.aStart.Row(), aMask.aStart.Row() ), |
| Max( aTemp.aStart.Tab(), aMask.aStart.Tab() ), |
| Min( aTemp.aEnd.Col(), aMask.aEnd.Col() ), |
| Min( aTemp.aEnd.Row(), aMask.aEnd.Row() ), |
| Min( aTemp.aEnd.Tab(), aMask.aEnd.Tab() ) ) ); |
| } |
| |
| return new ScCellRangesObj( pDocShell, aNew ); // kann leer sein |
| } |
| |
| // XFormulaQuery |
| |
| uno::Reference<sheet::XSheetCellRanges> SAL_CALL ScCellRangesBase::queryPrecedents( |
| sal_Bool bRecursive ) throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| if ( pDocShell ) |
| { |
| ScDocument* pDoc = pDocShell->GetDocument(); |
| |
| ScRangeList aNewRanges(aRanges); |
| sal_Bool bFound; |
| do |
| { |
| bFound = sal_False; |
| |
| // #97205# aMarkData uses aNewRanges, not aRanges, so GetMarkData can't be used |
| ScMarkData aMarkData; |
| aMarkData.MarkFromRangeList( aNewRanges, sal_False ); |
| aMarkData.MarkToMulti(); // needed for IsAllMarked |
| |
| sal_uLong nCount = aNewRanges.Count(); |
| for (sal_uLong nR=0; nR<nCount; nR++) |
| { |
| ScRange aRange(*aNewRanges.GetObject(nR)); |
| ScCellIterator aIter( pDoc, aRange ); |
| ScBaseCell* pCell = aIter.GetFirst(); |
| while (pCell) |
| { |
| if ( pCell->GetCellType() == CELLTYPE_FORMULA ) |
| { |
| ScFormulaCell* pFCell = (ScFormulaCell*) pCell; |
| |
| ScDetectiveRefIter aRefIter( pFCell ); |
| ScRange aRefRange; |
| while ( aRefIter.GetNextRef( aRefRange) ) |
| { |
| if ( bRecursive && !bFound && !aMarkData.IsAllMarked( aRefRange ) ) |
| bFound = sal_True; |
| aMarkData.SetMultiMarkArea( aRefRange, sal_True ); |
| } |
| } |
| pCell = aIter.GetNext(); |
| } |
| } |
| |
| aMarkData.FillRangeListWithMarks( &aNewRanges, sal_True ); |
| } |
| while ( bRecursive && bFound ); |
| |
| return new ScCellRangesObj( pDocShell, aNewRanges ); |
| } |
| |
| return NULL; |
| } |
| |
| uno::Reference<sheet::XSheetCellRanges> SAL_CALL ScCellRangesBase::queryDependents( |
| sal_Bool bRecursive ) throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| if ( pDocShell ) |
| { |
| ScDocument* pDoc = pDocShell->GetDocument(); |
| |
| ScRangeList aNewRanges(aRanges); |
| sal_Bool bFound; |
| do |
| { |
| bFound = sal_False; |
| sal_uLong nRangesCount = aNewRanges.Count(); |
| |
| // #97205# aMarkData uses aNewRanges, not aRanges, so GetMarkData can't be used |
| ScMarkData aMarkData; |
| aMarkData.MarkFromRangeList( aNewRanges, sal_False ); |
| aMarkData.MarkToMulti(); // needed for IsAllMarked |
| |
| SCTAB 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) |
| { |
| sal_Bool bMark = sal_False; |
| ScDetectiveRefIter aIter( (ScFormulaCell*) pCell ); |
| ScRange aRefRange; |
| while ( aIter.GetNextRef( aRefRange) ) |
| { |
| for (sal_uLong nR=0; nR<nRangesCount; nR++) |
| { |
| ScRange aRange(*aNewRanges.GetObject(nR)); |
| if (aRange.Intersects(aRefRange)) |
| bMark = sal_True; // von Teil des Ranges abhaengig |
| } |
| } |
| if (bMark) |
| { |
| ScRange aCellRange( aCellIter.GetCol(), |
| aCellIter.GetRow(), |
| aCellIter.GetTab() ); |
| if ( bRecursive && !bFound && !aMarkData.IsAllMarked( aCellRange ) ) |
| bFound = sal_True; |
| aMarkData.SetMultiMarkArea( aCellRange, sal_True ); |
| } |
| } |
| pCell = aCellIter.GetNext(); |
| } |
| |
| aMarkData.FillRangeListWithMarks( &aNewRanges, sal_True ); |
| } |
| while ( bRecursive && bFound ); |
| |
| return new ScCellRangesObj( pDocShell, aNewRanges ); |
| } |
| |
| return NULL; |
| } |
| |
| // XSearchable |
| |
| uno::Reference<util::XSearchDescriptor> SAL_CALL ScCellRangesBase::createSearchDescriptor() |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| return new ScCellSearchObj; |
| } |
| |
| uno::Reference<container::XIndexAccess> SAL_CALL ScCellRangesBase::findAll( |
| const uno::Reference<util::XSearchDescriptor>& xDesc ) |
| throw(uno::RuntimeException) |
| { |
| // Wenn nichts gefunden wird, soll Null zurueckgegeben werden (?) |
| uno::Reference<container::XIndexAccess> 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(*GetMarkData()); |
| |
| String aDummyUndo; |
| SCCOL nCol = 0; |
| SCROW nRow = 0; |
| SCTAB nTab = 0; |
| sal_Bool bFound = pDoc->SearchAndReplace( *pSearchItem, nCol, nRow, nTab, |
| aMark, aDummyUndo, NULL ); |
| if (bFound) |
| { |
| ScRangeList aNewRanges; |
| aMark.FillRangeListWithMarks( &aNewRanges, sal_True ); |
| // bei findAll immer CellRanges, egal wieviel gefunden wurde |
| xRet.set(new ScCellRangesObj( pDocShell, aNewRanges )); |
| } |
| } |
| } |
| } |
| return xRet; |
| } |
| |
| uno::Reference<uno::XInterface> ScCellRangesBase::Find_Impl( |
| const uno::Reference<util::XSearchDescriptor>& xDesc, |
| const ScAddress* pLastPos ) |
| { |
| uno::Reference<uno::XInterface> 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(*GetMarkData()); |
| |
| SCCOL nCol; |
| SCROW nRow; |
| SCTAB nTab; |
| if (pLastPos) |
| pLastPos->GetVars( nCol, nRow, nTab ); |
| else |
| { |
| nTab = lcl_FirstTab(aRanges); //! mehrere Tabellen? |
| ScDocument::GetSearchAndReplaceStart( *pSearchItem, nCol, nRow ); |
| } |
| |
| String aDummyUndo; |
| sal_Bool bFound = pDoc->SearchAndReplace( *pSearchItem, nCol, nRow, nTab, |
| aMark, aDummyUndo, NULL ); |
| if (bFound) |
| { |
| ScAddress aFoundPos( nCol, nRow, nTab ); |
| xRet.set((cppu::OWeakObject*) new ScCellObj( pDocShell, aFoundPos )); |
| } |
| } |
| } |
| } |
| return xRet; |
| } |
| |
| uno::Reference<uno::XInterface> SAL_CALL ScCellRangesBase::findFirst( |
| const uno::Reference<util::XSearchDescriptor>& xDesc ) |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| return Find_Impl( xDesc, NULL ); |
| } |
| |
| uno::Reference<uno::XInterface> SAL_CALL ScCellRangesBase::findNext( |
| const uno::Reference<uno::XInterface>& xStartAt, |
| const uno::Reference<util::XSearchDescriptor >& 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<util::XReplaceDescriptor> SAL_CALL ScCellRangesBase::createReplaceDescriptor() |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| return new ScCellSearchObj; |
| } |
| |
| sal_Int32 SAL_CALL ScCellRangesBase::replaceAll( const uno::Reference<util::XSearchDescriptor>& xDesc ) |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| sal_Int32 nReplaced = 0; |
| if ( pDocShell && xDesc.is() ) |
| { |
| ScCellSearchObj* pSearch = ScCellSearchObj::getImplementation( xDesc ); |
| if (pSearch) |
| { |
| SvxSearchItem* pSearchItem = pSearch->GetSearchItem(); |
| if (pSearchItem) |
| { |
| ScDocument* pDoc = pDocShell->GetDocument(); |
| sal_Bool bUndo(pDoc->IsUndoEnabled()); |
| pSearchItem->SetCommand( SVX_SEARCHCMD_REPLACE_ALL ); |
| // immer nur innerhalb dieses Objekts |
| pSearchItem->SetSelection( !lcl_WholeSheet(aRanges) ); |
| |
| ScMarkData aMark(*GetMarkData()); |
| |
| SCTAB nTabCount = pDoc->GetTableCount(); |
| sal_Bool bProtected = !pDocShell->IsEditable(); |
| for (SCTAB i=0; i<nTabCount; i++) |
| if ( aMark.GetTableSelect(i) && pDoc->IsTabProtected(i) ) |
| bProtected = sal_True; |
| if (bProtected) |
| { |
| //! Exception, oder was? |
| } |
| else |
| { |
| SCTAB nTab = aMark.GetFirstSelected(); // bei SearchAndReplace nicht benutzt |
| SCCOL nCol = 0; |
| SCROW nRow = 0; |
| |
| String aUndoStr; |
| ScDocument* pUndoDoc = NULL; |
| if (bUndo) |
| { |
| pUndoDoc = new ScDocument( SCDOCMODE_UNDO ); |
| pUndoDoc->InitUndo( pDoc, nTab, nTab ); |
| } |
| for (SCTAB i=0; i<nTabCount; i++) |
| if ( aMark.GetTableSelect(i) && i != nTab && bUndo) |
| pUndoDoc->AddUndoTab( i, i ); |
| ScMarkData* pUndoMark = NULL; |
| if (bUndo) |
| pUndoMark = new ScMarkData(aMark); |
| |
| sal_Bool bFound(sal_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<sal_Int8 >& rId ) throw(uno::RuntimeException) |
| { |
| if ( rId.getLength() == 16 && |
| 0 == rtl_compareMemory( getUnoTunnelId().getConstArray(), |
| rId.getConstArray(), 16 ) ) |
| { |
| return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(this)); |
| } |
| return 0; |
| } |
| |
| // static |
| const uno::Sequence<sal_Int8>& ScCellRangesBase::getUnoTunnelId() |
| { |
| static uno::Sequence<sal_Int8> * 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<uno::XInterface> xObj ) |
| { |
| ScCellRangesBase* pRet = NULL; |
| uno::Reference<lang::XUnoTunnel> xUT( xObj, uno::UNO_QUERY ); |
| if (xUT.is()) |
| pRet = reinterpret_cast<ScCellRangesBase*>(sal::static_int_cast<sal_IntPtr>(xUT->getSomething(getUnoTunnelId()))); |
| return pRet; |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| ScCellRangesObj::ScCellRangesObj(ScDocShell* pDocSh, const ScRangeList& rR) : |
| ScCellRangesBase( pDocSh, rR ) |
| { |
| } |
| |
| ScCellRangesObj::~ScCellRangesObj() |
| { |
| } |
| |
| void ScCellRangesObj::RefChanged() |
| { |
| ScCellRangesBase::RefChanged(); |
| |
| // nix weiter... |
| } |
| |
| uno::Any SAL_CALL ScCellRangesObj::queryInterface( const uno::Type& rType ) |
| throw(uno::RuntimeException) |
| { |
| SC_QUERYINTERFACE( sheet::XSheetCellRangeContainer ) |
| 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() |
| { |
| ScCellRangesBase::acquire(); |
| } |
| |
| void SAL_CALL ScCellRangesObj::release() throw() |
| { |
| ScCellRangesBase::release(); |
| } |
| |
| uno::Sequence<uno::Type> SAL_CALL ScCellRangesObj::getTypes() throw(uno::RuntimeException) |
| { |
| static uno::Sequence<uno::Type> aTypes; |
| if ( aTypes.getLength() == 0 ) |
| { |
| uno::Sequence<uno::Type> 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<sheet::XSheetCellRangeContainer>*)0); |
| pPtr[nParentLen + 1] = getCppuType((const uno::Reference<container::XNameContainer>*)0); |
| pPtr[nParentLen + 2] = getCppuType((const uno::Reference<container::XEnumerationAccess>*)0); |
| |
| for (long i=0; i<nParentLen; i++) |
| pPtr[i] = pParentPtr[i]; // parent types first |
| } |
| return aTypes; |
| } |
| |
| uno::Sequence<sal_Int8> 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(sal_Int32 nIndex) const |
| { |
| ScDocShell* pDocSh = GetDocShell(); |
| const ScRangeList& rRanges = GetRangeList(); |
| if ( pDocSh && nIndex >= 0 && nIndex < sal::static_int_cast<sal_Int32>(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<table::CellRangeAddress> SAL_CALL ScCellRangesObj::getRangeAddresses() |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| const ScRangeList& rRanges = GetRangeList(); |
| sal_uLong nCount = rRanges.Count(); |
| if ( pDocSh && nCount ) |
| { |
| table::CellRangeAddress aRangeAddress; |
| uno::Sequence<table::CellRangeAddress> aSeq(nCount); |
| table::CellRangeAddress* pAry = aSeq.getArray(); |
| for (sal_uInt32 i=0; i<nCount; i++) |
| { |
| ScUnoConversion::FillApiRange( aRangeAddress, *rRanges.GetObject(i) ); |
| pAry[i] = aRangeAddress; |
| } |
| return aSeq; |
| } |
| |
| return uno::Sequence<table::CellRangeAddress>(0); // leer ist moeglich |
| } |
| |
| uno::Reference<container::XEnumerationAccess> 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; |
| } |
| |
| // XSheetCellRangeContainer |
| |
| void SAL_CALL ScCellRangesObj::addRangeAddress( const table::CellRangeAddress& rRange, |
| sal_Bool bMergeRanges ) |
| throw(::com::sun::star::uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScRange aRange(static_cast<SCCOL>(rRange.StartColumn), |
| static_cast<SCROW>(rRange.StartRow), |
| static_cast<SCTAB>(rRange.Sheet), |
| static_cast<SCCOL>(rRange.EndColumn), |
| static_cast<SCROW>(rRange.EndRow), |
| static_cast<SCTAB>(rRange.Sheet)); |
| AddRange(aRange, bMergeRanges); |
| } |
| |
| void lcl_RemoveNamedEntry( ScNamedEntryArr_Impl& rNamedEntries, const ScRange& rRange ) |
| { |
| sal_uInt16 nCount = rNamedEntries.Count(); |
| for ( sal_uInt16 n=nCount; n--; ) |
| if ( rNamedEntries[n]->GetRange() == rRange ) |
| rNamedEntries.DeleteAndDestroy( n ); |
| } |
| |
| void SAL_CALL ScCellRangesObj::removeRangeAddress( const table::CellRangeAddress& rRange ) |
| throw(::com::sun::star::container::NoSuchElementException, |
| ::com::sun::star::uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| const ScRangeList& rRanges = GetRangeList(); |
| |
| ScRangeList aSheetRanges; |
| ScRangeList aNotSheetRanges; |
| for (sal_uInt32 i = 0; i < rRanges.Count(); ++i) |
| { |
| if (rRanges.GetObject(i)->aStart.Tab() == rRange.Sheet) |
| { |
| aSheetRanges.Append(*rRanges.GetObject(i)); |
| } |
| else |
| { |
| aNotSheetRanges.Append(*rRanges.GetObject(i)); |
| } |
| } |
| ScMarkData aMarkData; |
| aMarkData.MarkFromRangeList( aSheetRanges, sal_False ); |
| ScRange aRange(static_cast<SCCOL>(rRange.StartColumn), |
| static_cast<SCROW>(rRange.StartRow), |
| static_cast<SCTAB>(rRange.Sheet), |
| static_cast<SCCOL>(rRange.EndColumn), |
| static_cast<SCROW>(rRange.EndRow), |
| static_cast<SCTAB>(rRange.Sheet)); |
| if (aMarkData.GetTableSelect( aRange.aStart.Tab() )) |
| { |
| aMarkData.MarkToMulti(); |
| if (aMarkData.IsAllMarked( aRange ) ) |
| { |
| aMarkData.SetMultiMarkArea( aRange, sal_False ); |
| lcl_RemoveNamedEntry(aNamedEntries, aRange); |
| } |
| else |
| throw container::NoSuchElementException(); |
| } |
| SetNewRanges(aNotSheetRanges); |
| ScRangeList aNew; |
| aMarkData.FillRangeListWithMarks( &aNew, sal_False ); |
| for (sal_uInt32 j = 0; j < aNew.Count(); ++j) |
| { |
| AddRange(*aNew.GetObject(j), sal_False); |
| } |
| } |
| |
| void SAL_CALL ScCellRangesObj::addRangeAddresses( const uno::Sequence<table::CellRangeAddress >& rRanges, |
| sal_Bool bMergeRanges ) |
| throw(::com::sun::star::uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| sal_Int32 nCount(rRanges.getLength()); |
| if (nCount) |
| { |
| const table::CellRangeAddress* pRanges = rRanges.getConstArray(); |
| for (sal_Int32 i = 0; i < rRanges.getLength(); i++, pRanges++) |
| { |
| ScRange aRange(static_cast<SCCOL>(pRanges->StartColumn), |
| static_cast<SCROW>(pRanges->StartRow), |
| static_cast<SCTAB>(pRanges->Sheet), |
| static_cast<SCCOL>(pRanges->EndColumn), |
| static_cast<SCROW>(pRanges->EndRow), |
| static_cast<SCTAB>(pRanges->Sheet)); |
| AddRange(aRange, bMergeRanges); |
| } |
| } |
| } |
| |
| void SAL_CALL ScCellRangesObj::removeRangeAddresses( const uno::Sequence<table::CellRangeAddress >& rRangeSeq ) |
| throw(::com::sun::star::container::NoSuchElementException, |
| ::com::sun::star::uno::RuntimeException) |
| { |
| // with this implementation not needed |
| // ScUnoGuard aGuard; |
| |
| |
| // use sometimes a better/faster implementation |
| sal_uInt32 nCount(rRangeSeq.getLength()); |
| if (nCount) |
| { |
| const table::CellRangeAddress* pRanges = rRangeSeq.getConstArray(); |
| for (sal_uInt32 i=0; i < nCount; ++i, ++pRanges) |
| { |
| removeRangeAddress(*pRanges); |
| } |
| } |
| } |
| |
| // XNameContainer |
| |
| void lcl_RemoveNamedEntry( ScNamedEntryArr_Impl& rNamedEntries, const String& rName ) |
| { |
| sal_uInt16 nCount = rNamedEntries.Count(); |
| for ( sal_uInt16 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(); |
| sal_Bool bDone = sal_False; |
| |
| //! Type of aElement can be some specific interface instead of XInterface |
| |
| uno::Reference<uno::XInterface> xInterface(aElement, uno::UNO_QUERY); |
| if ( pDocSh && xInterface.is() ) |
| { |
| ScCellRangesBase* pRangesImp = ScCellRangesBase::getImplementation( xInterface ); |
| if ( pRangesImp && pRangesImp->GetDocShell() == pDocSh ) |
| { |
| // if explicit name is given and already existing, throw exception |
| |
| String aNamStr(aName); |
| if ( aNamStr.Len() ) |
| { |
| sal_uInt16 nNamedCount = aNamedEntries.Count(); |
| for (sal_uInt16 n=0; n<nNamedCount; n++) |
| if ( aNamedEntries[n]->GetName() == aNamStr ) |
| throw container::ElementExistException(); |
| } |
| |
| ScRangeList aNew(GetRangeList()); |
| const ScRangeList& rAddRanges = pRangesImp->GetRangeList(); |
| sal_uLong nAddCount = rAddRanges.Count(); |
| for (sal_uLong i=0; i<nAddCount; i++) |
| aNew.Join( *rAddRanges.GetObject(i) ); |
| SetNewRanges(aNew); |
| bDone = sal_True; |
| |
| if ( aName.getLength() && nAddCount == 1 ) |
| { |
| // if a name is given, also insert into list of named entries |
| // (only possible for a single range) |
| // name is not in aNamedEntries (tested above) |
| |
| ScNamedEntry* pEntry = new ScNamedEntry( aNamStr, *rAddRanges.GetObject(0) ); |
| aNamedEntries.Insert( pEntry, aNamedEntries.Count() ); |
| } |
| } |
| } |
| |
| if (!bDone) |
| { |
| // invalid element - double names are handled above |
| throw lang::IllegalArgumentException(); |
| } |
| } |
| |
| sal_Bool lcl_FindRangeByName( const ScRangeList& rRanges, ScDocShell* pDocSh, |
| const String& rName, sal_uLong& rIndex ) |
| { |
| if (pDocSh) |
| { |
| String aRangeStr; |
| ScDocument* pDoc = pDocSh->GetDocument(); |
| sal_uLong nCount = rRanges.Count(); |
| for (sal_uLong i=0; i<nCount; i++) |
| { |
| rRanges.GetObject(i)->Format( aRangeStr, SCA_VALID | SCA_TAB_3D, pDoc ); |
| if ( aRangeStr == rName ) |
| { |
| rIndex = i; |
| return sal_True; |
| } |
| } |
| } |
| return sal_False; // nicht gefunden |
| } |
| |
| sal_Bool lcl_FindRangeOrEntry( const ScNamedEntryArr_Impl& rNamedEntries, |
| const ScRangeList& rRanges, ScDocShell* pDocSh, |
| const String& rName, ScRange& rFound ) |
| { |
| // exact range in list? |
| |
| sal_uLong nIndex = 0; |
| if ( lcl_FindRangeByName( rRanges, pDocSh, rName, nIndex ) ) |
| { |
| rFound = *rRanges.GetObject(nIndex); |
| return sal_True; |
| } |
| |
| // range contained in selection? (sheet must be specified) |
| |
| ScRange aCellRange; |
| sal_uInt16 nParse = aCellRange.ParseAny( rName, pDocSh->GetDocument() ); |
| if ( ( nParse & ( SCA_VALID | SCA_TAB_3D ) ) == ( SCA_VALID | SCA_TAB_3D ) ) |
| { |
| ScMarkData aMarkData; |
| aMarkData.MarkFromRangeList( rRanges, sal_False ); |
| aMarkData.MarkToMulti(); // needed for IsAllMarked |
| if ( aMarkData.IsAllMarked( aCellRange ) ) |
| { |
| rFound = aCellRange; |
| return sal_True; |
| } |
| } |
| |
| // named entry in this object? |
| |
| if ( rNamedEntries.Count() ) |
| { |
| for ( sal_uInt16 n=0; n<rNamedEntries.Count(); n++ ) |
| if ( rNamedEntries[n]->GetName() == rName ) |
| { |
| // test if named entry is contained in rRanges |
| |
| const ScRange& rComp = rNamedEntries[n]->GetRange(); |
| ScMarkData aMarkData; |
| aMarkData.MarkFromRangeList( rRanges, sal_False ); |
| aMarkData.MarkToMulti(); // needed for IsAllMarked |
| if ( aMarkData.IsAllMarked( rComp ) ) |
| { |
| rFound = rComp; |
| return sal_True; |
| } |
| } |
| } |
| |
| return sal_False; // not found |
| } |
| |
| void SAL_CALL ScCellRangesObj::removeByName( const rtl::OUString& aName ) |
| throw(container::NoSuchElementException, |
| lang::WrappedTargetException, uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| sal_Bool bDone = sal_False; |
| String aNameStr(aName); |
| ScDocShell* pDocSh = GetDocShell(); |
| const ScRangeList& rRanges = GetRangeList(); |
| sal_uLong nIndex = 0; |
| if ( lcl_FindRangeByName( rRanges, pDocSh, aNameStr, nIndex ) ) |
| { |
| // einzelnen Range weglassen |
| ScRangeList aNew; |
| sal_uLong nCount = rRanges.Count(); |
| for (sal_uLong i=0; i<nCount; i++) |
| if (i != nIndex) |
| aNew.Append( *rRanges.GetObject(i) ); |
| SetNewRanges(aNew); |
| bDone = sal_True; |
| } |
| else if (pDocSh) |
| { |
| // deselect any ranges (parsed or named entry) |
| ScRangeList aDiff; |
| sal_Bool bValid = ( aDiff.Parse( aNameStr, pDocSh->GetDocument() ) & SCA_VALID ) != 0; |
| if ( !bValid && aNamedEntries.Count() ) |
| { |
| sal_uInt16 nCount = aNamedEntries.Count(); |
| for (sal_uInt16 n=0; n<nCount && !bValid; n++) |
| if (aNamedEntries[n]->GetName() == aNameStr) |
| { |
| aDiff.RemoveAll(); |
| aDiff.Append( aNamedEntries[n]->GetRange() ); |
| bValid = sal_True; |
| } |
| } |
| if ( bValid ) |
| { |
| ScMarkData aMarkData; |
| aMarkData.MarkFromRangeList( rRanges, sal_False ); |
| |
| sal_uLong nDiffCount = aDiff.Count(); |
| for (sal_uLong i=0; i<nDiffCount; i++) |
| { |
| ScRange* pDiffRange = aDiff.GetObject(i); |
| if (aMarkData.GetTableSelect( pDiffRange->aStart.Tab() )) |
| aMarkData.SetMultiMarkArea( *pDiffRange, sal_False ); |
| } |
| |
| ScRangeList aNew; |
| aMarkData.FillRangeListWithMarks( &aNew, sal_False ); |
| SetNewRanges(aNew); |
| |
| bDone = sal_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<table::XCellRange> xRange; |
| if ( aRange.aStart == aRange.aEnd ) |
| xRange.set(new ScCellObj( pDocSh, aRange.aStart )); |
| else |
| xRange.set(new ScCellRangeObj( pDocSh, aRange )); |
| aRet <<= xRange; |
| } |
| else |
| throw container::NoSuchElementException(); |
| return aRet; |
| } |
| |
| sal_Bool lcl_FindEntryName( const ScNamedEntryArr_Impl& rNamedEntries, |
| const ScRange& rRange, String& rName ) |
| { |
| sal_uInt16 nCount = rNamedEntries.Count(); |
| for (sal_uInt16 i=0; i<nCount; i++) |
| if (rNamedEntries[i]->GetRange() == rRange) |
| { |
| rName = rNamedEntries[i]->GetName(); |
| return sal_True; |
| } |
| return sal_False; |
| } |
| |
| uno::Sequence<rtl::OUString> SAL_CALL ScCellRangesObj::getElementNames() |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| |
| ScDocShell* pDocSh = GetDocShell(); |
| const ScRangeList& rRanges = GetRangeList(); |
| if (pDocSh) |
| { |
| String aRangeStr; |
| ScDocument* pDoc = pDocSh->GetDocument(); |
| sal_uLong nCount = rRanges.Count(); |
| |
| uno::Sequence<rtl::OUString> aSeq(nCount); |
| rtl::OUString* pAry = aSeq.getArray(); |
| for (sal_uLong i=0; i<nCount; i++) |
| { |
| // use given name if for exactly this range, otherwise just format |
| ScRange aRange = *rRanges.GetObject(i); |
| if ( !aNamedEntries.Count() || !lcl_FindEntryName( aNamedEntries, aRange, aRangeStr ) ) |
| aRange.Format( aRangeStr, SCA_VALID | SCA_TAB_3D, pDoc ); |
| pAry[i] = aRangeStr; |
| } |
| return aSeq; |
| } |
| return uno::Sequence<rtl::OUString>(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<container::XEnumeration> SAL_CALL ScCellRangesObj::createEnumeration() |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| return new ScIndexEnumeration(this, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.sheet.SheetCellRangesEnumeration"))); |
| } |
| |
| // 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<table::XCellRange> xRange(GetObjectByIndex_Impl(nIndex)); |
| if (xRange.is()) |
| return uno::makeAny(xRange); |
| else |
| throw lang::IndexOutOfBoundsException(); |
| // return uno::Any(); |
| } |
| |
| uno::Type SAL_CALL ScCellRangesObj::getElementType() throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| return getCppuType((uno::Reference<table::XCellRange>*)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 ) || |
| aServiceStr.EqualsAscii( SCPARAPROPERTIES_SERVICE ); |
| } |
| |
| uno::Sequence<rtl::OUString> SAL_CALL ScCellRangesObj::getSupportedServiceNames() |
| throw(uno::RuntimeException) |
| { |
| uno::Sequence<rtl::OUString> aRet(4); |
| 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 ); |
| pArray[3] = rtl::OUString::createFromAscii( SCPARAPROPERTIES_SERVICE ); |
| return aRet; |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| // static |
| uno::Reference<table::XCellRange> 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 ), |
| pRangePropSet( lcl_GetRangePropertySet() ), |
| 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::XArrayFormulaTokens ) |
| SC_QUERYINTERFACE( sheet::XCellRangeData ) |
| SC_QUERYINTERFACE( sheet::XCellRangeFormula ) |
| 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 ) |
| SC_QUERYINTERFACE( sheet::XUniqueCellFormatRangesSupplier ) |
| |
| return ScCellRangesBase::queryInterface( rType ); |
| } |
| |
| void SAL_CALL ScCellRangeObj::acquire() throw() |
| { |
| ScCellRangesBase::acquire(); |
| } |
| |
| void SAL_CALL ScCellRangeObj::release() throw() |
| { |
| ScCellRangesBase::release(); |
| } |
| |
| uno::Sequence<uno::Type> SAL_CALL ScCellRangeObj::getTypes() throw(uno::RuntimeException) |
| { |
| static uno::Sequence<uno::Type> aTypes; |
| if ( aTypes.getLength() == 0 ) |
| { |
| uno::Sequence<uno::Type> aParentTypes(ScCellRangesBase::getTypes()); |
| long nParentLen = aParentTypes.getLength(); |
| const uno::Type* pParentPtr = aParentTypes.getConstArray(); |
| |
| aTypes.realloc( nParentLen + 17 ); |
| uno::Type* pPtr = aTypes.getArray(); |
| pPtr[nParentLen + 0] = getCppuType((const uno::Reference<sheet::XCellRangeAddressable>*)0); |
| pPtr[nParentLen + 1] = getCppuType((const uno::Reference<sheet::XSheetCellRange>*)0); |
| pPtr[nParentLen + 2] = getCppuType((const uno::Reference<sheet::XArrayFormulaRange>*)0); |
| pPtr[nParentLen + 3] = getCppuType((const uno::Reference<sheet::XArrayFormulaTokens>*)0); |
| pPtr[nParentLen + 4] = getCppuType((const uno::Reference<sheet::XCellRangeData>*)0); |
| pPtr[nParentLen + 5] = getCppuType((const uno::Reference<sheet::XCellRangeFormula>*)0); |
| pPtr[nParentLen + 6] = getCppuType((const uno::Reference<sheet::XMultipleOperation>*)0); |
| pPtr[nParentLen + 7] = getCppuType((const uno::Reference<util::XMergeable>*)0); |
| pPtr[nParentLen + 8] = getCppuType((const uno::Reference<sheet::XCellSeries>*)0); |
| pPtr[nParentLen + 9] = getCppuType((const uno::Reference<table::XAutoFormattable>*)0); |
| pPtr[nParentLen +10] = getCppuType((const uno::Reference<util::XSortable>*)0); |
| pPtr[nParentLen +11] = getCppuType((const uno::Reference<sheet::XSheetFilterableEx>*)0); |
| pPtr[nParentLen +12] = getCppuType((const uno::Reference<sheet::XSubTotalCalculatable>*)0); |
| pPtr[nParentLen +13] = getCppuType((const uno::Reference<table::XColumnRowRange>*)0); |
| pPtr[nParentLen +14] = getCppuType((const uno::Reference<util::XImportable>*)0); |
| pPtr[nParentLen +15] = getCppuType((const uno::Reference<sheet::XCellFormatRangesSupplier>*)0); |
| pPtr[nParentLen +16] = getCppuType((const uno::Reference<sheet::XUniqueCellFormatRangesSupplier>*)0); |
| |
| for (long i=0; i<nParentLen; i++) |
| pPtr[i] = pParentPtr[i]; // parent types first |
| } |
| return aTypes; |
| } |
| |
| uno::Sequence<sal_Int8> 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<table::XCell> ScCellRangeObj::GetCellByPosition_Impl( |
| sal_Int32 nColumn, sal_Int32 nRow ) |
| throw(lang::IndexOutOfBoundsException, uno::RuntimeException) |
| { |
| ScDocShell* pDocSh = GetDocShell(); |
| if (!pDocSh) |
| throw uno::RuntimeException(); |
| |
| if ( nColumn >= 0 && nRow >= 0 ) |
| { |
| sal_Int32 nPosX = aRange.aStart.Col() + nColumn; |
| sal_Int32 nPosY = aRange.aStart.Row() + nRow; |
| |
| if ( nPosX <= aRange.aEnd.Col() && nPosY <= aRange.aEnd.Row() ) |
| { |
| ScAddress aNew( (SCCOL)nPosX, (SCROW)nPosY, aRange.aStart.Tab() ); |
| return new ScCellObj( pDocSh, aNew ); |
| } |
| } |
| |
| throw lang::IndexOutOfBoundsException(); |
| // return NULL; |
| } |
| |
| uno::Reference<table::XCell> SAL_CALL ScCellRangeObj::getCellByPosition( |
| sal_Int32 nColumn, sal_Int32 nRow ) |
| throw(lang::IndexOutOfBoundsException, uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| |
| return GetCellByPosition_Impl(nColumn, nRow); |
| } |
| |
| uno::Reference<table::XCellRange> SAL_CALL ScCellRangeObj::getCellRangeByPosition( |
| sal_Int32 nLeft, sal_Int32 nTop, sal_Int32 nRight, sal_Int32 nBottom ) |
| throw(lang::IndexOutOfBoundsException, uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| |
| ScDocShell* pDocSh = GetDocShell(); |
| if (!pDocSh) |
| throw uno::RuntimeException(); |
| |
| if ( nLeft >= 0 && nTop >= 0 && nRight >= 0 && nBottom >= 0 ) |
| { |
| 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 ( nStartX <= nEndX && nEndX <= aRange.aEnd.Col() && |
| nStartY <= nEndY && nEndY <= aRange.aEnd.Row() ) |
| { |
| ScRange aNew( (SCCOL)nStartX, (SCROW)nStartY, aRange.aStart.Tab(), |
| (SCCOL)nEndX, (SCROW)nEndY, aRange.aEnd.Tab() ); |
| return new ScCellRangeObj( pDocSh, aNew ); |
| } |
| } |
| |
| throw lang::IndexOutOfBoundsException(); |
| // return NULL; |
| } |
| |
| |
| uno::Reference<table::XCellRange> SAL_CALL ScCellRangeObj::getCellRangeByName( |
| const rtl::OUString& aName ) throw(uno::RuntimeException) |
| { |
| return getCellRangeByName( aName, ScAddress::detailsOOOa1 ); |
| } |
| |
| uno::Reference<table::XCellRange> ScCellRangeObj::getCellRangeByName( |
| const rtl::OUString& aName, const ScAddress::Details& rDetails ) 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(); |
| SCTAB nTab = aRange.aStart.Tab(); |
| |
| ScRange aCellRange; |
| sal_Bool bFound = sal_False; |
| String aString(aName); |
| sal_uInt16 nParse = aCellRange.ParseAny( aString, pDoc, rDetails ); |
| if ( nParse & SCA_VALID ) |
| { |
| if ( !(nParse & SCA_TAB_3D) ) // keine Tabelle angegeben -> auf dieser Tabelle |
| { |
| aCellRange.aStart.SetTab(nTab); |
| aCellRange.aEnd.SetTab(nTab); |
| } |
| bFound = sal_True; |
| } |
| else |
| { |
| ScRangeUtil aRangeUtil; |
| if ( aRangeUtil.MakeRangeFromName( aString, pDoc, nTab, aCellRange, RUTL_NAMES ) || |
| aRangeUtil.MakeRangeFromName( aString, pDoc, nTab, aCellRange, RUTL_DBASE ) ) |
| bFound = sal_True; |
| } |
| |
| if (bFound) // valid only if within this object's range |
| { |
| if (!aRange.In(aCellRange)) |
| bFound = sal_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<table::XTableColumns> 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<table::XTableRows> 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<sheet::XSpreadsheet> 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 ScCellRangeObj::SetArrayFormula_Impl( const rtl::OUString& rFormula, |
| const rtl::OUString& rFormulaNmsp, const formula::FormulaGrammar::Grammar eGrammar ) throw(uno::RuntimeException) |
| { |
| ScDocShell* pDocSh = GetDocShell(); |
| if (pDocSh) |
| { |
| ScDocFunc aFunc(*pDocSh); |
| if ( rFormula.getLength() ) |
| { |
| if ( ScTableSheetObj::getImplementation( (cppu::OWeakObject*)this ) ) |
| { |
| // #74681# don't set array formula for sheet object |
| throw uno::RuntimeException(); |
| } |
| |
| aFunc.EnterMatrix( aRange, NULL, NULL, rFormula, sal_True, sal_True, rFormulaNmsp, eGrammar ); |
| } |
| else |
| { |
| // empty string -> erase array formula |
| ScMarkData aMark; |
| aMark.SetMarkArea( aRange ); |
| aMark.SelectTable( aRange.aStart.Tab(), sal_True ); |
| aFunc.DeleteContents( aMark, IDF_CONTENTS, sal_True, sal_True ); |
| } |
| } |
| } |
| |
| void SAL_CALL ScCellRangeObj::setArrayFormula( const rtl::OUString& aFormula ) |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| // GRAM_PODF_A1 for API compatibility. |
| SetArrayFormula_Impl( aFormula, ::rtl::OUString(), formula::FormulaGrammar::GRAM_PODF_A1); |
| } |
| |
| void ScCellRangeObj::SetArrayFormulaWithGrammar( const rtl::OUString& rFormula, |
| const rtl::OUString& rFormulaNmsp, const formula::FormulaGrammar::Grammar eGrammar ) throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| SetArrayFormula_Impl( rFormula, rFormulaNmsp, eGrammar); |
| } |
| |
| // XArrayFormulaTokens |
| |
| uno::Sequence<sheet::FormulaToken> SAL_CALL ScCellRangeObj::getArrayTokens() throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| |
| // same cell logic as in getArrayFormula |
| |
| uno::Sequence<sheet::FormulaToken> aSequence; |
| 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 ) |
| { |
| ScTokenArray* pTokenArray = pFCell1->GetCode(); |
| if ( pTokenArray ) |
| (void)ScTokenConversion::ConvertToTokenSequence( *pDoc, aSequence, *pTokenArray ); |
| } |
| } |
| } |
| } |
| return aSequence; |
| } |
| |
| void SAL_CALL ScCellRangeObj::setArrayTokens( const uno::Sequence<sheet::FormulaToken>& rTokens ) throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh ) |
| { |
| ScDocFunc aFunc(*pDocSh); |
| if ( rTokens.getLength() ) |
| { |
| if ( ScTableSheetObj::getImplementation( (cppu::OWeakObject*)this ) ) |
| { |
| throw uno::RuntimeException(); |
| } |
| |
| ScDocument* pDoc = pDocSh->GetDocument(); |
| ScTokenArray aTokenArray; |
| (void)ScTokenConversion::ConvertToTokenArray( *pDoc, aTokenArray, rTokens ); |
| |
| // Actually GRAM_PODF_A1 is a don't-care here because of the token |
| // array being set, it fits with other API compatibility grammars |
| // though. |
| aFunc.EnterMatrix( aRange, NULL, &aTokenArray, EMPTY_STRING, sal_True, sal_True, EMPTY_STRING, formula::FormulaGrammar::GRAM_PODF_A1 ); |
| } |
| else |
| { |
| // empty sequence -> erase array formula |
| ScMarkData aMark; |
| aMark.SetMarkArea( aRange ); |
| aMark.SelectTable( aRange.aStart.Tab(), sal_True ); |
| aFunc.DeleteContents( aMark, IDF_CONTENTS, sal_True, sal_True ); |
| } |
| } |
| } |
| |
| // XCellRangeData |
| |
| uno::Sequence< uno::Sequence<uno::Any> > 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, sal_True ) ) |
| { |
| uno::Sequence< uno::Sequence<uno::Any> > aSeq; |
| if ( aAny >>= aSeq ) |
| return aSeq; // success |
| } |
| } |
| |
| throw uno::RuntimeException(); // no other exceptions specified |
| // return uno::Sequence< uno::Sequence<uno::Any> >(0); |
| } |
| |
| void SAL_CALL ScCellRangeObj::setDataArray( |
| const uno::Sequence< uno::Sequence<uno::Any> >& aArray ) |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| |
| sal_Bool bDone = sal_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 |
| } |
| |
| // XCellRangeFormula |
| |
| uno::Sequence< uno::Sequence<rtl::OUString> > SAL_CALL ScCellRangeObj::getFormulaArray() |
| 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) |
| { |
| SCCOL nStartCol = aRange.aStart.Col(); |
| SCROW nStartRow = aRange.aStart.Row(); |
| SCCOL nEndCol = aRange.aEnd.Col(); |
| SCROW nEndRow = aRange.aEnd.Row(); |
| SCCOL nColCount = nEndCol + 1 - nStartCol; |
| SCROW nRowCount = nEndRow + 1 - nStartRow; |
| SCTAB nTab = aRange.aStart.Tab(); |
| |
| uno::Sequence< uno::Sequence<rtl::OUString> > aRowSeq( nRowCount ); |
| uno::Sequence<rtl::OUString>* pRowAry = aRowSeq.getArray(); |
| for (SCROW nRowIndex = 0; nRowIndex < nRowCount; nRowIndex++) |
| { |
| uno::Sequence<rtl::OUString> aColSeq( nColCount ); |
| rtl::OUString* pColAry = aColSeq.getArray(); |
| for (SCCOL nColIndex = 0; nColIndex < nColCount; nColIndex++) |
| pColAry[nColIndex] = lcl_GetInputString( pDocSh->GetDocument(), |
| ScAddress( nStartCol+nColIndex, nStartRow+nRowIndex, nTab ), sal_True ); |
| |
| pRowAry[nRowIndex] = aColSeq; |
| } |
| |
| return aRowSeq; |
| } |
| |
| throw uno::RuntimeException(); // no other exceptions specified |
| // return uno::Sequence< uno::Sequence<rtl::OUString> >(0); |
| } |
| |
| void SAL_CALL ScCellRangeObj::setFormulaArray( |
| const uno::Sequence< uno::Sequence<rtl::OUString> >& aArray ) |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| |
| sal_Bool bDone = sal_False; |
| ScDocShell* pDocSh = GetDocShell(); |
| if (pDocSh) |
| { |
| ScExternalRefManager::ApiGuard aExtRefGuard(pDocSh->GetDocument()); |
| |
| // GRAM_PODF_A1 for API compatibility. |
| bDone = lcl_PutFormulaArray( *pDocSh, aRange, aArray, EMPTY_STRING, formula::FormulaGrammar::GRAM_PODF_A1 ); |
| } |
| |
| 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) |
| { |
| sal_Bool bError = sal_False; |
| ScTabOpParam aParam; |
| aParam.aRefFormulaCell = ScRefAddress( (SCCOL)aFormulaRange.StartColumn, |
| (SCROW)aFormulaRange.StartRow, aFormulaRange.Sheet, |
| sal_False, sal_False, sal_False ); |
| aParam.aRefFormulaEnd = ScRefAddress( (SCCOL)aFormulaRange.EndColumn, |
| (SCROW)aFormulaRange.EndRow, aFormulaRange.Sheet, |
| sal_False, sal_False, sal_False ); |
| aParam.aRefRowCell = ScRefAddress( (SCCOL)aRowCell.Column, |
| (SCROW)aRowCell.Row, aRowCell.Sheet, |
| sal_False, sal_False, sal_False ); |
| aParam.aRefColCell = ScRefAddress( (SCCOL)aColumnCell.Column, |
| (SCROW)aColumnCell.Row, aColumnCell.Sheet, |
| sal_False, sal_False, sal_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 = sal_True; |
| } |
| |
| if (!bError) |
| { |
| ScDocFunc aFunc(*pDocSh); |
| aFunc.TabOp( aRange, NULL, aParam, sal_True, sal_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, sal_False, sal_True, sal_True ); |
| else |
| aFunc.UnmergeCells( aRange, sal_True, sal_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 ) |
| { |
| sal_Bool bError = sal_False; |
| |
| FillDir eDir = FILL_TO_BOTTOM; |
| 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 = sal_True; |
| } |
| |
| FillCmd eCmd = FILL_SIMPLE; |
| 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 = sal_True; |
| } |
| |
| FillDateCmd eDateCmd = FILL_DAY; |
| 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 = sal_True; |
| } |
| |
| if (!bError) |
| { |
| ScDocFunc aFunc(*pDocSh); |
| aFunc.FillSeries( aRange, NULL, eDir, eCmd, eDateCmd, |
| MAXDOUBLE, fStep, fEndValue, sal_True, sal_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); |
| SCsCOLROW nCount = 0; // "Dest-Count" |
| FillDir eDir = FILL_TO_BOTTOM; |
| sal_Bool bError = sal_False; |
| switch (nFillDirection) |
| { |
| case sheet::FillDirection_TO_BOTTOM: |
| aSourceRange.aEnd.SetRow( static_cast<SCROW>( 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( static_cast<SCCOL>( 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( static_cast<SCROW>( 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( static_cast<SCCOL>( aSourceRange.aEnd.Col() - nSourceCount + 1 ) ); |
| nCount = aSourceRange.aStart.Col() - aRange.aStart.Col(); |
| eDir = FILL_TO_LEFT; |
| break; |
| default: |
| bError = sal_True; |
| } |
| if (nCount < 0 || nCount > MAXROW) // overflow |
| bError = sal_True; |
| |
| if (!bError) |
| { |
| ScDocFunc aFunc(*pDocSh); |
| aFunc.FillAuto( aSourceRange, NULL, eDir, nCount, sal_True, sal_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); |
| sal_uInt16 nCount = pAutoFormat->GetCount(); |
| sal_uInt16 nIndex; |
| String aCompare; |
| for (nIndex=0; nIndex<nCount; nIndex++) |
| { |
| (*pAutoFormat)[nIndex]->GetName(aCompare); |
| if ( aCompare == aNameString ) //! Case-insensitiv ??? |
| break; |
| } |
| if (nIndex<nCount) |
| { |
| ScDocFunc aFunc(*pDocSh); |
| aFunc.AutoFormat( aRange, NULL, nIndex, sal_True, sal_True ); |
| } |
| else |
| throw lang::IllegalArgumentException(); |
| } |
| } |
| |
| // XSortable |
| |
| uno::Sequence<beans::PropertyValue> 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, SC_DBSEL_FORCE_MARK ); |
| if (pData) |
| { |
| pData->GetSortParam(aParam); |
| |
| // im SortDescriptor sind die Fields innerhalb des Bereichs gezaehlt |
| ScRange aDBRange; |
| pData->GetArea(aDBRange); |
| SCCOLROW nFieldStart = aParam.bByRow ? |
| static_cast<SCCOLROW>(aDBRange.aStart.Col()) : |
| static_cast<SCCOLROW>(aDBRange.aStart.Row()); |
| for (sal_uInt16 i=0; i<MAXSORT; i++) |
| if ( aParam.bDoSort[i] && aParam.nField[i] >= nFieldStart ) |
| aParam.nField[i] -= nFieldStart; |
| } |
| } |
| |
| uno::Sequence<beans::PropertyValue> aSeq( ScSortDescriptor::GetPropertyCount() ); |
| ScSortDescriptor::FillProperties( aSeq, aParam ); |
| return aSeq; |
| } |
| |
| void SAL_CALL ScCellRangeObj::sort( const uno::Sequence<beans::PropertyValue>& aDescriptor ) |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| if (pDocSh) |
| { |
| sal_uInt16 i; |
| ScSortParam aParam; |
| ScDBData* pData = pDocSh->GetDBData( aRange, SC_DB_MAKE, SC_DBSEL_FORCE_MARK ); // ggf. Bereich anlegen |
| if (pData) |
| { |
| // alten Einstellungen holen, falls nicht alles neu gesetzt wird |
| pData->GetSortParam(aParam); |
| SCCOLROW nOldStart = aParam.bByRow ? |
| static_cast<SCCOLROW>(aRange.aStart.Col()) : |
| static_cast<SCCOLROW>(aRange.aStart.Row()); |
| for (i=0; i<MAXSORT; i++) |
| if ( aParam.bDoSort[i] && aParam.nField[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 |
| SCCOLROW nFieldStart = aParam.bByRow ? |
| static_cast<SCCOLROW>(aRange.aStart.Col()) : |
| static_cast<SCCOLROW>(aRange.aStart.Row()); |
| for (i=0; i<MAXSORT; i++) |
| aParam.nField[i] += nFieldStart; |
| |
| SCTAB 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, SC_DBSEL_FORCE_MARK ); // ggf. Bereich anlegen |
| |
| ScDBDocFunc aFunc(*pDocSh); // Bereich muss angelegt sein |
| aFunc.Sort( nTab, aParam, sal_True, sal_True, sal_True ); |
| } |
| } |
| |
| // XFilterable |
| |
| uno::Reference<sheet::XSheetFilterDescriptor> SAL_CALL ScCellRangeObj::createFilterDescriptor( |
| sal_Bool bEmpty ) throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| ScFilterDescriptor* pNew = new ScFilterDescriptor(pDocSh); |
| if ( !bEmpty && pDocSh ) |
| { |
| // DB-Bereich anlegen erst beim Ausfuehren, per API immer genau den Bereich |
| ScDBData* pData = pDocSh->GetDBData( aRange, SC_DB_OLD, SC_DBSEL_FORCE_MARK ); |
| if (pData) |
| { |
| ScQueryParam aParam; |
| pData->GetQueryParam(aParam); |
| // im FilterDescriptor sind die Fields innerhalb des Bereichs gezaehlt |
| ScRange aDBRange; |
| pData->GetArea(aDBRange); |
| SCCOLROW nFieldStart = aParam.bByRow ? |
| static_cast<SCCOLROW>(aDBRange.aStart.Col()) : |
| static_cast<SCCOLROW>(aDBRange.aStart.Row()); |
| SCSIZE nCount = aParam.GetEntryCount(); |
| for (SCSIZE i=0; i<nCount; i++) |
| { |
| ScQueryEntry& rEntry = aParam.GetEntry(i); |
| if (rEntry.bDoQuery && rEntry.nField >= nFieldStart) |
| rEntry.nField -= nFieldStart; |
| } |
| pNew->SetParam(aParam); |
| } |
| } |
| return pNew; |
| } |
| |
| void SAL_CALL ScCellRangeObj::filter( const uno::Reference<sheet::XSheetFilterDescriptor>& 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? |
| |
| ScDocShell* pDocSh = GetDocShell(); |
| ScFilterDescriptor aImpl(pDocSh); |
| uno::Reference< sheet::XSheetFilterDescriptor2 > xDescriptor2( xDescriptor, uno::UNO_QUERY ); |
| if ( xDescriptor2.is() ) |
| { |
| aImpl.setFilterFields2( xDescriptor2->getFilterFields2() ); |
| } |
| else |
| { |
| aImpl.setFilterFields( xDescriptor->getFilterFields() ); |
| } |
| // Rest sind jetzt Properties... |
| |
| uno::Reference<beans::XPropertySet> xPropSet( xDescriptor, uno::UNO_QUERY ); |
| if (xPropSet.is()) |
| lcl_CopyProperties( aImpl, *(beans::XPropertySet*)xPropSet.get() ); |
| |
| // |
| // ausfuehren... |
| // |
| |
| if (pDocSh) |
| { |
| ScQueryParam aParam = aImpl.GetParam(); |
| // im FilterDescriptor sind die Fields innerhalb des Bereichs gezaehlt |
| SCCOLROW nFieldStart = aParam.bByRow ? |
| static_cast<SCCOLROW>(aRange.aStart.Col()) : |
| static_cast<SCCOLROW>(aRange.aStart.Row()); |
| SCSIZE nCount = aParam.GetEntryCount(); |
| for (SCSIZE i=0; i<nCount; i++) |
| { |
| ScQueryEntry& rEntry = aParam.GetEntry(i); |
| if (rEntry.bDoQuery) |
| { |
| rEntry.nField += nFieldStart; |
| // Im Dialog wird immer der String angezeigt -> muss zum Wert passen |
| if ( !rEntry.bQueryByString ) |
| pDocSh->GetDocument()->GetFormatTable()-> |
| GetInputLineString( rEntry.nVal, 0, *rEntry.pStr ); |
| } |
| } |
| |
| SCTAB 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, SC_DBSEL_FORCE_MARK ); // ggf. Bereich anlegen |
| |
| //! keep source range in filter descriptor |
| //! if created by createFilterDescriptorByObject ??? |
| |
| ScDBDocFunc aFunc(*pDocSh); |
| aFunc.Query( nTab, aParam, NULL, sal_True, sal_True ); // Bereich muss angelegt sein |
| } |
| } |
| |
| //! get/setAutoFilter als Properties!!! |
| |
| // XAdvancedFilterSource |
| |
| uno::Reference<sheet::XSheetFilterDescriptor> SAL_CALL ScCellRangeObj::createFilterDescriptorByObject( |
| const uno::Reference<sheet::XSheetFilterable>& xObject ) |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| |
| // this ist hier nicht der Bereich, der gefiltert wird, sondern der |
| // Bereich mit der Abfrage... |
| |
| uno::Reference<sheet::XCellRangeAddressable> xAddr( xObject, uno::UNO_QUERY ); |
| |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh && xAddr.is() ) |
| { |
| //! Test, ob xObject im selben Dokument ist |
| |
| ScFilterDescriptor* pNew = new ScFilterDescriptor(pDocSh); //! stattdessen vom Objekt? |
| //XSheetFilterDescriptorRef xNew = xObject->createFilterDescriptor(sal_True); |
| |
| ScQueryParam aParam = pNew->GetParam(); |
| aParam.bHasHeader = sal_True; |
| |
| table::CellRangeAddress aDataAddress(xAddr->getRangeAddress()); |
| aParam.nCol1 = (SCCOL)aDataAddress.StartColumn; |
| aParam.nRow1 = (SCROW)aDataAddress.StartRow; |
| aParam.nCol2 = (SCCOL)aDataAddress.EndColumn; |
| aParam.nRow2 = (SCROW)aDataAddress.EndRow; |
| aParam.nTab = aDataAddress.Sheet; |
| |
| ScDocument* pDoc = pDocSh->GetDocument(); |
| sal_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 |
| SCCOLROW nFieldStart = aParam.bByRow ? |
| static_cast<SCCOLROW>(aDataAddress.StartColumn) : |
| static_cast<SCCOLROW>(aDataAddress.StartRow); |
| SCSIZE nCount = aParam.GetEntryCount(); |
| for (SCSIZE i=0; i<nCount; i++) |
| { |
| ScQueryEntry& rEntry = aParam.GetEntry(i); |
| if (rEntry.bDoQuery && rEntry.nField >= 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<sheet::XSubTotalDescriptor> 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, SC_DBSEL_FORCE_MARK ); |
| if (pData) |
| { |
| ScSubTotalParam aParam; |
| pData->GetSubTotalParam(aParam); |
| // im SubTotalDescriptor sind die Fields innerhalb des Bereichs gezaehlt |
| ScRange aDBRange; |
| pData->GetArea(aDBRange); |
| SCCOL nFieldStart = aDBRange.aStart.Col(); |
| for (sal_uInt16 i=0; i<MAXSUBTOTAL; i++) |
| { |
| if ( aParam.bGroupActive[i] ) |
| { |
| if ( aParam.nField[i] >= nFieldStart ) |
| aParam.nField[i] = sal::static_int_cast<SCCOL>( aParam.nField[i] - nFieldStart ); |
| for (SCCOL j=0; j<aParam.nSubTotals[i]; j++) |
| if ( aParam.pSubTotals[i][j] >= nFieldStart ) |
| aParam.pSubTotals[i][j] = sal::static_int_cast<SCCOL>( aParam.pSubTotals[i][j] - nFieldStart ); |
| } |
| } |
| pNew->SetParam(aParam); |
| } |
| } |
| return pNew; |
| } |
| |
| void SAL_CALL ScCellRangeObj::applySubTotals( |
| const uno::Reference<sheet::XSubTotalDescriptor>& 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 |
| SCCOL nFieldStart = aRange.aStart.Col(); |
| for (sal_uInt16 i=0; i<MAXSUBTOTAL; i++) |
| { |
| if ( aParam.bGroupActive[i] ) |
| { |
| aParam.nField[i] = sal::static_int_cast<SCCOL>( aParam.nField[i] + nFieldStart ); |
| for (SCCOL j=0; j<aParam.nSubTotals[i]; j++) |
| aParam.pSubTotals[i][j] = sal::static_int_cast<SCCOL>( aParam.pSubTotals[i][j] + nFieldStart ); |
| } |
| } |
| |
| aParam.bReplace = bReplace; |
| |
| SCTAB 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, SC_DBSEL_FORCE_MARK ); // ggf. Bereich anlegen |
| |
| ScDBDocFunc aFunc(*pDocSh); |
| aFunc.DoSubTotals( nTab, aParam, NULL, sal_True, sal_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, SC_DBSEL_FORCE_MARK ); |
| if (pData) |
| pData->GetSubTotalParam(aParam); // auch bei Remove die Feld-Eintraege behalten |
| |
| aParam.bRemoveOnly = sal_True; |
| |
| SCTAB 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, SC_DBSEL_FORCE_MARK ); // ggf. Bereich anlegen |
| |
| ScDBDocFunc aFunc(*pDocSh); |
| aFunc.DoSubTotals( nTab, aParam, NULL, sal_True, sal_True ); // Bereich muss angelegt sein |
| } |
| } |
| |
| uno::Sequence<beans::PropertyValue> 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, SC_DBSEL_FORCE_MARK ); |
| if (pData) |
| pData->GetImportParam(aParam); |
| } |
| |
| uno::Sequence<beans::PropertyValue> aSeq( ScImportDescriptor::GetPropertyCount() ); |
| ScImportDescriptor::FillProperties( aSeq, aParam ); |
| return aSeq; |
| } |
| |
| void SAL_CALL ScCellRangeObj::doImport( const uno::Sequence<beans::PropertyValue>& aDescriptor ) |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| if (pDocSh) |
| { |
| ScImportParam aParam; |
| ScImportDescriptor::FillImportParam( aParam, aDescriptor ); |
| |
| SCTAB nTab = aRange.aStart.Tab(); |
| aParam.nCol1 = aRange.aStart.Col(); |
| aParam.nRow1 = aRange.aStart.Row(); |
| aParam.nCol2 = aRange.aEnd.Col(); |
| aParam.nRow2 = aRange.aEnd.Row(); |
| |
| //! TODO: could we get passed a valid result set by any means? |
| |
| pDocSh->GetDBData( aRange, SC_DB_MAKE, SC_DBSEL_FORCE_MARK ); // ggf. Bereich anlegen |
| |
| ScDBDocFunc aFunc(*pDocSh); // Bereich muss angelegt sein |
| aFunc.DoImport( nTab, aParam, NULL, sal_True ); //! Api-Flag as parameter |
| } |
| } |
| |
| // XCellFormatRangesSupplier |
| |
| uno::Reference<container::XIndexAccess> SAL_CALL ScCellRangeObj::getCellFormatRanges() |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh ) |
| return new ScCellFormatsObj( pDocSh, aRange ); |
| return NULL; |
| } |
| |
| // XUniqueCellFormatRangesSupplier |
| |
| uno::Reference<container::XIndexAccess> SAL_CALL ScCellRangeObj::getUniqueCellFormatRanges() |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh ) |
| return new ScUniqueCellFormatsObj( pDocSh, aRange ); |
| return NULL; |
| } |
| |
| // XPropertySet erweitert fuer Range-Properties |
| |
| uno::Reference<beans::XPropertySetInfo> SAL_CALL ScCellRangeObj::getPropertySetInfo() |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| static uno::Reference<beans::XPropertySetInfo> aRef( |
| new SfxItemPropertySetInfo( pRangePropSet->getPropertyMap() )); |
| return aRef; |
| } |
| |
| void ScCellRangeObj::SetOnePropertyValue( const SfxItemPropertySimpleEntry* pEntry, const uno::Any& aValue ) |
| throw(lang::IllegalArgumentException, uno::RuntimeException) |
| { |
| // Range has only Position and Size in addition to ScCellRangesBase, both are ReadOnly |
| // -> nothing to do here |
| |
| ScCellRangesBase::SetOnePropertyValue( pEntry, aValue ); |
| } |
| |
| void ScCellRangeObj::GetOnePropertyValue( const SfxItemPropertySimpleEntry* pEntry, |
| uno::Any& rAny ) |
| throw(uno::RuntimeException) |
| { |
| if ( pEntry ) |
| { |
| if ( pEntry->nWID == SC_WID_UNO_POS ) |
| { |
| ScDocShell* pDocSh = GetDocShell(); |
| if (pDocSh) |
| { |
| // GetMMRect converts using HMM_PER_TWIPS, like the 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() ); |
| rAny <<= aPos; |
| } |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_SIZE ) |
| { |
| ScDocShell* pDocSh = GetDocShell(); |
| if (pDocSh) |
| { |
| // GetMMRect converts using HMM_PER_TWIPS, like the 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() ); |
| rAny <<= aAwtSize; |
| } |
| } |
| else |
| ScCellRangesBase::GetOnePropertyValue( pEntry, rAny ); |
| |
| } |
| } |
| |
| const SfxItemPropertyMap* ScCellRangeObj::GetItemPropertyMap() |
| { |
| return pRangePropSet->getPropertyMap(); |
| } |
| |
| // 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 ) || |
| aServiceStr.EqualsAscii( SCPARAPROPERTIES_SERVICE ); |
| } |
| |
| uno::Sequence<rtl::OUString> SAL_CALL ScCellRangeObj::getSupportedServiceNames() |
| throw(uno::RuntimeException) |
| { |
| uno::Sequence<rtl::OUString> aRet(5); |
| 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 ); |
| pArray[4] = rtl::OUString::createFromAscii( SCPARAPROPERTIES_SERVICE ); |
| return aRet; |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| const SvxItemPropertySet* ScCellObj::GetEditPropertySet() // static |
| { |
| return lcl_GetEditPropertySet(); |
| } |
| const SfxItemPropertyMap* ScCellObj::GetCellPropertyMap() |
| { |
| return lcl_GetCellPropertySet()->getPropertyMap(); |
| } |
| |
| ScCellObj::ScCellObj(ScDocShell* pDocSh, const ScAddress& rP) : |
| ScCellRangeObj( pDocSh, ScRange(rP,rP) ), |
| pUnoText( NULL ), |
| pCellPropSet( lcl_GetCellPropertySet() ), |
| aCellPos( rP ), |
| nActionLockCount( 0 ) |
| { |
| // pUnoText is allocated on demand (GetUnoText) |
| // can't be aggregated because getString/setString is handled here |
| } |
| |
| SvxUnoText& ScCellObj::GetUnoText() |
| { |
| if (!pUnoText) |
| { |
| pUnoText = new ScCellTextObj( GetDocShell(), aCellPos ); |
| pUnoText->acquire(); |
| if (nActionLockCount) |
| { |
| ScSharedCellEditSource* pEditSource = |
| static_cast<ScSharedCellEditSource*> (pUnoText->GetEditSource()); |
| if (pEditSource) |
| pEditSource->SetDoUpdateData(sal_False); |
| } |
| } |
| 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::XFormulaTokens ) |
| 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 ) |
| SC_QUERYINTERFACE( document::XActionLockable ) |
| |
| return ScCellRangeObj::queryInterface( rType ); |
| } |
| |
| void SAL_CALL ScCellObj::acquire() throw() |
| { |
| ScCellRangeObj::acquire(); |
| } |
| |
| void SAL_CALL ScCellObj::release() throw() |
| { |
| ScCellRangeObj::release(); |
| } |
| |
| uno::Sequence<uno::Type> SAL_CALL ScCellObj::getTypes() throw(uno::RuntimeException) |
| { |
| static uno::Sequence<uno::Type> aTypes; |
| if ( aTypes.getLength() == 0 ) |
| { |
| uno::Sequence<uno::Type> aParentTypes(ScCellRangeObj::getTypes()); |
| long nParentLen = aParentTypes.getLength(); |
| const uno::Type* pParentPtr = aParentTypes.getConstArray(); |
| |
| aTypes.realloc( nParentLen + 8 ); |
| uno::Type* pPtr = aTypes.getArray(); |
| pPtr[nParentLen + 0] = getCppuType((const uno::Reference<table::XCell>*)0); |
| pPtr[nParentLen + 1] = getCppuType((const uno::Reference<sheet::XCellAddressable>*)0); |
| pPtr[nParentLen + 2] = getCppuType((const uno::Reference<text::XText>*)0); |
| pPtr[nParentLen + 3] = getCppuType((const uno::Reference<container::XEnumerationAccess>*)0); |
| pPtr[nParentLen + 4] = getCppuType((const uno::Reference<sheet::XSheetAnnotationAnchor>*)0); |
| pPtr[nParentLen + 5] = getCppuType((const uno::Reference<text::XTextFieldsSupplier>*)0); |
| pPtr[nParentLen + 6] = getCppuType((const uno::Reference<document::XActionLockable>*)0); |
| pPtr[nParentLen + 7] = getCppuType((const uno::Reference<sheet::XFormulaTokens>*)0); |
| |
| for (long i=0; i<nParentLen; i++) |
| pPtr[i] = pParentPtr[i]; // parent types first |
| } |
| return aTypes; |
| } |
| |
| uno::Sequence<sal_Int8> 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(sal_Bool bEnglish) const // fuer getFormula / FormulaLocal |
| { |
| if (GetDocShell()) |
| return lcl_GetInputString( GetDocShell()->GetDocument(), aCellPos, bEnglish ); |
| return String(); |
| } |
| |
| String ScCellObj::GetOutputString_Impl(ScDocument* pDoc, const ScAddress& aCellPos) |
| { |
| String aVal; |
| if ( pDoc ) |
| { |
| 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; |
| sal_uLong nNumFmt = pDoc->GetNumberFormat( aCellPos ); |
| ScCellFormat::GetString( pCell, nNumFmt, aVal, &pColor, *pDoc->GetFormatTable() ); |
| } |
| } |
| } |
| return aVal; |
| } |
| |
| String ScCellObj::GetOutputString_Impl() const |
| { |
| ScDocShell* pDocSh = GetDocShell(); |
| String aVal; |
| if ( pDocSh ) |
| aVal = GetOutputString_Impl(pDocSh->GetDocument(), aCellPos); |
| return aVal; |
| } |
| |
| void ScCellObj::SetString_Impl(const String& rString, sal_Bool bInterpret, sal_Bool bEnglish) |
| { |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh ) |
| { |
| ScDocFunc aFunc(*pDocSh); |
| // GRAM_PODF_A1 for API compatibility. |
| (void)aFunc.SetCellText( aCellPos, rString, bInterpret, bEnglish, sal_True, EMPTY_STRING, formula::FormulaGrammar::GRAM_PODF_A1 ); |
| } |
| } |
| |
| 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); |
| (void)aFunc.PutCell( aCellPos, new ScValueCell(fValue), sal_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)->SetHybridString( 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)->SetHybridDouble( fResult ); |
| } |
| } |
| |
| void ScCellObj::SetFormulaWithGrammar( const ::rtl::OUString& rFormula, |
| const ::rtl::OUString& rFormulaNmsp, const formula::FormulaGrammar::Grammar eGrammar ) |
| { |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh ) |
| { |
| ScDocFunc aFunc(*pDocSh); |
| aFunc.SetCellText( aCellPos, rFormula, sal_True, sal_True, sal_True, rFormulaNmsp, eGrammar); |
| } |
| } |
| |
| void ScCellObj::InputEnglishString( const ::rtl::OUString& rText ) |
| { |
| // This is like a mixture of setFormula and property FormulaLocal: |
| // The cell's number format is checked for "text", a new cell format may be set, |
| // but all parsing is in English. |
| |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh ) |
| { |
| String aString(rText); |
| ScDocument* pDoc = pDocSh->GetDocument(); |
| SvNumberFormatter* pFormatter = pDoc->GetFormatTable(); |
| sal_uInt32 nOldFormat = pDoc->GetNumberFormat( aCellPos ); |
| if ( pFormatter->GetType( nOldFormat ) == NUMBERFORMAT_TEXT ) |
| { |
| SetString_Impl(aString, sal_False, sal_False); // text cell |
| } |
| else |
| { |
| ScDocFunc aFunc(*pDocSh); |
| short nFormatType = 0; |
| ScBaseCell* pNewCell = aFunc.InterpretEnglishString( aCellPos, aString, |
| EMPTY_STRING, formula::FormulaGrammar::GRAM_PODF_A1, &nFormatType ); |
| if (pNewCell) |
| { |
| if ( ( nOldFormat % SV_COUNTRY_LANGUAGE_OFFSET ) == 0 && nFormatType != 0 ) |
| { |
| // apply a format for the recognized type and the old format's language |
| sal_uInt32 nNewFormat = ScGlobal::GetStandardFormat( *pFormatter, nOldFormat, nFormatType ); |
| if ( nNewFormat != nOldFormat ) |
| { |
| ScPatternAttr aPattern( pDoc->GetPool() ); |
| aPattern.GetItemSet().Put( SfxUInt32Item( ATTR_VALUE_FORMAT, nNewFormat ) ); |
| // ATTR_LANGUAGE_FORMAT remains unchanged |
| aFunc.ApplyAttributes( *GetMarkData(), aPattern, sal_True, sal_True ); |
| } |
| } |
| // put the cell into the document |
| // (after applying the format, so possible formula recalculation already uses the new format) |
| (void)aFunc.PutCell( aCellPos, pNewCell, sal_True ); |
| } |
| else |
| SetString_Impl(aString, sal_False, sal_False); // no cell from InterpretEnglishString, probably empty string |
| } |
| } |
| } |
| |
| // XText |
| |
| uno::Reference<text::XTextCursor> SAL_CALL ScCellObj::createTextCursor() |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| return new ScCellTextCursor( *this ); |
| } |
| |
| uno::Reference<text::XTextCursor> SAL_CALL ScCellObj::createTextCursorByRange( |
| const uno::Reference<text::XTextRange>& aTextPosition ) |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| SvxUnoTextCursor* pCursor = new ScCellTextCursor( *this ); |
| uno::Reference<text::XTextCursor> 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, sal_False, sal_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<text::XTextRange>& xRange, |
| const rtl::OUString& aString, sal_Bool bAbsorb ) |
| throw(uno::RuntimeException) |
| { |
| // special handling for ScCellTextCursor is no longer needed, |
| // SvxUnoText::insertString checks for SvxUnoTextRangeBase instead of SvxUnoTextRange |
| |
| ScUnoGuard aGuard; |
| GetUnoText().insertString(xRange, aString, bAbsorb); |
| } |
| |
| void SAL_CALL ScCellObj::insertControlCharacter( const uno::Reference<text::XTextRange>& 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<text::XTextRange >& xRange, |
| const uno::Reference<text::XTextContent >& 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 ); |
| |
| // #91431# for bAbsorb=sal_False, the new selection must be behind the inserted content |
| // (the xml filter relies on this) |
| if (!bAbsorb) |
| aSelection.nStartPos = aSelection.nEndPos; |
| |
| pTextRange->SetSelection( aSelection ); |
| |
| return; |
| } |
| } |
| GetUnoText().insertTextContent(xRange, xContent, bAbsorb); |
| } |
| |
| void SAL_CALL ScCellObj::removeTextContent( const uno::Reference<text::XTextContent>& 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<text::XText> SAL_CALL ScCellObj::getText() throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| return this; |
| } |
| |
| uno::Reference<text::XTextRange> SAL_CALL ScCellObj::getStart() throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| return GetUnoText().getStart(); |
| } |
| |
| uno::Reference<text::XTextRange> SAL_CALL ScCellObj::getEnd() throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| return GetUnoText().getEnd(); |
| } |
| |
| uno::Reference<container::XEnumeration> 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; |
| // sal_True = englisch |
| return GetInputString_Impl(sal_True); |
| } |
| |
| void SAL_CALL ScCellObj::setFormula( const rtl::OUString& aFormula ) throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| String aString(aFormula); |
| SetString_Impl(aString, sal_True, sal_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 ) |
| { |
| sal_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; |
| sal_uInt16 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; |
| } |
| |
| // XFormulaTokens |
| |
| uno::Sequence<sheet::FormulaToken> SAL_CALL ScCellObj::getTokens() throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| uno::Sequence<sheet::FormulaToken> aSequence; |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh ) |
| { |
| ScDocument* pDoc = pDocSh->GetDocument(); |
| ScBaseCell* pCell = pDoc->GetCell( aCellPos ); |
| if ( pCell && pCell->GetCellType() == CELLTYPE_FORMULA ) |
| { |
| ScTokenArray* pTokenArray = static_cast<ScFormulaCell*>(pCell)->GetCode(); |
| if ( pTokenArray ) |
| (void)ScTokenConversion::ConvertToTokenSequence( *pDoc, aSequence, *pTokenArray ); |
| } |
| } |
| return aSequence; |
| } |
| |
| void SAL_CALL ScCellObj::setTokens( const uno::Sequence<sheet::FormulaToken>& rTokens ) throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh ) |
| { |
| ScDocument* pDoc = pDocSh->GetDocument(); |
| ScTokenArray aTokenArray; |
| (void)ScTokenConversion::ConvertToTokenArray( *pDoc, aTokenArray, rTokens ); |
| |
| ScDocFunc aFunc( *pDocSh ); |
| ScBaseCell* pNewCell = new ScFormulaCell( pDoc, aCellPos, &aTokenArray ); |
| (void)aFunc.PutCell( aCellPos, pNewCell, sal_True ); |
| } |
| } |
| |
| // 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<sheet::XSheetAnnotation> 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<container::XEnumerationAccess> SAL_CALL ScCellObj::getTextFields() |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh ) |
| return new ScCellFieldsObj( pDocSh, aCellPos ); |
| |
| return NULL; |
| } |
| |
| uno::Reference<container::XNameAccess> SAL_CALL ScCellObj::getTextFieldMasters() |
| throw(uno::RuntimeException) |
| { |
| // sowas gibts nicht im Calc (?) |
| return NULL; |
| } |
| |
| // XPropertySet erweitert fuer Zell-Properties |
| |
| uno::Reference<beans::XPropertySetInfo> SAL_CALL ScCellObj::getPropertySetInfo() |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| static uno::Reference<beans::XPropertySetInfo> aRef( |
| new SfxItemPropertySetInfo( pCellPropSet->getPropertyMap() )); |
| return aRef; |
| } |
| |
| void ScCellObj::SetOnePropertyValue( const SfxItemPropertySimpleEntry* pEntry, const uno::Any& aValue ) |
| throw(lang::IllegalArgumentException, uno::RuntimeException) |
| { |
| if ( pEntry ) |
| { |
| if ( pEntry->nWID == SC_WID_UNO_FORMLOC ) |
| { |
| rtl::OUString aStrVal; |
| aValue >>= aStrVal; |
| String aString(aStrVal); |
| SetString_Impl(aString, sal_True, sal_False); // lokal interpretieren |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_FORMRT ) |
| { |
| // Read-Only |
| //! Exception oder so... |
| } |
| else |
| ScCellRangeObj::SetOnePropertyValue( pEntry, aValue ); |
| } |
| } |
| |
| void ScCellObj::GetOnePropertyValue( const SfxItemPropertySimpleEntry* pEntry, |
| uno::Any& rAny ) |
| throw(uno::RuntimeException) |
| { |
| if ( pEntry ) |
| { |
| if ( pEntry->nWID == SC_WID_UNO_FORMLOC ) |
| { |
| // sal_False = lokal |
| rAny <<= rtl::OUString( GetInputString_Impl(sal_False) ); |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_FORMRT ) |
| { |
| table::CellContentType eType = GetResultType_Impl(); |
| rAny <<= eType; |
| } |
| else |
| ScCellRangeObj::GetOnePropertyValue(pEntry, rAny); |
| } |
| } |
| |
| const SfxItemPropertyMap* ScCellObj::GetItemPropertyMap() |
| { |
| return pCellPropSet->getPropertyMap(); |
| } |
| |
| // 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( SCPARAPROPERTIES_SERVICE ) || |
| aServiceStr.EqualsAscii( SCSHEETCELLRANGE_SERVICE ) || |
| aServiceStr.EqualsAscii( SCCELLRANGE_SERVICE ); |
| } |
| |
| uno::Sequence<rtl::OUString> SAL_CALL ScCellObj::getSupportedServiceNames() |
| throw(uno::RuntimeException) |
| { |
| uno::Sequence<rtl::OUString> aRet(7); |
| 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( SCPARAPROPERTIES_SERVICE ); |
| pArray[5] = rtl::OUString::createFromAscii( SCSHEETCELLRANGE_SERVICE ); |
| pArray[6] = rtl::OUString::createFromAscii( SCCELLRANGE_SERVICE ); |
| return aRet; |
| } |
| |
| // XActionLockable |
| |
| sal_Bool SAL_CALL ScCellObj::isActionLocked() throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| return nActionLockCount != 0; |
| } |
| |
| void SAL_CALL ScCellObj::addActionLock() throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| if (!nActionLockCount) |
| { |
| if (pUnoText) |
| { |
| ScSharedCellEditSource* pEditSource = |
| static_cast<ScSharedCellEditSource*> (pUnoText->GetEditSource()); |
| if (pEditSource) |
| pEditSource->SetDoUpdateData(sal_False); |
| } |
| } |
| nActionLockCount++; |
| } |
| |
| void SAL_CALL ScCellObj::removeActionLock() throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| if (nActionLockCount > 0) |
| { |
| nActionLockCount--; |
| if (!nActionLockCount) |
| { |
| if (pUnoText) |
| { |
| ScSharedCellEditSource* pEditSource = |
| static_cast<ScSharedCellEditSource*> (pUnoText->GetEditSource()); |
| if (pEditSource) |
| { |
| pEditSource->SetDoUpdateData(sal_True); |
| if (pEditSource->IsDirty()) |
| pEditSource->UpdateData(); |
| } |
| } |
| } |
| } |
| } |
| |
| void SAL_CALL ScCellObj::setActionLocks( sal_Int16 nLock ) throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| if (pUnoText) |
| { |
| ScSharedCellEditSource* pEditSource = |
| static_cast<ScSharedCellEditSource*> (pUnoText->GetEditSource()); |
| if (pEditSource) |
| { |
| pEditSource->SetDoUpdateData(nLock == 0); |
| if ((nActionLockCount > 0) && (nLock == 0) && pEditSource->IsDirty()) |
| pEditSource->UpdateData(); |
| } |
| } |
| nActionLockCount = nLock; |
| } |
| |
| sal_Int16 SAL_CALL ScCellObj::resetActionLocks() throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| sal_uInt16 nRet(nActionLockCount); |
| if (pUnoText) |
| { |
| ScSharedCellEditSource* pEditSource = |
| static_cast<ScSharedCellEditSource*> (pUnoText->GetEditSource()); |
| if (pEditSource) |
| { |
| pEditSource->SetDoUpdateData(sal_True); |
| if (pEditSource->IsDirty()) |
| pEditSource->UpdateData(); |
| } |
| } |
| nActionLockCount = 0; |
| return nRet; |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| ScTableSheetObj::ScTableSheetObj( ScDocShell* pDocSh, SCTAB nTab ) : |
| ScCellRangeObj( pDocSh, ScRange(0,0,nTab, MAXCOL,MAXROW,nTab) ), |
| pSheetPropSet(lcl_GetSheetPropertySet()) |
| { |
| } |
| |
| ScTableSheetObj::~ScTableSheetObj() |
| { |
| } |
| |
| void ScTableSheetObj::InitInsertSheet(ScDocShell* pDocSh, SCTAB 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::XScenarioEnhanced ) |
| SC_QUERYINTERFACE( sheet::XSheetLinkable ) |
| SC_QUERYINTERFACE( sheet::XExternalSheetName ) |
| SC_QUERYINTERFACE( document::XEventsSupplier ) |
| |
| return ScCellRangeObj::queryInterface( rType ); |
| } |
| |
| void SAL_CALL ScTableSheetObj::acquire() throw() |
| { |
| ScCellRangeObj::acquire(); |
| } |
| |
| void SAL_CALL ScTableSheetObj::release() throw() |
| { |
| ScCellRangeObj::release(); |
| } |
| |
| uno::Sequence<uno::Type> SAL_CALL ScTableSheetObj::getTypes() throw(uno::RuntimeException) |
| { |
| static uno::Sequence<uno::Type> aTypes; |
| if ( aTypes.getLength() == 0 ) |
| { |
| uno::Sequence<uno::Type> aParentTypes = ScCellRangeObj::getTypes(); |
| long nParentLen = aParentTypes.getLength(); |
| const uno::Type* pParentPtr = aParentTypes.getConstArray(); |
| |
| aTypes.realloc( nParentLen + 18 ); |
| uno::Type* pPtr = aTypes.getArray(); |
| pPtr[nParentLen + 0] = getCppuType((const uno::Reference<sheet::XSpreadsheet>*)0); |
| pPtr[nParentLen + 1] = getCppuType((const uno::Reference<container::XNamed>*)0); |
| pPtr[nParentLen + 2] = getCppuType((const uno::Reference<sheet::XSheetPageBreak>*)0); |
| pPtr[nParentLen + 3] = getCppuType((const uno::Reference<sheet::XCellRangeMovement>*)0); |
| pPtr[nParentLen + 4] = getCppuType((const uno::Reference<table::XTableChartsSupplier>*)0); |
| pPtr[nParentLen + 5] = getCppuType((const uno::Reference<sheet::XDataPilotTablesSupplier>*)0); |
| pPtr[nParentLen + 6] = getCppuType((const uno::Reference<sheet::XScenariosSupplier>*)0); |
| pPtr[nParentLen + 7] = getCppuType((const uno::Reference<sheet::XSheetAnnotationsSupplier>*)0); |
| pPtr[nParentLen + 8] = getCppuType((const uno::Reference<drawing::XDrawPageSupplier>*)0); |
| pPtr[nParentLen + 9] = getCppuType((const uno::Reference<sheet::XPrintAreas>*)0); |
| pPtr[nParentLen +10] = getCppuType((const uno::Reference<sheet::XSheetAuditing>*)0); |
| pPtr[nParentLen +11] = getCppuType((const uno::Reference<sheet::XSheetOutline>*)0); |
| pPtr[nParentLen +12] = getCppuType((const uno::Reference<util::XProtectable>*)0); |
| pPtr[nParentLen +13] = getCppuType((const uno::Reference<sheet::XScenario>*)0); |
| pPtr[nParentLen +14] = getCppuType((const uno::Reference<sheet::XScenarioEnhanced>*)0); |
| pPtr[nParentLen +15] = getCppuType((const uno::Reference<sheet::XSheetLinkable>*)0); |
| pPtr[nParentLen +16] = getCppuType((const uno::Reference<sheet::XExternalSheetName>*)0); |
| pPtr[nParentLen +17] = getCppuType((const uno::Reference<document::XEventsSupplier>*)0); |
| |
| for (long i=0; i<nParentLen; i++) |
| pPtr[i] = pParentPtr[i]; // parent types first |
| } |
| return aTypes; |
| } |
| |
| uno::Sequence<sal_Int8> 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 |
| |
| SCTAB 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<table::XTableCharts> 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<sheet::XDataPilotTables> 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<sheet::XScenarios> 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<sheet::XSheetAnnotations> 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<table::XCellRange> SAL_CALL ScTableSheetObj::getCellRangeByName( |
| const rtl::OUString& rRange ) throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| return ScCellRangeObj::getCellRangeByName( rRange ); |
| } |
| |
| uno::Reference<sheet::XSheetCellCursor> SAL_CALL ScTableSheetObj::createCursor() |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh ) |
| { |
| //! einzelne Zelle oder ganze Tabelle??????? |
| SCTAB nTab = GetTab_Impl(); |
| return new ScCellCursorObj( pDocSh, ScRange( 0,0,nTab, MAXCOL,MAXROW,nTab ) ); |
| } |
| return NULL; |
| } |
| |
| uno::Reference<sheet::XSheetCellCursor> SAL_CALL ScTableSheetObj::createCursorByRange( |
| const uno::Reference<sheet::XSheetCellRange>& xCellRange ) |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh && xCellRange.is() ) |
| { |
| ScCellRangesBase* pRangesImp = ScCellRangesBase::getImplementation( xCellRange ); |
| 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<sheet::XSpreadsheet> SAL_CALL ScTableSheetObj::getSpreadsheet() |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| return this; //!??? |
| } |
| |
| // XCellRange |
| |
| uno::Reference<table::XCell> SAL_CALL ScTableSheetObj::getCellByPosition( |
| sal_Int32 nColumn, sal_Int32 nRow ) |
| throw(lang::IndexOutOfBoundsException, uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| return ScCellRangeObj::GetCellByPosition_Impl(nColumn, nRow); |
| } |
| |
| uno::Reference<table::XCellRange> SAL_CALL ScTableSheetObj::getCellRangeByPosition( |
| sal_Int32 nLeft, sal_Int32 nTop, sal_Int32 nRight, sal_Int32 nBottom ) |
| throw(lang::IndexOutOfBoundsException, uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| return ScCellRangeObj::getCellRangeByPosition(nLeft,nTop,nRight,nBottom); |
| } |
| |
| uno::Sequence<sheet::TablePageBreakData> SAL_CALL ScTableSheetObj::getColumnPageBreaks() |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh ) |
| { |
| ScDocument* pDoc = pDocSh->GetDocument(); |
| SCTAB 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(); |
| } |
| |
| SCCOL nCount = 0; |
| SCCOL nCol; |
| for (nCol=0; nCol<=MAXCOL; nCol++) |
| if (pDoc->HasColBreak(nCol, nTab)) |
| ++nCount; |
| |
| sheet::TablePageBreakData aData; |
| uno::Sequence<sheet::TablePageBreakData> aSeq(nCount); |
| sheet::TablePageBreakData* pAry = aSeq.getArray(); |
| sal_uInt16 nPos = 0; |
| for (nCol=0; nCol<=MAXCOL; nCol++) |
| { |
| ScBreakType nBreak = pDoc->HasColBreak(nCol, nTab); |
| if (nBreak) |
| { |
| aData.Position = nCol; |
| aData.ManualBreak = (nBreak & BREAK_MANUAL); |
| pAry[nPos] = aData; |
| ++nPos; |
| } |
| } |
| return aSeq; |
| } |
| return uno::Sequence<sheet::TablePageBreakData>(0); |
| } |
| |
| uno::Sequence<sheet::TablePageBreakData> SAL_CALL ScTableSheetObj::getRowPageBreaks() |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh ) |
| { |
| ScDocument* pDoc = pDocSh->GetDocument(); |
| SCTAB 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(); |
| } |
| return pDoc->GetRowBreakData(nTab); |
| } |
| return uno::Sequence<sheet::TablePageBreakData>(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(); |
| sal_Bool bUndo (pDoc->IsUndoEnabled()); |
| SCTAB nTab = GetTab_Impl(); |
| |
| if (bUndo) |
| { |
| ScDocument* pUndoDoc = new ScDocument( SCDOCMODE_UNDO ); |
| pUndoDoc->InitUndo( pDoc, nTab, nTab, sal_True, sal_True ); |
| pDoc->CopyToDocument( 0,0,nTab, MAXCOL,MAXROW,nTab, IDF_NONE, sal_False, pUndoDoc ); |
| pDocSh->GetUndoManager()->AddUndoAction( |
| new ScUndoRemoveBreaks( pDocSh, nTab, pUndoDoc ) ); |
| } |
| |
| pDoc->RemoveManualBreaks(nTab); |
| pDoc->UpdatePageBreaks(nTab); |
| |
| //? UpdatePageBreakData( sal_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, sal_True, sal_True ); |
| } |
| } |
| |
| // XDrawPageSupplier |
| |
| uno::Reference<drawing::XDrawPage> 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"); |
| |
| SCTAB nTab = GetTab_Impl(); |
| SdrPage* pPage = pDrawLayer->GetPage(static_cast<sal_uInt16>(nTab)); |
| DBG_ASSERT(pPage,"Draw-Page nicht gefunden"); |
| if (pPage) |
| return uno::Reference<drawing::XDrawPage> (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& rRangeAddress, |
| sheet::CellInsertMode nMode ) throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh ) |
| { |
| sal_Bool bDo = sal_True; |
| InsCellCmd eCmd = INS_NONE; |
| switch (nMode) |
| { |
| case sheet::CellInsertMode_NONE: bDo = sal_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 = sal_False; |
| } |
| |
| if (bDo) |
| { |
| DBG_ASSERT( rRangeAddress.Sheet == GetTab_Impl(), "falsche Tabelle in CellRangeAddress" ); |
| ScRange aScRange; |
| ScUnoConversion::FillScRange( aScRange, rRangeAddress ); |
| ScDocFunc aFunc(*pDocSh); |
| aFunc.InsertCells( aScRange, NULL, eCmd, sal_True, sal_True ); |
| } |
| } |
| } |
| |
| void SAL_CALL ScTableSheetObj::removeRange( const table::CellRangeAddress& rRangeAddress, |
| sheet::CellDeleteMode nMode ) throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh ) |
| { |
| sal_Bool bDo = sal_True; |
| DelCellCmd eCmd = DEL_NONE; |
| switch (nMode) |
| { |
| case sheet::CellDeleteMode_NONE: bDo = sal_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 = sal_False; |
| } |
| |
| if (bDo) |
| { |
| DBG_ASSERT( rRangeAddress.Sheet == GetTab_Impl(), "falsche Tabelle in CellRangeAddress" ); |
| ScRange aScRange; |
| ScUnoConversion::FillScRange( aScRange, rRangeAddress ); |
| ScDocFunc aFunc(*pDocSh); |
| aFunc.DeleteCells( aScRange, NULL, eCmd, sal_True, sal_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 aSourceRange; |
| ScUnoConversion::FillScRange( aSourceRange, aSource ); |
| ScAddress aDestPos( (SCCOL)aDestination.Column, (SCROW)aDestination.Row, aDestination.Sheet ); |
| ScDocFunc aFunc(*pDocSh); |
| aFunc.MoveBlock( aSourceRange, aDestPos, sal_True, sal_True, sal_True, sal_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 aSourceRange; |
| ScUnoConversion::FillScRange( aSourceRange, aSource ); |
| ScAddress aDestPos( (SCCOL)aDestination.Column, (SCROW)aDestination.Row, aDestination.Sheet ); |
| ScDocFunc aFunc(*pDocSh); |
| aFunc.MoveBlock( aSourceRange, aDestPos, sal_False, sal_True, sal_True, sal_True ); |
| } |
| } |
| |
| // XPrintAreas |
| |
| void ScTableSheetObj::PrintAreaUndo_Impl( ScPrintRangeSaver* pOldRanges ) |
| { |
| // Umbrueche und Undo |
| ScDocShell* pDocSh = GetDocShell(); |
| ScDocument* pDoc = pDocSh ? pDocSh->GetDocument() : 0; |
| |
| if(pDocSh && pDoc) |
| { |
| const bool bUndo(pDoc->IsUndoEnabled()); |
| const SCTAB nTab(GetTab_Impl()); |
| |
| if(bUndo) |
| { |
| pDocSh->GetUndoManager()->AddUndoAction( |
| new ScUndoPrintRange( |
| pDocSh, |
| nTab, |
| pOldRanges, |
| pDoc->CreatePrintRangeSaver())); // create new ranges |
| |
| // #120105# ownership of old ranges has changed, mark as consumed |
| pOldRanges = 0; |
| } |
| |
| ScPrintFunc(pDocSh, pDocSh->GetPrinter(), nTab).UpdatePages(); |
| SfxBindings* pBindings = pDocSh->GetViewBindings(); |
| |
| if(pBindings) |
| { |
| pBindings->Invalidate(SID_DELETE_PRINTAREA); |
| } |
| |
| pDocSh->SetDocumentModified(); |
| } |
| |
| if(pOldRanges) |
| { |
| // #120105# pOldRanges not used, need to cleanup |
| delete pOldRanges; |
| } |
| } |
| |
| uno::Sequence<table::CellRangeAddress> SAL_CALL ScTableSheetObj::getPrintAreas() |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh ) |
| { |
| ScDocument* pDoc = pDocSh->GetDocument(); |
| SCTAB nTab = GetTab_Impl(); |
| sal_uInt16 nCount = pDoc->GetPrintRangeCount( nTab ); |
| |
| table::CellRangeAddress aRangeAddress; |
| uno::Sequence<table::CellRangeAddress> aSeq(nCount); |
| table::CellRangeAddress* pAry = aSeq.getArray(); |
| for (sal_uInt16 i=0; i<nCount; i++) |
| { |
| const ScRange* pRange = pDoc->GetPrintRange( nTab, i ); |
| DBG_ASSERT(pRange,"wo ist der Druckbereich"); |
| if (pRange) |
| { |
| ScUnoConversion::FillApiRange( aRangeAddress, *pRange ); |
| aRangeAddress.Sheet = nTab; // core does not care about sheet index |
| pAry[i] = aRangeAddress; |
| } |
| } |
| return aSeq; |
| } |
| return uno::Sequence<table::CellRangeAddress>(); |
| } |
| |
| void SAL_CALL ScTableSheetObj::setPrintAreas( |
| const uno::Sequence<table::CellRangeAddress>& aPrintAreas ) |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh ) |
| { |
| ScDocument* pDoc = pDocSh->GetDocument(); |
| SCTAB nTab = GetTab_Impl(); |
| |
| ScPrintRangeSaver* pOldRanges = pDoc->CreatePrintRangeSaver(); |
| |
| sal_uInt16 nCount = (sal_uInt16) aPrintAreas.getLength(); |
| pDoc->ClearPrintRanges( nTab ); |
| if (nCount) |
| { |
| ScRange aPrintRange; |
| const table::CellRangeAddress* pAry = aPrintAreas.getConstArray(); |
| for (sal_uInt16 i=0; i<nCount; i++) |
| { |
| ScUnoConversion::FillScRange( aPrintRange, pAry[i] ); |
| pDoc->AddPrintRange( nTab, aPrintRange ); |
| } |
| } |
| |
| 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(); |
| SCTAB nTab = GetTab_Impl(); |
| return ( pDoc->GetRepeatColRange(nTab) != NULL ); |
| } |
| return sal_False; |
| } |
| |
| void SAL_CALL ScTableSheetObj::setPrintTitleColumns( sal_Bool bPrintTitleColumns ) |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh ) |
| { |
| ScDocument* pDoc = pDocSh->GetDocument(); |
| SCTAB 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(); |
| SCTAB nTab = GetTab_Impl(); |
| const ScRange* pRange = pDoc->GetRepeatColRange(nTab); |
| if (pRange) |
| { |
| ScUnoConversion::FillApiRange( aRet, *pRange ); |
| aRet.Sheet = nTab; // core does not care about sheet index |
| } |
| } |
| 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(); |
| SCTAB 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(); |
| SCTAB nTab = GetTab_Impl(); |
| return ( pDoc->GetRepeatRowRange(nTab) != NULL ); |
| } |
| return sal_False; |
| } |
| |
| void SAL_CALL ScTableSheetObj::setPrintTitleRows( sal_Bool bPrintTitleRows ) |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh ) |
| { |
| ScDocument* pDoc = pDocSh->GetDocument(); |
| SCTAB 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(); |
| SCTAB nTab = GetTab_Impl(); |
| const ScRange* pRange = pDoc->GetRepeatRowRange(nTab); |
| if (pRange) |
| { |
| ScUnoConversion::FillApiRange( aRet, *pRange ); |
| aRet.Sheet = nTab; // core does not care about sheet index |
| } |
| } |
| 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(); |
| SCTAB 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 ) |
| { |
| sal_uInt8 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(); |
| SCTAB 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, sal_True, sal_False ); |
| |
| // remove application prefix from filter name here, so the filter options |
| // aren't reset when the filter name is changed in ScTableLink::DataChanged |
| ScDocumentLoader::RemoveAppPrefix( aFilterString ); |
| |
| sal_uInt8 nLinkMode = SC_LINK_NONE; |
| if ( nMode == sheet::SheetLinkMode_NORMAL ) |
| nLinkMode = SC_LINK_NORMAL; |
| else if ( nMode == sheet::SheetLinkMode_VALUE ) |
| nLinkMode = SC_LINK_VALUE; |
| |
| sal_uLong nRefresh = 0; |
| pDoc->SetLink( nTab, nLinkMode, aFileString, aFilterString, aOptString, aSheetString, nRefresh ); |
| |
| 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 && pDoc->IsExecuteLinkEnabled() ) // Link updaten |
| { |
| // Update immer, auch wenn der Link schon da war |
| //! Update nur fuer die betroffene Tabelle??? |
| |
| sfx2::LinkManager* pLinkManager = pDoc->GetLinkManager(); |
| sal_uInt16 nCount = pLinkManager->GetLinks().Count(); |
| for ( sal_uInt16 i=0; i<nCount; i++ ) |
| { |
| ::sfx2::SvBaseLink* pBase = *pLinkManager->GetLinks()[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 ) |
| { |
| SCTAB nTab = GetTab_Impl(); |
| DBG_ASSERT( aPosition.Sheet == nTab, "falsche Tabelle in CellAddress" ); |
| ScAddress aPos( (SCCOL)aPosition.Column, (SCROW)aPosition.Row, nTab ); |
| ScDocFunc aFunc(*pDocSh); |
| return aFunc.DetectiveDelSucc( aPos ); |
| } |
| return sal_False; |
| } |
| |
| sal_Bool SAL_CALL ScTableSheetObj::hidePrecedents( const table::CellAddress& aPosition ) |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh ) |
| { |
| SCTAB nTab = GetTab_Impl(); |
| DBG_ASSERT( aPosition.Sheet == nTab, "falsche Tabelle in CellAddress" ); |
| ScAddress aPos( (SCCOL)aPosition.Column, (SCROW)aPosition.Row, nTab ); |
| ScDocFunc aFunc(*pDocSh); |
| return aFunc.DetectiveDelPred( aPos ); |
| } |
| return sal_False; |
| } |
| |
| sal_Bool SAL_CALL ScTableSheetObj::showDependents( const table::CellAddress& aPosition ) |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh ) |
| { |
| SCTAB nTab = GetTab_Impl(); |
| DBG_ASSERT( aPosition.Sheet == nTab, "falsche Tabelle in CellAddress" ); |
| ScAddress aPos( (SCCOL)aPosition.Column, (SCROW)aPosition.Row, nTab ); |
| ScDocFunc aFunc(*pDocSh); |
| return aFunc.DetectiveAddSucc( aPos ); |
| } |
| return sal_False; |
| } |
| |
| sal_Bool SAL_CALL ScTableSheetObj::showPrecedents( const table::CellAddress& aPosition ) |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh ) |
| { |
| SCTAB nTab = GetTab_Impl(); |
| DBG_ASSERT( aPosition.Sheet == nTab, "falsche Tabelle in CellAddress" ); |
| ScAddress aPos( (SCCOL)aPosition.Column, (SCROW)aPosition.Row, nTab ); |
| ScDocFunc aFunc(*pDocSh); |
| return aFunc.DetectiveAddPred( aPos ); |
| } |
| return sal_False; |
| } |
| |
| sal_Bool SAL_CALL ScTableSheetObj::showErrors( const table::CellAddress& aPosition ) |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh ) |
| { |
| SCTAB nTab = GetTab_Impl(); |
| DBG_ASSERT( aPosition.Sheet == nTab, "falsche Tabelle in CellAddress" ); |
| ScAddress aPos( (SCCOL)aPosition.Column, (SCROW)aPosition.Row, nTab ); |
| ScDocFunc aFunc(*pDocSh); |
| return aFunc.DetectiveAddError( aPos ); |
| } |
| return sal_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 sal_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& rGroupRange, |
| table::TableOrientation nOrientation ) |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh ) |
| { |
| sal_Bool bColumns = ( nOrientation == table::TableOrientation_COLUMNS ); |
| ScRange aGroupRange; |
| ScUnoConversion::FillScRange( aGroupRange, rGroupRange ); |
| ScOutlineDocFunc aFunc(*pDocSh); |
| aFunc.MakeOutline( aGroupRange, bColumns, sal_True, sal_True ); |
| } |
| } |
| |
| void SAL_CALL ScTableSheetObj::ungroup( const table::CellRangeAddress& rGroupRange, |
| table::TableOrientation nOrientation ) |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh ) |
| { |
| sal_Bool bColumns = ( nOrientation == table::TableOrientation_COLUMNS ); |
| ScRange aGroupRange; |
| ScUnoConversion::FillScRange( aGroupRange, rGroupRange ); |
| ScOutlineDocFunc aFunc(*pDocSh); |
| aFunc.RemoveOutline( aGroupRange, bColumns, sal_True, sal_True ); |
| } |
| } |
| |
| void SAL_CALL ScTableSheetObj::autoOutline( const table::CellRangeAddress& rCellRange ) |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh ) |
| { |
| ScRange aFormulaRange; |
| ScUnoConversion::FillScRange( aFormulaRange, rCellRange ); |
| ScOutlineDocFunc aFunc(*pDocSh); |
| aFunc.AutoOutline( aFormulaRange, sal_True, sal_True ); |
| } |
| } |
| |
| void SAL_CALL ScTableSheetObj::clearOutline() throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh ) |
| { |
| SCTAB nTab = GetTab_Impl(); |
| ScOutlineDocFunc aFunc(*pDocSh); |
| aFunc.RemoveAllOutlines( nTab, sal_True, sal_True ); |
| } |
| } |
| |
| void SAL_CALL ScTableSheetObj::hideDetail( const table::CellRangeAddress& rCellRange ) |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh ) |
| { |
| ScRange aMarkRange; |
| ScUnoConversion::FillScRange( aMarkRange, rCellRange ); |
| ScOutlineDocFunc aFunc(*pDocSh); |
| aFunc.HideMarkedOutlines( aMarkRange, sal_True, sal_True ); |
| } |
| } |
| |
| void SAL_CALL ScTableSheetObj::showDetail( const table::CellRangeAddress& rCellRange ) |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh ) |
| { |
| ScRange aMarkRange; |
| ScUnoConversion::FillScRange( aMarkRange, rCellRange ); |
| ScOutlineDocFunc aFunc(*pDocSh); |
| aFunc.ShowMarkedOutlines( aMarkRange, sal_True, sal_True ); |
| } |
| } |
| |
| void SAL_CALL ScTableSheetObj::showLevel( sal_Int16 nLevel, table::TableOrientation nOrientation ) |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh ) |
| { |
| sal_Bool bColumns = ( nOrientation == table::TableOrientation_COLUMNS ); |
| SCTAB nTab = GetTab_Impl(); |
| ScOutlineDocFunc aFunc(*pDocSh); |
| aFunc.SelectLevel( nTab, bColumns, nLevel, sal_True, sal_True, sal_True ); |
| } |
| } |
| |
| // XProtectable |
| |
| void SAL_CALL ScTableSheetObj::protect( const rtl::OUString& aPassword ) |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| // #i108245# if already protected, don't change anything |
| if ( pDocSh && !pDocSh->GetDocument()->IsTabProtected( GetTab_Impl() ) ) |
| { |
| String aString(aPassword); |
| ScDocFunc aFunc(*pDocSh); |
| aFunc.Protect( GetTab_Impl(), aString, sal_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); |
| sal_Bool bDone = aFunc.Unprotect( GetTab_Impl(), aString, sal_True ); |
| if (!bDone) |
| throw lang::IllegalArgumentException(); |
| } |
| } |
| |
| 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 sal_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 sal_False; |
| } |
| |
| rtl::OUString SAL_CALL ScTableSheetObj::getScenarioComment() throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh ) |
| { |
| String aComment; |
| Color aColor; |
| sal_uInt16 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(); |
| SCTAB nTab = GetTab_Impl(); |
| |
| String aName; |
| String aComment; |
| Color aColor; |
| sal_uInt16 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<table::CellRangeAddress>& rScenRanges ) |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh ) |
| { |
| ScDocument* pDoc = pDocSh->GetDocument(); |
| SCTAB nTab = GetTab_Impl(); |
| |
| if (pDoc->IsScenario(nTab)) |
| { |
| ScMarkData aMarkData; |
| aMarkData.SelectTable( nTab, sal_True ); |
| |
| sal_uInt16 nRangeCount = (sal_uInt16)rScenRanges.getLength(); |
| if (nRangeCount) |
| { |
| const table::CellRangeAddress* pAry = rScenRanges.getConstArray(); |
| for (sal_uInt16 i=0; i<nRangeCount; i++) |
| { |
| DBG_ASSERT( pAry[i].Sheet == nTab, "addRanges mit falscher Tab" ); |
| ScRange aOneRange( (SCCOL)pAry[i].StartColumn, (SCROW)pAry[i].StartRow, nTab, |
| (SCCOL)pAry[i].EndColumn, (SCROW)pAry[i].EndRow, nTab ); |
| |
| aMarkData.SetMultiMarkArea( aOneRange ); |
| } |
| } |
| |
| // Szenario-Ranges sind durch Attribut gekennzeichnet |
| ScPatternAttr aPattern( pDoc->GetPool() ); |
| aPattern.GetItemSet().Put( ScMergeFlagAttr( SC_MF_SCENARIO ) ); |
| aPattern.GetItemSet().Put( ScProtectionAttr( sal_True ) ); |
| ScDocFunc aFunc(*pDocSh); |
| aFunc.ApplyAttributes( aMarkData, aPattern, sal_True, sal_True ); |
| } |
| |
| // don't use. We should use therefor a private interface, so we can also set the flags. |
| /* else if (nTab > 0 && pDoc->IsImportingXML()) // make this sheet as an scenario and only if it is not the first sheet and only if it is ImportingXML, |
| // because than no UNDO and repaint is necessary. |
| { |
| sal_uInt16 nRangeCount = (sal_uInt16)rScenRanges.getLength(); |
| if (nRangeCount) |
| { |
| pDoc->SetScenario( nTab, sal_True ); |
| |
| // default flags |
| Color aColor( COL_LIGHTGRAY ); // Default |
| sal_uInt16 nFlags = SC_SCENARIO_SHOWFRAME | SC_SCENARIO_PRINTFRAME | SC_SCENARIO_TWOWAY; |
| String aComment; |
| |
| pDoc->SetScenarioData( nTab, aComment, aColor, nFlags ); |
| const table::CellRangeAddress* pAry = rScenRanges.getConstArray(); |
| for (sal_uInt16 i=0; i<nRangeCount; i++) |
| { |
| DBG_ASSERT( pAry[i].Sheet == nTab, "addRanges mit falscher Tab" ); |
| pDoc->ApplyFlagsTab( (sal_uInt16)pAry[i].StartColumn, (sal_uInt16)pAry[i].StartRow, |
| (sal_uInt16)pAry[i].EndColumn, (sal_uInt16)pAry[i].EndRow, nTab, SC_MF_SCENARIO ); |
| } |
| pDoc->SetActiveScenario( nTab, sal_True ); |
| |
| // set to next visible tab |
| sal_uInt16 j = nTab - 1; |
| sal_Bool bFinished = sal_False; |
| while (j < nTab && !bFinished) |
| { |
| if (pDoc->IsVisible(j)) |
| { |
| pDoc->SetVisibleTab(j); |
| bFinished = sal_True; |
| } |
| else |
| --j; |
| } |
| |
| ScDocFunc aFunc(*pDocSh); |
| aFunc.SetTableVisible( nTab, sal_False, sal_True ); |
| } |
| }*/ |
| } |
| } |
| |
| void SAL_CALL ScTableSheetObj::apply() throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh ) |
| { |
| ScDocument* pDoc = pDocSh->GetDocument(); |
| SCTAB nTab = GetTab_Impl(); |
| String aName; |
| pDoc->GetName( nTab, aName ); // Name dieses Szenarios |
| |
| SCTAB nDestTab = nTab; |
| while ( nDestTab > 0 && pDoc->IsScenario(nDestTab) ) |
| --nDestTab; |
| |
| if ( !pDoc->IsScenario(nDestTab) ) |
| pDocSh->UseScenario( nDestTab, aName ); |
| |
| //! sonst Fehler oder so |
| } |
| } |
| |
| // XScenarioEnhanced |
| |
| uno::Sequence< table::CellRangeAddress > SAL_CALL ScTableSheetObj::getRanges( ) |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh ) |
| { |
| ScDocument* pDoc = pDocSh->GetDocument(); |
| SCTAB nTab = GetTab_Impl(); |
| const ScRangeList* pRangeList = pDoc->GetScenarioRanges(nTab); |
| if (pRangeList) |
| { |
| sal_Int32 nCount = pRangeList->Count(); |
| uno::Sequence< table::CellRangeAddress > aRetRanges(nCount); |
| table::CellRangeAddress* pAry = aRetRanges.getArray(); |
| for( sal_Int32 nIndex = 0; nIndex < nCount; nIndex++ ) |
| { |
| const ScRange* pRange = pRangeList->GetObject( nIndex ); |
| pAry->StartColumn = pRange->aStart.Col(); |
| pAry->StartRow = pRange->aStart.Row(); |
| pAry->EndColumn = pRange->aEnd.Col(); |
| pAry->EndRow = pRange->aEnd.Row(); |
| pAry->Sheet = pRange->aStart.Tab(); |
| ++pAry; |
| } |
| return aRetRanges; |
| } |
| } |
| return uno::Sequence< table::CellRangeAddress > (); |
| } |
| |
| // XExternalSheetName |
| |
| void ScTableSheetObj::setExternalName( const ::rtl::OUString& aUrl, const ::rtl::OUString& aSheetName ) |
| throw (container::ElementExistException, uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh ) |
| { |
| ScDocument* pDoc = pDocSh->GetDocument(); |
| if ( pDoc ) |
| { |
| const SCTAB nTab = GetTab_Impl(); |
| const String aAbsDocName( ScGlobal::GetAbsDocName( aUrl, pDocSh ) ); |
| const String aDocTabName( ScGlobal::GetDocTabName( aAbsDocName, aSheetName ) ); |
| if ( !pDoc->RenameTab( nTab, aDocTabName, sal_False /*bUpdateRef*/, sal_True /*bExternalDocument*/ ) ) |
| { |
| throw container::ElementExistException( ::rtl::OUString(), *this ); |
| } |
| } |
| } |
| } |
| |
| // XEventsSupplier |
| |
| uno::Reference<container::XNameReplace> SAL_CALL ScTableSheetObj::getEvents() throw (uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| ScDocShell* pDocSh = GetDocShell(); |
| if ( pDocSh ) |
| return new ScSheetEventsObj( pDocSh, GetTab_Impl() ); |
| |
| return NULL; |
| } |
| |
| // XPropertySet erweitert fuer Sheet-Properties |
| |
| uno::Reference<beans::XPropertySetInfo> SAL_CALL ScTableSheetObj::getPropertySetInfo() |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| static uno::Reference<beans::XPropertySetInfo> aRef( |
| new SfxItemPropertySetInfo( pSheetPropSet->getPropertyMap() )); |
| return aRef; |
| } |
| |
| void ScTableSheetObj::SetOnePropertyValue( const SfxItemPropertySimpleEntry* pEntry, const uno::Any& aValue ) |
| throw(lang::IllegalArgumentException, uno::RuntimeException) |
| { |
| if ( pEntry ) |
| { |
| if ( IsScItemWid( pEntry->nWID ) ) |
| { |
| // for Item WIDs, call ScCellRangesBase directly |
| ScCellRangesBase::SetOnePropertyValue(pEntry, aValue); |
| return; |
| } |
| |
| // own properties |
| |
| ScDocShell* pDocSh = GetDocShell(); |
| if (!pDocSh) |
| return; //! Exception oder so? |
| ScDocument* pDoc = pDocSh->GetDocument(); |
| SCTAB nTab = GetTab_Impl(); |
| ScDocFunc aFunc(*pDocSh); |
| |
| if ( pEntry->nWID == SC_WID_UNO_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 ); |
| if (!pDoc->IsImportingXML()) |
| { |
| ScPrintFunc( pDocSh, pDocSh->GetPrinter(), nTab ).UpdatePages(); |
| |
| SfxBindings* pBindings = pDocSh->GetViewBindings(); |
| if (pBindings) |
| { |
| pBindings->Invalidate( SID_STYLE_FAMILY4 ); |
| pBindings->Invalidate( SID_STATUS_PAGESTYLE ); |
| pBindings->Invalidate( FID_RESET_PRINTZOOM ); |
| pBindings->Invalidate( SID_ATTR_PARA_LEFT_TO_RIGHT ); |
| pBindings->Invalidate( SID_ATTR_PARA_RIGHT_TO_LEFT ); |
| } |
| } |
| pDocSh->SetDocumentModified(); |
| } |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_CELLVIS ) |
| { |
| sal_Bool bVis = ScUnoHelpFunctions::GetBoolFromAny( aValue ); |
| aFunc.SetTableVisible( nTab, bVis, sal_True ); |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_ISACTIVE ) |
| { |
| if (pDoc->IsScenario(nTab)) |
| pDoc->SetActiveScenario( nTab, ScUnoHelpFunctions::GetBoolFromAny( aValue ) ); |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_BORDCOL ) |
| { |
| if (pDoc->IsScenario(nTab)) |
| { |
| sal_Int32 nNewColor = 0; |
| if (aValue >>= nNewColor) |
| { |
| String aName; |
| String aComment; |
| Color aColor; |
| sal_uInt16 nFlags; |
| pDoc->GetName( nTab, aName ); |
| pDoc->GetScenarioData( nTab, aComment, aColor, nFlags ); |
| |
| aColor = Color(static_cast<sal_uInt32>(nNewColor)); |
| |
| pDocSh->ModifyScenario( nTab, aName, aComment, aColor, nFlags ); |
| } |
| } |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_PROTECT ) |
| { |
| if (pDoc->IsScenario(nTab)) |
| { |
| String aName; |
| String aComment; |
| Color aColor; |
| sal_uInt16 nFlags; |
| pDoc->GetName( nTab, aName ); |
| pDoc->GetScenarioData( nTab, aComment, aColor, nFlags ); |
| sal_Bool bModify(sal_False); |
| |
| if (ScUnoHelpFunctions::GetBoolFromAny( aValue )) |
| { |
| if (!(nFlags & SC_SCENARIO_PROTECT)) |
| { |
| nFlags |= SC_SCENARIO_PROTECT; |
| bModify = sal_True; |
| } |
| } |
| else |
| { |
| if (nFlags & SC_SCENARIO_PROTECT) |
| { |
| nFlags -= SC_SCENARIO_PROTECT; |
| bModify = sal_True; |
| } |
| } |
| |
| if (bModify) |
| pDocSh->ModifyScenario( nTab, aName, aComment, aColor, nFlags ); |
| } |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_SHOWBORD ) |
| { |
| if (pDoc->IsScenario(nTab)) |
| { |
| String aName; |
| String aComment; |
| Color aColor; |
| sal_uInt16 nFlags; |
| pDoc->GetName( nTab, aName ); |
| pDoc->GetScenarioData( nTab, aComment, aColor, nFlags ); |
| sal_Bool bModify(sal_False); |
| |
| if (ScUnoHelpFunctions::GetBoolFromAny( aValue )) |
| { |
| if (!(nFlags & SC_SCENARIO_SHOWFRAME)) |
| { |
| nFlags |= SC_SCENARIO_SHOWFRAME; |
| bModify = sal_True; |
| } |
| } |
| else |
| { |
| if (nFlags & SC_SCENARIO_SHOWFRAME) |
| { |
| nFlags -= SC_SCENARIO_SHOWFRAME; |
| bModify = sal_True; |
| } |
| } |
| |
| if (bModify) |
| pDocSh->ModifyScenario( nTab, aName, aComment, aColor, nFlags ); |
| } |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_PRINTBORD ) |
| { |
| if (pDoc->IsScenario(nTab)) |
| { |
| String aName; |
| String aComment; |
| Color aColor; |
| sal_uInt16 nFlags; |
| pDoc->GetName( nTab, aName ); |
| pDoc->GetScenarioData( nTab, aComment, aColor, nFlags ); |
| sal_Bool bModify(sal_False); |
| |
| if (ScUnoHelpFunctions::GetBoolFromAny( aValue )) |
| { |
| if (!(nFlags & SC_SCENARIO_PRINTFRAME)) |
| { |
| nFlags |= SC_SCENARIO_PRINTFRAME; |
| bModify = sal_True; |
| } |
| } |
| else |
| { |
| if (nFlags & SC_SCENARIO_PRINTFRAME) |
| { |
| nFlags -= SC_SCENARIO_PRINTFRAME; |
| bModify = sal_True; |
| } |
| } |
| |
| if (bModify) |
| pDocSh->ModifyScenario( nTab, aName, aComment, aColor, nFlags ); |
| } |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_COPYBACK ) |
| { |
| if (pDoc->IsScenario(nTab)) |
| { |
| String aName; |
| String aComment; |
| Color aColor; |
| sal_uInt16 nFlags; |
| pDoc->GetName( nTab, aName ); |
| pDoc->GetScenarioData( nTab, aComment, aColor, nFlags ); |
| sal_Bool bModify(sal_False); |
| |
| if (ScUnoHelpFunctions::GetBoolFromAny( aValue )) |
| { |
| if (!(nFlags & SC_SCENARIO_TWOWAY)) |
| { |
| nFlags |= SC_SCENARIO_TWOWAY; |
| bModify = sal_True; |
| } |
| } |
| else |
| { |
| if (nFlags & SC_SCENARIO_TWOWAY) |
| { |
| nFlags -= SC_SCENARIO_TWOWAY; |
| bModify = sal_True; |
| } |
| } |
| |
| if (bModify) |
| pDocSh->ModifyScenario( nTab, aName, aComment, aColor, nFlags ); |
| } |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_COPYSTYL ) |
| { |
| if (pDoc->IsScenario(nTab)) |
| { |
| String aName; |
| String aComment; |
| Color aColor; |
| sal_uInt16 nFlags; |
| pDoc->GetName( nTab, aName ); |
| pDoc->GetScenarioData( nTab, aComment, aColor, nFlags ); |
| sal_Bool bModify(sal_False); |
| |
| if (ScUnoHelpFunctions::GetBoolFromAny( aValue )) |
| { |
| if (!(nFlags & SC_SCENARIO_ATTRIB)) |
| { |
| nFlags |= SC_SCENARIO_ATTRIB; |
| bModify = sal_True; |
| } |
| } |
| else |
| { |
| if (nFlags & SC_SCENARIO_ATTRIB) |
| { |
| nFlags -= SC_SCENARIO_ATTRIB; |
| bModify = sal_True; |
| } |
| } |
| |
| if (bModify) |
| pDocSh->ModifyScenario( nTab, aName, aComment, aColor, nFlags ); |
| } |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_COPYFORM ) |
| { |
| if (pDoc->IsScenario(nTab)) |
| { |
| String aName; |
| String aComment; |
| Color aColor; |
| sal_uInt16 nFlags; |
| pDoc->GetName( nTab, aName ); |
| pDoc->GetScenarioData( nTab, aComment, aColor, nFlags ); |
| sal_Bool bModify(sal_False); |
| |
| if (ScUnoHelpFunctions::GetBoolFromAny( aValue )) |
| { |
| if (nFlags & SC_SCENARIO_VALUE) |
| { |
| nFlags -= SC_SCENARIO_VALUE; |
| bModify = sal_True; |
| } |
| } |
| else |
| { |
| if (!(nFlags & SC_SCENARIO_VALUE)) |
| { |
| nFlags |= SC_SCENARIO_VALUE; |
| bModify = sal_True; |
| } |
| } |
| |
| if (bModify) |
| pDocSh->ModifyScenario( nTab, aName, aComment, aColor, nFlags ); |
| } |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_TABLAYOUT ) |
| { |
| sal_Int16 nValue = 0; |
| if (aValue >>= nValue) |
| { |
| if (nValue == com::sun::star::text::WritingMode2::RL_TB) |
| aFunc.SetLayoutRTL(nTab, sal_True, sal_True); |
| else |
| aFunc.SetLayoutRTL(nTab, sal_False, sal_True); |
| } |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_AUTOPRINT ) |
| { |
| sal_Bool bAutoPrint = ScUnoHelpFunctions::GetBoolFromAny( aValue ); |
| if (bAutoPrint) |
| pDoc->SetPrintEntireSheet( nTab ); // clears all print ranges |
| else |
| { |
| if (pDoc->IsPrintEntireSheet( nTab )) |
| pDoc->ClearPrintRanges( nTab ); // if this flag is true, there are no PrintRanges, so Clear clears only the flag. |
| } |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_TABCOLOR ) |
| { |
| sal_Int32 nColor = COL_AUTO; |
| if ( aValue >>= nColor ) |
| { |
| const Color aColor( static_cast< ColorData >( nColor ) ); |
| if ( pDoc->GetTabBgColor( nTab ) != aColor ) |
| aFunc.SetTabBgColor( nTab, aColor, sal_True, sal_True ); |
| } |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_CODENAME ) |
| { |
| rtl::OUString aCodeName; |
| if ( pDocSh && ( aValue >>= aCodeName ) ) |
| { |
| pDocSh->GetDocument()->SetCodeName( GetTab_Impl(), aCodeName ); |
| } |
| } |
| else |
| ScCellRangeObj::SetOnePropertyValue(pEntry, aValue); // base class, no Item WID |
| } |
| } |
| |
| void ScTableSheetObj::GetOnePropertyValue( const SfxItemPropertySimpleEntry* pEntry, |
| uno::Any& rAny ) |
| throw(uno::RuntimeException) |
| { |
| if ( pEntry ) |
| { |
| ScDocShell* pDocSh = GetDocShell(); |
| if (!pDocSh) |
| throw uno::RuntimeException(); |
| ScDocument* pDoc = pDocSh->GetDocument(); |
| SCTAB nTab = GetTab_Impl(); |
| |
| if ( pEntry->nWID == SC_WID_UNO_PAGESTL ) |
| { |
| rAny <<= rtl::OUString( ScStyleNameConversion::DisplayToProgrammaticName( |
| pDoc->GetPageStyle( nTab ), SFX_STYLE_FAMILY_PAGE ) ); |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_CELLVIS ) |
| { |
| sal_Bool bVis = pDoc->IsVisible( nTab ); |
| ScUnoHelpFunctions::SetBoolInAny( rAny, bVis ); |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_LINKDISPBIT ) |
| { |
| // no target bitmaps for individual entries (would be all equal) |
| // ScLinkTargetTypeObj::SetLinkTargetBitmap( aAny, SC_LINKTARGETTYPE_SHEET ); |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_LINKDISPNAME ) |
| { |
| // LinkDisplayName for hyperlink dialog |
| rAny <<= getName(); // sheet name |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_ISACTIVE ) |
| { |
| if (pDoc->IsScenario(nTab)) |
| ScUnoHelpFunctions::SetBoolInAny( rAny, pDoc->IsActiveScenario( nTab )); |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_BORDCOL ) |
| { |
| if (pDoc->IsScenario(nTab)) |
| { |
| String aComment; |
| Color aColor; |
| sal_uInt16 nFlags; |
| pDoc->GetScenarioData( nTab, aComment, aColor, nFlags ); |
| |
| rAny <<= static_cast<sal_Int32>(aColor.GetColor()); |
| } |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_PROTECT ) |
| { |
| if (pDoc->IsScenario(nTab)) |
| { |
| String aComment; |
| Color aColor; |
| sal_uInt16 nFlags; |
| pDoc->GetScenarioData( nTab, aComment, aColor, nFlags ); |
| |
| ScUnoHelpFunctions::SetBoolInAny( rAny, (nFlags & SC_SCENARIO_PROTECT) != 0 ); |
| } |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_SHOWBORD ) |
| { |
| if (pDoc->IsScenario(nTab)) |
| { |
| String aComment; |
| Color aColor; |
| sal_uInt16 nFlags; |
| pDoc->GetScenarioData( nTab, aComment, aColor, nFlags ); |
| |
| ScUnoHelpFunctions::SetBoolInAny( rAny, (nFlags & SC_SCENARIO_SHOWFRAME) != 0 ); |
| } |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_PRINTBORD ) |
| { |
| if (pDoc->IsScenario(nTab)) |
| { |
| String aComment; |
| Color aColor; |
| sal_uInt16 nFlags; |
| pDoc->GetScenarioData( nTab, aComment, aColor, nFlags ); |
| |
| ScUnoHelpFunctions::SetBoolInAny( rAny, (nFlags & SC_SCENARIO_PRINTFRAME) != 0 ); |
| } |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_COPYBACK ) |
| { |
| if (pDoc->IsScenario(nTab)) |
| { |
| String aComment; |
| Color aColor; |
| sal_uInt16 nFlags; |
| pDoc->GetScenarioData( nTab, aComment, aColor, nFlags ); |
| |
| ScUnoHelpFunctions::SetBoolInAny( rAny, (nFlags & SC_SCENARIO_TWOWAY) != 0 ); |
| } |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_COPYSTYL ) |
| { |
| if (pDoc->IsScenario(nTab)) |
| { |
| String aComment; |
| Color aColor; |
| sal_uInt16 nFlags; |
| pDoc->GetScenarioData( nTab, aComment, aColor, nFlags ); |
| |
| ScUnoHelpFunctions::SetBoolInAny( rAny, (nFlags & SC_SCENARIO_ATTRIB) != 0 ); |
| } |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_COPYFORM ) |
| { |
| if (pDoc->IsScenario(nTab)) |
| { |
| String aComment; |
| Color aColor; |
| sal_uInt16 nFlags; |
| pDoc->GetScenarioData( nTab, aComment, aColor, nFlags ); |
| |
| ScUnoHelpFunctions::SetBoolInAny( rAny, !(nFlags & SC_SCENARIO_VALUE)); |
| } |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_TABLAYOUT ) |
| { |
| if (pDoc->IsLayoutRTL(nTab)) |
| rAny <<= sal_Int16(com::sun::star::text::WritingMode2::RL_TB); |
| else |
| rAny <<= sal_Int16(com::sun::star::text::WritingMode2::LR_TB); |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_AUTOPRINT ) |
| { |
| sal_Bool bAutoPrint = pDoc->IsPrintEntireSheet( nTab ); |
| ScUnoHelpFunctions::SetBoolInAny( rAny, bAutoPrint ); |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_TABCOLOR ) |
| { |
| rAny <<= sal_Int32(pDoc->GetTabBgColor(nTab).GetColor()); |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_CODENAME ) |
| { |
| String aCodeName; |
| if ( pDocSh ) |
| pDocSh->GetDocument()->GetCodeName( GetTab_Impl(), aCodeName ); |
| rAny <<= rtl::OUString( aCodeName ); |
| } |
| else |
| ScCellRangeObj::GetOnePropertyValue(pEntry, rAny); |
| } |
| } |
| |
| const SfxItemPropertyMap* ScTableSheetObj::GetItemPropertyMap() |
| { |
| return pSheetPropSet->getPropertyMap(); |
| } |
| |
| // 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( SCPARAPROPERTIES_SERVICE ) || |
| aServiceStr.EqualsAscii( SCLINKTARGET_SERVICE ); |
| } |
| |
| uno::Sequence<rtl::OUString> SAL_CALL ScTableSheetObj::getSupportedServiceNames() |
| throw(uno::RuntimeException) |
| { |
| uno::Sequence<rtl::OUString> aRet(7); |
| 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( SCPARAPROPERTIES_SERVICE ); |
| pArray[6] = rtl::OUString::createFromAscii( SCLINKTARGET_SERVICE ); |
| return aRet; |
| } |
| |
| // XUnoTunnel |
| |
| sal_Int64 SAL_CALL ScTableSheetObj::getSomething( |
| const uno::Sequence<sal_Int8 >& rId ) throw(uno::RuntimeException) |
| { |
| if ( rId.getLength() == 16 && |
| 0 == rtl_compareMemory( getUnoTunnelId().getConstArray(), |
| rId.getConstArray(), 16 ) ) |
| { |
| return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(this)); |
| } |
| |
| return ScCellRangeObj::getSomething( rId ); |
| } |
| |
| // static |
| const uno::Sequence<sal_Int8>& ScTableSheetObj::getUnoTunnelId() |
| { |
| static uno::Sequence<sal_Int8> * 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<uno::XInterface> xObj ) |
| { |
| ScTableSheetObj* pRet = NULL; |
| uno::Reference<lang::XUnoTunnel> xUT( xObj, uno::UNO_QUERY ); |
| if (xUT.is()) |
| pRet = reinterpret_cast<ScTableSheetObj*>(sal::static_int_cast<sal_IntPtr>(xUT->getSomething(getUnoTunnelId()))); |
| return pRet; |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| ScTableColumnObj::ScTableColumnObj( ScDocShell* pDocSh, SCCOL nCol, SCTAB nTab ) : |
| ScCellRangeObj( pDocSh, ScRange(nCol,0,nTab, nCol,MAXROW,nTab) ), |
| pColPropSet(lcl_GetColumnPropertySet()) |
| { |
| } |
| |
| 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() |
| { |
| ScCellRangeObj::acquire(); |
| } |
| |
| void SAL_CALL ScTableColumnObj::release() throw() |
| { |
| ScCellRangeObj::release(); |
| } |
| |
| uno::Sequence<uno::Type> SAL_CALL ScTableColumnObj::getTypes() throw(uno::RuntimeException) |
| { |
| static uno::Sequence<uno::Type> aTypes; |
| if ( aTypes.getLength() == 0 ) |
| { |
| uno::Sequence<uno::Type> 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<container::XNamed>*)0); |
| |
| for (long i=0; i<nParentLen; i++) |
| pPtr[i] = pParentPtr[i]; // parent types first |
| } |
| return aTypes; |
| } |
| |
| uno::Sequence<sal_Int8> 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"); |
| SCCOL nCol = rRange.aStart.Col(); |
| |
| return ScColToAlpha( 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<beans::XPropertySetInfo> SAL_CALL ScTableColumnObj::getPropertySetInfo() |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| static uno::Reference<beans::XPropertySetInfo> aRef( |
| new SfxItemPropertySetInfo( pColPropSet->getPropertyMap() )); |
| return aRef; |
| } |
| |
| void ScTableColumnObj::SetOnePropertyValue( const SfxItemPropertySimpleEntry* pEntry, const uno::Any& aValue ) |
| throw(lang::IllegalArgumentException, uno::RuntimeException) |
| { |
| if ( pEntry ) |
| { |
| if ( IsScItemWid( pEntry->nWID ) ) |
| { |
| // for Item WIDs, call ScCellRangesBase directly |
| ScCellRangesBase::SetOnePropertyValue(pEntry, aValue); |
| return; |
| } |
| |
| // own properties |
| |
| ScDocShell* pDocSh = GetDocShell(); |
| if (!pDocSh) |
| return; //! Exception oder so? |
| const ScRange& rRange = GetRange(); |
| DBG_ASSERT(rRange.aStart.Col() == rRange.aEnd.Col(), "zuviele Spalten"); |
| SCCOL nCol = rRange.aStart.Col(); |
| SCTAB nTab = rRange.aStart.Tab(); |
| ScDocFunc aFunc(*pDocSh); |
| |
| SCCOLROW nColArr[2]; |
| nColArr[0] = nColArr[1] = nCol; |
| |
| if ( pEntry->nWID == SC_WID_UNO_CELLWID ) |
| { |
| sal_Int32 nNewWidth = 0; |
| if ( aValue >>= nNewWidth ) |
| { |
| // property is 1/100mm, column width is twips |
| nNewWidth = HMMToTwips(nNewWidth); |
| aFunc.SetWidthOrHeight( sal_True, 1, nColArr, nTab, SC_SIZE_ORIGINAL, |
| (sal_uInt16)nNewWidth, sal_True, sal_True ); |
| } |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_CELLVIS ) |
| { |
| sal_Bool bVis = ScUnoHelpFunctions::GetBoolFromAny( aValue ); |
| ScSizeMode eMode = bVis ? SC_SIZE_SHOW : SC_SIZE_DIRECT; |
| aFunc.SetWidthOrHeight( sal_True, 1, nColArr, nTab, eMode, 0, sal_True, sal_True ); |
| // SC_SIZE_DIRECT mit Groesse 0 blendet aus |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_OWIDTH ) |
| { |
| sal_Bool bOpt = ScUnoHelpFunctions::GetBoolFromAny( aValue ); |
| if (bOpt) |
| aFunc.SetWidthOrHeight( sal_True, 1, nColArr, nTab, |
| SC_SIZE_OPTIMAL, STD_EXTRA_WIDTH, sal_True, sal_True ); |
| // sal_False bei Spalten momentan ohne Auswirkung |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_NEWPAGE || pEntry->nWID == SC_WID_UNO_MANPAGE ) |
| { |
| sal_Bool bSet = ScUnoHelpFunctions::GetBoolFromAny( aValue ); |
| if (bSet) |
| aFunc.InsertPageBreak( sal_True, rRange.aStart, sal_True, sal_True, sal_True ); |
| else |
| aFunc.RemovePageBreak( sal_True, rRange.aStart, sal_True, sal_True, sal_True ); |
| } |
| else |
| ScCellRangeObj::SetOnePropertyValue(pEntry, aValue); // base class, no Item WID |
| } |
| } |
| |
| void ScTableColumnObj::GetOnePropertyValue( const SfxItemPropertySimpleEntry* pEntry, |
| uno::Any& rAny ) |
| throw(uno::RuntimeException) |
| { |
| if ( pEntry ) |
| { |
| ScDocShell* pDocSh = GetDocShell(); |
| if (!pDocSh) |
| throw uno::RuntimeException(); |
| |
| ScDocument* pDoc = pDocSh->GetDocument(); |
| const ScRange& rRange = GetRange(); |
| DBG_ASSERT(rRange.aStart.Col() == rRange.aEnd.Col(), "zuviele Spalten"); |
| SCCOL nCol = rRange.aStart.Col(); |
| SCTAB nTab = rRange.aStart.Tab(); |
| |
| if ( pEntry->nWID == SC_WID_UNO_CELLWID ) |
| { |
| // for hidden column, return original height |
| sal_uInt16 nWidth = pDoc->GetOriginalWidth( nCol, nTab ); |
| // property is 1/100mm, column width is twips |
| nWidth = (sal_uInt16) TwipsToHMM(nWidth); |
| rAny <<= (sal_Int32)( nWidth ); |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_CELLVIS ) |
| { |
| SCCOL nDummy; |
| bool bHidden = pDoc->ColHidden(nCol, nTab, nDummy); |
| ScUnoHelpFunctions::SetBoolInAny( rAny, !bHidden ); |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_OWIDTH ) |
| { |
| //! momentan immer gesetzt ??!?! |
| sal_Bool bOpt = !(pDoc->GetColFlags( nCol, nTab ) & CR_MANUALSIZE); |
| ScUnoHelpFunctions::SetBoolInAny( rAny, bOpt ); |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_NEWPAGE ) |
| { |
| ScBreakType nBreak = pDoc->HasColBreak(nCol, nTab); |
| ScUnoHelpFunctions::SetBoolInAny( rAny, nBreak ); |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_MANPAGE ) |
| { |
| ScBreakType nBreak = pDoc->HasColBreak(nCol, nTab); |
| ScUnoHelpFunctions::SetBoolInAny(rAny, (nBreak & BREAK_MANUAL)); |
| } |
| else |
| ScCellRangeObj::GetOnePropertyValue(pEntry, rAny); |
| } |
| } |
| |
| const SfxItemPropertyMap* ScTableColumnObj::GetItemPropertyMap() |
| { |
| return pColPropSet->getPropertyMap(); |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| ScTableRowObj::ScTableRowObj(ScDocShell* pDocSh, SCROW nRow, SCTAB nTab) : |
| ScCellRangeObj( pDocSh, ScRange(0,nRow,nTab, MAXCOL,nRow,nTab) ), |
| pRowPropSet(lcl_GetRowPropertySet()) |
| { |
| } |
| |
| ScTableRowObj::~ScTableRowObj() |
| { |
| } |
| |
| // XPropertySet erweitert fuer Zeilen-Properties |
| |
| uno::Reference<beans::XPropertySetInfo> SAL_CALL ScTableRowObj::getPropertySetInfo() |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| static uno::Reference<beans::XPropertySetInfo> aRef( |
| new SfxItemPropertySetInfo( pRowPropSet->getPropertyMap() )); |
| return aRef; |
| } |
| |
| void ScTableRowObj::SetOnePropertyValue( const SfxItemPropertySimpleEntry* pEntry, const uno::Any& aValue ) |
| throw(lang::IllegalArgumentException, uno::RuntimeException) |
| { |
| if ( pEntry ) |
| { |
| if ( IsScItemWid( pEntry->nWID ) ) |
| { |
| // for Item WIDs, call ScCellRangesBase directly |
| ScCellRangesBase::SetOnePropertyValue(pEntry, aValue); |
| return; |
| } |
| |
| // own 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"); |
| SCROW nRow = rRange.aStart.Row(); |
| SCTAB nTab = rRange.aStart.Tab(); |
| ScDocFunc aFunc(*pDocSh); |
| |
| SCCOLROW nRowArr[2]; |
| nRowArr[0] = nRowArr[1] = nRow; |
| |
| if ( pEntry->nWID == SC_WID_UNO_CELLHGT ) |
| { |
| sal_Int32 nNewHeight = 0; |
| if ( aValue >>= nNewHeight ) |
| { |
| // property is 1/100mm, row height is twips |
| nNewHeight = HMMToTwips(nNewHeight); |
| aFunc.SetWidthOrHeight( sal_False, 1, nRowArr, nTab, SC_SIZE_ORIGINAL, |
| (sal_uInt16)nNewHeight, sal_True, sal_True ); |
| } |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_CELLVIS ) |
| { |
| sal_Bool bVis = ScUnoHelpFunctions::GetBoolFromAny( aValue ); |
| ScSizeMode eMode = bVis ? SC_SIZE_SHOW : SC_SIZE_DIRECT; |
| aFunc.SetWidthOrHeight( sal_False, 1, nRowArr, nTab, eMode, 0, sal_True, sal_True ); |
| // SC_SIZE_DIRECT mit Groesse 0 blendet aus |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_CELLFILT ) |
| { |
| sal_Bool bFil = ScUnoHelpFunctions::GetBoolFromAny( aValue ); |
| // ScSizeMode eMode = bVis ? SC_SIZE_SHOW : SC_SIZE_DIRECT; |
| // aFunc.SetWidthOrHeight( sal_False, 1, nRowArr, nTab, eMode, 0, sal_True, sal_True ); |
| // SC_SIZE_DIRECT mit Groesse 0 blendet aus |
| pDoc->SetRowFiltered(nRow, nRow, nTab, bFil); |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_OHEIGHT ) |
| { |
| sal_Bool bOpt = ScUnoHelpFunctions::GetBoolFromAny( aValue ); |
| if (bOpt) |
| aFunc.SetWidthOrHeight( sal_False, 1, nRowArr, nTab, SC_SIZE_OPTIMAL, 0, sal_True, sal_True ); |
| else |
| { |
| // set current height again manually |
| sal_uInt16 nHeight = pDoc->GetOriginalHeight( nRow, nTab ); |
| aFunc.SetWidthOrHeight( sal_False, 1, nRowArr, nTab, SC_SIZE_ORIGINAL, nHeight, sal_True, sal_True ); |
| } |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_NEWPAGE || pEntry->nWID == SC_WID_UNO_MANPAGE ) |
| { |
| sal_Bool bSet = ScUnoHelpFunctions::GetBoolFromAny( aValue ); |
| if (bSet) |
| aFunc.InsertPageBreak( sal_False, rRange.aStart, sal_True, sal_True, sal_True ); |
| else |
| aFunc.RemovePageBreak( sal_False, rRange.aStart, sal_True, sal_True, sal_True ); |
| } |
| else |
| ScCellRangeObj::SetOnePropertyValue(pEntry, aValue); // base class, no Item WID |
| } |
| } |
| |
| void ScTableRowObj::GetOnePropertyValue( const SfxItemPropertySimpleEntry* pEntry, |
| uno::Any& rAny ) |
| throw(uno::RuntimeException) |
| { |
| if ( pEntry ) |
| { |
| ScDocShell* pDocSh = GetDocShell(); |
| if (!pDocSh) |
| throw uno::RuntimeException(); |
| ScDocument* pDoc = pDocSh->GetDocument(); |
| const ScRange& rRange = GetRange(); |
| DBG_ASSERT(rRange.aStart.Row() == rRange.aEnd.Row(), "zuviele Zeilen"); |
| SCROW nRow = rRange.aStart.Row(); |
| SCTAB nTab = rRange.aStart.Tab(); |
| |
| if ( pEntry->nWID == SC_WID_UNO_CELLHGT ) |
| { |
| // for hidden row, return original height |
| sal_uInt16 nHeight = pDoc->GetOriginalHeight( nRow, nTab ); |
| // property is 1/100mm, row height is twips |
| nHeight = (sal_uInt16) TwipsToHMM(nHeight); |
| rAny <<= (sal_Int32)( nHeight ); |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_CELLVIS ) |
| { |
| SCROW nDummy; |
| bool bHidden = pDoc->RowHidden(nRow, nTab, nDummy); |
| ScUnoHelpFunctions::SetBoolInAny( rAny, !bHidden ); |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_CELLFILT ) |
| { |
| bool bVis = pDoc->RowFiltered(nRow, nTab); |
| ScUnoHelpFunctions::SetBoolInAny( rAny, bVis ); |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_OHEIGHT ) |
| { |
| sal_Bool bOpt = !(pDoc->GetRowFlags( nRow, nTab ) & CR_MANUALSIZE); |
| ScUnoHelpFunctions::SetBoolInAny( rAny, bOpt ); |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_NEWPAGE ) |
| { |
| ScBreakType nBreak = pDoc->HasRowBreak(nRow, nTab); |
| ScUnoHelpFunctions::SetBoolInAny( rAny, nBreak ); |
| } |
| else if ( pEntry->nWID == SC_WID_UNO_MANPAGE ) |
| { |
| ScBreakType nBreak = (pDoc->HasRowBreak(nRow, nTab) & BREAK_MANUAL); |
| ScUnoHelpFunctions::SetBoolInAny( rAny, nBreak ); |
| } |
| else |
| ScCellRangeObj::GetOnePropertyValue(pEntry, rAny); |
| } |
| } |
| |
| const SfxItemPropertyMap* ScTableRowObj::GetItemPropertyMap() |
| { |
| return pRowPropSet->getPropertyMap(); |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| 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&, 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<container::XEnumeration> 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<table::XCell>*)0); |
| } |
| |
| sal_Bool SAL_CALL ScCellsObj::hasElements() throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| sal_Bool bHas = sal_False; |
| if ( pDocShell ) |
| { |
| //! schneller selber testen? |
| |
| uno::Reference<container::XEnumeration> xEnum(new ScCellsEnumeration( pDocShell, aRanges )); |
| bHas = xEnum->hasMoreElements(); |
| } |
| return bHas; |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| ScCellsEnumeration::ScCellsEnumeration(ScDocShell* pDocSh, const ScRangeList& rR) : |
| pDocShell( pDocSh ), |
| aRanges( rR ), |
| pMark( NULL ), |
| bAtEnd( sal_False ) |
| { |
| ScDocument* pDoc = pDocShell->GetDocument(); |
| pDoc->AddUnoObject(*this); |
| |
| if ( aRanges.Count() == 0 ) |
| bAtEnd = sal_True; |
| else |
| { |
| SCTAB 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) |
| { |
| sal_Bool bFound = sal_False; |
| ScDocument* pDoc = pDocShell->GetDocument(); |
| ScBaseCell* pCell = pDoc->GetCell(aPos); |
| if ( pCell && pCell->GetCellType() != CELLTYPE_NOTE ) |
| { |
| if (!pMark) |
| { |
| pMark = new ScMarkData; |
| pMark->MarkFromRangeList( aRanges, sal_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, sal_False ); |
| pMark->MarkToMulti(); // needed for GetNextMarkedCell |
| } |
| |
| SCCOL nCol = aPos.Col(); |
| SCROW nRow = aPos.Row(); |
| SCTAB nTab = aPos.Tab(); |
| sal_Bool bFound = pDocShell->GetDocument()->GetNextMarkedCell( nCol, nRow, nTab, *pMark ); |
| if (bFound) |
| aPos.Set( nCol, nRow, nTab ); |
| else |
| bAtEnd = sal_True; // kommt nix mehr |
| } |
| |
| void ScCellsEnumeration::Notify( SfxBroadcaster&, 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 |
| |
| ScAddress aTempPos(aPos); |
| Advance_Impl(); |
| return uno::makeAny(uno::Reference<table::XCell>(new ScCellObj( pDocShell, aTempPos ))); |
| } |
| |
| 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&, 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() ); |
| SCCOL nCol1, nCol2; |
| SCROW nRow1, nRow2; |
| while ( aIter.GetNext( nCol1, nCol2, nRow1, nRow2 ) ) |
| { |
| if ( nPos == nIndex ) |
| { |
| SCTAB 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() ); |
| SCCOL nCol1, nCol2; |
| SCROW 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<table::XCellRange> xRange(GetObjectByIndex_Impl(nIndex)); |
| if (xRange.is()) |
| return uno::makeAny(xRange); |
| else |
| throw lang::IndexOutOfBoundsException(); |
| // return uno::Any(); |
| } |
| |
| uno::Type SAL_CALL ScCellFormatsObj::getElementType() throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| return getCppuType((uno::Reference<table::XCellRange>*)0); |
| } |
| |
| sal_Bool SAL_CALL ScCellFormatsObj::hasElements() throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| return ( getCount() != 0 ); //! immer groesser 0 ?? |
| } |
| |
| // XEnumerationAccess |
| |
| uno::Reference<container::XEnumeration> 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( sal_False ), |
| bDirty( sal_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 = sal_False; |
| } |
| |
| SCCOL nCol1, nCol2; |
| SCROW nRow1, nRow2; |
| if ( pIter->GetNext( nCol1, nCol2, nRow1, nRow2 ) ) |
| aNext = ScRange( nCol1, nRow1, nTab, nCol2, nRow2, nTab ); |
| else |
| bAtEnd = sal_True; // kommt nix mehr |
| } |
| else |
| bAtEnd = sal_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&, const SfxHint& rHint ) |
| { |
| if ( rHint.ISA( ScUpdateRefHint ) ) |
| { |
| //! und nun ??? |
| } |
| else if ( rHint.ISA( SfxSimpleHint ) ) |
| { |
| sal_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 = sal_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 |
| |
| return uno::makeAny(uno::Reference<table::XCellRange> (NextObject_Impl())); |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| ScUniqueCellFormatsObj::ScUniqueCellFormatsObj(ScDocShell* pDocSh, const ScRange& rRange) : |
| pDocShell( pDocSh ), |
| aTotalRange( rRange ), |
| aRangeLists() |
| { |
| pDocShell->GetDocument()->AddUnoObject(*this); |
| |
| DBG_ASSERT( aTotalRange.aStart.Tab() == aTotalRange.aEnd.Tab(), "unterschiedliche Tabellen" ); |
| |
| GetObjects_Impl(); |
| } |
| |
| ScUniqueCellFormatsObj::~ScUniqueCellFormatsObj() |
| { |
| if (pDocShell) |
| pDocShell->GetDocument()->RemoveUnoObject(*this); |
| } |
| |
| void ScUniqueCellFormatsObj::Notify( SfxBroadcaster&, const SfxHint& rHint ) |
| { |
| if ( rHint.ISA( ScUpdateRefHint ) ) |
| { |
| //! aTotalRange... |
| } |
| else if ( rHint.ISA( SfxSimpleHint ) ) |
| { |
| sal_uLong nId = ((const SfxSimpleHint&)rHint).GetId(); |
| if ( nId == SFX_HINT_DYING ) |
| pDocShell = NULL; // ungueltig geworden |
| } |
| } |
| |
| // |
| // Fill the list of formats from the document |
| // |
| |
| // hash code to access the range lists by ScPatternAttr pointer |
| struct ScPatternHashCode |
| { |
| size_t operator()( const ScPatternAttr* pPattern ) const |
| { |
| return reinterpret_cast<size_t>(pPattern); |
| } |
| }; |
| |
| // Hash map to find a range by its start row |
| typedef ::std::hash_map< SCROW, ScRange > ScRowRangeHashMap; |
| |
| typedef ::std::vector<ScRange> ScRangeVector; |
| |
| // Hash map entry. |
| // The Join method depends on the column-wise order of ScAttrRectIterator |
| class ScUniqueFormatsEntry |
| { |
| enum EntryState { STATE_EMPTY, STATE_SINGLE, STATE_COMPLEX }; |
| |
| EntryState eState; |
| ScRange aSingleRange; |
| ScRowRangeHashMap aJoinedRanges; // "active" ranges to be merged |
| ScRangeVector aCompletedRanges; // ranges that will no longer be touched |
| ScRangeListRef aReturnRanges; // result as ScRangeList for further use |
| |
| public: |
| ScUniqueFormatsEntry() : eState( STATE_EMPTY ) {} |
| ScUniqueFormatsEntry( const ScUniqueFormatsEntry& r ) : |
| eState( r.eState ), |
| aSingleRange( r.aSingleRange ), |
| aJoinedRanges( r.aJoinedRanges ), |
| aCompletedRanges( r.aCompletedRanges ), |
| aReturnRanges( r.aReturnRanges ) {} |
| ~ScUniqueFormatsEntry() {} |
| |
| void Join( const ScRange& rNewRange ); |
| const ScRangeList& GetRanges(); |
| void Clear() { aReturnRanges.Clear(); } // aJoinedRanges and aCompletedRanges are cleared in GetRanges |
| }; |
| |
| void ScUniqueFormatsEntry::Join( const ScRange& rNewRange ) |
| { |
| // Special-case handling for single range |
| |
| if ( eState == STATE_EMPTY ) |
| { |
| aSingleRange = rNewRange; |
| eState = STATE_SINGLE; |
| return; |
| } |
| if ( eState == STATE_SINGLE ) |
| { |
| if ( aSingleRange.aStart.Row() == rNewRange.aStart.Row() && |
| aSingleRange.aEnd.Row() == rNewRange.aEnd.Row() && |
| aSingleRange.aEnd.Col() + 1 == rNewRange.aStart.Col() ) |
| { |
| aSingleRange.aEnd.SetCol( rNewRange.aEnd.Col() ); |
| return; // still a single range |
| } |
| |
| SCROW nSingleRow = aSingleRange.aStart.Row(); |
| aJoinedRanges.insert( ScRowRangeHashMap::value_type( nSingleRow, aSingleRange ) ); |
| eState = STATE_COMPLEX; |
| // continue normally |
| } |
| |
| // This is called in the order of ScAttrRectIterator results. |
| // rNewRange can only be joined with an existing entry if it's the same rows, starting in the next column. |
| // If the old entry for the start row extends to a different end row, or ends in a different column, it |
| // can be moved to aCompletedRanges because it can't be joined with following iterator results. |
| // Everything happens within one sheet, so Tab can be ignored. |
| |
| SCROW nStartRow = rNewRange.aStart.Row(); |
| ScRowRangeHashMap::iterator aIter( aJoinedRanges.find( nStartRow ) ); // find the active entry for the start row |
| if ( aIter != aJoinedRanges.end() ) |
| { |
| ScRange& rOldRange = aIter->second; |
| if ( rOldRange.aEnd.Row() == rNewRange.aEnd.Row() && |
| rOldRange.aEnd.Col() + 1 == rNewRange.aStart.Col() ) |
| { |
| // extend existing range |
| rOldRange.aEnd.SetCol( rNewRange.aEnd.Col() ); |
| } |
| else |
| { |
| // move old range to aCompletedRanges, keep rNewRange for joining |
| aCompletedRanges.push_back( rOldRange ); |
| rOldRange = rNewRange; // replace in hash map |
| } |
| } |
| else |
| { |
| // keep rNewRange for joining |
| aJoinedRanges.insert( ScRowRangeHashMap::value_type( nStartRow, rNewRange ) ); |
| } |
| } |
| |
| const ScRangeList& ScUniqueFormatsEntry::GetRanges() |
| { |
| if ( eState == STATE_SINGLE ) |
| { |
| aReturnRanges = new ScRangeList; |
| aReturnRanges->Append( aSingleRange ); |
| return *aReturnRanges; |
| } |
| |
| // move remaining entries from aJoinedRanges to aCompletedRanges |
| |
| ScRowRangeHashMap::const_iterator aJoinedEnd = aJoinedRanges.end(); |
| for ( ScRowRangeHashMap::const_iterator aJoinedIter = aJoinedRanges.begin(); aJoinedIter != aJoinedEnd; ++aJoinedIter ) |
| aCompletedRanges.push_back( aJoinedIter->second ); |
| aJoinedRanges.clear(); |
| |
| // sort all ranges for a predictable API result |
| |
| std::sort( aCompletedRanges.begin(), aCompletedRanges.end() ); |
| |
| // fill and return ScRangeList |
| |
| aReturnRanges = new ScRangeList; |
| ScRangeVector::const_iterator aCompEnd( aCompletedRanges.end() ); |
| for ( ScRangeVector::const_iterator aCompIter( aCompletedRanges.begin() ); aCompIter != aCompEnd; ++aCompIter ) |
| aReturnRanges->Append( *aCompIter ); |
| aCompletedRanges.clear(); |
| |
| return *aReturnRanges; |
| } |
| |
| typedef ::std::hash_map< const ScPatternAttr*, ScUniqueFormatsEntry, ScPatternHashCode > ScUniqueFormatsHashMap; |
| |
| // function object to sort the range lists by start of first range |
| struct ScUniqueFormatsOrder |
| { |
| bool operator()( const ScRangeList& rList1, const ScRangeList& rList2 ) const |
| { |
| // all range lists have at least one entry |
| DBG_ASSERT( rList1.Count() > 0 && rList2.Count() > 0, "ScUniqueFormatsOrder: empty list" ); |
| |
| // compare start positions using ScAddress comparison operator |
| return ( rList1.GetObject(0)->aStart < rList2.GetObject(0)->aStart ); |
| } |
| }; |
| |
| void ScUniqueCellFormatsObj::GetObjects_Impl() |
| { |
| if (pDocShell) |
| { |
| ScDocument* pDoc = pDocShell->GetDocument(); |
| SCTAB nTab = aTotalRange.aStart.Tab(); |
| ScAttrRectIterator aIter( pDoc, nTab, |
| aTotalRange.aStart.Col(), aTotalRange.aStart.Row(), |
| aTotalRange.aEnd.Col(), aTotalRange.aEnd.Row() ); |
| SCCOL nCol1, nCol2; |
| SCROW nRow1, nRow2; |
| |
| // Collect the ranges for each format in a hash map, to avoid nested loops |
| |
| ScUniqueFormatsHashMap aHashMap; |
| while (aIter.GetNext( nCol1, nCol2, nRow1, nRow2 ) ) |
| { |
| ScRange aRange( nCol1, nRow1, nTab, nCol2, nRow2, nTab ); |
| const ScPatternAttr* pPattern = pDoc->GetPattern(nCol1, nRow1, nTab); |
| aHashMap[pPattern].Join( aRange ); |
| } |
| |
| // Fill the vector aRangeLists with the range lists from the hash map |
| |
| aRangeLists.reserve( aHashMap.size() ); |
| ScUniqueFormatsHashMap::iterator aMapIter( aHashMap.begin() ); |
| ScUniqueFormatsHashMap::iterator aMapEnd( aHashMap.end() ); |
| while ( aMapIter != aMapEnd ) |
| { |
| ScUniqueFormatsEntry& rEntry = aMapIter->second; |
| const ScRangeList& rRanges = rEntry.GetRanges(); |
| aRangeLists.push_back( rRanges ); // copy ScRangeList |
| rEntry.Clear(); // free memory, don't hold both copies of all ranges |
| ++aMapIter; |
| } |
| |
| // Sort the vector by first range's start position, to avoid random shuffling |
| // due to using the ScPatterAttr pointers |
| |
| ScUniqueFormatsOrder aComp; |
| ::std::sort( aRangeLists.begin(), aRangeLists.end(), aComp ); |
| } |
| } |
| |
| // XIndexAccess |
| |
| sal_Int32 SAL_CALL ScUniqueCellFormatsObj::getCount() throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| |
| return aRangeLists.size(); |
| } |
| |
| uno::Any SAL_CALL ScUniqueCellFormatsObj::getByIndex( sal_Int32 nIndex ) |
| throw(lang::IndexOutOfBoundsException, |
| lang::WrappedTargetException, uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| |
| if(static_cast<sal_uInt32>(nIndex) < aRangeLists.size()) |
| return uno::makeAny(uno::Reference<sheet::XSheetCellRangeContainer>(new ScCellRangesObj(pDocShell, aRangeLists[nIndex]))); |
| else |
| throw lang::IndexOutOfBoundsException(); |
| // return uno::Any(); |
| } |
| |
| uno::Type SAL_CALL ScUniqueCellFormatsObj::getElementType() throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| return getCppuType((uno::Reference<sheet::XSheetCellRangeContainer>*)0); |
| } |
| |
| sal_Bool SAL_CALL ScUniqueCellFormatsObj::hasElements() throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| return ( aRangeLists.size() != 0 ); |
| } |
| |
| // XEnumerationAccess |
| |
| uno::Reference<container::XEnumeration> SAL_CALL ScUniqueCellFormatsObj::createEnumeration() |
| throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| if (pDocShell) |
| return new ScUniqueCellFormatsEnumeration( pDocShell, aRangeLists ); |
| return NULL; |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| ScUniqueCellFormatsEnumeration::ScUniqueCellFormatsEnumeration(ScDocShell* pDocSh, const ScMyRangeLists& rRangeLists) : |
| aRangeLists(rRangeLists), |
| pDocShell( pDocSh ), |
| nCurrentPosition(0) |
| { |
| pDocShell->GetDocument()->AddUnoObject(*this); |
| } |
| |
| ScUniqueCellFormatsEnumeration::~ScUniqueCellFormatsEnumeration() |
| { |
| if (pDocShell) |
| pDocShell->GetDocument()->RemoveUnoObject(*this); |
| } |
| |
| void ScUniqueCellFormatsEnumeration::Notify( SfxBroadcaster&, const SfxHint& rHint ) |
| { |
| if ( rHint.ISA( ScUpdateRefHint ) ) |
| { |
| //! und nun ??? |
| } |
| else if ( rHint.ISA( SfxSimpleHint ) ) |
| { |
| sal_uLong nId = ((const SfxSimpleHint&)rHint).GetId(); |
| if ( nId == SFX_HINT_DYING ) |
| pDocShell = NULL; // ungueltig geworden |
| } |
| } |
| |
| // XEnumeration |
| |
| sal_Bool SAL_CALL ScUniqueCellFormatsEnumeration::hasMoreElements() throw(uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| return static_cast<sal_uInt32>(nCurrentPosition) < aRangeLists.size(); |
| } |
| |
| uno::Any SAL_CALL ScUniqueCellFormatsEnumeration::nextElement() throw(container::NoSuchElementException, |
| lang::WrappedTargetException, uno::RuntimeException) |
| { |
| ScUnoGuard aGuard; |
| |
| if ( !hasMoreElements() || !pDocShell ) |
| throw container::NoSuchElementException(); // no more elements |
| |
| // Interface-Typ muss zu ScCellFormatsObj::getElementType passen |
| |
| return uno::makeAny(uno::Reference<sheet::XSheetCellRangeContainer>(new ScCellRangesObj(pDocShell, aRangeLists[nCurrentPosition++]))); |
| } |
| |
| |