svtools/source/filter.vcl/ixbm/xbmread.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: xbmread.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_svtools.hxx"
  33
  34 #define XBMMINREAD 512
  35
  36 #define _XBMPRIVATE
  37 #include <ctype.h>
  38 #include "xbmread.hxx"
  39
  40 // -------------
  41 // - XBMReader -
  42 // -------------
  43
  44 XBMReader::XBMReader( SvStream& rStm ) :
  45             rIStm                       ( rStm ),
  46             pAcc1                       ( NULL ),
  47             nLastPos            ( rStm.Tell() ),
  48             nWidth                      ( 0 ),
  49             nHeight                     ( 0 ),
  50             bStatus                     ( TRUE )
  51 {
  52     pHexTable = new short[ 256 ];
  53     maUpperName = String::CreateFromAscii( "SVIXBM", 6 );
  54     InitTable();
  55 }
  56
  57 // ------------------------------------------------------------------------
  58
  59 XBMReader::~XBMReader()
  60 {
  61     delete[] pHexTable;
  62
  63     if( pAcc1 )
  64         aBmp1.ReleaseAccess( pAcc1 );
  65 }
  66
  67 // ------------------------------------------------------------------------
  68
  69 void XBMReader::InitTable()
  70 {
  71     memset( pHexTable, 0, sizeof( short ) );
  72
  73     pHexTable['0'] = 0;
  74     pHexTable['1'] = 1;
  75     pHexTable['2'] = 2;
  76     pHexTable['3'] = 3;
  77     pHexTable['4'] = 4;
  78     pHexTable['5'] = 5;
  79     pHexTable['6'] = 6;
  80     pHexTable['7'] = 7;
  81     pHexTable['8'] = 8;
  82     pHexTable['9'] = 9;
  83     pHexTable['A'] = 10;
  84     pHexTable['B'] = 11;
  85     pHexTable['C'] = 12;
  86     pHexTable['D'] = 13;
  87     pHexTable['E'] = 14;
  88     pHexTable['F'] = 15;
  89     pHexTable['X'] = 0;
  90     pHexTable['a'] = 10;
  91     pHexTable['b'] = 11;
  92     pHexTable['c'] = 12;
  93     pHexTable['d'] = 13;
  94     pHexTable['e'] = 14;
  95     pHexTable['f'] = 15;
  96     pHexTable['x'] = 0;
  97     pHexTable[' '] =     -1;
  98     pHexTable[','] = -1;
  99     pHexTable['}'] = -1;
 100     pHexTable['\n'] = -1;
 101     pHexTable['\t'] = -1;
 102     pHexTable['\0'] = -1;
 103 }
 104
 105 // ------------------------------------------------------------------------
 106
 107 ByteString XBMReader::FindTokenLine( SvStream* pInStm, const char* pTok1,
 108                                  const char* pTok2, const char* pTok3 )
 109 {
 110     ByteString  aRet;
 111     long                nPos1;
 112     long                nPos2;
 113     long                nPos3;
 114
 115     bStatus = FALSE;
 116
 117     do
 118     {
 119         if( !pInStm->ReadLine( aRet ) )
 120             break;
 121
 122         if( pTok1 )
 123         {
 124             if( ( nPos1 = aRet.Search( pTok1 ) ) != STRING_NOTFOUND )
 125             {
 126                 bStatus = TRUE;
 127
 128                 if( pTok2 )
 129                 {
 130                     bStatus = FALSE;
 131
 132                     if( ( ( nPos2 = aRet.Search( pTok2 ) ) != STRING_NOTFOUND ) &&
 133                          ( nPos2 > nPos1 ) )
 134                     {
 135                         bStatus = TRUE;
 136
 137                         if( pTok3 )
 138                         {
 139                             bStatus = FALSE;
 140
 141                             if( ( ( nPos3 = aRet.Search( pTok3 ) ) != STRING_NOTFOUND ) && ( nPos3 > nPos2 ) )
 142                                 bStatus = TRUE;
 143                         }
 144                     }
 145                 }
 146             }
 147         }
 148     }
 149     while( !bStatus );
 150
 151     return aRet;
 152 }
 153
 154 // ------------------------------------------------------------------------
 155
 156 long XBMReader::ParseDefine( const sal_Char* pDefine )
 157 {
 158     long        nRet = 0;
 159     char*       pTmp = (char*) pDefine;
 160     unsigned char       cTmp;
 161
 162     // bis zum Ende gehen
 163     pTmp += ( strlen( pDefine ) - 1 );
 164     cTmp = *pTmp--;
 165
 166     // letzte Ziffer suchen
 167     while( pHexTable[ cTmp ] == -1 )
 168         cTmp = *pTmp--;
 169
 170     // bis vor die Zahl laufen
 171     while( pHexTable[ cTmp ] != -1 )
 172         cTmp = *pTmp--;
 173
 174     // auf Anfang der Zahl gehen
 175     pTmp += 2;
 176
 177     // Hex lesen
 178     if( ( pTmp[0] == '0' ) && ( ( pTmp[1] == 'X' ) || ( pTmp[1] == 'x' ) ) )
 179     {
 180         pTmp += 2;
 181         cTmp = *pTmp++;
 182
 183         while ( pHexTable[ cTmp ] != -1 )
 184         {
 185             nRet = ( nRet << 4 ) + pHexTable[ cTmp ];
 186             cTmp = *pTmp++;
 187         }
 188     }
 189     // Dezimal lesen
 190     else
 191     {
 192         cTmp = *pTmp++;
 193         while( ( cTmp >= '0' ) && ( cTmp <= '9' ) )
 194         {
 195             nRet = nRet * 10 + ( cTmp - '0' );
 196             cTmp = *pTmp++;
 197         }
 198     }
 199
 200     return nRet;
 201 }
 202
 203 // ------------------------------------------------------------------------
 204
 205 BOOL XBMReader::ParseData( SvStream* pInStm, const ByteString& aLastLine, XBMFormat eFormat )
 206 {
 207     ByteString          aLine;
 208     long                        nRow = 0;
 209     long                        nCol = 0;
 210     long                        nBits = ( eFormat == XBM10 ) ? 16 : 8;
 211     long                        nBit;
 212     USHORT                      nValue;
 213     USHORT                      nDigits;
 214     BOOL                        bFirstLine = TRUE;
 215
 216     while( nRow < nHeight )
 217     {
 218         if( bFirstLine )
 219         {
 220             xub_StrLen nPos;
 221
 222             // einfuehrende geschweifte Klammer loeschen
 223             if( (nPos = ( aLine = aLastLine ).Search( '{' ) ) != STRING_NOTFOUND )
 224                 aLine.Erase( 0, nPos + 1 );
 225
 226             bFirstLine = FALSE;
 227         }
 228         else if( !pInStm->ReadLine( aLine ) )
 229             break;
 230
 231         if( aLine.Len() )
 232         {
 233             const USHORT nCount = aLine.GetTokenCount( ',' );
 234
 235             for( USHORT i = 0; ( i < nCount ) && ( nRow < nHeight ); i++ )
 236             {
 237                 const ByteString        aToken( aLine.GetToken( i, ',' ) );
 238                 const xub_StrLen nLen = aToken.Len();
 239                 BOOL                            bProcessed = FALSE;
 240
 241                 nBit = nDigits = nValue = 0;
 242
 243                 for( xub_StrLen n = 0UL; n < nLen; n++ )
 244                 {
 245                     const unsigned char cChar = aToken.GetChar( n );
 246                     const short                 nTable = pHexTable[ cChar ];
 247
 248                     if( isxdigit( cChar ) || !nTable )
 249                     {
 250                         nValue = ( nValue << 4 ) + nTable;
 251                         nDigits++;
 252                         bProcessed = TRUE;
 253                     }
 254                     else if( ( nTable < 0 ) && nDigits )
 255                     {
 256                         bProcessed = TRUE;
 257                         break;
 258                     }
 259                 }
 260
 261                 if( bProcessed )
 262                 {
 263                     while( ( nCol < nWidth ) && ( nBit < nBits ) )
 264                         pAcc1->SetPixel( nRow, nCol++, ( nValue & ( 1 << nBit++ ) ) ? aBlack : aWhite );
 265
 266                     if( nCol == nWidth )
 267                         nCol = 0, nRow++;
 268                 }
 269             }
 270         }
 271     }
 272
 273     return TRUE;
 274 }
 275
 276 // ------------------------------------------------------------------------
 277
 278 ReadState XBMReader::ReadXBM( Graphic& rGraphic )
 279 {
 280     ReadState   eReadState;
 281     BYTE                cDummy;
 282
 283     // sehen, ob wir _alles_ lesen koennen
 284     rIStm.Seek( STREAM_SEEK_TO_END );
 285     rIStm >> cDummy;
 286
 287     // falls wir nicht alles lesen koennen
 288     // kehren wir zurueck und warten auf neue Daten
 289     if ( rIStm.GetError() != ERRCODE_IO_PENDING )
 290     {
 291         ByteString      aLine;
 292         int                     nValue;
 293
 294         rIStm.Seek( nLastPos );
 295         bStatus = FALSE;
 296         aLine = FindTokenLine( &rIStm, "#define", "_width" );
 297
 298         if ( bStatus )
 299         {
 300             if ( ( nValue = (int) ParseDefine( aLine.GetBuffer() ) ) > 0 )
 301             {
 302                 nWidth = nValue;
 303                 aLine = FindTokenLine( &rIStm, "#define", "_height" );
 304
 305                 // Falls die Hoehe nicht folgt, suchen wir noch
 306                 // einmal vom Anfang der Datei an
 307                 if ( !bStatus )
 308                 {
 309                     rIStm.Seek( nLastPos );
 310                     aLine = FindTokenLine( &rIStm, "#define", "_height" );
 311                 }
 312             }
 313             else
 314                 bStatus = FALSE;
 315
 316             if ( bStatus )
 317             {
 318                 if ( ( nValue = (int) ParseDefine( aLine.GetBuffer() ) ) > 0 )
 319                 {
 320                     nHeight = nValue;
 321                     aLine = FindTokenLine( &rIStm, "static", "_bits" );
 322
 323                     if ( bStatus )
 324                     {
 325                         XBMFormat eFormat = XBM10;
 326
 327                         if ( aLine.Search( "short" ) != STRING_NOTFOUND )
 328                             eFormat = XBM10;
 329                         else if ( aLine.Search( "char" ) != STRING_NOTFOUND )
 330                             eFormat = XBM11;
 331                         else
 332                             bStatus = FALSE;
 333
 334                         if ( bStatus && nWidth && nHeight )
 335                         {
 336                             aBmp1 = Bitmap( Size( nWidth, nHeight ), 1 );
 337                             pAcc1 = aBmp1.AcquireWriteAccess();
 338
 339                             if( pAcc1 )
 340                             {
 341                                 aWhite = pAcc1->GetBestMatchingColor( Color( COL_WHITE ) );
 342                                 aBlack = pAcc1->GetBestMatchingColor( Color( COL_BLACK ) );
 343                                 bStatus = ParseData( &rIStm, aLine, eFormat );
 344                             }
 345                             else
 346                                 bStatus = FALSE;
 347                         }
 348                     }
 349                 }
 350             }
 351         }
 352
 353         if( bStatus )
 354         {
 355             Bitmap aBlackBmp( Size( pAcc1->Width(), pAcc1->Height() ), 1 );
 356
 357             aBmp1.ReleaseAccess( pAcc1 ), pAcc1 = NULL;
 358             aBlackBmp.Erase( Color( COL_BLACK ) );
 359             rGraphic = BitmapEx( aBlackBmp, aBmp1 );
 360             eReadState = XBMREAD_OK;
 361         }
 362         else
 363             eReadState = XBMREAD_ERROR;
 364     }
 365     else
 366     {
 367         rIStm.ResetError();
 368         eReadState = XBMREAD_NEED_MORE;
 369     }
 370
 371     return eReadState;
 372 }
 373
 374 // -------------
 375 // - ImportXBM -
 376 // -------------
 377
 378 BOOL ImportXBM( SvStream& rStm, Graphic& rGraphic )
 379 {
 380     XBMReader*  pXBMReader = (XBMReader*) rGraphic.GetContext();
 381     ReadState   eReadState;
 382     BOOL                bRet = TRUE;
 383
 384     if( !pXBMReader )
 385         pXBMReader = new XBMReader( rStm );
 386
 387     rGraphic.SetContext( NULL );
 388     eReadState = pXBMReader->ReadXBM( rGraphic );
 389
 390     if( eReadState == XBMREAD_ERROR )
 391     {
 392         bRet = FALSE;
 393         delete pXBMReader;
 394     }
 395     else if( eReadState == XBMREAD_OK )
 396         delete pXBMReader;
 397     else
 398         rGraphic.SetContext( pXBMReader );
 399
 400     return bRet;
 401 }