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