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 <com/sun/star/uno/Any.hxx>
21 : #include <tools/stream.hxx>
22 : #include <svl/cintitem.hxx>
23 :
24 45524 : TYPEINIT1_AUTOFACTORY(CntByteItem, SfxPoolItem);
25 :
26 : // virtual
27 12160 : bool CntByteItem::operator ==(const SfxPoolItem & rItem) const
28 : {
29 : DBG_ASSERT(rItem.ISA(CntByteItem),
30 : "CntByteItem::operator ==(): Bad type");
31 12160 : return m_nValue == (static_cast< const CntByteItem * >(&rItem))->m_nValue;
32 : }
33 :
34 : // virtual
35 0 : int CntByteItem::Compare(const SfxPoolItem & rWith) const
36 : {
37 : DBG_ASSERT(rWith.ISA(CntByteItem), "CntByteItem::Compare(): Bad type");
38 0 : return (static_cast< const CntByteItem * >(&rWith))->m_nValue < m_nValue ?
39 : -1 :
40 : (static_cast< const CntByteItem * >(&rWith))->m_nValue
41 : == m_nValue ?
42 0 : 0 : 1;
43 : }
44 :
45 : // virtual
46 0 : bool CntByteItem::GetPresentation(SfxItemPresentation,
47 : SfxMapUnit, SfxMapUnit,
48 : OUString & rText,
49 : const IntlWrapper *) const
50 : {
51 0 : rText = OUString::number( m_nValue );
52 0 : return true;
53 : }
54 :
55 : // virtual
56 116 : bool CntByteItem::QueryValue(com::sun::star::uno::Any& rVal, sal_uInt8) const
57 : {
58 116 : sal_Int8 nValue = m_nValue;
59 116 : rVal <<= nValue;
60 116 : return true;
61 : }
62 :
63 : // virtual
64 13370 : bool CntByteItem::PutValue(const com::sun::star::uno::Any& rVal, sal_uInt8)
65 : {
66 13370 : sal_Int8 nValue = sal_Int8();
67 13370 : if (rVal >>= nValue)
68 : {
69 13370 : m_nValue = nValue;
70 13370 : return true;
71 : }
72 :
73 : OSL_FAIL( "CntByteItem::PutValue - Wrong type!" );
74 0 : return false;
75 : }
76 :
77 : // virtual
78 0 : SfxPoolItem * CntByteItem::Create(SvStream & rStream, sal_uInt16) const
79 : {
80 0 : short nTheValue = 0;
81 0 : rStream.ReadInt16( nTheValue );
82 0 : return new CntByteItem(Which(), sal_uInt8(nTheValue));
83 : }
84 :
85 : // virtual
86 0 : SvStream & CntByteItem::Store(SvStream & rStream, sal_uInt16) const
87 : {
88 0 : rStream.WriteInt16( short(m_nValue) );
89 0 : return rStream;
90 : }
91 :
92 : // virtual
93 0 : SfxPoolItem * CntByteItem::Clone(SfxItemPool *) const
94 : {
95 0 : return new CntByteItem(*this);
96 : }
97 :
98 : // virtual
99 0 : sal_uInt8 CntByteItem::GetMin() const
100 : {
101 0 : return 0;
102 : }
103 :
104 : // virtual
105 0 : sal_uInt8 CntByteItem::GetMax() const
106 : {
107 0 : return 255;
108 : }
109 :
110 : // virtual
111 0 : SfxFieldUnit CntByteItem::GetUnit() const
112 : {
113 0 : return SFX_FUNIT_NONE;
114 : }
115 :
116 1074004 : TYPEINIT1_AUTOFACTORY(CntUInt16Item, SfxPoolItem);
117 :
118 0 : CntUInt16Item::CntUInt16Item(sal_uInt16 which, SvStream & rStream) :
119 0 : SfxPoolItem(which)
120 : {
121 0 : sal_uInt16 nTheValue = 0;
122 0 : rStream.ReadUInt16( nTheValue );
123 0 : m_nValue = nTheValue;
124 0 : }
125 :
126 : // virtual
127 269480 : bool CntUInt16Item::operator ==(const SfxPoolItem & rItem) const
128 : {
129 : DBG_ASSERT(rItem.ISA(CntUInt16Item),
130 : "CntUInt16Item::operator ==(): Bad type");
131 269480 : return m_nValue == (static_cast< const CntUInt16Item * >(&rItem))->
132 269480 : m_nValue;
133 : }
134 :
135 : // virtual
136 0 : int CntUInt16Item::Compare(const SfxPoolItem & rWith) const
137 : {
138 : DBG_ASSERT(rWith.ISA(CntUInt16Item),
139 : "CntUInt16Item::Compare(): Bad type");
140 : return (static_cast< const CntUInt16Item * >(&rWith))->m_nValue
141 0 : < m_nValue ?
142 : -1 :
143 : (static_cast< const CntUInt16Item * >(&rWith))->m_nValue
144 : == m_nValue ?
145 0 : 0 : 1;
146 : }
147 :
148 : // virtual
149 0 : bool CntUInt16Item::GetPresentation(SfxItemPresentation,
150 : SfxMapUnit, SfxMapUnit,
151 : OUString & rText,
152 : const IntlWrapper *)
153 : const
154 : {
155 0 : rText = OUString::number( m_nValue );
156 0 : return true;
157 : }
158 :
159 : // virtual
160 12931 : bool CntUInt16Item::QueryValue(com::sun::star::uno::Any& rVal, sal_uInt8) const
161 : {
162 12931 : sal_Int32 nValue = m_nValue;
163 12931 : rVal <<= nValue;
164 12931 : return true;
165 : }
166 :
167 : // virtual
168 71634 : bool CntUInt16Item::PutValue(const com::sun::star::uno::Any& rVal, sal_uInt8)
169 : {
170 71634 : sal_Int32 nValue = 0;
171 71634 : if (rVal >>= nValue)
172 : {
173 : DBG_ASSERT( nValue <= USHRT_MAX, "Overflow in UInt16 value!");
174 71634 : m_nValue = (sal_uInt16)nValue;
175 71634 : return true;
176 : }
177 :
178 : OSL_FAIL( "CntUInt16Item::PutValue - Wrong type!" );
179 0 : return false;
180 : }
181 :
182 : // virtual
183 0 : SfxPoolItem * CntUInt16Item::Create(SvStream & rStream, sal_uInt16) const
184 : {
185 0 : return new CntUInt16Item(Which(), rStream);
186 : }
187 :
188 : // virtual
189 0 : SvStream & CntUInt16Item::Store(SvStream &rStream, sal_uInt16) const
190 : {
191 0 : rStream.WriteUInt16( m_nValue );
192 0 : return rStream;
193 : }
194 :
195 : // virtual
196 0 : SfxPoolItem * CntUInt16Item::Clone(SfxItemPool *) const
197 : {
198 0 : return new CntUInt16Item(*this);
199 : }
200 :
201 : // virtual
202 0 : sal_uInt16 CntUInt16Item::GetMin() const
203 : {
204 0 : return 0;
205 : }
206 :
207 : // virtual
208 0 : sal_uInt16 CntUInt16Item::GetMax() const
209 : {
210 0 : return 65535;
211 : }
212 :
213 : // virtual
214 0 : SfxFieldUnit CntUInt16Item::GetUnit() const
215 : {
216 0 : return SFX_FUNIT_NONE;
217 : }
218 :
219 1072394 : TYPEINIT1_AUTOFACTORY(CntInt32Item, SfxPoolItem);
220 :
221 512 : CntInt32Item::CntInt32Item(sal_uInt16 which, SvStream & rStream)
222 : : SfxPoolItem(which)
223 512 : , m_nValue(0)
224 : {
225 512 : rStream.ReadInt32( m_nValue );
226 512 : }
227 :
228 : // virtual
229 1023588 : bool CntInt32Item::operator ==(const SfxPoolItem & rItem) const
230 : {
231 : DBG_ASSERT(rItem.ISA(CntInt32Item),
232 : "CntInt32Item::operator ==(): Bad type");
233 1023588 : return m_nValue == (static_cast< const CntInt32Item * >(&rItem))->
234 1023588 : m_nValue;
235 : }
236 :
237 : // virtual
238 0 : int CntInt32Item::Compare(const SfxPoolItem & rWith) const
239 : {
240 : DBG_ASSERT(rWith.ISA(CntInt32Item), "CntInt32Item::Compare(): Bad type");
241 : return (static_cast< const CntInt32Item * >(&rWith))->m_nValue
242 0 : < m_nValue ?
243 : -1 :
244 : (static_cast< const CntInt32Item * >(&rWith))->m_nValue
245 : == m_nValue ?
246 0 : 0 : 1;
247 : }
248 :
249 : // virtual
250 0 : bool CntInt32Item::GetPresentation(SfxItemPresentation,
251 : SfxMapUnit, SfxMapUnit,
252 : OUString & rText,
253 : const IntlWrapper *) const
254 : {
255 0 : rText = OUString::number( m_nValue );
256 0 : return true;
257 : }
258 :
259 : // virtual
260 14490 : bool CntInt32Item::QueryValue(com::sun::star::uno::Any& rVal, sal_uInt8) const
261 : {
262 14490 : sal_Int32 nValue = m_nValue;
263 14490 : rVal <<= nValue;
264 14490 : return true;
265 : }
266 :
267 : // virtual
268 57107 : bool CntInt32Item::PutValue(const com::sun::star::uno::Any& rVal, sal_uInt8)
269 : {
270 57107 : sal_Int32 nValue = 0;
271 57107 : if (rVal >>= nValue)
272 : {
273 57107 : m_nValue = nValue;
274 57107 : return true;
275 : }
276 :
277 : OSL_FAIL( "CntInt32Item::PutValue - Wrong type!" );
278 0 : return false;
279 : }
280 :
281 : // virtual
282 0 : SfxPoolItem * CntInt32Item::Create(SvStream & rStream, sal_uInt16) const
283 : {
284 0 : return new CntInt32Item(Which(), rStream);
285 : }
286 :
287 : // virtual
288 1312 : SvStream & CntInt32Item::Store(SvStream &rStream, sal_uInt16) const
289 : {
290 1312 : rStream.WriteInt32( m_nValue );
291 1312 : return rStream;
292 : }
293 :
294 : // virtual
295 0 : SfxPoolItem * CntInt32Item::Clone(SfxItemPool *) const
296 : {
297 0 : return new CntInt32Item(*this);
298 : }
299 :
300 : // virtual
301 0 : sal_Int32 CntInt32Item::GetMin() const
302 : {
303 0 : return sal_Int32(0x80000000);
304 : }
305 :
306 : // virtual
307 0 : sal_Int32 CntInt32Item::GetMax() const
308 : {
309 0 : return 0x7FFFFFFF;
310 : }
311 :
312 : // virtual
313 0 : SfxFieldUnit CntInt32Item::GetUnit() const
314 : {
315 0 : return SFX_FUNIT_NONE;
316 : }
317 :
318 148654 : TYPEINIT1_AUTOFACTORY(CntUInt32Item, SfxPoolItem);
319 :
320 0 : CntUInt32Item::CntUInt32Item(sal_uInt16 which, SvStream & rStream) :
321 0 : SfxPoolItem(which)
322 : {
323 0 : sal_uInt32 nTheValue = 0;
324 0 : rStream.ReadUInt32( nTheValue );
325 0 : m_nValue = nTheValue;
326 0 : }
327 :
328 : // virtual
329 41981 : bool CntUInt32Item::operator ==(const SfxPoolItem & rItem) const
330 : {
331 : DBG_ASSERT(rItem.ISA(CntUInt32Item),
332 : "CntUInt32Item::operator ==(): Bad type");
333 41981 : return m_nValue == (static_cast< const CntUInt32Item * >(&rItem))->
334 41981 : m_nValue;
335 : }
336 :
337 : // virtual
338 0 : int CntUInt32Item::Compare(const SfxPoolItem & rWith) const
339 : {
340 : DBG_ASSERT(rWith.ISA(CntUInt32Item),
341 : "CntUInt32Item::operator ==(): Bad type");
342 : return (static_cast< const CntUInt32Item * >(&rWith))->m_nValue
343 0 : < m_nValue ?
344 : -1 :
345 : (static_cast< const CntUInt32Item * >(&rWith))->m_nValue
346 : == m_nValue ?
347 0 : 0 : 1;
348 : }
349 :
350 : // virtual
351 0 : bool CntUInt32Item::GetPresentation(SfxItemPresentation,
352 : SfxMapUnit, SfxMapUnit,
353 : OUString & rText,
354 : const IntlWrapper *)
355 : const
356 : {
357 0 : rText = OUString::number(m_nValue);
358 0 : return true;
359 : }
360 :
361 : // virtual
362 21 : bool CntUInt32Item::QueryValue(com::sun::star::uno::Any& rVal, sal_uInt8) const
363 : {
364 21 : sal_Int32 nValue = m_nValue;
365 : DBG_ASSERT( nValue>=0, "Overflow in UInt32 value!");
366 21 : rVal <<= nValue;
367 21 : return true;
368 : }
369 :
370 : // virtual
371 3486 : bool CntUInt32Item::PutValue(const com::sun::star::uno::Any& rVal, sal_uInt8)
372 : {
373 3486 : sal_Int32 nValue = 0;
374 3486 : if (rVal >>= nValue)
375 : {
376 : DBG_ASSERT( nValue>=0, "Overflow in UInt32 value!");
377 3486 : m_nValue = nValue;
378 3486 : return true;
379 : }
380 :
381 : OSL_FAIL( "CntUInt32Item::PutValue - Wrong type!" );
382 0 : return false;
383 : }
384 :
385 : // virtual
386 0 : SfxPoolItem * CntUInt32Item::Create(SvStream & rStream, sal_uInt16) const
387 : {
388 0 : return new CntUInt32Item(Which(), rStream);
389 : }
390 :
391 : // virtual
392 0 : SvStream & CntUInt32Item::Store(SvStream &rStream, sal_uInt16) const
393 : {
394 0 : rStream.WriteUInt32( m_nValue );
395 0 : return rStream;
396 : }
397 :
398 : // virtual
399 0 : SfxPoolItem * CntUInt32Item::Clone(SfxItemPool *) const
400 : {
401 0 : return new CntUInt32Item(*this);
402 : }
403 :
404 : // virtual
405 0 : sal_uInt32 CntUInt32Item::GetMin() const
406 : {
407 0 : return 0;
408 : }
409 :
410 : // virtual
411 0 : sal_uInt32 CntUInt32Item::GetMax() const
412 : {
413 0 : return 0xFFFFFFFF;
414 : }
415 :
416 : // virtual
417 0 : SfxFieldUnit CntUInt32Item::GetUnit() const
418 : {
419 0 : return SFX_FUNIT_NONE;
420 : }
421 :
422 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
