svl/source/items/cintitem.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 <com/sun/star/uno/Any.hxx>
  21 #include <svl/cintitem.hxx>
  22 #include <sal/log.hxx>
  23
  24
  25 // virtual
  26 bool CntByteItem::operator ==(const SfxPoolItem & rItem) const
  27 {
  28     assert(dynamic_cast<const CntByteItem*>(&rItem) != nullptr);
  29     return m_nValue == static_cast< const CntByteItem * >(&rItem)->m_nValue;
  30 }
  31
  32 // virtual
  33 bool CntByteItem::GetPresentation(SfxItemPresentation, MapUnit, MapUnit,
  34                                   OUString & rText,
  35                                   const IntlWrapper&) const
  36 {
  37     rText = OUString::number( m_nValue );
  38     return true;
  39 }
  40
  41 // virtual
  42 bool CntByteItem::QueryValue(css::uno::Any& rVal, sal_uInt8) const
  43 {
  44     sal_Int8 nValue = m_nValue;
  45     rVal <<= nValue;
  46     return true;
  47 }
  48
  49 // virtual
  50 bool CntByteItem::PutValue(const css::uno::Any& rVal, sal_uInt8)
  51 {
  52     sal_Int8 nValue = sal_Int8();
  53     if (rVal >>= nValue)
  54     {
  55         m_nValue = nValue;
  56         return true;
  57     }
  58
  59     SAL_WARN("svl.items", "CntByteItem::PutValue - Wrong type!");
  60     return false;
  61 }
  62
  63 // virtual
  64 CntByteItem* CntByteItem::Clone(SfxItemPool *) const
  65 {
  66     return new CntByteItem(*this);
  67 }
  68
  69 // virtual
  70 bool CntUInt16Item::operator ==(const SfxPoolItem & rItem) const
  71 {
  72     assert(dynamic_cast<const CntUInt16Item*>(&rItem) != nullptr);
  73     return m_nValue == static_cast<const CntUInt16Item *>(&rItem)->m_nValue;
  74 }
  75
  76 // virtual
  77 bool CntUInt16Item::GetPresentation(SfxItemPresentation,
  78                                     MapUnit, MapUnit,
  79                                     OUString & rText,
  80                                     const IntlWrapper&)
  81     const
  82 {
  83     rText = OUString::number( m_nValue );
  84     return true;
  85 }
  86
  87 // virtual
  88 bool CntUInt16Item::QueryValue(css::uno::Any& rVal, sal_uInt8) const
  89 {
  90     sal_Int32 nValue = m_nValue;
  91     rVal <<= nValue;
  92     return true;
  93 }
  94
  95 // virtual
  96 bool CntUInt16Item::PutValue(const css::uno::Any& rVal, sal_uInt8)
  97 {
  98     sal_Int32 nValue = 0;
  99     if (rVal >>= nValue)
 100     {
 101         SAL_WARN_IF(nValue < 0 || nValue > SAL_MAX_UINT16, "svl.items", "Overflow in UInt16 value!");
 102         m_nValue = static_cast<sal_uInt16>(nValue);
 103         return true;
 104     }
 105
 106     SAL_WARN("svl.items", "CntUInt16Item::PutValue - Wrong type!");
 107     return false;
 108 }
 109
 110 // virtual
 111 CntUInt16Item* CntUInt16Item::Clone(SfxItemPool *) const
 112 {
 113     return new CntUInt16Item(*this);
 114 }
 115
 116 // virtual
 117 bool CntInt32Item::operator ==(const SfxPoolItem & rItem) const
 118 {
 119     assert(dynamic_cast<const CntInt32Item*>(&rItem) != nullptr);
 120     return m_nValue == static_cast<const CntInt32Item *>(&rItem)->m_nValue;
 121 }
 122
 123 // virtual
 124 bool CntInt32Item::GetPresentation(SfxItemPresentation,
 125                                    MapUnit, MapUnit,
 126                                    OUString & rText,
 127                                    const IntlWrapper&) const
 128 {
 129     rText = OUString::number( m_nValue );
 130     return true;
 131 }
 132
 133 // virtual
 134 bool CntInt32Item::QueryValue(css::uno::Any& rVal, sal_uInt8) const
 135 {
 136     sal_Int32 nValue = m_nValue;
 137     rVal <<= nValue;
 138     return true;
 139 }
 140
 141 // virtual
 142 bool CntInt32Item::PutValue(const css::uno::Any& rVal, sal_uInt8)
 143 {
 144     sal_Int32 nValue = 0;
 145     if (rVal >>= nValue)
 146     {
 147         m_nValue = nValue;
 148         return true;
 149     }
 150
 151     SAL_WARN("svl.items", "CntInt32Item::PutValue - Wrong type!");
 152     return false;
 153 }
 154
 155 // virtual
 156 CntInt32Item* CntInt32Item::Clone(SfxItemPool *) const
 157 {
 158     return new CntInt32Item(*this);
 159 }
 160
 161 // virtual
 162 bool CntUInt32Item::operator ==(const SfxPoolItem & rItem) const
 163 {
 164     assert(dynamic_cast<const CntUInt32Item*>(&rItem) != nullptr);
 165     return m_nValue == static_cast<const CntUInt32Item *>(&rItem)->m_nValue;
 166 }
 167
 168 // virtual
 169 bool CntUInt32Item::GetPresentation(SfxItemPresentation,
 170                                     MapUnit, MapUnit,
 171                                     OUString & rText,
 172                                     const IntlWrapper&)
 173     const
 174 {
 175     rText = OUString::number(m_nValue);
 176     return true;
 177 }
 178
 179 // virtual
 180 bool CntUInt32Item::QueryValue(css::uno::Any& rVal, sal_uInt8) const
 181 {
 182     sal_Int32 nValue = m_nValue;
 183     SAL_WARN_IF(nValue < 0, "svl.items", "Overflow in UInt32 value!");
 184     rVal <<= nValue;
 185     return true;
 186 }
 187
 188 // virtual
 189 bool CntUInt32Item::PutValue(const css::uno::Any& rVal, sal_uInt8)
 190 {
 191     sal_Int32 nValue = 0;
 192     if (rVal >>= nValue)
 193     {
 194         SAL_WARN_IF(nValue < 0, "svl.items", "Overflow in UInt32 value!");
 195         m_nValue = nValue;
 196         return true;
 197     }
 198
 199     SAL_WARN("svl.items", "CntUInt32Item::PutValue - Wrong type!");
 200     return false;
 201 }
 202
 203 // virtual
 204 CntUInt32Item* CntUInt32Item::Clone(SfxItemPool *) const
 205 {
 206     return new CntUInt32Item(*this);
 207 }
 208
 209 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */