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 "oox/helper/attributelist.hxx"
21 :
22 : #include <osl/diagnose.h>
23 : #include <rtl/ustrbuf.hxx>
24 : #include "oox/token/tokenmap.hxx"
25 :
26 : namespace oox {
27 :
28 : // ============================================================================
29 :
30 : using namespace ::com::sun::star;
31 : using namespace ::com::sun::star::uno;
32 : using namespace ::com::sun::star::xml::sax;
33 :
34 : // ============================================================================
35 :
36 : namespace {
37 :
38 : const sal_Int32 XSTRING_ENCCHAR_LEN = 7;
39 :
40 225 : bool lclAddHexDigit( sal_Unicode& orcChar, sal_Unicode cDigit, int nBitShift )
41 : {
42 225 : if( ('0' <= cDigit) && (cDigit <= '9') ) { orcChar |= ((cDigit - '0') << nBitShift); return true; }
43 1 : if( ('a' <= cDigit) && (cDigit <= 'f') ) { orcChar |= ((cDigit - 'a' + 10) << nBitShift); return true; }
44 1 : if( ('A' <= cDigit) && (cDigit <= 'F') ) { orcChar |= ((cDigit - 'A' + 10) << nBitShift); return true; }
45 1 : return false;
46 : }
47 :
48 1307 : sal_Unicode lclGetXChar( const sal_Unicode*& rpcStr, const sal_Unicode* pcEnd )
49 : {
50 1307 : sal_Unicode cChar = 0;
51 2187 : if( (pcEnd - rpcStr >= XSTRING_ENCCHAR_LEN) &&
52 540 : (rpcStr[ 0 ] == '_') &&
53 58 : (rpcStr[ 1 ] == 'x') &&
54 57 : (rpcStr[ 6 ] == '_') &&
55 57 : lclAddHexDigit( cChar, rpcStr[ 2 ], 12 ) &&
56 56 : lclAddHexDigit( cChar, rpcStr[ 3 ], 8 ) &&
57 56 : lclAddHexDigit( cChar, rpcStr[ 4 ], 4 ) &&
58 56 : lclAddHexDigit( cChar, rpcStr[ 5 ], 0 ) )
59 : {
60 56 : rpcStr += XSTRING_ENCCHAR_LEN;
61 56 : return cChar;
62 : }
63 1251 : return *rpcStr++;
64 : }
65 :
66 : } // namespace
67 :
68 : // ----------------------------------------------------------------------------
69 :
70 42 : sal_Int32 AttributeConversion::decodeToken( const OUString& rValue )
71 : {
72 42 : return StaticTokenMap::get().getTokenFromUnicode( rValue );
73 : }
74 :
75 320 : OUString AttributeConversion::decodeXString( const OUString& rValue )
76 : {
77 : // string shorter than one encoded character - no need to decode
78 320 : if( rValue.getLength() < XSTRING_ENCCHAR_LEN )
79 177 : return rValue;
80 143 : OUStringBuffer aBuffer;
81 143 : const sal_Unicode* pcStr = rValue.getStr();
82 143 : const sal_Unicode* pcEnd = pcStr + rValue.getLength();
83 1593 : while( pcStr < pcEnd )
84 1307 : aBuffer.append( lclGetXChar( pcStr, pcEnd ) );
85 143 : return aBuffer.makeStringAndClear();
86 : }
87 :
88 457 : double AttributeConversion::decodeDouble( const OUString& rValue )
89 : {
90 457 : return rValue.toDouble();
91 : }
92 :
93 3410 : sal_Int32 AttributeConversion::decodeInteger( const OUString& rValue )
94 : {
95 3410 : return rValue.toInt32();
96 : }
97 :
98 4 : sal_uInt32 AttributeConversion::decodeUnsigned( const OUString& rValue )
99 : {
100 4 : return getLimitedValue< sal_uInt32, sal_Int64 >( rValue.toInt64(), 0, SAL_MAX_UINT32 );
101 : }
102 :
103 0 : sal_Int64 AttributeConversion::decodeHyper( const OUString& rValue )
104 : {
105 0 : return rValue.toInt64();
106 : }
107 :
108 232 : sal_Int32 AttributeConversion::decodeIntegerHex( const OUString& rValue )
109 : {
110 232 : return rValue.toInt32( 16 );
111 : }
112 :
113 : // ============================================================================
114 :
115 12452 : AttributeList::AttributeList( const Reference< XFastAttributeList >& rxAttribs ) :
116 12452 : mxAttribs( rxAttribs )
117 : {
118 : OSL_ENSURE( mxAttribs.is(), "AttributeList::AttributeList - missing attribute list interface" );
119 12452 : }
120 :
121 2311 : bool AttributeList::hasAttribute( sal_Int32 nAttrToken ) const
122 : {
123 2311 : return mxAttribs->hasAttribute( nAttrToken );
124 : }
125 :
126 : // optional return values -----------------------------------------------------
127 :
128 389 : OptValue< sal_Int32 > AttributeList::getToken( sal_Int32 nAttrToken ) const
129 : {
130 389 : sal_Int32 nToken = mxAttribs->getOptionalValueToken( nAttrToken, XML_TOKEN_INVALID );
131 389 : return OptValue< sal_Int32 >( nToken != XML_TOKEN_INVALID, nToken );
132 : }
133 :
134 644 : OptValue< OUString > AttributeList::getString( sal_Int32 nAttrToken ) const
135 : {
136 : // check if the attribute exists (empty string may be different to missing attribute)
137 644 : if( mxAttribs->hasAttribute( nAttrToken ) )
138 242 : return OptValue< OUString >( mxAttribs->getOptionalValue( nAttrToken ) );
139 402 : return OptValue< OUString >();
140 : }
141 :
142 333 : OptValue< OUString > AttributeList::getXString( sal_Int32 nAttrToken ) const
143 : {
144 : // check if the attribute exists (empty string may be different to missing attribute)
145 333 : if( mxAttribs->hasAttribute( nAttrToken ) )
146 318 : return OptValue< OUString >( AttributeConversion::decodeXString( mxAttribs->getOptionalValue( nAttrToken ) ) );
147 15 : return OptValue< OUString >();
148 : }
149 :
150 567 : OptValue< double > AttributeList::getDouble( sal_Int32 nAttrToken ) const
151 : {
152 567 : OUString aValue = mxAttribs->getOptionalValue( nAttrToken );
153 567 : bool bValid = !aValue.isEmpty();
154 567 : return OptValue< double >( bValid, bValid ? AttributeConversion::decodeDouble( aValue ) : 0.0 );
155 : }
156 :
157 8512 : OptValue< sal_Int32 > AttributeList::getInteger( sal_Int32 nAttrToken ) const
158 : {
159 8512 : OUString aValue = mxAttribs->getOptionalValue( nAttrToken );
160 8512 : bool bValid = !aValue.isEmpty();
161 8512 : return OptValue< sal_Int32 >( bValid, bValid ? AttributeConversion::decodeInteger( aValue ) : 0 );
162 : }
163 :
164 4 : OptValue< sal_uInt32 > AttributeList::getUnsigned( sal_Int32 nAttrToken ) const
165 : {
166 4 : OUString aValue = mxAttribs->getOptionalValue( nAttrToken );
167 4 : bool bValid = !aValue.isEmpty();
168 4 : return OptValue< sal_uInt32 >( bValid, AttributeConversion::decodeUnsigned( aValue ) );
169 : }
170 :
171 0 : OptValue< sal_Int64 > AttributeList::getHyper( sal_Int32 nAttrToken ) const
172 : {
173 0 : OUString aValue = mxAttribs->getOptionalValue( nAttrToken );
174 0 : bool bValid = !aValue.isEmpty();
175 0 : return OptValue< sal_Int64 >( bValid, bValid ? AttributeConversion::decodeHyper( aValue ) : 0 );
176 : }
177 :
178 232 : OptValue< sal_Int32 > AttributeList::getIntegerHex( sal_Int32 nAttrToken ) const
179 : {
180 232 : OUString aValue = mxAttribs->getOptionalValue( nAttrToken );
181 232 : bool bValid = !aValue.isEmpty();
182 232 : return OptValue< sal_Int32 >( bValid, bValid ? AttributeConversion::decodeIntegerHex( aValue ) : 0 );
183 : }
184 :
185 4985 : OptValue< bool > AttributeList::getBool( sal_Int32 nAttrToken ) const
186 : {
187 : // boolean attributes may be "t", "f", "true", "false", "on", "off", "1", or "0"
188 4985 : switch( getToken( nAttrToken, XML_TOKEN_INVALID ) )
189 : {
190 0 : case XML_t: return OptValue< bool >( true ); // used in VML
191 405 : case XML_true: return OptValue< bool >( true );
192 0 : case XML_on: return OptValue< bool >( true );
193 0 : case XML_f: return OptValue< bool >( false ); // used in VML
194 1281 : case XML_false: return OptValue< bool >( false );
195 0 : case XML_off: return OptValue< bool >( false );
196 : }
197 3299 : OptValue< sal_Int32 > onValue = getInteger( nAttrToken );
198 3299 : return OptValue< bool >( onValue.has(), onValue.get() != 0 );
199 : }
200 :
201 0 : OptValue< util::DateTime > AttributeList::getDateTime( sal_Int32 nAttrToken ) const
202 : {
203 0 : OUString aValue = mxAttribs->getOptionalValue( nAttrToken );
204 0 : util::DateTime aDateTime;
205 0 : bool bValid = (aValue.getLength() == 19) && (aValue[ 4 ] == '-') && (aValue[ 7 ] == '-') &&
206 0 : (aValue[ 10 ] == 'T') && (aValue[ 13 ] == ':') && (aValue[ 16 ] == ':');
207 0 : if( bValid )
208 : {
209 0 : aDateTime.Year = static_cast< sal_uInt16 >( aValue.copy( 0, 4 ).toInt32() );
210 0 : aDateTime.Month = static_cast< sal_uInt16 >( aValue.copy( 5, 2 ).toInt32() );
211 0 : aDateTime.Day = static_cast< sal_uInt16 >( aValue.copy( 8, 2 ).toInt32() );
212 0 : aDateTime.Hours = static_cast< sal_uInt16 >( aValue.copy( 11, 2 ).toInt32() );
213 0 : aDateTime.Minutes = static_cast< sal_uInt16 >( aValue.copy( 14, 2 ).toInt32() );
214 0 : aDateTime.Seconds = static_cast< sal_uInt16 >( aValue.copy( 17, 2 ).toInt32() );
215 : }
216 0 : return OptValue< util::DateTime >( bValid, aDateTime );
217 : }
218 :
219 : // defaulted return values ----------------------------------------------------
220 :
221 10061 : sal_Int32 AttributeList::getToken( sal_Int32 nAttrToken, sal_Int32 nDefault ) const
222 : {
223 10061 : return mxAttribs->getOptionalValueToken( nAttrToken, nDefault );
224 : }
225 :
226 4767 : OUString AttributeList::getString( sal_Int32 nAttrToken, const OUString& rDefault ) const
227 : {
228 : // try to avoid slow exception throw/catch if we can
229 4767 : if (rDefault.isEmpty())
230 4741 : return mxAttribs->getOptionalValue( nAttrToken );
231 :
232 : try
233 : {
234 26 : return mxAttribs->getValue( nAttrToken );
235 : }
236 20 : catch( Exception& )
237 : {
238 : }
239 20 : return rDefault;
240 : }
241 :
242 331 : OUString AttributeList::getXString( sal_Int32 nAttrToken, const OUString& rDefault ) const
243 : {
244 331 : return getXString( nAttrToken ).get( rDefault );
245 : }
246 :
247 567 : double AttributeList::getDouble( sal_Int32 nAttrToken, double fDefault ) const
248 : {
249 567 : return getDouble( nAttrToken ).get( fDefault );
250 : }
251 :
252 4906 : sal_Int32 AttributeList::getInteger( sal_Int32 nAttrToken, sal_Int32 nDefault ) const
253 : {
254 4906 : return getInteger( nAttrToken ).get( nDefault );
255 : }
256 :
257 4 : sal_uInt32 AttributeList::getUnsigned( sal_Int32 nAttrToken, sal_uInt32 nDefault ) const
258 : {
259 4 : return getUnsigned( nAttrToken ).get( nDefault );
260 : }
261 :
262 0 : sal_Int64 AttributeList::getHyper( sal_Int32 nAttrToken, sal_Int64 nDefault ) const
263 : {
264 0 : return getHyper( nAttrToken ).get( nDefault );
265 : }
266 :
267 232 : sal_Int32 AttributeList::getIntegerHex( sal_Int32 nAttrToken, sal_Int32 nDefault ) const
268 : {
269 232 : return getIntegerHex( nAttrToken ).get( nDefault );
270 : }
271 :
272 4894 : bool AttributeList::getBool( sal_Int32 nAttrToken, bool bDefault ) const
273 : {
274 4894 : return getBool( nAttrToken ).get( bDefault );
275 : }
276 :
277 0 : util::DateTime AttributeList::getDateTime( sal_Int32 nAttrToken, const util::DateTime& rDefault ) const
278 : {
279 0 : return getDateTime( nAttrToken ).get( rDefault );
280 : }
281 :
282 : // ============================================================================
283 :
284 : } // namespace oox
285 :
286 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
