svx/source/svrtf/rtfgrf.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: rtfgrf.cxx,v $
  10  * $Revision: 1.13 $
  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_svx.hxx"
  33
  34 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil -*- */
  35 #include <osl/endian.h>
  36 #include <tools/cachestr.hxx>
  37 #include <vcl/graph.hxx>
  38 #include <vcl/svapp.hxx>
  39 #include <svtools/rtfkeywd.hxx>
  40 #include <svtools/rtftoken.h>
  41 #include <svtools/filter.hxx>
  42 #include <svtools/wmf.hxx>
  43
  44 #include "impgrf.hxx"
  45 #include "svxrtf.hxx"
  46
  47
  48 #ifdef PRODUCT
  49 #undef DEBUG_JP
  50 #endif
  51
  52 #ifdef DEBUG_JP
  53
  54 #include <tools/fsys.hxx>
  55
  56 class GrfWindow : public WorkWindow
  57 {
  58     Graphic aGrf;
  59 public:
  60     GrfWindow( const Graphic& rGrf );
  61     virtual void    Paint( const Rectangle& rRect );
  62 };
  63
  64 GrfWindow::GrfWindow( const Graphic& rGrf )
  65     : WorkWindow( NULL ),
  66     aGrf( rGrf )
  67 {
  68     SetPosSizePixel( Point( 100, 0 ), Size( 300, 300 ));
  69     Show();
  70     Invalidate();
  71     Update();
  72 }
  73
  74 void GrfWindow::Paint( const Rectangle& )
  75 {
  76     aGrf.Draw( this, Point(0,0), GetSizePixel() );
  77 }
  78 #endif
  79
  80 static BYTE __FAR_DATA aPal1[ 2 * 4 ] = {
  81         0x00, 0x00, 0x00, 0x00,                         // Schwarz
  82         0xFF, 0xFF, 0xFF, 0x00                          // Weiss
  83 };
  84
  85 static BYTE __FAR_DATA aPal4[ 16 * 4 ] = {
  86         0x00, 0x00, 0x00, 0x00,
  87         0x80, 0x00, 0x00, 0x00,
  88         0x00, 0x80, 0x00, 0x00,
  89         0x80, 0x80, 0x00, 0x00,
  90         0x00, 0x00, 0x80, 0x00,
  91         0x80, 0x00, 0x80, 0x00,
  92         0x00, 0x80, 0x80, 0x00,
  93         0x80, 0x80, 0x80, 0x00,
  94         0xC0, 0xC0, 0xC0, 0x00,
  95         0xFF, 0x00, 0x00, 0x00,
  96         0x00, 0xFF, 0x00, 0x00,
  97         0xFF, 0xFF, 0x00, 0x00,
  98         0x00, 0x00, 0xFF, 0x00,
  99         0xFF, 0x00, 0xFF, 0x00,
 100         0x00, 0xFF, 0xFF, 0x00,
 101         0xFF, 0xFF, 0xFF, 0x00
 102 };
 103
 104 static BYTE __FAR_DATA aPal8[ 256 * 4 ] =
 105 {
 106 0x00, 0x00, 0x00, 0x00,   0x80, 0x00, 0x00, 0x00,   0x00, 0x92, 0x00, 0x00,
 107 0x80, 0x92, 0x00, 0x00,   0x00, 0x00, 0xAA, 0x00,   0x80, 0x00, 0xAA, 0x00,
 108 0x00, 0x92, 0xAA, 0x00,   0xC1, 0xC1, 0xC1, 0x00,   0xC9, 0xC9, 0xC9, 0x00,
 109 0xAA, 0xDB, 0xFF, 0x00,   0x00, 0x49, 0xAA, 0x00,   0x00, 0x49, 0xFF, 0x00,
 110 0x00, 0x6D, 0x00, 0x00,   0x00, 0x6D, 0x55, 0x00,   0x00, 0x6D, 0xAA, 0x00,
 111 0x00, 0x6D, 0xFF, 0x00,   0x00, 0x24, 0x00, 0x00,   0x00, 0x92, 0x55, 0x00,
 112 0x00, 0x24, 0xAA, 0x00,   0x00, 0x92, 0xFF, 0x00,   0x00, 0xB6, 0x00, 0x00,
 113 0x00, 0xB6, 0x55, 0x00,   0x00, 0xB6, 0xAA, 0x00,   0x00, 0xB6, 0xFF, 0x00,
 114 0x00, 0xDB, 0x00, 0x00,   0x00, 0xDB, 0x55, 0x00,   0x00, 0xDB, 0xAA, 0x00,
 115 0x00, 0xDB, 0xFF, 0x00,   0xFF, 0xDB, 0xAA, 0x00,   0x00, 0xFF, 0x55, 0x00,
 116 0x00, 0xFF, 0xAA, 0x00,   0xFF, 0xFF, 0xAA, 0x00,   0x2B, 0x00, 0x00, 0x00,
 117 0x2B, 0x00, 0x55, 0x00,   0x2B, 0x00, 0xAA, 0x00,   0x2B, 0x00, 0xFF, 0x00,
 118 0x2B, 0x24, 0x00, 0x00,   0x2B, 0x24, 0x55, 0x00,   0x2B, 0x24, 0xAA, 0x00,
 119 0x2B, 0x24, 0xFF, 0x00,   0x2B, 0x49, 0x00, 0x00,   0x2B, 0x49, 0x55, 0x00,
 120 0x2B, 0x49, 0xAA, 0x00,   0x2B, 0x49, 0xFF, 0x00,   0x2B, 0x6D, 0x00, 0x00,
 121 0x2B, 0x6D, 0x55, 0x00,   0x2B, 0x6D, 0xAA, 0x00,   0x2B, 0x6D, 0xFF, 0x00,
 122 0x2B, 0x92, 0x00, 0x00,   0x2B, 0x92, 0x55, 0x00,   0x2B, 0x92, 0xAA, 0x00,
 123 0x2B, 0x92, 0xFF, 0x00,   0x2B, 0xB6, 0x00, 0x00,   0x2B, 0xB6, 0x55, 0x00,
 124 0x2B, 0xB6, 0xAA, 0x00,   0x2B, 0xB6, 0xFF, 0x00,   0x2B, 0xDB, 0x00, 0x00,
 125 0x2B, 0xDB, 0x55, 0x00,   0x2B, 0xDB, 0xAA, 0x00,   0x2B, 0xDB, 0xFF, 0x00,
 126 0x2B, 0xFF, 0x00, 0x00,   0x2B, 0xFF, 0x55, 0x00,   0x2B, 0xFF, 0xAA, 0x00,
 127 0x2B, 0xFF, 0xFF, 0x00,   0x55, 0x00, 0x00, 0x00,   0x55, 0x00, 0x55, 0x00,
 128 0x55, 0x00, 0xAA, 0x00,   0x55, 0x00, 0xFF, 0x00,   0x55, 0x24, 0x00, 0x00,
 129 0x55, 0x24, 0x55, 0x00,   0x55, 0x24, 0xAA, 0x00,   0x55, 0x24, 0xFF, 0x00,
 130 0x55, 0x49, 0x00, 0x00,   0x55, 0x49, 0x55, 0x00,   0x55, 0x49, 0xAA, 0x00,
 131 0x55, 0x49, 0xFF, 0x00,   0x55, 0x6D, 0x00, 0x00,   0x55, 0x6D, 0x55, 0x00,
 132 0x55, 0x6D, 0xAA, 0x00,   0x55, 0x6D, 0xFF, 0x00,   0x55, 0x92, 0x00, 0x00,
 133 0x55, 0x92, 0x55, 0x00,   0x55, 0x92, 0xAA, 0x00,   0x55, 0x92, 0xFF, 0x00,
 134 0x55, 0xB6, 0x00, 0x00,   0x55, 0xB6, 0x55, 0x00,   0x55, 0xB6, 0xAA, 0x00,
 135 0x55, 0xB6, 0xFF, 0x00,   0x55, 0xDB, 0x00, 0x00,   0x55, 0xDB, 0x55, 0x00,
 136 0x55, 0xDB, 0xAA, 0x00,   0x55, 0xDB, 0xFF, 0x00,   0x55, 0xFF, 0x00, 0x00,
 137 0x55, 0xFF, 0x55, 0x00,   0x55, 0xFF, 0xAA, 0x00,   0x55, 0xFF, 0xFF, 0x00,
 138 0x00, 0x00, 0x55, 0x00,   0x80, 0x00, 0x55, 0x00,   0x00, 0x24, 0x55, 0x00,
 139 0x80, 0x00, 0xFF, 0x00,   0x80, 0x24, 0x00, 0x00,   0x80, 0x24, 0x55, 0x00,
 140 0x80, 0x24, 0xAA, 0x00,   0x80, 0x24, 0xFF, 0x00,   0x80, 0x49, 0x00, 0x00,
 141 0x80, 0x49, 0x55, 0x00,   0x80, 0x49, 0xAA, 0x00,   0x80, 0x49, 0xFF, 0x00,
 142 0x80, 0x6D, 0x00, 0x00,   0x80, 0x6D, 0x55, 0x00,   0x80, 0x6D, 0xAA, 0x00,
 143 0x80, 0x6D, 0xFF, 0x00,   0x08, 0x08, 0x08, 0x00,   0x0F, 0x0F, 0x0F, 0x00,
 144 0x17, 0x17, 0x17, 0x00,   0x1F, 0x1F, 0x1F, 0x00,   0x27, 0x27, 0x27, 0x00,
 145 0x2E, 0x2E, 0x2E, 0x00,   0x36, 0x36, 0x36, 0x00,   0x3E, 0x3E, 0x3E, 0x00,
 146 0x46, 0x46, 0x46, 0x00,   0x4D, 0x4D, 0x4D, 0x00,   0x55, 0x55, 0x55, 0x00,
 147 0x5D, 0x5D, 0x5D, 0x00,   0x64, 0x64, 0x64, 0x00,   0x6C, 0x6C, 0x6C, 0x00,
 148 0x74, 0x74, 0x74, 0x00,   0x7C, 0x7C, 0x7C, 0x00,   0xFF, 0xDB, 0x00, 0x00,
 149 0x8B, 0x8B, 0x8B, 0x00,   0x93, 0x93, 0x93, 0x00,   0x9B, 0x9B, 0x9B, 0x00,
 150 0xFF, 0xB6, 0xFF, 0x00,   0xAA, 0xAA, 0xAA, 0x00,   0xB2, 0xB2, 0xB2, 0x00,
 151 0xB9, 0xB9, 0xB9, 0x00,   0x00, 0x24, 0xFF, 0x00,   0x00, 0x49, 0x00, 0x00,
 152 0xD1, 0xD1, 0xD1, 0x00,   0xD8, 0xD8, 0xD8, 0x00,   0xE0, 0xE0, 0xE0, 0x00,
 153 0xE8, 0xE8, 0xE8, 0x00,   0xF0, 0xF0, 0xF0, 0x00,   0xFF, 0xB6, 0xAA, 0x00,
 154 0xFF, 0xDB, 0xFF, 0x00,   0x80, 0x92, 0x55, 0x00,   0x80, 0x92, 0xAA, 0x00,
 155 0x80, 0x92, 0xFF, 0x00,   0x80, 0xB6, 0x00, 0x00,   0x80, 0xB6, 0x55, 0x00,
 156 0x80, 0xB6, 0xAA, 0x00,   0x80, 0xB6, 0xFF, 0x00,   0x80, 0xDB, 0x00, 0x00,
 157 0x80, 0xDB, 0x55, 0x00,   0x80, 0xDB, 0xAA, 0x00,   0x80, 0xDB, 0xFF, 0x00,
 158 0x80, 0xFF, 0x00, 0x00,   0x80, 0xFF, 0x55, 0x00,   0x80, 0xFF, 0xAA, 0x00,
 159 0x80, 0xFF, 0xFF, 0x00,   0xAA, 0x00, 0x00, 0x00,   0xAA, 0x00, 0x55, 0x00,
 160 0xAA, 0x00, 0xAA, 0x00,   0xAA, 0x00, 0xFF, 0x00,   0xAA, 0x24, 0x00, 0x00,
 161 0xAA, 0x24, 0x55, 0x00,   0xAA, 0x24, 0xAA, 0x00,   0xAA, 0x24, 0xFF, 0x00,
 162 0xAA, 0x49, 0x00, 0x00,   0xAA, 0x49, 0x55, 0x00,   0xAA, 0x49, 0xAA, 0x00,
 163 0xAA, 0x49, 0xFF, 0x00,   0xAA, 0x6D, 0x00, 0x00,   0xAA, 0x6D, 0x55, 0x00,
 164 0xAA, 0x6D, 0xAA, 0x00,   0xAA, 0x6D, 0xFF, 0x00,   0xAA, 0x92, 0x00, 0x00,
 165 0xAA, 0x92, 0x55, 0x00,   0xAA, 0x92, 0xAA, 0x00,   0xAA, 0x92, 0xFF, 0x00,
 166 0xAA, 0xB6, 0x00, 0x00,   0xAA, 0xB6, 0x55, 0x00,   0xAA, 0xB6, 0xAA, 0x00,
 167 0xAA, 0xB6, 0xFF, 0x00,   0xAA, 0xDB, 0x00, 0x00,   0xAA, 0xDB, 0x55, 0x00,
 168 0xAA, 0xDB, 0xAA, 0x00,   0x00, 0x49, 0x55, 0x00,   0xAA, 0xFF, 0x00, 0x00,
 169 0xAA, 0xFF, 0x55, 0x00,   0xAA, 0xFF, 0xAA, 0x00,   0xAA, 0xFF, 0xFF, 0x00,
 170 0xD5, 0x00, 0x00, 0x00,   0xD5, 0x00, 0x55, 0x00,   0xD5, 0x00, 0xAA, 0x00,
 171 0xD5, 0x00, 0xFF, 0x00,   0xD5, 0x24, 0x00, 0x00,   0xD5, 0x24, 0x55, 0x00,
 172 0xD5, 0x24, 0xAA, 0x00,   0xD5, 0x24, 0xFF, 0x00,   0xD5, 0x49, 0x00, 0x00,
 173 0xD5, 0x49, 0x55, 0x00,   0xD5, 0x49, 0xAA, 0x00,   0xD5, 0x49, 0xFF, 0x00,
 174 0xD5, 0x6D, 0x00, 0x00,   0xD5, 0x6D, 0x55, 0x00,   0xD5, 0x6D, 0xAA, 0x00,
 175 0xD5, 0x6D, 0xFF, 0x00,   0xD5, 0x92, 0x00, 0x00,   0xD5, 0x92, 0x55, 0x00,
 176 0xD5, 0x92, 0xAA, 0x00,   0xD5, 0x92, 0xFF, 0x00,   0xD5, 0xB6, 0x00, 0x00,
 177 0xD5, 0xB6, 0x55, 0x00,   0xD5, 0xB6, 0xAA, 0x00,   0xD5, 0xB6, 0xFF, 0x00,
 178 0xD5, 0xDB, 0x00, 0x00,   0xD5, 0xDB, 0x55, 0x00,   0xD5, 0xDB, 0xAA, 0x00,
 179 0xD5, 0xDB, 0xFF, 0x00,   0xD5, 0xFF, 0x00, 0x00,   0xD5, 0xFF, 0x55, 0x00,
 180 0xD5, 0xFF, 0xAA, 0x00,   0xD5, 0xFF, 0xFF, 0x00,   0xFF, 0xDB, 0x55, 0x00,
 181 0xFF, 0x00, 0x55, 0x00,   0xFF, 0x00, 0xAA, 0x00,   0xFF, 0xFF, 0x55, 0x00,
 182 0xFF, 0x24, 0x00, 0x00,   0xFF, 0x24, 0x55, 0x00,   0xFF, 0x24, 0xAA, 0x00,
 183 0xFF, 0x24, 0xFF, 0x00,   0xFF, 0x49, 0x00, 0x00,   0xFF, 0x49, 0x55, 0x00,
 184 0xFF, 0x49, 0xAA, 0x00,   0xFF, 0x49, 0xFF, 0x00,   0xFF, 0x6D, 0x00, 0x00,
 185 0xFF, 0x6D, 0x55, 0x00,   0xFF, 0x6D, 0xAA, 0x00,   0xFF, 0x6D, 0xFF, 0x00,
 186 0xFF, 0x92, 0x00, 0x00,   0xFF, 0x92, 0x55, 0x00,   0xFF, 0x92, 0xAA, 0x00,
 187 0xFF, 0x92, 0xFF, 0x00,   0xFF, 0xB6, 0x00, 0x00,   0xFF, 0xB6, 0x55, 0x00,
 188 0xF7, 0xF7, 0xF7, 0x00,   0xA2, 0xA2, 0xA2, 0x00,   0x83, 0x83, 0x83, 0x00,
 189 0xFF, 0x00, 0x00, 0x00,   0x00, 0xFF, 0x00, 0x00,   0xFF, 0xFF, 0x00, 0x00,
 190 0x00, 0x00, 0xFF, 0x00,   0xFF, 0x00, 0xFF, 0x00,   0x00, 0xFF, 0xFF, 0x00,
 191 0xFF, 0xFF, 0xFF, 0x00
 192 };
 193
 194
 195 /* \f */
 196
 197
 198 inline long SwapLong( long n )
 199 {
 200 #ifndef OSL_LITENDIAN
 201     return SWAPLONG( n );
 202 #else
 203     return n;
 204 #endif
 205 }
 206
 207 inline short SwapShort( short n )
 208 {
 209 #ifndef OSL_LITENDIAN
 210     return SWAPSHORT( n );
 211 #else
 212     return n;
 213 #endif
 214 }
 215
 216
 217 static void WriteBMPHeader( SvStream& rStream,
 218                             const SvxRTFPictureType& rPicType )
 219 {
 220     ULONG n4Width = rPicType.nWidth;
 221     ULONG n4Height = rPicType.nHeight;
 222     USHORT n4ColBits = rPicType.nBitsPerPixel;
 223
 224     USHORT nColors = (1 << n4ColBits);  // Anzahl der Farben ( 1, 16, 256 )
 225     USHORT nWdtOut = rPicType.nWidthBytes;
 226     if( !nWdtOut )
 227         nWdtOut = (USHORT)((( n4Width * n4ColBits + 31 ) / 32 ) * 4 );
 228
 229     long nOffset = 14 + 40;     // BMP_FILE_HD_SIZ + sizeof(*pBmpInfo);
 230     if( 256 >= nColors )
 231         nOffset += nColors * 4;
 232     long nSize = nOffset + nWdtOut * n4Height;
 233     rStream << "BM"                                             // = "BM"
 234             << SwapLong(nSize)          // Filesize in Bytes
 235             << SwapShort(0)             // Reserviert
 236             << SwapShort(0)             // Reserviert
 237             << SwapLong(nOffset);       // Offset?
 238
 239     rStream     << SwapLong(40)                         // sizeof( BmpInfo )
 240             << SwapLong(n4Width)
 241             << SwapLong(n4Height)
 242             << (USHORT)1
 243             << n4ColBits
 244             << SwapLong(0)
 245             << SwapLong(0)
 246             << SwapLong( rPicType.nGoalWidth
 247                         ? rPicType.nGoalWidth * 1000L / 254L
 248                         : 0 )         // DPI in Pixel per Meter
 249             << SwapLong( rPicType.nGoalHeight
 250                         ? rPicType.nGoalHeight * 1000L / 254L      // dito
 251                         : 0 )
 252             << SwapLong(0)
 253             << SwapLong(0);
 254
 255
 256     switch( rPicType.nBitsPerPixel )
 257     {
 258     case 1:             rStream.Write( aPal1, sizeof( aPal1 )); break;
 259     case 4:             rStream.Write( aPal4, sizeof( aPal4 )); break;
 260     case 8:             rStream.Write( aPal8, sizeof( aPal8 )); break;
 261     }
 262 }
 263
 264 /* \f */
 265
 266         // wandel die ASCII-HexCodes in binaere Zeichen um. Werden
 267         // ungueltige Daten gefunden (Zeichen ausser 0-9|a-f|A-F, so
 268         // wird USHRT_MAX returnt, ansonsten die Anzahl der umgewandelten Ze.
 269 xub_StrLen SvxRTFParser::HexToBin( String& rToken )
 270 {
 271     // dann mache aus den Hex-Werten mal "Binare Daten"
 272     // (missbrauche den String als temp Buffer)
 273     if( rToken.Len() & 1 )              // ungerade Anzahl, mit 0 auffuellen
 274         rToken += '0';
 275
 276     xub_StrLen n, nLen;
 277     sal_Unicode nVal;
 278     BOOL bValidData = TRUE;
 279     const sal_Unicode* pStr = rToken.GetBufferAccess();
 280     sal_Char* pData = (sal_Char*)pStr;
 281     for( n = 0, nLen = rToken.Len(); n < nLen; ++n, ++pStr )
 282     {
 283         if( ((nVal = *pStr) >= '0') && ( nVal <= '9') )
 284             nVal -= '0';
 285         else if( (nVal >= 'A') && (nVal <= 'F') )
 286             nVal -= 'A' - 10;
 287         else if( (nVal >= 'a') && (nVal <= 'f') )
 288             nVal -= 'a' - 10;
 289         else
 290         {
 291             DBG_ASSERT( !this, "ungueltiger Hex-Wert" );
 292             bValidData = FALSE;
 293             break;
 294         }
 295
 296         if( n & 1 )
 297             *(pData++) |= nVal & 0x0f;
 298         else
 299             *(pData) = sal::static_int_cast< char >( ( nVal << 4 ) & 0xf0 );
 300     }
 301     // the len div 2, because 2 character are one byte
 302     return bValidData ? nLen / 2  : STRING_NOTFOUND;
 303 }
 304
 305 BOOL SvxRTFParser::ReadBmpData( Graphic& rGrf, SvxRTFPictureType& rPicType )
 306 {
 307     // die alten Daten loeschen
 308     rGrf.Clear();
 309 //      ULONG nBmpSize = 0;
 310
 311     rtl_TextEncoding eOldEnc = GetSrcEncoding();
 312     SetSrcEncoding( RTL_TEXTENCODING_MS_1252 );
 313
 314     const sal_Char* pFilterNm = 0;
 315     SvCacheStream* pTmpFile = 0;
 316
 317     int nToken = 0;
 318     bool bValidBmp = true, bFirstTextToken = true;
 319     int _nOpenBrakets = 1,              // die erste wurde schon vorher erkannt !!
 320         nValidDataBraket = 1;
 321
 322     if( RTF_SHPPICT == GetStackPtr(0)->nTokenId )
 323         ++nValidDataBraket;
 324
 325     while( _nOpenBrakets && IsParserWorking() && bValidBmp )
 326     {
 327         nToken = GetNextToken();
 328         USHORT nVal = USHORT( nTokenValue );
 329         switch( nToken )
 330         {
 331         case '}':               --_nOpenBrakets;        break;
 332         case '{':
 333             {
 334                 if( RTF_IGNOREFLAG != GetNextToken() )
 335                     nToken = SkipToken( -1 );
 336                 else if( RTF_UNKNOWNCONTROL != GetNextToken() )
 337                     nToken = SkipToken( -2 );
 338                 else
 339                 {
 340                     // gleich herausfiltern
 341                     ReadUnknownData();
 342                     nToken = GetNextToken();
 343                     if( '}' != nToken )
 344                         eState = SVPAR_ERROR;
 345                     break;
 346                 }
 347                 ++_nOpenBrakets;
 348             }
 349             break;
 350
 351         case RTF_MACPICT:
 352             {
 353                 rPicType.eStyle = SvxRTFPictureType::MAC_QUICKDRAW;
 354                 // Mac-Pict bekommt einen leeren Header voran
 355                 pTmpFile = new SvCacheStream;
 356                 ByteString aStr;
 357                 aStr.Fill( 512, '\0' );
 358                 pTmpFile->Write( aStr.GetBuffer(), aStr.Len() );
 359                 pFilterNm = "PCT";
 360             }
 361             break;
 362
 363         case RTF_EMFBLIP:
 364         case RTF_WMETAFILE:
 365         case RTF_PNGBLIP:
 366         case RTF_JPEGBLIP:
 367         case RTF_WBITMAP:
 368         case RTF_OSMETAFILE:
 369         case RTF_DIBITMAP:
 370             {
 371                 switch( nToken )
 372                 {
 373                 case RTF_EMFBLIP:
 374                     rPicType.eStyle = SvxRTFPictureType::ENHANCED_MF;
 375                     pFilterNm = "EMF";
 376                     break;
 377                 case RTF_WMETAFILE:
 378                     rPicType.eStyle = SvxRTFPictureType::WIN_METAFILE;
 379                     pFilterNm = "WMF";
 380                     break;
 381                 case RTF_PNGBLIP:
 382                     rPicType.eStyle = SvxRTFPictureType::RTF_PNG;
 383                     pFilterNm = "PNG";
 384                     break;
 385                 case RTF_JPEGBLIP:
 386                     rPicType.eStyle = SvxRTFPictureType::RTF_JPG;
 387                     pFilterNm = "JPG";
 388                     break;
 389
 390                 case RTF_WBITMAP:
 391                     rPicType.eStyle = SvxRTFPictureType::RTF_BITMAP;
 392                     break;
 393                 case RTF_OSMETAFILE:
 394                     rPicType.eStyle = SvxRTFPictureType::OS2_METAFILE;
 395                     break;
 396                 case RTF_DIBITMAP:
 397                     rPicType.eStyle = SvxRTFPictureType::RTF_DI_BMP;
 398                     break;
 399                 }
 400
 401                 rPicType.nType = nVal;
 402                 pTmpFile = new SvCacheStream;
 403             }
 404             break;
 405
 406         case RTF_PICW:                          rPicType.nWidth = nVal; break;
 407         case RTF_PICH:                          rPicType.nHeight = nVal; break;
 408         case RTF_WBMBITSPIXEL:          rPicType.nBitsPerPixel = nVal; break;
 409         case RTF_WBMPLANES:             rPicType.nPlanes = nVal; break;
 410         case RTF_WBMWIDTHBYTES:         rPicType.nWidthBytes = nVal; break;
 411         case RTF_PICWGOAL:                      rPicType.nGoalWidth = nVal; break;
 412         case RTF_PICHGOAL:                      rPicType.nGoalHeight = nVal; break;
 413         case RTF_BIN:
 414             rPicType.nMode = SvxRTFPictureType::BINARY_MODE;
 415             rPicType.uPicLen = nTokenValue;
 416             if (rPicType.uPicLen)
 417             {
 418                 ULONG nPos = rStrm.Tell();
 419                 nPos = nPos;
 420                 rStrm.SeekRel(-1);
 421                 sal_uInt8 aData[4096];
 422                 ULONG nSize = sizeof(aData);
 423
 424                 while (rPicType.uPicLen > 0)
 425                 {
 426                     if (rPicType.uPicLen < nSize)
 427                         nSize = rPicType.uPicLen;
 428
 429                     rStrm.Read(aData, nSize);
 430                     pTmpFile->Write(aData, nSize);
 431                     rPicType.uPicLen -= nSize;
 432                 }
 433                 nNextCh = GetNextChar();
 434                 bValidBmp = !pTmpFile->GetError();
 435                 nPos = rStrm.Tell();
 436                 nPos = nPos;
 437             }
 438             break;
 439         case RTF_PICSCALEX:                     rPicType.nScalX = nVal; break;
 440         case RTF_PICSCALEY:                     rPicType.nScalY = nVal; break;
 441         case RTF_PICSCALED:             break;
 442
 443         case RTF_PICCROPT:                      rPicType.nCropT = (short)nTokenValue; break;
 444         case RTF_PICCROPB:                      rPicType.nCropB = (short)nTokenValue; break;
 445         case RTF_PICCROPL:                      rPicType.nCropL = (short)nTokenValue; break;
 446         case RTF_PICCROPR:                      rPicType.nCropR = (short)nTokenValue; break;
 447
 448         case RTF_TEXTTOKEN:
 449             // JP 26.06.98: Bug #51719# - nur TextToken auf 1. Ebene
 450             //                          auswerten. Alle anderen sind irgendwelche
 451             //                          nicht auszuwertende Daten
 452             if( nValidDataBraket != _nOpenBrakets )
 453                 break;
 454
 455             if( bFirstTextToken )
 456             {
 457                 switch( rPicType.eStyle )
 458                 {
 459                 case SvxRTFPictureType::RTF_BITMAP:
 460                     // erstmal die Header und Info-Struktur schreiben
 461                     if( pTmpFile )
 462                         ::WriteBMPHeader( *pTmpFile, rPicType );
 463                     break;
 464                 default:
 465                     break;
 466                 }
 467                 bFirstTextToken = FALSE;
 468             }
 469
 470             if( pTmpFile && SvxRTFPictureType::HEX_MODE == rPicType.nMode )
 471             {
 472                 xub_StrLen nTokenLen = HexToBin( aToken );
 473                 if( STRING_NOTFOUND == nTokenLen )
 474                     bValidBmp = FALSE;
 475                 else
 476                 {
 477                     pTmpFile->Write( (sal_Char*)aToken.GetBuffer(),
 478                                         nTokenLen );
 479                     bValidBmp = 0 == pTmpFile->GetError();
 480                 }
 481             }
 482             break;
 483         }
 484     }
 485
 486     if (pTmpFile)
 487     {
 488         //#i20775#
 489         if (pTmpFile->Tell() == 0)
 490             bValidBmp = false;
 491
 492         if( bValidBmp )
 493         {
 494             GraphicFilter* pGF = ::GetGrfFilter();
 495             USHORT nImportFilter = GRFILTER_FORMAT_DONTKNOW;
 496
 497             if( pFilterNm )
 498             {
 499                 String sTmp;
 500                 for( USHORT n = pGF->GetImportFormatCount(); n; )
 501                 {
 502                     sTmp = pGF->GetImportFormatShortName( --n );
 503                     if( sTmp.EqualsAscii( pFilterNm ))
 504                     {
 505                         nImportFilter = n;
 506                         break;
 507                     }
 508                 }
 509             }
 510
 511             String sTmpStr;
 512                         WMF_APMFILEHEADER aAPMHeader;
 513                         aAPMHeader.left=0;
 514                         aAPMHeader.top=0;
 515                         aAPMHeader.right=rPicType.nWidth;
 516                         aAPMHeader.bottom=rPicType.nHeight;
 517
 518                         WMF_APMFILEHEADER *pAPMHeader=(aAPMHeader.right>0 && aAPMHeader.bottom>0?&aAPMHeader:NULL);
 519             pTmpFile->Seek( STREAM_SEEK_TO_BEGIN );
 520                         bValidBmp = 0 == pGF->ImportGraphic( rGrf, sTmpStr, *pTmpFile, nImportFilter, NULL, 0, pAPMHeader );
 521         }
 522         delete pTmpFile;
 523     }
 524
 525     if( !bValidBmp )
 526     {
 527         rGrf.Clear();
 528         //TODO  If nToken were not initialized to 0 above, it would potentially
 529         // be used uninitialized here (if IsParserWorking() is false at the
 530         // start of the while loop above):
 531         if( '}' != nToken )
 532             SkipGroup();
 533     }
 534     else
 535     {
 536         switch( rPicType.eStyle )
 537         {
 538 //??            ENHANCED_MF,            // in den Pict.Daten steht ein Enhanced-Metafile
 539         case SvxRTFPictureType::RTF_PNG:
 540         case SvxRTFPictureType::RTF_JPG:
 541             {
 542                 const MapMode aMap( MAP_100TH_MM );
 543                  Size aSize( rGrf.GetPrefSize() );
 544                 if( MAP_PIXEL == rGrf.GetPrefMapMode().GetMapUnit() )
 545                     aSize = Application::GetDefaultDevice()->PixelToLogic(
 546                                         aSize, aMap );
 547                 else
 548                     aSize = OutputDevice::LogicToLogic( aSize,
 549                                         rGrf.GetPrefMapMode(), aMap );
 550                 rPicType.nWidth = sal::static_int_cast< USHORT >(aSize.Width());
 551                 rPicType.nHeight = sal::static_int_cast< USHORT >(
 552                     aSize.Height());
 553             }
 554             break;
 555         default:
 556             break;
 557         }
 558
 559 #ifdef DEBUG_JP
 560         new GrfWindow( rGrf );
 561 #endif
 562     }
 563     SetSrcEncoding( eOldEnc );
 564
 565     SkipToken( -1 );            // die schliesende Klammer wird "oben" ausgewertet
 566     return bValidBmp;
 567 }
 568
 569 /* vi:set tabstop=4 shiftwidth=4 expandtab: */