sc/source/core/data/documen6.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "scitems.hxx"
  21 #include <editeng/scripttypeitem.hxx>
  22
  23 #include <com/sun/star/i18n/BreakIterator.hpp>
  24 #include <com/sun/star/i18n/ScriptType.hpp>
  25 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  26 #include <comphelper/processfactory.hxx>
  27
  28 #include "document.hxx"
  29 #include "cellform.hxx"
  30 #include "patattr.hxx"
  31 #include "scrdata.hxx"
  32 #include "poolhelp.hxx"
  33 #include "attrib.hxx"
  34 #include "globalnames.hxx"
  35 #include "columnspanset.hxx"
  36 #include "table.hxx"
  37
  38 using namespace com::sun::star;
  39
  40 //  this file is compiled with exceptions enabled
  41 //  put functions here that need exceptions!
  42
  43 const uno::Reference< i18n::XBreakIterator >& ScDocument::GetBreakIterator()
  44 {
  45     if ( !pScriptTypeData )
  46         pScriptTypeData = new ScScriptTypeData;
  47     if ( !pScriptTypeData->xBreakIter.is() )
  48     {
  49         pScriptTypeData->xBreakIter = i18n::BreakIterator::create( comphelper::getProcessComponentContext() );
  50     }
  51     return pScriptTypeData->xBreakIter;
  52 }
  53
  54 bool ScDocument::HasStringWeakCharacters( const OUString& rString )
  55 {
  56     if (!rString.isEmpty())
  57     {
  58         uno::Reference<i18n::XBreakIterator> xBreakIter = GetBreakIterator();
  59         if ( xBreakIter.is() )
  60         {
  61             sal_Int32 nLen = rString.getLength();
  62
  63             sal_Int32 nPos = 0;
  64             do
  65             {
  66                 sal_Int16 nType = xBreakIter->getScriptType( rString, nPos );
  67                 if ( nType == i18n::ScriptType::WEAK )
  68                     return true;                            // found
  69
  70                 nPos = xBreakIter->endOfScript( rString, nPos, nType );
  71             }
  72             while ( nPos >= 0 && nPos < nLen );
  73         }
  74     }
  75
  76     return false;       // none found
  77 }
  78
  79 SvtScriptType ScDocument::GetStringScriptType( const OUString& rString )
  80 {
  81     SvtScriptType nRet = SvtScriptType::NONE;
  82     if (!rString.isEmpty())
  83     {
  84         uno::Reference<i18n::XBreakIterator> xBreakIter = GetBreakIterator();
  85         if ( xBreakIter.is() )
  86         {
  87             sal_Int32 nLen = rString.getLength();
  88
  89             sal_Int32 nPos = 0;
  90             do
  91             {
  92                 sal_Int16 nType = xBreakIter->getScriptType( rString, nPos );
  93                 switch ( nType )
  94                 {
  95                     case i18n::ScriptType::LATIN:
  96                         nRet |= SvtScriptType::LATIN;
  97                         break;
  98                     case i18n::ScriptType::ASIAN:
  99                         nRet |= SvtScriptType::ASIAN;
 100                         break;
 101                     case i18n::ScriptType::COMPLEX:
 102                         nRet |= SvtScriptType::COMPLEX;
 103                         break;
 104                     // WEAK is ignored
 105                 }
 106                 nPos = xBreakIter->endOfScript( rString, nPos, nType );
 107             }
 108             while ( nPos >= 0 && nPos < nLen );
 109         }
 110     }
 111     return nRet;
 112 }
 113
 114 SvtScriptType ScDocument::GetCellScriptType( const ScAddress& rPos, sal_uLong nNumberFormat )
 115 {
 116     SvtScriptType nStored = GetScriptType(rPos);
 117     if ( nStored != SvtScriptType::UNKNOWN )         // stored value valid?
 118         return nStored;                             // use stored value
 119
 120     Color* pColor;
 121     OUString aStr = ScCellFormat::GetString(*this, rPos, nNumberFormat, &pColor, *xPoolHelper->GetFormTable());
 122
 123     SvtScriptType nRet = GetStringScriptType( aStr );
 124
 125     SetScriptType(rPos, nRet);       // store for later calls
 126
 127     return nRet;
 128 }
 129
 130 SvtScriptType ScDocument::GetScriptType( SCCOL nCol, SCROW nRow, SCTAB nTab )
 131 {
 132     // if script type is set, don't have to get number formats
 133
 134     ScAddress aPos(nCol, nRow, nTab);
 135     SvtScriptType nStored = GetScriptType(aPos);
 136     if ( nStored != SvtScriptType::UNKNOWN )         // stored value valid?
 137         return nStored;                             // use stored value
 138
 139     // include number formats from conditional formatting
 140
 141     const ScPatternAttr* pPattern = GetPattern( nCol, nRow, nTab );
 142     if (!pPattern) return SvtScriptType::NONE;
 143     const SfxItemSet* pCondSet = NULL;
 144     if ( !static_cast<const ScCondFormatItem&>(pPattern->GetItem(ATTR_CONDITIONAL)).GetCondFormatData().empty() )
 145         pCondSet = GetCondResult( nCol, nRow, nTab );
 146
 147     sal_uLong nFormat = pPattern->GetNumberFormat( xPoolHelper->GetFormTable(), pCondSet );
 148
 149     return GetCellScriptType(aPos, nFormat);
 150 }
 151
 152 namespace {
 153
 154 class ScriptTypeAggregator : public sc::ColumnSpanSet::Action
 155 {
 156     ScDocument& mrDoc;
 157     sc::ColumnBlockPosition maBlockPos;
 158     SvtScriptType mnScriptType;
 159
 160 public:
 161     ScriptTypeAggregator(ScDocument& rDoc) : mrDoc(rDoc), mnScriptType(SvtScriptType::NONE) {}
 162
 163     virtual void startColumn(SCTAB nTab, SCCOL nCol) SAL_OVERRIDE
 164     {
 165         mrDoc.InitColumnBlockPosition(maBlockPos, nTab, nCol);
 166     }
 167
 168     virtual void execute(const ScAddress& rPos, SCROW nLength, bool bVal) SAL_OVERRIDE
 169     {
 170         if (!bVal)
 171             return;
 172
 173         mnScriptType |= mrDoc.GetRangeScriptType(maBlockPos, rPos, nLength);
 174     };
 175
 176     SvtScriptType getScriptType() const { return mnScriptType; }
 177 };
 178
 179 }
 180
 181 SvtScriptType ScDocument::GetRangeScriptType(
 182     sc::ColumnBlockPosition& rBlockPos, const ScAddress& rPos, SCROW nLength )
 183 {
 184     if (!TableExists(rPos.Tab()))
 185         return SvtScriptType::NONE;
 186
 187     return maTabs[rPos.Tab()]->GetRangeScriptType(rBlockPos, rPos.Col(), rPos.Row(), rPos.Row()+nLength-1);
 188 }
 189
 190 SvtScriptType ScDocument::GetRangeScriptType( const ScRangeList& rRanges )
 191 {
 192     sc::ColumnSpanSet aSet(false);
 193     for (size_t i = 0, n = rRanges.size(); i < n; ++i)
 194     {
 195         const ScRange& rRange = *rRanges[i];
 196         SCTAB nTab = rRange.aStart.Tab();
 197         SCROW nRow1 = rRange.aStart.Row();
 198         SCROW nRow2 = rRange.aEnd.Row();
 199         for (SCCOL nCol = rRange.aStart.Col(); nCol <= rRange.aEnd.Col(); ++nCol)
 200             aSet.set(nTab, nCol, nRow1, nRow2, true);
 201     }
 202
 203     ScriptTypeAggregator aAction(*this);
 204     aSet.executeAction(aAction);
 205     return aAction.getScriptType();
 206 }
 207
 208 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */