LCOV - code coverage report
Current view: top level - sw/source/core/uibase/envelp - labelcfg.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 195 0.0 %
Date: 2014-04-14 Functions: 0 16 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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 <config_folders.h>
      21             : 
      22             : #include <swtypes.hxx>
      23             : #include <labelcfg.hxx>
      24             : #include <labimp.hxx>
      25             : #include <comphelper/string.hxx>
      26             : #include <rtl/bootstrap.hxx>
      27             : #include <unotools/configpaths.hxx>
      28             : #include <xmlreader/xmlreader.hxx>
      29             : 
      30             : #include <unomid.h>
      31             : 
      32             : using namespace utl;
      33             : using namespace ::com::sun::star::uno;
      34             : using namespace ::com::sun::star::beans;
      35             : 
      36           0 : static inline void lcl_assertEndingItem(xmlreader::XmlReader& reader)
      37             : {
      38             :     int nsId;
      39           0 :     xmlreader::Span name;
      40             :     xmlreader::XmlReader::Result res;
      41           0 :     res = reader.nextItem(xmlreader::XmlReader::TEXT_NONE, &name, &nsId);
      42             :     assert(res == xmlreader::XmlReader::RESULT_END);
      43             :     (void) res;
      44           0 : }
      45             : 
      46           0 : static inline OUString lcl_getValue(xmlreader::XmlReader& reader,
      47             :                                     const xmlreader::Span& span)
      48             : {
      49             :     int nsId;
      50           0 :     xmlreader::Span name;
      51             :     xmlreader::XmlReader::Result res;
      52           0 :     res = reader.nextItem(xmlreader::XmlReader::TEXT_NONE, &name, &nsId);
      53             :     assert(res == xmlreader::XmlReader::RESULT_BEGIN && name.equals(span));
      54           0 :     res = reader.nextItem(xmlreader::XmlReader::TEXT_RAW, &name, &nsId);
      55             :     assert(res == xmlreader::XmlReader::RESULT_TEXT);
      56             :     (void) res; (void) span;
      57           0 :     OUString sTmp = name.convertFromUtf8();
      58           0 :     lcl_assertEndingItem(reader);
      59           0 :     return sTmp;
      60             : }
      61             : 
      62           0 : static Sequence<OUString> lcl_CreatePropertyNames(const OUString& rPrefix)
      63             : {
      64           0 :     Sequence<OUString> aProperties(2);
      65           0 :     OUString* pProperties = aProperties.getArray();
      66           0 :     for(sal_Int32 nProp = 0; nProp < 2; nProp++)
      67           0 :         pProperties[nProp] = rPrefix;
      68             : 
      69           0 :     pProperties[ 0] += "Name";
      70           0 :     pProperties[ 1] += "Measure";
      71           0 :     return aProperties;
      72             : }
      73             : 
      74           0 : SwLabelConfig::SwLabelConfig() :
      75           0 :     ConfigItem("Office.Labels/Manufacturer")
      76             : {
      77           0 :     OUString uri("$BRAND_BASE_DIR/" LIBO_SHARE_FOLDER "/labels/labels.xml");
      78           0 :     rtl::Bootstrap::expandMacros(uri);
      79           0 :     xmlreader::XmlReader reader(uri);
      80             :     int nsId;
      81           0 :     xmlreader::Span name;
      82             :     xmlreader::XmlReader::Result res;
      83           0 :     OUString sManufacturer;
      84           0 :     OUString sName;
      85           0 :     OUString sMeasure;
      86             : 
      87             :     // fill m_aLabels and m_aManufacturers with the predefined labels
      88             :     res = reader.nextItem(
      89           0 :             xmlreader::XmlReader::TEXT_NONE, &name, &nsId);
      90             :     assert(
      91             :         res == xmlreader::XmlReader::RESULT_BEGIN
      92             :         && name.equals("manufacturers"));
      93             :     res = reader.nextItem(
      94           0 :             xmlreader::XmlReader::TEXT_NONE, &name, &nsId);
      95           0 :     while (res != xmlreader::XmlReader::RESULT_END)
      96             :     {
      97             :         // Opening manufacturer
      98             :         assert(
      99             :             res == xmlreader::XmlReader::RESULT_BEGIN
     100             :             && name.equals("manufacturer"));
     101             :         // Get the name
     102           0 :         reader.nextAttribute(&nsId, &name);
     103             :         assert(
     104             :             nsId == xmlreader::XmlReader::NAMESPACE_NONE
     105             :             && name.equals("name"));
     106           0 :         sManufacturer = reader.getAttributeValue(false).convertFromUtf8();
     107             : 
     108             :         for(;;) {
     109             :             // Opening label or ending manufacturer
     110             :             res = reader.nextItem(
     111           0 :                     xmlreader::XmlReader::TEXT_NONE, &name, &nsId);
     112           0 :             if (res == xmlreader::XmlReader::RESULT_END)
     113           0 :                 break;
     114             :             assert(
     115             :                 res == xmlreader::XmlReader::RESULT_BEGIN
     116             :                 && name.equals("label"));
     117             :             // Get name value
     118           0 :             sName = lcl_getValue(reader, xmlreader::Span("name"));
     119             :             // Get measure value
     120           0 :             sMeasure = lcl_getValue(reader, xmlreader::Span("measure"));
     121             :             // Ending label mark
     122           0 :             lcl_assertEndingItem(reader);
     123           0 :             if ( m_aLabels.find( sManufacturer ) == m_aLabels.end() )
     124           0 :                 m_aManufacturers.push_back( sManufacturer );
     125           0 :             m_aLabels[sManufacturer][sName].m_aMeasure = sMeasure;
     126           0 :             m_aLabels[sManufacturer][sName].m_bPredefined = true;
     127             :         }
     128             :         // Get next manufacturer or end
     129             :         res = reader.nextItem(
     130           0 :                 xmlreader::XmlReader::TEXT_NONE, &name, &nsId);
     131             :     };
     132             :     res = reader.nextItem(
     133           0 :             xmlreader::XmlReader::TEXT_NONE, &name, &nsId);
     134             :     assert(res == xmlreader::XmlReader::RESULT_DONE);
     135             : 
     136             :     // add to m_aLabels and m_aManufacturers the custom labels
     137           0 :     const Sequence<OUString>& rMan = GetNodeNames( OUString() );
     138           0 :     const OUString* pMan = rMan.getConstArray();
     139           0 :     for ( sal_Int32 nMan = 0; nMan < rMan.getLength(); nMan++ )
     140             :     {
     141           0 :         sManufacturer = pMan[nMan];
     142           0 :         const Sequence<OUString> aLabels = GetNodeNames( sManufacturer );
     143           0 :         const OUString* pLabels = aLabels.getConstArray();
     144           0 :         for( sal_Int32 nLabel = 0; nLabel < aLabels.getLength(); nLabel++ )
     145             :         {
     146           0 :             OUString sPrefix( sManufacturer );
     147           0 :             sPrefix += "/";
     148           0 :             sPrefix += pLabels[nLabel];
     149           0 :             sPrefix += "/";
     150           0 :             Sequence<OUString> aPropNames = lcl_CreatePropertyNames( sPrefix );
     151           0 :             Sequence<Any>   aValues = GetProperties( aPropNames );
     152           0 :             const Any* pValues = aValues.getConstArray();
     153           0 :             if (aValues.getLength() >= 1)
     154           0 :                 if(pValues[0].hasValue())
     155           0 :                     pValues[0] >>= sName;
     156           0 :             if (aValues.getLength() >= 2)
     157           0 :                 if(pValues[1].hasValue())
     158           0 :                     pValues[1] >>= sMeasure;
     159           0 :             if ( m_aLabels.find( sManufacturer ) == m_aLabels.end() )
     160           0 :                 m_aManufacturers.push_back( sManufacturer );
     161           0 :             m_aLabels[sManufacturer][sName].m_aMeasure = sMeasure;
     162           0 :             m_aLabels[sManufacturer][sName].m_bPredefined = false;
     163           0 :         }
     164           0 :     }
     165           0 : }
     166             : 
     167           0 : SwLabelConfig::~SwLabelConfig()
     168             : {
     169           0 : }
     170             : 
     171             : // the config item is not writable ?:
     172           0 : void SwLabelConfig::Commit() {}
     173             : 
     174           0 : void SwLabelConfig::Notify( const ::com::sun::star::uno::Sequence< OUString >& ) {}
     175             : 
     176           0 : static SwLabRec* lcl_CreateSwLabRec(const OUString& rType, const OUString& rMeasure, const OUString& rManufacturer)
     177             : {
     178           0 :     SwLabRec* pNewRec = new SwLabRec;
     179           0 :     pNewRec->aMake = rManufacturer;
     180           0 :     pNewRec->lPWidth = 0;
     181           0 :     pNewRec->lPHeight = 0;
     182           0 :     pNewRec->aType = rType;
     183             :     //all values are contained as colon-separated 1/100 mm values
     184             :     //except for the continuous flag ('C'/'S') and nCols, nRows (sal_Int32)
     185           0 :     OUString sMeasure(rMeasure);
     186           0 :     sal_uInt16 nTokenCount = comphelper::string::getTokenCount(sMeasure, ';');
     187           0 :     for(sal_uInt16 i = 0; i < nTokenCount; i++)
     188             :     {
     189           0 :         OUString sToken(sMeasure.getToken(i, ';' ));
     190           0 :         int nVal = sToken.toInt32();
     191           0 :         switch(i)
     192             :         {
     193           0 :             case  0 : pNewRec->bCont = sToken[0] == 'C'; break;
     194           0 :             case  1 : pNewRec->lHDist    = convertMm100ToTwip(nVal);  break;
     195           0 :             case  2 : pNewRec->lVDist    = convertMm100ToTwip(nVal);  break;
     196           0 :             case  3 : pNewRec->lWidth    = convertMm100ToTwip(nVal);  break;
     197           0 :             case  4 : pNewRec->lHeight   = convertMm100ToTwip(nVal);  break;
     198           0 :             case  5 : pNewRec->lLeft     = convertMm100ToTwip(nVal);  break;
     199           0 :             case  6 : pNewRec->lUpper    = convertMm100ToTwip(nVal);  break;
     200           0 :             case  7 : pNewRec->nCols     = nVal;                 break;
     201           0 :             case  8 : pNewRec->nRows     = nVal;                 break;
     202           0 :             case  9 : pNewRec->lPWidth   = convertMm100ToTwip(nVal);  break;
     203           0 :             case 10 : pNewRec->lPHeight  = convertMm100ToTwip(nVal);  break;
     204             :         }
     205           0 :     }
     206             :     // lines added for compatibility with custom label definitions saved before patch fdo#44516
     207           0 :     if (pNewRec->lPWidth == 0 || pNewRec->lPHeight == 0)
     208             :     {
     209             :         // old style definition (no paper dimensions), calculate probable values
     210           0 :         pNewRec->lPWidth = 2 * pNewRec->lLeft + (pNewRec->nCols - 1) * pNewRec->lHDist + pNewRec->lWidth;
     211           0 :         pNewRec->lPHeight = ( pNewRec->bCont ? pNewRec->nRows * pNewRec->lVDist : 2 * pNewRec->lUpper + (pNewRec->nRows - 1) * pNewRec->lVDist + pNewRec->lHeight );
     212             :     }
     213           0 :     return pNewRec;
     214             : }
     215             : 
     216           0 : static Sequence<PropertyValue> lcl_CreateProperties(
     217             :     Sequence<OUString>& rPropNames, OUString& rMeasure, const SwLabRec& rRec)
     218             : {
     219           0 :     const OUString* pNames = rPropNames.getConstArray();
     220           0 :     Sequence<PropertyValue> aRet(rPropNames.getLength());
     221           0 :     PropertyValue* pValues = aRet.getArray();
     222           0 :     OUString sColon(";");
     223             : 
     224           0 :     for(sal_Int32 nProp = 0; nProp < rPropNames.getLength(); nProp++)
     225             :     {
     226           0 :         pValues[nProp].Name = pNames[nProp];
     227           0 :         switch(nProp)
     228             :         {
     229           0 :             case 0: pValues[nProp].Value <<= OUString(rRec.aType); break;
     230             :             case 1:
     231             :             {
     232           0 :                 rMeasure = "";
     233           0 :                 rMeasure += rRec.bCont ? OUString( "C" ) : OUString( "S" );      rMeasure += sColon;
     234           0 :                 rMeasure += OUString::number( convertTwipToMm100( rRec.lHDist ) );   rMeasure += sColon;
     235           0 :                 rMeasure += OUString::number( convertTwipToMm100( rRec.lVDist ) );   rMeasure += sColon;
     236           0 :                 rMeasure += OUString::number( convertTwipToMm100( rRec.lWidth ) );   rMeasure += sColon;
     237           0 :                 rMeasure += OUString::number( convertTwipToMm100( rRec.lHeight ) );  rMeasure += sColon;
     238           0 :                 rMeasure += OUString::number( convertTwipToMm100( rRec.lLeft ) );    rMeasure += sColon;
     239           0 :                 rMeasure += OUString::number( convertTwipToMm100( rRec.lUpper ) );   rMeasure += sColon;
     240           0 :                 rMeasure += OUString::number( rRec.nCols );                     rMeasure += sColon;
     241           0 :                 rMeasure += OUString::number( rRec.nRows );                     rMeasure += sColon;
     242           0 :                 rMeasure += OUString::number( convertTwipToMm100( rRec.lPWidth ) );  rMeasure += sColon;
     243           0 :                 rMeasure += OUString::number( convertTwipToMm100( rRec.lPHeight ) );
     244           0 :                 pValues[nProp].Value <<= rMeasure;
     245             :             }
     246           0 :             break;
     247             :         }
     248             :     }
     249           0 :     return aRet;
     250             : }
     251             : 
     252             : // function fills SwLabDlg with label definitions for manufacturer rManufacturer
     253           0 : void    SwLabelConfig::FillLabels(const OUString& rManufacturer, SwLabRecs& rLabArr)
     254             : {
     255           0 :     if (m_aLabels.find(rManufacturer) == m_aLabels.end())
     256           0 :         return;
     257           0 :     for (std::map<OUString, SwLabelMeasure>::iterator it = m_aLabels[rManufacturer].begin();
     258           0 :             it != m_aLabels[rManufacturer].end(); ++it)
     259           0 :         rLabArr.push_back( lcl_CreateSwLabRec(it->first, it->second.m_aMeasure, rManufacturer) );
     260             : }
     261             : 
     262           0 : sal_Bool    SwLabelConfig::HasLabel(const OUString& rManufacturer, const OUString& rType)
     263             : {
     264           0 :     return ( ( m_aLabels.find(rManufacturer) != m_aLabels.end() ) &&
     265           0 :              ( m_aLabels[rManufacturer].find(rType) != m_aLabels[rManufacturer].end() ) );
     266             : }
     267             : 
     268           0 : static bool lcl_Exists(const OUString& rNode, const Sequence<OUString>& rLabels)
     269             : {
     270           0 :     const OUString* pLabels = rLabels.getConstArray();
     271           0 :     for(sal_Int32 i = 0; i < rLabels.getLength(); i++)
     272           0 :         if(pLabels[i] == rNode)
     273           0 :             return true;
     274           0 :     return false;
     275             : }
     276             : 
     277             : // label is always saved as a custom label
     278             : // predefined labels can NOT be overwritten by custom labels with same manufacturer/name
     279           0 : void SwLabelConfig::SaveLabel( const OUString& rManufacturer,
     280             :         const OUString& rType, const SwLabRec& rRec )
     281             : {
     282           0 :     OUString sFoundNode;
     283             :     bool bManufacturerNodeFound;
     284           0 :     if ( m_aLabels.find( rManufacturer ) == m_aLabels.end() ||
     285           0 :          GetNodeNames( rManufacturer ).getLength() == 0 )
     286             :     {
     287           0 :         bManufacturerNodeFound = false;
     288             :         // manufacturer node does not exist, add (and also to m_aManufacturers)
     289           0 :         if ( !AddNode( OUString(), rManufacturer ) )
     290             :         {
     291             :             OSL_FAIL("New configuration node could not be created");
     292           0 :             return ;
     293             :         }
     294           0 :         m_aManufacturers.push_back( rManufacturer );
     295             :     }
     296             :     else
     297           0 :         bManufacturerNodeFound = true;
     298             : 
     299           0 :     if ( !bManufacturerNodeFound ||
     300           0 :          m_aLabels[rManufacturer].find( rType ) == m_aLabels[rManufacturer].end() )
     301             :     {
     302             :         // type does not yet exist, add to config
     303           0 :         const Sequence<OUString> aLabels = GetNodeNames( rManufacturer );
     304           0 :         sal_Int32 nIndex = aLabels.getLength();
     305           0 :         OUString sPrefix( "Label" );
     306           0 :         sFoundNode = sPrefix;
     307           0 :         sFoundNode += OUString::number( nIndex );
     308           0 :         while ( lcl_Exists( sFoundNode, aLabels ) )
     309             :         {
     310           0 :             sFoundNode = sPrefix;
     311           0 :             sFoundNode += OUString::number(nIndex++);
     312           0 :         }
     313             :     }
     314             :     else
     315             :     {
     316             :         // get the appropiate node
     317           0 :         OUString sManufacturer( wrapConfigurationElementName( rManufacturer ) );
     318           0 :         const Sequence<OUString> aLabels = GetNodeNames( sManufacturer );
     319           0 :         const OUString* pLabels = aLabels.getConstArray();
     320           0 :         for (sal_Int32 nLabel = 0; nLabel < aLabels.getLength(); nLabel++)
     321             :         {
     322           0 :             OUString sPrefix( sManufacturer );
     323           0 :             sPrefix += "/";
     324           0 :             sPrefix += pLabels[nLabel];
     325           0 :             sPrefix += "/";
     326           0 :             Sequence<OUString> aProperties(1);
     327           0 :             aProperties.getArray()[0] = sPrefix;
     328           0 :             aProperties.getArray()[0] += "Name";
     329           0 :             Sequence<Any> aValues = GetProperties( aProperties );
     330           0 :             const Any* pValues = aValues.getConstArray();
     331           0 :             if ( pValues[0].hasValue() )
     332             :             {
     333           0 :                 OUString sTmp;
     334           0 :                 pValues[0] >>= sTmp;
     335           0 :                 if ( rType == sTmp )
     336             :                 {
     337           0 :                     sFoundNode = pLabels[nLabel];
     338           0 :                     break;
     339           0 :                 }
     340             :             }
     341           0 :         }
     342             :     }
     343             : 
     344           0 :     OUString sPrefix( wrapConfigurationElementName( rManufacturer ) );
     345           0 :     sPrefix += "/";
     346           0 :     sPrefix += sFoundNode;
     347           0 :     sPrefix += "/";
     348           0 :     Sequence<OUString> aPropNames = lcl_CreatePropertyNames( sPrefix );
     349           0 :     OUString sMeasure;
     350           0 :     Sequence<PropertyValue> aPropValues = lcl_CreateProperties( aPropNames, sMeasure, rRec );
     351           0 :     SetSetProperties( wrapConfigurationElementName( rManufacturer ), aPropValues );
     352             : 
     353             :     //update m_aLabels
     354           0 :     m_aLabels[rManufacturer][rType].m_aMeasure = sMeasure;
     355           0 :     m_aLabels[rManufacturer][rType].m_bPredefined = false;
     356           0 : }
     357             : 
     358             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10