rsc/source/res/rscflag.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: rscflag.cxx,v $
  10  * $Revision: 1.8 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_rsc.hxx"
  33 /****************** I N C L U D E S **************************************/
  34
  35 // C and C++ Includes.
  36 #include <stdlib.h>
  37 #include <stdio.h>
  38 #include <string.h>
  39
  40 #include <rscflag.hxx>
  41
  42 /****************** C O D E **********************************************/
  43 /****************** R s c F l a g ****************************************/
  44 /*************************************************************************
  45 |*
  46 |*    RscFlag::RscFlag()
  47 |*
  48 |*    Beschreibung
  49 |*    Ersterstellung    MM 03.04.91
  50 |*    Letzte Aenderung  MM 03.04.91
  51 |*
  52 *************************************************************************/
  53 RscFlag::RscFlag( Atom nId, sal_uInt32 nTypeId )
  54             : RscConst( nId, nTypeId )
  55 {}
  56
  57 /*************************************************************************
  58 |*
  59 |*    RscFlag::Size()
  60 |*
  61 |*    Beschreibung      Die Groe�e der Instanzdaten richtet sich nach
  62 |*                      der Anzahl der Flags
  63 |*    Ersterstellung    MM 03.04.91
  64 |*    Letzte Aenderung  MM 03.04.91
  65 |*
  66 *************************************************************************/
  67 sal_uInt32 RscFlag::Size()
  68 {
  69     return( ALIGNED_SIZE( sizeof( RscFlagInst ) *
  70             ( 1 + (nEntries -1) / (sizeof( sal_uInt32 ) * 8) ) ) );
  71 }
  72
  73 /*************************************************************************
  74 |*
  75 |*    RscFlag::SetNotConst()
  76 |*
  77 |*    Beschreibung
  78 |*    Ersterstellung    MM 03.04.91
  79 |*    Letzte Aenderung  MM 03.04.91
  80 |*
  81 *************************************************************************/
  82 ERRTYPE RscFlag::SetNotConst( const RSCINST & rInst, Atom nConst )
  83 {
  84     sal_uInt32 i = 0, nFlag = 0;
  85
  86     if( nEntries != (i = GetConstPos( nConst )) ){
  87         nFlag = 1 << (i % (sizeof( sal_uInt32 ) * 8) );
  88         i = i / (sizeof( sal_uInt32 ) * 8);
  89         ((RscFlagInst *)rInst.pData)[ i ].nFlags     &= ~nFlag;
  90         ((RscFlagInst *)rInst.pData)[ i ].nDfltFlags &= ~nFlag;
  91         return( ERR_OK );
  92     };
  93
  94     return( ERR_RSCFLAG );
  95 }
  96
  97 /*************************************************************************
  98 |*
  99 |*    RscFlag::SetConst()
 100 |*
 101 |*    Beschreibung
 102 |*    Ersterstellung    MM 03.04.91
 103 |*    Letzte Aenderung  MM 03.04.91
 104 |*
 105 *************************************************************************/
 106 ERRTYPE RscFlag::SetConst( const RSCINST & rInst, Atom nConst, INT32 /*nVal*/ )
 107 {
 108     sal_uInt32 i = 0, nFlag = 0;
 109
 110     if( nEntries != (i = GetConstPos( nConst )) ){
 111         nFlag = 1 << (i % (sizeof( sal_uInt32 ) * 8) );
 112         i = i / (sizeof( sal_uInt32 ) * 8);
 113         ((RscFlagInst *)rInst.pData)[ i ].nFlags     |= nFlag;
 114         ((RscFlagInst *)rInst.pData)[ i ].nDfltFlags &= ~nFlag;
 115         return( ERR_OK );
 116     };
 117
 118     return( ERR_RSCFLAG );
 119 }
 120
 121 /*************************************************************************
 122 |*
 123 |*    RscFlag::CreateBasic()
 124 |*
 125 |*    Beschreibung
 126 |*    Ersterstellung    MM 16.01.92
 127 |*    Letzte Aenderung  MM 16.01.92
 128 |*
 129 *************************************************************************/
 130 RSCINST RscFlag::CreateBasic( RSCINST * pInst )
 131 {
 132     RSCINST aInst;
 133
 134     if( !pInst ){
 135         aInst.pClass = this;
 136         aInst.pData = (CLASS_DATA) rtl_allocateMemory( Size() );
 137     }
 138     else
 139         aInst = *pInst;
 140
 141     return( aInst );
 142 }
 143
 144 /*************************************************************************
 145 |*
 146 |*    RscFlag::Create()
 147 |*
 148 |*    Beschreibung
 149 |*    Ersterstellung    MM 03.04.91
 150 |*    Letzte Aenderung  MM 16.01.92
 151 |*
 152 *************************************************************************/
 153 RSCINST RscFlag::Create( RSCINST * pInst, const RSCINST & rDflt, BOOL bOwnClass )
 154 {
 155     RSCINST aInst = CreateBasic( pInst );
 156     sal_uInt32  i = 0;
 157
 158     if( !bOwnClass && rDflt.IsInst() )
 159         bOwnClass = rDflt.pClass->InHierarchy( this );
 160
 161     if( bOwnClass )
 162         memmove( aInst.pData, rDflt.pData, Size() );
 163     else
 164     {
 165         for( i = 0; i < Size() / sizeof( RscFlagInst ); i++ )
 166         {
 167             ((RscFlagInst *)aInst.pData)[ i ].nFlags = 0;
 168             ((RscFlagInst *)aInst.pData)[ i ].nDfltFlags = 0xFFFFFFFF;
 169         }
 170     };
 171
 172     return( aInst );
 173 }
 174
 175 /*************************************************************************
 176 |*
 177 |*    RscFlag::CreateClient()
 178 |*
 179 |*    Beschreibung
 180 |*    Ersterstellung    MM 16.01.92
 181 |*    Letzte Aenderung  MM 16.01.92
 182 |*
 183 *************************************************************************/
 184 RSCINST RscFlag::CreateClient( RSCINST * pInst, const RSCINST & rDfltI,
 185                                BOOL bOwnClass, Atom nConstId )
 186 {
 187     RSCINST aInst = CreateBasic( pInst );
 188     sal_uInt32 i = 0, nFlag = 0;
 189
 190     if( !bOwnClass && rDfltI.IsInst() )
 191         bOwnClass = rDfltI.pClass->InHierarchy( this );
 192
 193     if( nEntries != (i = GetConstPos( nConstId )) ){
 194         nFlag = 1 << (i % (sizeof( sal_uInt32 ) * 8) );
 195         i = i / (sizeof( sal_uInt32 ) * 8);
 196         if( bOwnClass ){
 197             ((RscFlagInst *)aInst.pData)[ i ].nFlags &=
 198             ~nFlag | ((RscFlagInst *)rDfltI.pData)[ i ].nFlags;
 199             ((RscFlagInst *)aInst.pData)[ i ].nDfltFlags &=
 200             ~nFlag | ((RscFlagInst *)rDfltI.pData)[ i ].nDfltFlags;
 201         }
 202         else{
 203             ((RscFlagInst *)aInst.pData)[ i ].nFlags &= ~nFlag;
 204             ((RscFlagInst *)aInst.pData)[ i ].nDfltFlags |= nFlag;
 205         }
 206     }
 207
 208     return( aInst );
 209 }
 210
 211 /*************************************************************************
 212 |*
 213 |*    RscFlag::SetToDefault()
 214 |*
 215 |*    Beschreibung
 216 |*    Ersterstellung    MM 03.04.91
 217 |*    Letzte Aenderung  MM 03.04.91
 218 |*
 219 *************************************************************************/
 220 void RscFlag::SetToDefault( const RSCINST & rInst )
 221 {
 222     sal_uInt32 i = 0;
 223
 224     for( i = 0; i < Size() / sizeof( RscFlagInst ); i++ )
 225         ((RscFlagInst *)rInst.pData)[ i ].nDfltFlags = 0xFFFFFFFF;
 226 }
 227
 228 /*************************************************************************
 229 |*
 230 |*    RscFlag::IsDlft()
 231 |*
 232 |*    Beschreibung
 233 |*    Ersterstellung    MM 03.04.91
 234 |*    Letzte Aenderung  MM 03.04.91
 235 |*
 236 *************************************************************************/
 237 BOOL RscFlag::IsDefault( const RSCINST & rInst )
 238 {
 239     sal_uInt32 i = 0;
 240
 241     for( i = 0; i < Size() / sizeof( RscFlagInst ); i++ )
 242         if( ((RscFlagInst *)rInst.pData)[ i ].nDfltFlags != 0xFFFFFFFF )
 243             return( FALSE );
 244     return( TRUE );
 245 }
 246
 247 BOOL RscFlag::IsDefault( const RSCINST & rInst, Atom nConstId )
 248 {
 249     sal_uInt32 i = 0, nFlag = 0;
 250
 251     if( nEntries != (i = GetConstPos( nConstId )) ){
 252         nFlag = 1 << (i % (sizeof( sal_uInt32 ) * 8) );
 253         i = i / (sizeof( sal_uInt32 ) * 8);
 254         if( ((RscFlagInst *)rInst.pData)[ i ].nDfltFlags & nFlag )
 255             return( TRUE );
 256         else
 257             return( FALSE );
 258     };
 259     return( TRUE );
 260 }
 261
 262 /*************************************************************************
 263 |*
 264 |*    RscFlag::IsValueDefault()
 265 |*
 266 |*    Beschreibung
 267 |*    Ersterstellung    MM 25.04.91
 268 |*    Letzte Aenderung  MM 25.04.91
 269 |*
 270 *************************************************************************/
 271 BOOL RscFlag::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef,
 272                               Atom nConstId )
 273 {
 274     sal_uInt32 i = 0, nFlag = 0;
 275
 276     if( nEntries != (i = GetConstPos( nConstId )) ){
 277         nFlag = 1 << (i % (sizeof( sal_uInt32 ) * 8) );
 278         i = i / (sizeof( sal_uInt32 ) * 8);
 279
 280         if( pDef ){
 281             if( (((RscFlagInst *)rInst.pData)[ i ].nFlags & nFlag)
 282               == (((RscFlagInst *)pDef)[ i ].nFlags & nFlag) )
 283             {
 284                 return TRUE;
 285             }
 286         }
 287     };
 288
 289     return FALSE;
 290 }
 291
 292 BOOL RscFlag::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
 293 {
 294     sal_uInt32 i = 0;
 295
 296     if( pDef ){
 297         sal_uInt32  Flag = 0, nIndex = 0;
 298
 299         Flag = 1;
 300         for( i = 0; i < nEntries; i++ ){
 301             nIndex = i / (sizeof( sal_uInt32 ) * 8);
 302             if( (((RscFlagInst *)rInst.pData)[ nIndex ].nFlags & Flag)
 303               != (((RscFlagInst *)pDef)[ nIndex ].nFlags & Flag)  )
 304             {
 305                 return FALSE;
 306             }
 307             Flag <<= 1;
 308             if( !Flag )
 309                 Flag = 1;
 310         };
 311     }
 312     else
 313         return FALSE;
 314
 315     return TRUE;
 316 }
 317
 318 /*************************************************************************
 319 |*
 320 |*    RscFlag::IsSet()
 321 |*
 322 |*    Beschreibung
 323 |*    Ersterstellung    MM 10.04.91
 324 |*    Letzte Aenderung  MM 10.04.91
 325 |*
 326 *************************************************************************/
 327 BOOL RscFlag::IsSet( const RSCINST & rInst, Atom nConstId )
 328 {
 329     sal_uInt32 i = 0, nFlag = 0;
 330
 331     if( nEntries != (i = GetConstPos( nConstId )) ){
 332         nFlag = 1 << (i % (sizeof( sal_uInt32 ) * 8) );
 333         i = i / (sizeof( sal_uInt32 ) * 8);
 334         if( ((RscFlagInst *)rInst.pData)[ i ].nFlags & nFlag )
 335             return( TRUE );
 336         else
 337             return( FALSE );
 338     };
 339     return( TRUE );
 340 }
 341
 342 /*************************************************************************
 343 |*
 344 |*    RscFlag::WriteSrc()
 345 |*
 346 |*    Beschreibung
 347 |*    Ersterstellung    MM 08.04.91
 348 |*    Letzte Aenderung  MM 08.04.91
 349 |*
 350 *************************************************************************/
 351 void RscFlag::WriteSrc( const RSCINST & rInst, FILE * fOutput,
 352                         RscTypCont *, sal_uInt32, const char * )
 353 {
 354     sal_uInt32  i = 0, Flag = 0, nIndex = 0;
 355     BOOL    bComma = FALSE;
 356
 357     Flag = 1;
 358     for( i = 0; i < nEntries; i++ ){
 359         nIndex = i / (sizeof( sal_uInt32 ) * 8);
 360         if( !( ((RscFlagInst *)rInst.pData)[ nIndex ].nDfltFlags & Flag) ){
 361             if( bComma )
 362                 fprintf( fOutput, ", " );
 363             if( ((RscFlagInst *)rInst.pData)[ nIndex ].nFlags & Flag )
 364                 fprintf( fOutput, "%s", pHS->getString( pVarArray[ i ].nId ).getStr() );
 365             else{
 366                 fprintf( fOutput, "not " );
 367                 fprintf( fOutput, "%s", pHS->getString( pVarArray[ i ].nId ).getStr() );
 368             }
 369             bComma = TRUE;
 370         }
 371         Flag <<= 1;
 372         if( !Flag )
 373             Flag = 1;
 374     };
 375 }
 376
 377 /*************************************************************************
 378 |*
 379 |*    RscFlag::WriteRc()
 380 |*
 381 |*    Beschreibung
 382 |*    Ersterstellung    MM 15.04.91
 383 |*    Letzte Aenderung  MM 15.04.91
 384 |*
 385 *************************************************************************/
 386 ERRTYPE RscFlag::WriteRc( const RSCINST & rInst, RscWriteRc & aMem,
 387                           RscTypCont *, sal_uInt32, BOOL )
 388 {
 389     INT32       lVal = 0;
 390     sal_uInt32  i = 0, Flag = 0, nIndex = 0;
 391
 392     Flag = 1;
 393     for( i = 0; i < nEntries; i++ ){
 394         nIndex = i / (sizeof( sal_uInt32 ) * 8);
 395         if( ((RscFlagInst *)rInst.pData)[ nIndex ].nFlags & Flag )
 396             lVal |= pVarArray[ i ].lValue;
 397
 398         Flag <<= 1;
 399         if( !Flag )
 400             Flag = 1;
 401     };
 402
 403     aMem.Put( (INT32)lVal );
 404     return( ERR_OK );
 405 }
 406
 407 /*************************************************************************
 408 |*
 409 |*    RscClient::RscClient()
 410 |*
 411 |*    Beschreibung
 412 |*    Ersterstellung    MM 08.04.91
 413 |*    Letzte Aenderung  MM 08.04.91
 414 |*
 415 *************************************************************************/
 416 RscClient::RscClient( Atom nId, sal_uInt32 nTypeId, RscFlag * pClass,
 417                        Atom nConstantId )
 418            : RscTop ( nId, nTypeId )
 419 {
 420    pRefClass = pClass;
 421    nConstId = nConstantId;
 422 }
 423
 424 /*************************************************************************
 425 |*
 426 |*    RscClient::GetClassType()
 427 |*
 428 |*    Beschreibung
 429 |*    Ersterstellung    MM 08.04.91
 430 |*    Letzte Aenderung  MM 08.04.91
 431 |*
 432 *************************************************************************/
 433 RSCCLASS_TYPE RscClient::GetClassType() const
 434 {
 435     return RSCCLASS_BOOL;
 436 }
 437
 438 /*************************************************************************
 439 |*
 440 |*    RscClient::WriteSrc()
 441 |*
 442 |*    Beschreibung
 443 |*    Ersterstellung    MM 08.04.91
 444 |*    Letzte Aenderung  MM 08.04.91
 445 |*
 446 *************************************************************************/
 447 void RscClient::WriteSrc( const RSCINST & rInst, FILE * fOutput,
 448                           RscTypCont *, sal_uInt32, const char * )
 449 {
 450     if( pRefClass->IsSet( rInst, nConstId ) )
 451         fprintf( fOutput, "TRUE" );
 452     else
 453         fprintf( fOutput, "FALSE" );
 454 }
 455
 456 /*************************************************************************
 457 |*
 458 |*    RscClient::Create()
 459 |*
 460 |*    Beschreibung
 461 |*    Ersterstellung    MM 08.04.91
 462 |*    Letzte Aenderung  MM 08.04.91
 463 |*
 464 *************************************************************************/
 465 RSCINST RscClient::Create( RSCINST * pInst, const RSCINST & rDflt,
 466                            BOOL bOwnClass )
 467 {
 468     RSCINST aTmpI, aDfltI;
 469
 470     if( pInst ){
 471         aTmpI.pClass = pRefClass;
 472         aTmpI.pData  = pInst->pData;
 473     }
 474
 475     if( !bOwnClass && rDflt.IsInst() ){
 476         bOwnClass = rDflt.pClass->InHierarchy( this );
 477         if( bOwnClass ){
 478             aDfltI.pClass = pRefClass;
 479             aDfltI.pData = rDflt.pData;
 480         }
 481     }
 482
 483     if( pInst )
 484         aTmpI = pRefClass->CreateClient( &aTmpI, aDfltI,
 485                                          bOwnClass, nConstId );
 486     else
 487         aTmpI = pRefClass->CreateClient( NULL, aDfltI,
 488                                          bOwnClass, nConstId );
 489     aTmpI.pClass = this;
 490
 491     return( aTmpI );
 492 }
 493