tools/source/generic/gen.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: gen.cxx,v $
  10  * $Revision: 1.5 $
  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_tools.hxx"
  33 #include <tools/debug.hxx>
  34 #include <tools/gen.hxx>
  35 #include <tools/stream.hxx>
  36
  37 // =======================================================================
  38
  39 SvStream& operator>>( SvStream& rIStream, Pair& rPair )
  40 {
  41     DBG_ASSERTWARNING( rIStream.GetVersion(), "Pair::>> - Solar-Version not set on rIStream" );
  42
  43     if ( rIStream.GetCompressMode() == COMPRESSMODE_FULL )
  44     {
  45         unsigned char   cId;
  46         unsigned char   cAry[8];
  47         int                     i;
  48         int                     i1;
  49         int                     i2;
  50         UINT32                  nNum;
  51
  52         rIStream >> cId;
  53         i1 = (cId & 0x70) >> 4;
  54         i2 = cId & 0x07;
  55         rIStream.Read( cAry, i1+i2 );
  56
  57         nNum = 0;
  58         i = i1;
  59         while ( i )
  60         {
  61             i--;
  62             nNum <<= 8;
  63             nNum |= cAry[i];
  64         }
  65         if ( cId & 0x80 )
  66             nNum ^= 0xFFFFFFFF;
  67         rPair.nA = (INT32)nNum;
  68
  69         nNum = 0;
  70         i = i1+i2;
  71         while ( i > i1 )
  72         {
  73             i--;
  74             nNum <<= 8;
  75             nNum |= cAry[i];
  76         }
  77         if ( cId & 0x08 )
  78             nNum ^= 0xFFFFFFFF;
  79         rPair.nB = (INT32)nNum;
  80     }
  81     else
  82     {
  83         rIStream >> rPair.nA >> rPair.nB;
  84     }
  85
  86     return rIStream;
  87 }
  88
  89 // -----------------------------------------------------------------------
  90
  91 SvStream& operator<<( SvStream& rOStream, const Pair& rPair )
  92 {
  93     DBG_ASSERTWARNING( rOStream.GetVersion(), "Pair::<< - Solar-Version not set on rOStream" );
  94
  95     if ( rOStream.GetCompressMode() == COMPRESSMODE_FULL )
  96     {
  97         unsigned char   cAry[9];
  98         int                     i = 1;
  99         UINT32                  nNum;
 100
 101         cAry[0] = 0;
 102
 103         nNum = (UINT32)(INT32)rPair.nA;
 104         if ( rPair.nA < 0 )
 105         {
 106             cAry[0] |= 0x80;
 107             nNum ^= 0xFFFFFFFF;
 108         }
 109         if ( nNum )
 110         {
 111             cAry[i] = (unsigned char)(nNum & 0xFF);
 112             nNum >>= 8;
 113             i++;
 114
 115             if ( nNum )
 116             {
 117                 cAry[i] = (unsigned char)(nNum & 0xFF);
 118                 nNum >>= 8;
 119                 i++;
 120
 121                 if ( nNum )
 122                 {
 123                     cAry[i] = (unsigned char)(nNum & 0xFF);
 124                     nNum >>= 8;
 125                     i++;
 126
 127                     if ( nNum )
 128                     {
 129                         cAry[i] = (unsigned char)(nNum & 0xFF);
 130                         nNum >>= 8;
 131                         i++;
 132                         cAry[0] |= 0x40;
 133                     }
 134                     else
 135                         cAry[0] |= 0x30;
 136                 }
 137                 else
 138                     cAry[0] |= 0x20;
 139             }
 140             else
 141                 cAry[0] |= 0x10;
 142         }
 143
 144         nNum = (UINT32)(INT32)rPair.nB;
 145         if ( rPair.nB < 0 )
 146         {
 147             cAry[0] |= 0x08;
 148             nNum ^= 0xFFFFFFFF;
 149         }
 150         if ( nNum )
 151         {
 152             cAry[i] = (unsigned char)(nNum & 0xFF);
 153             nNum >>= 8;
 154             i++;
 155
 156             if ( nNum )
 157             {
 158                 cAry[i] = (unsigned char)(nNum & 0xFF);
 159                 nNum >>= 8;
 160                 i++;
 161
 162                 if ( nNum )
 163                 {
 164                     cAry[i] = (unsigned char)(nNum & 0xFF);
 165                     nNum >>= 8;
 166                     i++;
 167
 168                     if ( nNum )
 169                     {
 170                         cAry[i] = (unsigned char)(nNum & 0xFF);
 171                         nNum >>= 8;
 172                         i++;
 173                         cAry[0] |= 0x04;
 174                     }
 175                     else
 176                         cAry[0] |= 0x03;
 177                 }
 178                 else
 179                     cAry[0] |= 0x02;
 180             }
 181             else
 182                 cAry[0] |= 0x01;
 183         }
 184
 185         rOStream.Write( cAry, i );
 186     }
 187     else
 188     {
 189         rOStream << rPair.nA << rPair.nB;
 190     }
 191
 192     return rOStream;
 193 }
 194
 195 /*************************************************************************
 196 |*
 197 |*    Rectangle::SetSize()
 198 |*
 199 |*    Beschreibung      GEN.SDW
 200 |*    Ersterstellung    DV 29.10.91
 201 |*    Letzte Aenderung  MM 21.04.94
 202 |*
 203 *************************************************************************/
 204
 205 void Rectangle::SetSize( const Size& rSize )
 206 {
 207     if ( rSize.Width() < 0 )
 208         nRight  = nLeft + rSize.Width() +1;
 209     else if ( rSize.Width() > 0 )
 210         nRight  = nLeft + rSize.Width() -1;
 211     else
 212         nRight = RECT_EMPTY;
 213
 214     if ( rSize.Height() < 0 )
 215         nBottom  = nTop + rSize.Height() +1;
 216     else if ( rSize.Height() > 0 )
 217         nBottom  = nTop + rSize.Height() -1;
 218     else
 219         nBottom = RECT_EMPTY;
 220 }
 221
 222 /*************************************************************************
 223 |*
 224 |*    Rectangle::Union()
 225 |*
 226 |*    Beschreibung      GEN.SDW
 227 |*    Ersterstellung    TH 20.10.92
 228 |*    Letzte Aenderung  MM 21.04.94
 229 |*
 230 *************************************************************************/
 231
 232 Rectangle& Rectangle::Union( const Rectangle& rRect )
 233 {
 234     if ( rRect.IsEmpty() )
 235         return *this;
 236
 237     if ( IsEmpty() )
 238         *this = rRect;
 239     else
 240     {
 241         nLeft  =  Min( Min( nLeft, rRect.nLeft ), Min( nRight, rRect.nRight )   );
 242         nRight  = Max( Max( nLeft, rRect.nLeft ), Max( nRight, rRect.nRight )   );
 243         nTop    = Min( Min( nTop, rRect.nTop ),   Min( nBottom, rRect.nBottom ) );
 244         nBottom = Max( Max( nTop, rRect.nTop ),   Max( nBottom, rRect.nBottom ) );
 245     }
 246
 247     return *this;
 248 }
 249
 250 /*************************************************************************
 251 |*
 252 |*    Rectangle::Intersection()
 253 |*
 254 |*    Beschreibung      GEN.SDW
 255 |*    Ersterstellung    TH 20.10.92
 256 |*    Letzte Aenderung  MM 21.04.94
 257 |*
 258 *************************************************************************/
 259
 260 Rectangle& Rectangle::Intersection( const Rectangle& rRect )
 261 {
 262     if ( IsEmpty() )
 263         return *this;
 264     if ( rRect.IsEmpty() )
 265     {
 266         *this = Rectangle();
 267         return *this;
 268     }
 269
 270     // nicht mit umgedrehten Rechtecken arbeiten
 271     Rectangle aTmpRect( rRect );
 272     Justify();
 273     aTmpRect.Justify();
 274
 275     // Schnitt bilden
 276     nLeft  = Max( nLeft, aTmpRect.nLeft );
 277     nRight = Min( nRight, aTmpRect.nRight );
 278     nTop   = Max( nTop, aTmpRect.nTop );
 279     nBottom= Min( nBottom, aTmpRect.nBottom );
 280
 281     // Feststellen ob Schnitt leer
 282     if ( nRight < nLeft || nBottom < nTop )
 283         *this = Rectangle();
 284
 285     return *this;
 286 }
 287
 288 /*************************************************************************
 289 |*
 290 |*    Rectangle::Justify()
 291 |*
 292 |*    Beschreibung      GEN.SDW
 293 |*    Ersterstellung    DV 07.03.91
 294 |*    Letzte Aenderung  DV 07.03.91
 295 |*
 296 *************************************************************************/
 297
 298 void Rectangle::Justify()
 299 {
 300     long nHelp;
 301
 302     // Abfrage, ob Right kleiner Left
 303     if ( (nRight < nLeft) && (nRight != RECT_EMPTY) )
 304     {
 305         nHelp = nLeft;
 306         nLeft = nRight;
 307         nRight = nHelp;
 308     }
 309
 310     // Abfrage, ob Bottom kleiner Top
 311     if ( (nBottom < nTop) && (nBottom != RECT_EMPTY) )
 312     {
 313         nHelp = nBottom;
 314         nBottom = nTop;
 315         nTop = nHelp;
 316     }
 317 }
 318
 319 /*************************************************************************
 320 |*
 321 |*    Rectangle::IsInside()
 322 |*
 323 |*    Beschreibung      GEN.SDW
 324 |*    Ersterstellung    TH 19.03.90
 325 |*    Letzte Aenderung  MM 21.04.94
 326 |*
 327 *************************************************************************/
 328
 329 BOOL Rectangle::IsInside( const Point& rPoint ) const
 330 {
 331     if ( IsEmpty() )
 332         return FALSE;
 333
 334     BOOL bRet = TRUE;
 335     if ( nLeft <= nRight )
 336     {
 337         if ( (rPoint.X() < nLeft) || (rPoint.X() > nRight) )
 338             bRet = FALSE;
 339     }
 340     else
 341     {
 342         if ( (rPoint.X() > nLeft) || (rPoint.X() < nRight) )
 343             bRet = FALSE;
 344     }
 345     if ( nTop <= nBottom )
 346     {
 347         if ( (rPoint.Y() < nTop) || (rPoint.Y() > nBottom) )
 348             bRet = FALSE;
 349     }
 350     else
 351     {
 352         if ( (rPoint.Y() > nTop) || (rPoint.Y() < nBottom) )
 353             bRet = FALSE;
 354     }
 355     return bRet;
 356 }
 357
 358 /*************************************************************************
 359 |*
 360 |*    Rectangle::IsInside()
 361 |*
 362 |*    Beschreibung      GEN.SDW
 363 |*    Ersterstellung    TH 19.03.90
 364 |*    Letzte Aenderung  MM 21.04.94
 365 |*
 366 *************************************************************************/
 367
 368 BOOL Rectangle::IsInside( const Rectangle& rRect ) const
 369 {
 370     if ( IsInside( rRect.TopLeft() ) && IsInside( rRect.BottomRight() ) )
 371         return TRUE;
 372     else
 373         return FALSE;
 374 }
 375
 376 /*************************************************************************
 377 |*
 378 |*    Rectangle::IsOver()
 379 |*
 380 |*    Beschreibung      GEN.SDW
 381 |*    Ersterstellung    TH 19.03.90
 382 |*    Letzte Aenderung  MM 21.04.94
 383 |*
 384 *************************************************************************/
 385
 386 BOOL Rectangle::IsOver( const Rectangle& rRect ) const
 387 {
 388     // Wenn sie sich nicht schneiden, ueberlappen sie auch nicht
 389     return !GetIntersection( rRect ).IsEmpty();
 390 }
 391
 392 // =======================================================================
 393
 394 SvStream& operator>>( SvStream& rIStream, Rectangle& rRect )
 395 {
 396     DBG_ASSERTWARNING( rIStream.GetVersion(), "Rectangle::>> - Solar-Version not set on rIStream" );
 397
 398     if ( rIStream.GetCompressMode() == COMPRESSMODE_FULL )
 399     {
 400         unsigned char   cIdAry[2];
 401         unsigned char   cAry[16];
 402         int                     i;
 403         int                     iLast;
 404         int                     i1;
 405         int                     i2;
 406         int                     i3;
 407         int                     i4;
 408         UINT32                  nNum;
 409
 410         rIStream.Read( cIdAry, 2 );
 411         i1 = (cIdAry[0] & 0x70) >> 4;
 412         i2 = cIdAry[0] & 0x07;
 413         i3 = (cIdAry[1] & 0x70) >> 4;
 414         i4 = cIdAry[1] & 0x07;
 415         rIStream.Read( cAry, i1+i2+i3+i4 );
 416
 417         nNum = 0;
 418         i = i1;
 419         iLast = i;
 420         while ( i )
 421         {
 422             i--;
 423             nNum <<= 8;
 424             nNum |= cAry[i];
 425         }
 426         iLast = i1;
 427         if ( cIdAry[0] & 0x80 )
 428             nNum ^= 0xFFFFFFFF;
 429         rRect.nLeft = (INT32)nNum;
 430
 431         nNum = 0;
 432         i = iLast+i2;
 433         while ( i > iLast )
 434         {
 435             i--;
 436             nNum <<= 8;
 437             nNum |= cAry[i];
 438         }
 439         iLast += i2;
 440         if ( cIdAry[0] & 0x08 )
 441             nNum ^= 0xFFFFFFFF;
 442         rRect.nTop = (INT32)nNum;
 443
 444         nNum = 0;
 445         i = iLast+i3;
 446         while ( i > iLast )
 447         {
 448             i--;
 449             nNum <<= 8;
 450             nNum |= cAry[i];
 451         }
 452         iLast += i3;
 453         if ( cIdAry[1] & 0x80 )
 454             nNum ^= 0xFFFFFFFF;
 455         rRect.nRight = (INT32)nNum;
 456
 457         nNum = 0;
 458         i = iLast+i4;
 459         while ( i > iLast )
 460         {
 461             i--;
 462             nNum <<= 8;
 463             nNum |= cAry[i];
 464         }
 465         if ( cIdAry[1] & 0x08 )
 466             nNum ^= 0xFFFFFFFF;
 467         rRect.nBottom = (INT32)nNum;
 468     }
 469     else
 470     {
 471         rIStream >> rRect.nLeft >> rRect.nTop >> rRect.nRight >> rRect.nBottom;
 472     }
 473
 474     return rIStream;
 475 }
 476
 477 // -----------------------------------------------------------------------
 478
 479 SvStream& operator<<( SvStream& rOStream, const Rectangle& rRect )
 480 {
 481     DBG_ASSERTWARNING( rOStream.GetVersion(), "Rectangle::<< - Solar-Version not set on rOStream" );
 482
 483     if ( rOStream.GetCompressMode() == COMPRESSMODE_FULL )
 484     {
 485         unsigned char   cAry[18];
 486         int                     i = 2;
 487         UINT32                  nNum;
 488
 489         cAry[0] = 0;
 490         cAry[1] = 0;
 491
 492         nNum = (UINT32)(INT32)rRect.nLeft;
 493         if ( rRect.nLeft < 0 )
 494         {
 495             cAry[0] |= 0x80;
 496             nNum ^= 0xFFFFFFFF;
 497         }
 498         if ( nNum )
 499         {
 500             cAry[i] = (unsigned char)(nNum & 0xFF);
 501             nNum >>= 8;
 502             i++;
 503
 504             if ( nNum )
 505             {
 506                 cAry[i] = (unsigned char)(nNum & 0xFF);
 507                 nNum >>= 8;
 508                 i++;
 509
 510                 if ( nNum )
 511                 {
 512                     cAry[i] = (unsigned char)(nNum & 0xFF);
 513                     nNum >>= 8;
 514                     i++;
 515
 516                     if ( nNum )
 517                     {
 518                         cAry[i] = (unsigned char)(nNum & 0xFF);
 519                         nNum >>= 8;
 520                         i++;
 521                         cAry[0] |= 0x40;
 522                     }
 523                     else
 524                         cAry[0] |= 0x30;
 525                 }
 526                 else
 527                     cAry[0] |= 0x20;
 528             }
 529             else
 530                 cAry[0] |= 0x10;
 531         }
 532
 533         nNum = (UINT32)(INT32)rRect.nTop;
 534         if ( rRect.nTop < 0 )
 535         {
 536             cAry[0] |= 0x08;
 537             nNum ^= 0xFFFFFFFF;
 538         }
 539         if ( nNum )
 540         {
 541             cAry[i] = (unsigned char)(nNum & 0xFF);
 542             nNum >>= 8;
 543             i++;
 544
 545             if ( nNum )
 546             {
 547                 cAry[i] = (unsigned char)(nNum & 0xFF);
 548                 nNum >>= 8;
 549                 i++;
 550
 551                 if ( nNum )
 552                 {
 553                     cAry[i] = (unsigned char)(nNum & 0xFF);
 554                     nNum >>= 8;
 555                     i++;
 556
 557                     if ( nNum )
 558                     {
 559                         cAry[i] = (unsigned char)(nNum & 0xFF);
 560                         nNum >>= 8;
 561                         i++;
 562                         cAry[0] |= 0x04;
 563                     }
 564                     else
 565                         cAry[0] |= 0x03;
 566                 }
 567                 else
 568                     cAry[0] |= 0x02;
 569             }
 570             else
 571                 cAry[0] |= 0x01;
 572         }
 573
 574         nNum = (UINT32)(INT32)rRect.nRight;
 575         if ( rRect.nRight < 0 )
 576         {
 577             cAry[1] |= 0x80;
 578             nNum ^= 0xFFFFFFFF;
 579         }
 580         if ( nNum )
 581         {
 582             cAry[i] = (unsigned char)(nNum & 0xFF);
 583             nNum >>= 8;
 584             i++;
 585
 586             if ( nNum )
 587             {
 588                 cAry[i] = (unsigned char)(nNum & 0xFF);
 589                 nNum >>= 8;
 590                 i++;
 591
 592                 if ( nNum )
 593                 {
 594                     cAry[i] = (unsigned char)(nNum & 0xFF);
 595                     nNum >>= 8;
 596                     i++;
 597
 598                     if ( nNum )
 599                     {
 600                         cAry[i] = (unsigned char)(nNum & 0xFF);
 601                         nNum >>= 8;
 602                         i++;
 603                         cAry[1] |= 0x40;
 604                     }
 605                     else
 606                         cAry[1] |= 0x30;
 607                 }
 608                 else
 609                     cAry[1] |= 0x20;
 610             }
 611             else
 612                 cAry[1] |= 0x10;
 613         }
 614
 615         nNum = (UINT32)(INT32)rRect.nBottom;
 616         if ( rRect.nBottom < 0 )
 617         {
 618             cAry[1] |= 0x08;
 619             nNum ^= 0xFFFFFFFF;
 620         }
 621         if ( nNum )
 622         {
 623             cAry[i] = (unsigned char)(nNum & 0xFF);
 624             nNum >>= 8;
 625             i++;
 626
 627             if ( nNum )
 628             {
 629                 cAry[i] = (unsigned char)(nNum & 0xFF);
 630                 nNum >>= 8;
 631                 i++;
 632
 633                 if ( nNum )
 634                 {
 635                     cAry[i] = (unsigned char)(nNum & 0xFF);
 636                     nNum >>= 8;
 637                     i++;
 638
 639                     if ( nNum )
 640                     {
 641                         cAry[i] = (unsigned char)(nNum & 0xFF);
 642                         nNum >>= 8;
 643                         i++;
 644                         cAry[1] |= 0x04;
 645                     }
 646                     else
 647                         cAry[1] |= 0x03;
 648                 }
 649                 else
 650                     cAry[1] |= 0x02;
 651             }
 652             else
 653                 cAry[1] |= 0x01;
 654         }
 655
 656         rOStream.Write( cAry, i );
 657     }
 658     else
 659     {
 660         rOStream << rRect.nLeft << rRect.nTop << rRect.nRight << rRect.nBottom;
 661     }
 662
 663     return rOStream;
 664 }