svtools/source/misc/imap2.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: imap2.cxx,v $
  10  * $Revision: 1.12 $
  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_svtools.hxx"
  33
  34 #ifdef WIN
  35 #include <sysdep.hxx>
  36 #endif
  37 #include <string.h>
  38 // #include <math.h>
  39 #include <vcl/svapp.hxx>
  40 #include <tools/urlobj.hxx>
  41 #ifndef _WRKWIN_HXX //autogen
  42 #include <vcl/wrkwin.hxx>
  43 #endif
  44 #include <sot/formats.hxx>
  45
  46 #include "urihelper.hxx"
  47 #include <svtools/imap.hxx>
  48 #include <svtools/imap.hxx>
  49 #include <svtools/imapobj.hxx>
  50 #include <svtools/imaprect.hxx>
  51 #include <svtools/imapcirc.hxx>
  52 #include <svtools/imappoly.hxx>
  53
  54 #ifdef WIN
  55 #include <sysdep.hxx>
  56 #endif
  57 #include <string.h>
  58 #include <math.h>
  59
  60 #define NOTEOL(c) ((c)!='\0')
  61
  62
  63 TYPEINIT0_AUTOFACTORY( ImageMap );
  64
  65
  66 /******************************************************************************/
  67 /******************************************************************************/
  68
  69
  70 /******************************************************************************
  71 |*
  72 |*
  73 |*
  74 \******************************************************************************/
  75
  76 void IMapObject::AppendCERNCoords( const Point& rPoint100, ByteString& rStr ) const
  77 {
  78     const Point aPixPt( Application::GetDefaultDevice()->LogicToPixel( rPoint100, MapMode( MAP_100TH_MM ) ) );
  79
  80     rStr += '(';
  81     rStr += ByteString::CreateFromInt32( aPixPt.X() );
  82     rStr += ',';
  83     rStr += ByteString::CreateFromInt32( aPixPt.Y() );
  84     rStr += ") ";
  85 }
  86
  87
  88 /******************************************************************************
  89 |*
  90 |*
  91 |*
  92 \******************************************************************************/
  93
  94 void IMapObject::AppendNCSACoords( const Point& rPoint100, ByteString& rStr ) const
  95 {
  96     const Point aPixPt( Application::GetDefaultDevice()->LogicToPixel( rPoint100, MapMode( MAP_100TH_MM ) ) );
  97
  98     rStr += ByteString::CreateFromInt32( aPixPt.X() );
  99     rStr += ',';
 100     rStr += ByteString::CreateFromInt32( aPixPt.Y() );
 101     rStr += ' ';
 102 }
 103
 104
 105 /******************************************************************************
 106 |*
 107 |*
 108 |*
 109 \******************************************************************************/
 110
 111 void IMapObject::AppendCERNURL( ByteString& rStr, const String& rBaseURL ) const
 112 {
 113     rStr += ByteString( String(URIHelper::simpleNormalizedMakeRelative( rBaseURL, aURL )), gsl_getSystemTextEncoding() );
 114 }
 115
 116
 117 /******************************************************************************
 118 |*
 119 |*
 120 |*
 121 \******************************************************************************/
 122
 123 void IMapObject::AppendNCSAURL( ByteString& rStr, const String& rBaseURL ) const
 124 {
 125     rStr += ByteString( String(URIHelper::simpleNormalizedMakeRelative( rBaseURL, aURL )), gsl_getSystemTextEncoding() );
 126     rStr += ' ';
 127 }
 128
 129
 130 /******************************************************************************/
 131 /******************************************************************************/
 132
 133
 134 /******************************************************************************
 135 |*
 136 |*
 137 |*
 138 \******************************************************************************/
 139
 140 void IMapRectangleObject::WriteCERN( SvStream& rOStm, const String& rBaseURL ) const
 141 {
 142     ByteString aStr( "rectangle " );
 143
 144     AppendCERNCoords( aRect.TopLeft(), aStr );
 145     AppendCERNCoords( aRect.BottomRight(), aStr );
 146     AppendCERNURL( aStr, rBaseURL );
 147
 148     rOStm.WriteLine( aStr );
 149 }
 150
 151
 152 /******************************************************************************
 153 |*
 154 |*
 155 |*
 156 \******************************************************************************/
 157
 158 void IMapRectangleObject::WriteNCSA( SvStream& rOStm, const String& rBaseURL ) const
 159 {
 160     ByteString aStr( "rect " );
 161
 162     AppendNCSAURL( aStr, rBaseURL );
 163     AppendNCSACoords( aRect.TopLeft(), aStr );
 164     AppendNCSACoords( aRect.BottomRight(), aStr );
 165
 166     rOStm.WriteLine( aStr );
 167 }
 168
 169
 170 /******************************************************************************/
 171 /******************************************************************************/
 172
 173
 174 /******************************************************************************
 175 |*
 176 |*
 177 |*
 178 \******************************************************************************/
 179
 180 void IMapCircleObject::WriteCERN( SvStream& rOStm, const String& rBaseURL ) const
 181 {
 182     ByteString aStr( "circle " );
 183
 184     AppendCERNCoords( aCenter, aStr );
 185     aStr += ByteString::CreateFromInt32(nRadius);
 186     aStr += ' ';
 187     AppendCERNURL( aStr, rBaseURL );
 188
 189     rOStm.WriteLine( aStr );
 190 }
 191
 192
 193 /******************************************************************************
 194 |*
 195 |*
 196 |*
 197 \******************************************************************************/
 198
 199 void IMapCircleObject::WriteNCSA( SvStream& rOStm, const String& rBaseURL ) const
 200 {
 201     ByteString aStr( "circle " );
 202
 203     AppendNCSAURL( aStr, rBaseURL );
 204     AppendNCSACoords( aCenter, aStr );
 205     AppendNCSACoords( aCenter + Point( nRadius, 0 ), aStr );
 206
 207     rOStm.WriteLine( aStr );
 208 }
 209
 210
 211 /******************************************************************************/
 212 /******************************************************************************/
 213
 214
 215 /******************************************************************************
 216 |*
 217 |*
 218 |*
 219 \******************************************************************************/
 220
 221 void IMapPolygonObject::WriteCERN( SvStream& rOStm, const String& rBaseURL  ) const
 222 {
 223     ByteString          aStr( "polygon " );
 224     const USHORT        nCount = aPoly.GetSize();
 225
 226     for ( USHORT i = 0; i < nCount; i++ )
 227         AppendCERNCoords( aPoly[ i ], aStr );
 228
 229     AppendCERNURL( aStr, rBaseURL );
 230
 231     rOStm.WriteLine( aStr );
 232 }
 233
 234
 235 /******************************************************************************
 236 |*
 237 |*
 238 |*
 239 \******************************************************************************/
 240
 241 void IMapPolygonObject::WriteNCSA( SvStream& rOStm, const String& rBaseURL  ) const
 242 {
 243     ByteString          aStr( "poly " );
 244     const USHORT        nCount = Min( aPoly.GetSize(), (USHORT) 100 );
 245
 246     AppendNCSAURL( aStr, rBaseURL );
 247
 248     for ( USHORT i = 0; i < nCount; i++ )
 249         AppendNCSACoords( aPoly[ i ], aStr );
 250
 251     rOStm.WriteLine( aStr );
 252 }
 253
 254
 255 /******************************************************************************/
 256 /******************************************************************************/
 257
 258
 259 /******************************************************************************
 260 |*
 261 |*
 262 |*
 263 \******************************************************************************/
 264
 265 void ImageMap::Write( SvStream& rOStm, ULONG nFormat, const String& rBaseURL ) const
 266 {
 267     switch( nFormat )
 268     {
 269         case( IMAP_FORMAT_BIN ) : Write( rOStm, rBaseURL );
 270         case( IMAP_FORMAT_CERN ) : ImpWriteCERN( rOStm, rBaseURL ); break;
 271         case( IMAP_FORMAT_NCSA ) : ImpWriteNCSA( rOStm, rBaseURL ); break;
 272
 273         default:
 274         break;
 275     }
 276 }
 277
 278
 279 /******************************************************************************
 280 |*
 281 |*
 282 |*
 283 \******************************************************************************/
 284
 285 void ImageMap::ImpWriteCERN( SvStream& rOStm, const String& rBaseURL ) const
 286 {
 287     IMapObject* pObj;
 288     USHORT              nCount = (USHORT) maList.Count();
 289
 290     for ( USHORT i = 0; i < nCount; i++ )
 291     {
 292         pObj = GetIMapObject( i );
 293
 294         switch( pObj->GetType() )
 295         {
 296             case( IMAP_OBJ_RECTANGLE ):
 297                 ( (IMapRectangleObject*) pObj )->WriteCERN( rOStm, rBaseURL );
 298             break;
 299
 300             case( IMAP_OBJ_CIRCLE ):
 301                 ( (IMapCircleObject*) pObj )->WriteCERN( rOStm, rBaseURL );
 302             break;
 303
 304             case( IMAP_OBJ_POLYGON ):
 305                 ( (IMapPolygonObject*) pObj )->WriteCERN( rOStm, rBaseURL );
 306             break;
 307
 308             default:
 309             break;
 310         }
 311     }
 312 }
 313
 314
 315 /******************************************************************************
 316 |*
 317 |*
 318 |*
 319 \******************************************************************************/
 320
 321 void ImageMap::ImpWriteNCSA( SvStream& rOStm, const String& rBaseURL  ) const
 322 {
 323     IMapObject* pObj;
 324     USHORT              nCount = (USHORT) maList.Count();
 325
 326     for ( USHORT i = 0; i < nCount; i++ )
 327     {
 328         pObj = GetIMapObject( i );
 329
 330             switch( pObj->GetType() )
 331         {
 332             case( IMAP_OBJ_RECTANGLE ):
 333                 ( (IMapRectangleObject*) pObj )->WriteNCSA( rOStm, rBaseURL );
 334             break;
 335
 336             case( IMAP_OBJ_CIRCLE ):
 337                 ( (IMapCircleObject*) pObj )->WriteNCSA( rOStm, rBaseURL );
 338             break;
 339
 340             case( IMAP_OBJ_POLYGON ):
 341                 ( (IMapPolygonObject*) pObj )->WriteNCSA( rOStm, rBaseURL );
 342             break;
 343
 344             default:
 345             break;
 346         }
 347     }
 348 }
 349
 350
 351 /******************************************************************************
 352 |*
 353 |*
 354 |*
 355 \******************************************************************************/
 356
 357 ULONG ImageMap::Read( SvStream& rIStm, ULONG nFormat, const String& rBaseURL  )
 358 {
 359     ULONG nRet = IMAP_ERR_FORMAT;
 360
 361     if ( nFormat == IMAP_FORMAT_DETECT )
 362         nFormat = ImpDetectFormat( rIStm );
 363
 364     switch ( nFormat )
 365     {
 366         case ( IMAP_FORMAT_BIN )    : Read( rIStm, rBaseURL ); break;
 367         case ( IMAP_FORMAT_CERN )   : nRet = ImpReadCERN( rIStm, rBaseURL ); break;
 368         case ( IMAP_FORMAT_NCSA )   : nRet = ImpReadNCSA( rIStm, rBaseURL ); break;
 369
 370         default:
 371         break;
 372     }
 373
 374     if ( !rIStm.GetError() )
 375         nRet = IMAP_ERR_OK;
 376
 377     return nRet;
 378 }
 379
 380
 381 /******************************************************************************
 382 |*
 383 |*
 384 |*
 385 \******************************************************************************/
 386
 387 ULONG ImageMap::ImpReadCERN( SvStream& rIStm, const String& rBaseURL )
 388 {
 389     ByteString aStr;
 390
 391     // alten Inhalt loeschen
 392     ClearImageMap();
 393
 394     while ( rIStm.ReadLine( aStr ) )
 395         ImpReadCERNLine( aStr, rBaseURL );
 396
 397     return IMAP_ERR_OK;
 398 }
 399
 400
 401 /******************************************************************************
 402 |*
 403 |*
 404 |*
 405 \******************************************************************************/
 406
 407 void ImageMap::ImpReadCERNLine( const ByteString& rLine, const String& rBaseURL  )
 408 {
 409     ByteString  aStr( rLine );
 410     ByteString  aToken;
 411
 412     aStr.EraseLeadingChars( ' ' );
 413     aStr.EraseLeadingChars( '\t' );
 414     aStr.EraseAllChars( ';' );
 415     aStr.ToLowerAscii();
 416
 417     const char* pStr = aStr.GetBuffer();
 418     char                cChar = *pStr++;
 419
 420         // Anweisung finden
 421     while( ( cChar >= 'a' ) && ( cChar <= 'z' ) && NOTEOL( cChar ) )
 422     {
 423         aToken += cChar;
 424         cChar = *pStr++;
 425     }
 426
 427     if ( NOTEOL( cChar ) )
 428     {
 429         if ( ( aToken == "rectangle" ) || ( aToken == "rect" ) )
 430         {
 431             const Point         aTopLeft( ImpReadCERNCoords( &pStr ) );
 432             const Point         aBottomRight( ImpReadCERNCoords( &pStr ) );
 433             const String    aURL( ImpReadCERNURL( &pStr, rBaseURL ) );
 434             const Rectangle     aRect( aTopLeft, aBottomRight );
 435
 436             IMapRectangleObject* pObj = new IMapRectangleObject( aRect, aURL, String(), String(), String(), String() );
 437             maList.Insert( pObj, LIST_APPEND );
 438         }
 439         else if ( ( aToken == "circle" ) || ( aToken == "circ" ) )
 440         {
 441             const Point         aCenter( ImpReadCERNCoords( &pStr ) );
 442             const long          nRadius = ImpReadCERNRadius( &pStr );
 443             const String    aURL( ImpReadCERNURL( &pStr, rBaseURL ) );
 444
 445             IMapCircleObject* pObj = new IMapCircleObject( aCenter, nRadius, aURL, String(), String(), String(), String() );
 446             maList.Insert( pObj, LIST_APPEND );
 447         }
 448         else if ( ( aToken == "polygon" ) || ( aToken == "poly" ) )
 449         {
 450             const USHORT        nCount = aStr.GetTokenCount( '(' ) - 1;
 451             Polygon                     aPoly( nCount );
 452             String                      aURL;
 453
 454             for ( USHORT i = 0; i < nCount; i++ )
 455                 aPoly[ i ] = ImpReadCERNCoords( &pStr );
 456
 457             aURL = ImpReadCERNURL( &pStr, rBaseURL );
 458
 459             IMapPolygonObject* pObj = new IMapPolygonObject( aPoly, aURL, String(), String(), String(), String() );
 460             maList.Insert( pObj, LIST_APPEND );
 461         }
 462     }
 463 }
 464
 465
 466 /******************************************************************************
 467 |*
 468 |*
 469 |*
 470 \******************************************************************************/
 471
 472 Point ImageMap::ImpReadCERNCoords( const char** ppStr )
 473 {
 474     String      aStrX;
 475     String      aStrY;
 476     Point       aPt;
 477     char        cChar = *(*ppStr)++;
 478
 479     while( NOTEOL( cChar ) && ( ( cChar < '0' ) || ( cChar > '9' ) ) )
 480         cChar = *(*ppStr)++;
 481
 482     if ( NOTEOL( cChar ) )
 483     {
 484         while( NOTEOL( cChar ) && ( cChar >= '0' ) && ( cChar <= '9' ) )
 485         {
 486             aStrX += cChar;
 487             cChar = *(*ppStr)++;
 488         }
 489
 490         if ( NOTEOL( cChar ) )
 491         {
 492             while( NOTEOL( cChar ) && ( ( cChar < '0' ) || ( cChar > '9' ) ) )
 493                 cChar = *(*ppStr)++;
 494
 495             while( NOTEOL( cChar ) && ( cChar >= '0' ) && ( cChar <= '9' ) )
 496             {
 497                 aStrY += cChar;
 498                 cChar = *(*ppStr)++;
 499             }
 500
 501             if ( NOTEOL( cChar ) )
 502                 while( NOTEOL( cChar ) && ( cChar != ')' ) )
 503                     cChar = *(*ppStr)++;
 504
 505             aPt = Point( aStrX.ToInt32(), aStrY.ToInt32() );
 506         }
 507     }
 508
 509     return aPt;
 510 }
 511
 512
 513 /******************************************************************************
 514 |*
 515 |*
 516 |*
 517 \******************************************************************************/
 518
 519 long ImageMap::ImpReadCERNRadius( const char** ppStr )
 520 {
 521     String      aStr;
 522     char        cChar = *(*ppStr)++;
 523
 524     while( NOTEOL( cChar ) && ( ( cChar < '0' ) || ( cChar > '9' ) ) )
 525         cChar = *(*ppStr)++;
 526
 527     if ( NOTEOL( cChar ) )
 528     {
 529         while( NOTEOL( cChar ) && ( cChar >= '0' ) && ( cChar <= '9' ) )
 530         {
 531             aStr += cChar;
 532             cChar = *(*ppStr)++;
 533         }
 534     }
 535
 536     return aStr.ToInt32();
 537 }
 538
 539
 540 /******************************************************************************
 541 |*
 542 |*
 543 |*
 544 \******************************************************************************/
 545
 546 String ImageMap::ImpReadCERNURL( const char** ppStr, const String& rBaseURL )
 547 {
 548     String      aStr( String::CreateFromAscii( *ppStr ) );
 549
 550     aStr.EraseLeadingChars( ' ' );
 551     aStr.EraseLeadingChars( '\t' );
 552     aStr.EraseTrailingChars( ' ' );
 553     aStr.EraseTrailingChars( '\t' );
 554
 555     return INetURLObject::GetAbsURL( rBaseURL, aStr );
 556 }
 557
 558
 559 /******************************************************************************
 560 |*
 561 |*
 562 |*
 563 \******************************************************************************/
 564
 565 ULONG ImageMap::ImpReadNCSA( SvStream& rIStm, const String& rBaseURL )
 566 {
 567     ByteString aStr;
 568
 569     // alten Inhalt loeschen
 570     ClearImageMap();
 571
 572     while ( rIStm.ReadLine( aStr ) )
 573         ImpReadNCSALine( aStr, rBaseURL );
 574
 575     return IMAP_ERR_OK;
 576 }
 577
 578
 579 /******************************************************************************
 580 |*
 581 |*
 582 |*
 583 \******************************************************************************/
 584
 585 void ImageMap::ImpReadNCSALine( const ByteString& rLine, const String& rBaseURL )
 586 {
 587     ByteString  aStr( rLine );
 588     ByteString  aToken;
 589
 590     aStr.EraseLeadingChars( ' ' );
 591     aStr.EraseLeadingChars( '\t' );
 592     aStr.EraseAllChars( ';' );
 593     aStr.ToLowerAscii();
 594
 595     const char* pStr = aStr.GetBuffer();
 596     char                cChar = *pStr++;
 597
 598         // Anweisung finden
 599     while( ( cChar >= 'a' ) && ( cChar <= 'z' ) && NOTEOL( cChar ) )
 600     {
 601         aToken += cChar;
 602         cChar = *pStr++;
 603     }
 604
 605     if ( NOTEOL( cChar ) )
 606     {
 607         if ( aToken == "rect" )
 608         {
 609             const String    aURL( ImpReadNCSAURL( &pStr, rBaseURL ) );
 610             const Point         aTopLeft( ImpReadNCSACoords( &pStr ) );
 611             const Point         aBottomRight( ImpReadNCSACoords( &pStr ) );
 612             const Rectangle     aRect( aTopLeft, aBottomRight );
 613
 614             IMapRectangleObject* pObj = new IMapRectangleObject( aRect, aURL, String(), String(), String(), String() );
 615             maList.Insert( pObj, LIST_APPEND );
 616         }
 617         else if ( aToken == "circle" )
 618         {
 619             const String    aURL( ImpReadNCSAURL( &pStr, rBaseURL ) );
 620             const Point         aCenter( ImpReadNCSACoords( &pStr ) );
 621             const Point         aDX( aCenter - ImpReadNCSACoords( &pStr ) );
 622             long                        nRadius = (long) sqrt( (double) aDX.X() * aDX.X() +
 623                                                    (double) aDX.Y() * aDX.Y() );
 624
 625             IMapCircleObject* pObj = new IMapCircleObject( aCenter, nRadius, aURL, String(), String(), String(), String() );
 626             maList.Insert( pObj, LIST_APPEND );
 627         }
 628         else if ( aToken == "poly" )
 629         {
 630             const USHORT        nCount = aStr.GetTokenCount( ',' ) - 1;
 631             const String    aURL( ImpReadNCSAURL( &pStr, rBaseURL ) );
 632             Polygon                     aPoly( nCount );
 633
 634             for ( USHORT i = 0; i < nCount; i++ )
 635                 aPoly[ i ] = ImpReadNCSACoords( &pStr );
 636
 637             IMapPolygonObject* pObj = new IMapPolygonObject( aPoly, aURL, String(), String(), String(), String() );
 638             maList.Insert( pObj, LIST_APPEND );
 639         }
 640     }
 641 }
 642
 643
 644 /******************************************************************************
 645 |*
 646 |*
 647 |*
 648 \******************************************************************************/
 649
 650 String ImageMap::ImpReadNCSAURL( const char** ppStr, const String& rBaseURL )
 651 {
 652     String      aStr;
 653     char        cChar = *(*ppStr)++;
 654
 655     while( NOTEOL( cChar ) && ( ( cChar == ' ' ) || ( cChar == '\t' ) ) )
 656         cChar = *(*ppStr)++;
 657
 658     if ( NOTEOL( cChar ) )
 659     {
 660         while( NOTEOL( cChar ) && ( cChar != ' ' ) && ( cChar != '\t' ) )
 661         {
 662             aStr += cChar;
 663             cChar = *(*ppStr)++;
 664         }
 665     }
 666
 667     return INetURLObject::GetAbsURL( rBaseURL, aStr );
 668 }
 669
 670
 671 /******************************************************************************
 672 |*
 673 |*
 674 |*
 675 \******************************************************************************/
 676
 677 Point ImageMap::ImpReadNCSACoords( const char** ppStr )
 678 {
 679     String      aStrX;
 680     String      aStrY;
 681     Point       aPt;
 682     char        cChar = *(*ppStr)++;
 683
 684     while( NOTEOL( cChar ) && ( ( cChar < '0' ) || ( cChar > '9' ) ) )
 685         cChar = *(*ppStr)++;
 686
 687     if ( NOTEOL( cChar ) )
 688     {
 689         while( NOTEOL( cChar ) && ( cChar >= '0' ) && ( cChar <= '9' ) )
 690         {
 691             aStrX += cChar;
 692             cChar = *(*ppStr)++;
 693         }
 694
 695         if ( NOTEOL( cChar ) )
 696         {
 697             while( NOTEOL( cChar ) && ( ( cChar < '0' ) || ( cChar > '9' ) ) )
 698                 cChar = *(*ppStr)++;
 699
 700             while( NOTEOL( cChar ) && ( cChar >= '0' ) && ( cChar <= '9' ) )
 701             {
 702                 aStrY += cChar;
 703                 cChar = *(*ppStr)++;
 704             }
 705
 706             aPt = Point( aStrX.ToInt32(), aStrY.ToInt32() );
 707         }
 708     }
 709
 710     return aPt;
 711 }
 712
 713
 714 /******************************************************************************
 715 |*
 716 |*
 717 |*
 718 \******************************************************************************/
 719
 720 ULONG ImageMap::ImpDetectFormat( SvStream& rIStm )
 721 {
 722     ULONG       nPos = rIStm.Tell();
 723     ULONG       nRet = IMAP_FORMAT_BIN;
 724     char        cMagic[6];
 725
 726     rIStm.Read( cMagic, sizeof( cMagic ) );
 727
 728     // Falls wir kein internes Format haben,
 729     // untersuchen wir das Format
 730     if ( memcmp( cMagic, IMAPMAGIC, sizeof( cMagic ) ) )
 731     {
 732         ByteString      aStr;
 733         long            nCount = 128;
 734
 735         rIStm.Seek( nPos );
 736         while ( rIStm.ReadLine( aStr ) && nCount-- )
 737         {
 738             aStr.ToLowerAscii();
 739
 740             if ( ( aStr.Search( "rect" ) != STRING_NOTFOUND ) ||
 741                  ( aStr.Search( "circ" ) != STRING_NOTFOUND ) ||
 742                  ( aStr.Search( "poly" ) != STRING_NOTFOUND ) )
 743             {
 744                 if ( ( aStr.Search( '(' ) != STRING_NOTFOUND ) &&
 745                      ( aStr.Search( ')' ) != STRING_NOTFOUND ) )
 746                 {
 747                     nRet = IMAP_FORMAT_CERN;
 748                 }
 749                 else
 750                     nRet = IMAP_FORMAT_NCSA;
 751
 752                 break;
 753             }
 754         }
 755     }
 756
 757     rIStm.Seek( nPos );
 758
 759     return nRet;
 760 }