rsc/source/res/rscrange.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
  21 #include <stdlib.h>
  22 #include <stdio.h>
  23 #include <string.h>
  24
  25 #include <rscrange.hxx>
  26
  27 RscRange::RscRange( Atom nId, sal_uInt32 nTypeId )
  28     : RscTop( nId, nTypeId )
  29 {
  30     nMin = nMax = 0;
  31     nSize = ALIGNED_SIZE( sizeof( RscRangeInst ) );
  32 }
  33
  34 RSCCLASS_TYPE RscRange::GetClassType() const
  35 {
  36     return RSCCLASS_NUMBER;
  37 }
  38
  39 ERRTYPE RscRange::SetRange( sal_Int32 nMinimum, sal_Int32 nMaximum )
  40 {
  41     if( nMinimum > nMaximum )
  42     {
  43         nMin = nMaximum;
  44         nMax = nMinimum;
  45     }
  46     else
  47     {
  48         nMax = nMaximum;
  49         nMin = nMinimum;
  50     }
  51
  52     return ERR_OK;
  53 }
  54
  55 bool RscRange::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
  56 {
  57     if( pDef )
  58     {
  59         if( reinterpret_cast<RscRangeInst*>(rInst.pData)->nValue ==
  60             reinterpret_cast<RscRangeInst*>(pDef)->nValue )
  61         {
  62             return true;
  63         }
  64     }
  65
  66     return false;
  67 }
  68
  69 ERRTYPE RscRange::SetNumber( const RSCINST & rInst, sal_Int32 nValue )
  70 {
  71     if( nMax < nValue || nMin > nValue )
  72         return ERR_RSCRANGE_OUTDEFSET;
  73
  74     reinterpret_cast<RscRangeInst *>(rInst.pData)->nValue = (sal_uInt16)( nValue - nMin );
  75     reinterpret_cast<RscRangeInst *>(rInst.pData)->bDflt = false;
  76     return ERR_OK;
  77 }
  78
  79 ERRTYPE RscRange::GetNumber( const RSCINST & rInst, sal_Int32 * pN )
  80 {
  81     *pN = reinterpret_cast<RscRangeInst *>(rInst.pData)->nValue + nMin;
  82     return ERR_OK;
  83 }
  84
  85 RSCINST RscRange::Create( RSCINST * pInst, const RSCINST & rDflt,
  86                           bool bOwnClass )
  87 {
  88     RSCINST aInst;
  89
  90     if( !pInst )
  91     {
  92         aInst.pClass = this;
  93         aInst.pData = static_cast<CLASS_DATA>(rtl_allocateMemory( sizeof( RscRangeInst ) ));
  94     }
  95     else
  96         aInst = *pInst;
  97
  98     if( !bOwnClass && rDflt.IsInst() )
  99         bOwnClass = rDflt.pClass->InHierarchy( this );
 100
 101     if( bOwnClass )
 102         memmove( aInst.pData, rDflt.pData, sizeof( RscRangeInst ) );
 103     else
 104     {
 105         if( 0L >= nMin && 0L <= nMax )
 106             reinterpret_cast<RscRangeInst *>(aInst.pData)->nValue = (sal_uInt16)(0L - nMin);
 107         else
 108             reinterpret_cast<RscRangeInst *>(aInst.pData)->nValue = 0;
 109
 110         reinterpret_cast<RscRangeInst *>(aInst.pData)->bDflt = true;
 111     }
 112
 113     return aInst;
 114 }
 115
 116 void RscRange::WriteSrc( const RSCINST & rInst, FILE * fOutput,
 117                          RscTypCont *, sal_uInt32, const char * )
 118 {
 119     fprintf( fOutput, "%ld", long( reinterpret_cast<RscRangeInst *>(rInst.pData)->nValue + nMin ) );
 120 }
 121
 122 ERRTYPE RscRange::WriteRc( const RSCINST & rInst, RscWriteRc & aMem,
 123                            RscTypCont *, sal_uInt32, bool )
 124 {
 125     if( nMin >= 0 )
 126     {
 127         sal_uInt16 n;
 128         n = (sal_uInt16)(reinterpret_cast<RscRangeInst *>(rInst.pData)->nValue + nMin);
 129         aMem.Put( n );
 130     }
 131     else
 132     {
 133         sal_Int16 n;
 134         n = (sal_Int16)(reinterpret_cast<RscRangeInst *>(rInst.pData)->nValue + nMin);
 135         aMem.Put( n );
 136     }
 137
 138     return ERR_OK;
 139 }
 140
 141 RscLongRange::RscLongRange( Atom nId, sal_uInt32 nTypeId )
 142     : RscTop( nId, nTypeId )
 143 {
 144     nMin = nMax = 0;
 145     nSize = ALIGNED_SIZE( sizeof( RscLongRangeInst ) );
 146 }
 147
 148 RSCCLASS_TYPE RscLongRange::GetClassType() const
 149 {
 150     return RSCCLASS_NUMBER;
 151 }
 152
 153 ERRTYPE RscLongRange::SetRange( sal_Int32 nMinimum, sal_Int32 nMaximum )
 154 {
 155     if( nMinimum > nMaximum )
 156     {
 157         nMin = nMaximum;
 158         nMax = nMinimum;
 159     }
 160     else
 161     {
 162         nMax = nMaximum;
 163         nMin = nMinimum;
 164     }
 165
 166     return ERR_OK;
 167 }
 168
 169 bool RscLongRange::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
 170 {
 171     if( pDef )
 172         return 0 == memcmp( &reinterpret_cast<RscLongRangeInst*>(rInst.pData)->nValue,
 173                             &reinterpret_cast<RscLongRangeInst*>(pDef)->nValue,
 174                             sizeof( sal_Int32 ) );
 175
 176     return false;
 177 }
 178
 179 ERRTYPE RscLongRange::SetNumber( const RSCINST & rInst, sal_Int32 nValue )
 180 {
 181     if( nMax < nValue || nMin > nValue )
 182         return ERR_RSCRANGE_OUTDEFSET;
 183
 184     void * pData = &reinterpret_cast<RscLongRangeInst*>(rInst.pData)->nValue;
 185     memcpy( pData, &nValue, sizeof( sal_Int32 ) );
 186     reinterpret_cast<RscLongRangeInst *>(rInst.pData)->bDflt = false;
 187     return ERR_OK;
 188 }
 189
 190 ERRTYPE RscLongRange::GetNumber( const RSCINST & rInst, sal_Int32 * pN )
 191 {
 192     memmove( pN, &reinterpret_cast<RscLongRangeInst*>(rInst.pData)->nValue,
 193              sizeof( sal_Int32 ) );
 194     return ERR_OK;
 195 }
 196
 197 RSCINST RscLongRange::Create( RSCINST * pInst, const RSCINST & rDflt,
 198                               bool bOwnClass )
 199 {
 200     RSCINST aInst;
 201
 202     if( !pInst )
 203     {
 204         aInst.pClass = this;
 205         aInst.pData = static_cast<CLASS_DATA>(rtl_allocateMemory( sizeof( RscLongRangeInst ) ));
 206     }
 207     else
 208         aInst = *pInst;
 209
 210     if( !bOwnClass && rDflt.IsInst() )
 211         bOwnClass = rDflt.pClass->InHierarchy( this );
 212
 213     if( bOwnClass )
 214         memmove( aInst.pData, rDflt.pData, sizeof( RscLongRangeInst ) );
 215     else
 216     {
 217         sal_Int32   lDflt;
 218         if( 0L >= nMin && 0L <= nMax )
 219             lDflt = 0;
 220         else
 221             lDflt = nMin;
 222
 223         void * pData = &reinterpret_cast<RscLongRangeInst*>(aInst.pData)->nValue;
 224         memcpy( pData, &lDflt, sizeof( sal_Int32 ) );
 225         reinterpret_cast<RscLongRangeInst *>(aInst.pData)->bDflt = true;
 226     }
 227
 228     return aInst;
 229 }
 230
 231 void RscLongRange::WriteSrc( const RSCINST & rInst, FILE * fOutput,
 232                              RscTypCont *, sal_uInt32, const char * )
 233 {
 234     sal_Int32 lVal;
 235     GetNumber( rInst, &lVal );
 236     fprintf( fOutput, "%d", static_cast<int>(lVal) );
 237 }
 238
 239 ERRTYPE RscLongRange::WriteRc( const RSCINST & rInst, RscWriteRc & aMem,
 240                                RscTypCont *, sal_uInt32, bool )
 241 {
 242     sal_Int32 lVal;
 243
 244     GetNumber( rInst, &lVal );
 245     aMem.Put( (sal_Int32)lVal );
 246
 247     return ERR_OK;
 248 }
 249
 250 RscLongEnumRange::RscLongEnumRange( Atom nId, sal_uInt32 nTypeId )
 251     : RscLongRange( nId, nTypeId )
 252 {
 253 }
 254
 255 ERRTYPE RscLongEnumRange::SetConst( const RSCINST & rInst, Atom /*nConst*/,
 256                                     sal_Int32 nValue )
 257 {
 258     return SetNumber( rInst, nValue );
 259 }
 260
 261 RscIdRange::RscIdRange( Atom nId, sal_uInt32 nTypeId )
 262     : RscTop( nId, nTypeId )
 263 {
 264     nSize = ALIGNED_SIZE( sizeof( RscId ) );
 265     nMin = nMax = 0;
 266 }
 267
 268 RSCCLASS_TYPE RscIdRange::GetClassType() const
 269 {
 270     return RSCCLASS_NUMBER;
 271 }
 272
 273 RSCINST RscIdRange::Create( RSCINST * pInst, const RSCINST & rDflt, bool bOwnClass )
 274 {
 275     RSCINST aInst;
 276     RscId * pClassData;
 277
 278     if( !pInst )
 279     {
 280         aInst.pClass = this;
 281         aInst.pData = static_cast<CLASS_DATA>(rtl_allocateMemory( sizeof( RscId ) ));
 282     }
 283     else
 284         aInst = *pInst;
 285
 286
 287     if( !bOwnClass && rDflt.IsInst() )
 288         bOwnClass = rDflt.pClass->InHierarchy( this );
 289
 290     pClassData = reinterpret_cast<RscId *>(aInst.pData);
 291
 292     pClassData->Create();
 293
 294     if( bOwnClass )
 295         *pClassData = *reinterpret_cast<RscId *>(rDflt.pData);
 296     else
 297     {
 298         *pClassData = RscId();
 299         if( 0 >= nMin && 0 <= nMax )
 300             *pClassData = RscId( (sal_Int32)0 );
 301         else
 302             *pClassData = RscId( nMin );
 303
 304         //cUnused wird fuer Defaultkennung verwendet
 305         reinterpret_cast<RscId *>(aInst.pData)->aExp.cUnused = true;
 306     }
 307
 308     return aInst;
 309 }
 310
 311 void RscIdRange :: Destroy( const RSCINST & rInst )
 312 {
 313     reinterpret_cast<RscId *>(rInst.pData)->Destroy();
 314 }
 315
 316 bool RscIdRange::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
 317 {
 318     if( pDef )
 319     {
 320         if( reinterpret_cast<RscId*>(rInst.pData)->aExp.IsNumber() &&
 321             reinterpret_cast<RscId*>(pDef)->aExp.IsNumber() )
 322         {
 323             if( reinterpret_cast<RscId*>(rInst.pData)->GetNumber() ==
 324                 reinterpret_cast<RscId*>(pDef)->GetNumber() )
 325             {
 326                 return true;
 327             }
 328         }
 329     }
 330
 331     return false;
 332 }
 333
 334 ERRTYPE RscIdRange::SetNumber( const RSCINST & rInst, sal_Int32 nValue )
 335 {
 336     if( nMax < nValue || nMin > nValue )
 337         return ERR_RSCRANGE_OUTDEFSET;
 338
 339     *reinterpret_cast<RscId *>(rInst.pData) = RscId( nValue );
 340     reinterpret_cast<RscId *>(rInst.pData)->aExp.cUnused = false;
 341     return ERR_OK;
 342 }
 343
 344 ERRTYPE RscIdRange::GetNumber( const RSCINST & rInst, sal_Int32 * plValue )
 345 {
 346     *plValue = reinterpret_cast<RscId *>(rInst.pData)->GetNumber();
 347     return ERR_OK;
 348 }
 349
 350 ERRTYPE RscIdRange::SetRef( const RSCINST & rInst, const RscId & rRscId )
 351 {
 352     ERRTYPE aError;
 353     if( rRscId.IsId() )
 354     {
 355         aError = SetNumber( rInst, rRscId );
 356         if( aError.IsOk() )
 357         {
 358             *reinterpret_cast<RscId *>(rInst.pData) = rRscId;
 359             reinterpret_cast<RscId *>(rInst.pData)->aExp.cUnused = false;
 360         }
 361     }
 362     else
 363         aError = ERR_RSCRANGE_OUTDEFSET;
 364
 365     return aError;
 366 }
 367
 368 ERRTYPE RscIdRange::GetRef( const RSCINST & rInst, RscId * pRscId )
 369 {
 370     *pRscId = *reinterpret_cast<RscId *>(rInst.pData);
 371
 372     return ERR_OK;
 373 }
 374
 375 void RscIdRange::WriteSrc( const RSCINST & rInst, FILE * fOutput,
 376                            RscTypCont *, sal_uInt32, const char * )
 377 {
 378     fprintf( fOutput, "%s", reinterpret_cast<RscId *>(rInst.pData)->GetName().getStr() );
 379 }
 380
 381 ERRTYPE RscIdRange::WriteRc( const RSCINST & rInst, RscWriteRc & aMem,
 382                              RscTypCont *, sal_uInt32, bool )
 383 {
 384     sal_Int32 lVal = reinterpret_cast<RscId*>(rInst.pData)->GetNumber();
 385
 386     aMem.Put( (sal_Int32)lVal );
 387
 388     return ERR_OK;
 389 }
 390
 391 bool RscIdRange::IsConsistent( const RSCINST & rInst )
 392 {
 393     long nValue = reinterpret_cast<RscId *>(rInst.pData)->GetNumber();
 394
 395     return (nMax >= nValue) && (nMin <= nValue);
 396
 397 }
 398
 399 RscBool::RscBool( Atom nId, sal_uInt32 nTypeId )
 400     : RscRange( nId, nTypeId )
 401 {
 402     RscRange::SetRange( 0, 1 );
 403 }
 404
 405 RSCCLASS_TYPE  RscBool::GetClassType() const
 406 {
 407     return RSCCLASS_BOOL;
 408 }
 409
 410 void RscBool::WriteSrc( const RSCINST & rInst, FILE * fOutput,
 411                         RscTypCont *, sal_uInt32, const char * )
 412 {
 413     sal_Int32 l;
 414
 415     GetNumber( rInst, &l );
 416     if( l )
 417         fprintf( fOutput, "TRUE" );
 418     else
 419         fprintf( fOutput, "FALSE" );
 420 }
 421
 422 RscBreakRange :: RscBreakRange( Atom nId, sal_uInt32 nTypeId )
 423     : RscRange( nId, nTypeId )
 424 {
 425     nOutRange = 0xFFFFFFFF;
 426 }
 427
 428 ERRTYPE RscBreakRange::SetNumber( const RSCINST & rInst, sal_Int32 nValue )
 429 {
 430     if( nValue == nOutRange )
 431         return ERR_RSCRANGE_OUTDEFSET;
 432     else
 433         return RscRange::SetNumber( rInst, nValue );
 434 }
 435
 436 RSCINST RscBreakRange::Create( RSCINST * pInst, const RSCINST & rDflt,
 437                                bool bOwnClass )
 438 {
 439     RSCINST aInst;
 440     sal_Int32   l;
 441
 442     aInst = RscRange::Create( pInst, rDflt, bOwnClass );
 443
 444     GetNumber( aInst, &l );
 445     if( l == nOutRange )
 446         reinterpret_cast<RscRangeInst *>(aInst.pData)->nValue++;
 447
 448     return aInst;
 449 }
 450
 451 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */