Branch data Line data Source code
1 : : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : : /*************************************************************************
3 : : *
4 : : * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 : : *
6 : : * Copyright 2000, 2010 Oracle and/or its affiliates.
7 : : *
8 : : * OpenOffice.org - a multi-platform office productivity suite
9 : : *
10 : : * This file is part of OpenOffice.org.
11 : : *
12 : : * OpenOffice.org is free software: you can redistribute it and/or modify
13 : : * it under the terms of the GNU Lesser General Public License version 3
14 : : * only, as published by the Free Software Foundation.
15 : : *
16 : : * OpenOffice.org is distributed in the hope that it will be useful,
17 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 : : * GNU Lesser General Public License version 3 for more details
20 : : * (a copy is included in the LICENSE file that accompanied this code).
21 : : *
22 : : * You should have received a copy of the GNU Lesser General Public License
23 : : * version 3 along with OpenOffice.org. If not, see
24 : : * <http://www.openoffice.org/license.html>
25 : : * for a copy of the LGPLv3 License.
26 : : *
27 : : ************************************************************************/
28 : :
29 : :
30 : : #include <boost/scoped_ptr.hpp>
31 : :
32 : : #include <osl/endian.h>
33 : : #include <tools/cachestr.hxx>
34 : : #include <vcl/graph.hxx>
35 : : #include <vcl/svapp.hxx>
36 : : #include <svtools/rtfkeywd.hxx>
37 : : #include <svtools/rtftoken.h>
38 : : #include <svtools/filter.hxx>
39 : : #include <svtools/wmf.hxx>
40 : :
41 : : #include <editeng/svxrtf.hxx>
42 : :
43 : : #include <vector>
44 : :
45 : : using namespace ::rtl;
46 : :
47 : : static sal_uInt8 aPal1[ 2 * 4 ] = {
48 : : 0x00, 0x00, 0x00, 0x00, // Black
49 : : 0xFF, 0xFF, 0xFF, 0x00 // White
50 : : };
51 : :
52 : : static sal_uInt8 aPal4[ 16 * 4 ] = {
53 : : 0x00, 0x00, 0x00, 0x00,
54 : : 0x80, 0x00, 0x00, 0x00,
55 : : 0x00, 0x80, 0x00, 0x00,
56 : : 0x80, 0x80, 0x00, 0x00,
57 : : 0x00, 0x00, 0x80, 0x00,
58 : : 0x80, 0x00, 0x80, 0x00,
59 : : 0x00, 0x80, 0x80, 0x00,
60 : : 0x80, 0x80, 0x80, 0x00,
61 : : 0xC0, 0xC0, 0xC0, 0x00,
62 : : 0xFF, 0x00, 0x00, 0x00,
63 : : 0x00, 0xFF, 0x00, 0x00,
64 : : 0xFF, 0xFF, 0x00, 0x00,
65 : : 0x00, 0x00, 0xFF, 0x00,
66 : : 0xFF, 0x00, 0xFF, 0x00,
67 : : 0x00, 0xFF, 0xFF, 0x00,
68 : : 0xFF, 0xFF, 0xFF, 0x00
69 : : };
70 : :
71 : : static sal_uInt8 aPal8[ 256 * 4 ] =
72 : : {
73 : : 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x92, 0x00, 0x00,
74 : : 0x80, 0x92, 0x00, 0x00, 0x00, 0x00, 0xAA, 0x00, 0x80, 0x00, 0xAA, 0x00,
75 : : 0x00, 0x92, 0xAA, 0x00, 0xC1, 0xC1, 0xC1, 0x00, 0xC9, 0xC9, 0xC9, 0x00,
76 : : 0xAA, 0xDB, 0xFF, 0x00, 0x00, 0x49, 0xAA, 0x00, 0x00, 0x49, 0xFF, 0x00,
77 : : 0x00, 0x6D, 0x00, 0x00, 0x00, 0x6D, 0x55, 0x00, 0x00, 0x6D, 0xAA, 0x00,
78 : : 0x00, 0x6D, 0xFF, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x92, 0x55, 0x00,
79 : : 0x00, 0x24, 0xAA, 0x00, 0x00, 0x92, 0xFF, 0x00, 0x00, 0xB6, 0x00, 0x00,
80 : : 0x00, 0xB6, 0x55, 0x00, 0x00, 0xB6, 0xAA, 0x00, 0x00, 0xB6, 0xFF, 0x00,
81 : : 0x00, 0xDB, 0x00, 0x00, 0x00, 0xDB, 0x55, 0x00, 0x00, 0xDB, 0xAA, 0x00,
82 : : 0x00, 0xDB, 0xFF, 0x00, 0xFF, 0xDB, 0xAA, 0x00, 0x00, 0xFF, 0x55, 0x00,
83 : : 0x00, 0xFF, 0xAA, 0x00, 0xFF, 0xFF, 0xAA, 0x00, 0x2B, 0x00, 0x00, 0x00,
84 : : 0x2B, 0x00, 0x55, 0x00, 0x2B, 0x00, 0xAA, 0x00, 0x2B, 0x00, 0xFF, 0x00,
85 : : 0x2B, 0x24, 0x00, 0x00, 0x2B, 0x24, 0x55, 0x00, 0x2B, 0x24, 0xAA, 0x00,
86 : : 0x2B, 0x24, 0xFF, 0x00, 0x2B, 0x49, 0x00, 0x00, 0x2B, 0x49, 0x55, 0x00,
87 : : 0x2B, 0x49, 0xAA, 0x00, 0x2B, 0x49, 0xFF, 0x00, 0x2B, 0x6D, 0x00, 0x00,
88 : : 0x2B, 0x6D, 0x55, 0x00, 0x2B, 0x6D, 0xAA, 0x00, 0x2B, 0x6D, 0xFF, 0x00,
89 : : 0x2B, 0x92, 0x00, 0x00, 0x2B, 0x92, 0x55, 0x00, 0x2B, 0x92, 0xAA, 0x00,
90 : : 0x2B, 0x92, 0xFF, 0x00, 0x2B, 0xB6, 0x00, 0x00, 0x2B, 0xB6, 0x55, 0x00,
91 : : 0x2B, 0xB6, 0xAA, 0x00, 0x2B, 0xB6, 0xFF, 0x00, 0x2B, 0xDB, 0x00, 0x00,
92 : : 0x2B, 0xDB, 0x55, 0x00, 0x2B, 0xDB, 0xAA, 0x00, 0x2B, 0xDB, 0xFF, 0x00,
93 : : 0x2B, 0xFF, 0x00, 0x00, 0x2B, 0xFF, 0x55, 0x00, 0x2B, 0xFF, 0xAA, 0x00,
94 : : 0x2B, 0xFF, 0xFF, 0x00, 0x55, 0x00, 0x00, 0x00, 0x55, 0x00, 0x55, 0x00,
95 : : 0x55, 0x00, 0xAA, 0x00, 0x55, 0x00, 0xFF, 0x00, 0x55, 0x24, 0x00, 0x00,
96 : : 0x55, 0x24, 0x55, 0x00, 0x55, 0x24, 0xAA, 0x00, 0x55, 0x24, 0xFF, 0x00,
97 : : 0x55, 0x49, 0x00, 0x00, 0x55, 0x49, 0x55, 0x00, 0x55, 0x49, 0xAA, 0x00,
98 : : 0x55, 0x49, 0xFF, 0x00, 0x55, 0x6D, 0x00, 0x00, 0x55, 0x6D, 0x55, 0x00,
99 : : 0x55, 0x6D, 0xAA, 0x00, 0x55, 0x6D, 0xFF, 0x00, 0x55, 0x92, 0x00, 0x00,
100 : : 0x55, 0x92, 0x55, 0x00, 0x55, 0x92, 0xAA, 0x00, 0x55, 0x92, 0xFF, 0x00,
101 : : 0x55, 0xB6, 0x00, 0x00, 0x55, 0xB6, 0x55, 0x00, 0x55, 0xB6, 0xAA, 0x00,
102 : : 0x55, 0xB6, 0xFF, 0x00, 0x55, 0xDB, 0x00, 0x00, 0x55, 0xDB, 0x55, 0x00,
103 : : 0x55, 0xDB, 0xAA, 0x00, 0x55, 0xDB, 0xFF, 0x00, 0x55, 0xFF, 0x00, 0x00,
104 : : 0x55, 0xFF, 0x55, 0x00, 0x55, 0xFF, 0xAA, 0x00, 0x55, 0xFF, 0xFF, 0x00,
105 : : 0x00, 0x00, 0x55, 0x00, 0x80, 0x00, 0x55, 0x00, 0x00, 0x24, 0x55, 0x00,
106 : : 0x80, 0x00, 0xFF, 0x00, 0x80, 0x24, 0x00, 0x00, 0x80, 0x24, 0x55, 0x00,
107 : : 0x80, 0x24, 0xAA, 0x00, 0x80, 0x24, 0xFF, 0x00, 0x80, 0x49, 0x00, 0x00,
108 : : 0x80, 0x49, 0x55, 0x00, 0x80, 0x49, 0xAA, 0x00, 0x80, 0x49, 0xFF, 0x00,
109 : : 0x80, 0x6D, 0x00, 0x00, 0x80, 0x6D, 0x55, 0x00, 0x80, 0x6D, 0xAA, 0x00,
110 : : 0x80, 0x6D, 0xFF, 0x00, 0x08, 0x08, 0x08, 0x00, 0x0F, 0x0F, 0x0F, 0x00,
111 : : 0x17, 0x17, 0x17, 0x00, 0x1F, 0x1F, 0x1F, 0x00, 0x27, 0x27, 0x27, 0x00,
112 : : 0x2E, 0x2E, 0x2E, 0x00, 0x36, 0x36, 0x36, 0x00, 0x3E, 0x3E, 0x3E, 0x00,
113 : : 0x46, 0x46, 0x46, 0x00, 0x4D, 0x4D, 0x4D, 0x00, 0x55, 0x55, 0x55, 0x00,
114 : : 0x5D, 0x5D, 0x5D, 0x00, 0x64, 0x64, 0x64, 0x00, 0x6C, 0x6C, 0x6C, 0x00,
115 : : 0x74, 0x74, 0x74, 0x00, 0x7C, 0x7C, 0x7C, 0x00, 0xFF, 0xDB, 0x00, 0x00,
116 : : 0x8B, 0x8B, 0x8B, 0x00, 0x93, 0x93, 0x93, 0x00, 0x9B, 0x9B, 0x9B, 0x00,
117 : : 0xFF, 0xB6, 0xFF, 0x00, 0xAA, 0xAA, 0xAA, 0x00, 0xB2, 0xB2, 0xB2, 0x00,
118 : : 0xB9, 0xB9, 0xB9, 0x00, 0x00, 0x24, 0xFF, 0x00, 0x00, 0x49, 0x00, 0x00,
119 : : 0xD1, 0xD1, 0xD1, 0x00, 0xD8, 0xD8, 0xD8, 0x00, 0xE0, 0xE0, 0xE0, 0x00,
120 : : 0xE8, 0xE8, 0xE8, 0x00, 0xF0, 0xF0, 0xF0, 0x00, 0xFF, 0xB6, 0xAA, 0x00,
121 : : 0xFF, 0xDB, 0xFF, 0x00, 0x80, 0x92, 0x55, 0x00, 0x80, 0x92, 0xAA, 0x00,
122 : : 0x80, 0x92, 0xFF, 0x00, 0x80, 0xB6, 0x00, 0x00, 0x80, 0xB6, 0x55, 0x00,
123 : : 0x80, 0xB6, 0xAA, 0x00, 0x80, 0xB6, 0xFF, 0x00, 0x80, 0xDB, 0x00, 0x00,
124 : : 0x80, 0xDB, 0x55, 0x00, 0x80, 0xDB, 0xAA, 0x00, 0x80, 0xDB, 0xFF, 0x00,
125 : : 0x80, 0xFF, 0x00, 0x00, 0x80, 0xFF, 0x55, 0x00, 0x80, 0xFF, 0xAA, 0x00,
126 : : 0x80, 0xFF, 0xFF, 0x00, 0xAA, 0x00, 0x00, 0x00, 0xAA, 0x00, 0x55, 0x00,
127 : : 0xAA, 0x00, 0xAA, 0x00, 0xAA, 0x00, 0xFF, 0x00, 0xAA, 0x24, 0x00, 0x00,
128 : : 0xAA, 0x24, 0x55, 0x00, 0xAA, 0x24, 0xAA, 0x00, 0xAA, 0x24, 0xFF, 0x00,
129 : : 0xAA, 0x49, 0x00, 0x00, 0xAA, 0x49, 0x55, 0x00, 0xAA, 0x49, 0xAA, 0x00,
130 : : 0xAA, 0x49, 0xFF, 0x00, 0xAA, 0x6D, 0x00, 0x00, 0xAA, 0x6D, 0x55, 0x00,
131 : : 0xAA, 0x6D, 0xAA, 0x00, 0xAA, 0x6D, 0xFF, 0x00, 0xAA, 0x92, 0x00, 0x00,
132 : : 0xAA, 0x92, 0x55, 0x00, 0xAA, 0x92, 0xAA, 0x00, 0xAA, 0x92, 0xFF, 0x00,
133 : : 0xAA, 0xB6, 0x00, 0x00, 0xAA, 0xB6, 0x55, 0x00, 0xAA, 0xB6, 0xAA, 0x00,
134 : : 0xAA, 0xB6, 0xFF, 0x00, 0xAA, 0xDB, 0x00, 0x00, 0xAA, 0xDB, 0x55, 0x00,
135 : : 0xAA, 0xDB, 0xAA, 0x00, 0x00, 0x49, 0x55, 0x00, 0xAA, 0xFF, 0x00, 0x00,
136 : : 0xAA, 0xFF, 0x55, 0x00, 0xAA, 0xFF, 0xAA, 0x00, 0xAA, 0xFF, 0xFF, 0x00,
137 : : 0xD5, 0x00, 0x00, 0x00, 0xD5, 0x00, 0x55, 0x00, 0xD5, 0x00, 0xAA, 0x00,
138 : : 0xD5, 0x00, 0xFF, 0x00, 0xD5, 0x24, 0x00, 0x00, 0xD5, 0x24, 0x55, 0x00,
139 : : 0xD5, 0x24, 0xAA, 0x00, 0xD5, 0x24, 0xFF, 0x00, 0xD5, 0x49, 0x00, 0x00,
140 : : 0xD5, 0x49, 0x55, 0x00, 0xD5, 0x49, 0xAA, 0x00, 0xD5, 0x49, 0xFF, 0x00,
141 : : 0xD5, 0x6D, 0x00, 0x00, 0xD5, 0x6D, 0x55, 0x00, 0xD5, 0x6D, 0xAA, 0x00,
142 : : 0xD5, 0x6D, 0xFF, 0x00, 0xD5, 0x92, 0x00, 0x00, 0xD5, 0x92, 0x55, 0x00,
143 : : 0xD5, 0x92, 0xAA, 0x00, 0xD5, 0x92, 0xFF, 0x00, 0xD5, 0xB6, 0x00, 0x00,
144 : : 0xD5, 0xB6, 0x55, 0x00, 0xD5, 0xB6, 0xAA, 0x00, 0xD5, 0xB6, 0xFF, 0x00,
145 : : 0xD5, 0xDB, 0x00, 0x00, 0xD5, 0xDB, 0x55, 0x00, 0xD5, 0xDB, 0xAA, 0x00,
146 : : 0xD5, 0xDB, 0xFF, 0x00, 0xD5, 0xFF, 0x00, 0x00, 0xD5, 0xFF, 0x55, 0x00,
147 : : 0xD5, 0xFF, 0xAA, 0x00, 0xD5, 0xFF, 0xFF, 0x00, 0xFF, 0xDB, 0x55, 0x00,
148 : : 0xFF, 0x00, 0x55, 0x00, 0xFF, 0x00, 0xAA, 0x00, 0xFF, 0xFF, 0x55, 0x00,
149 : : 0xFF, 0x24, 0x00, 0x00, 0xFF, 0x24, 0x55, 0x00, 0xFF, 0x24, 0xAA, 0x00,
150 : : 0xFF, 0x24, 0xFF, 0x00, 0xFF, 0x49, 0x00, 0x00, 0xFF, 0x49, 0x55, 0x00,
151 : : 0xFF, 0x49, 0xAA, 0x00, 0xFF, 0x49, 0xFF, 0x00, 0xFF, 0x6D, 0x00, 0x00,
152 : : 0xFF, 0x6D, 0x55, 0x00, 0xFF, 0x6D, 0xAA, 0x00, 0xFF, 0x6D, 0xFF, 0x00,
153 : : 0xFF, 0x92, 0x00, 0x00, 0xFF, 0x92, 0x55, 0x00, 0xFF, 0x92, 0xAA, 0x00,
154 : : 0xFF, 0x92, 0xFF, 0x00, 0xFF, 0xB6, 0x00, 0x00, 0xFF, 0xB6, 0x55, 0x00,
155 : : 0xF7, 0xF7, 0xF7, 0x00, 0xA2, 0xA2, 0xA2, 0x00, 0x83, 0x83, 0x83, 0x00,
156 : : 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00,
157 : : 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00,
158 : : 0xFF, 0xFF, 0xFF, 0x00
159 : : };
160 : :
161 : :
162 : :
163 : :
164 : 0 : inline sal_Int32 SwapDWord( sal_Int32 n )
165 : : {
166 : : #ifndef OSL_LITENDIAN
167 : : return OSL_SWAPDWORD( n );
168 : : #else
169 : 0 : return n;
170 : : #endif
171 : : }
172 : :
173 : 0 : inline sal_Int16 SwapWord( sal_Int16 n )
174 : : {
175 : : #ifndef OSL_LITENDIAN
176 : : return OSL_SWAPWORD( n );
177 : : #else
178 : 0 : return n;
179 : : #endif
180 : : }
181 : :
182 : :
183 : 0 : static void WriteBMPHeader( SvStream& rStream,
184 : : const SvxRTFPictureType& rPicType )
185 : : {
186 : 0 : sal_uInt32 n4Width = rPicType.nWidth;
187 : 0 : sal_uInt32 n4Height = rPicType.nHeight;
188 : 0 : sal_uInt16 n4ColBits = rPicType.nBitsPerPixel;
189 : :
190 : 0 : sal_uInt16 nColors = (1 << n4ColBits); // Number of colors (1, 16, 256)
191 : 0 : sal_uInt16 nWdtOut = rPicType.nWidthBytes;
192 [ # # ]: 0 : if( !nWdtOut )
193 : 0 : nWdtOut = (sal_uInt16)((( n4Width * n4ColBits + 31 ) / 32 ) * 4 );
194 : :
195 : 0 : sal_Int32 nOffset = 14 + 40; // BMP_FILE_HD_SIZ + sizeof(*pBmpInfo);
196 [ # # ]: 0 : if( 256 >= nColors )
197 : 0 : nOffset += nColors * 4;
198 : 0 : sal_Int32 nSize = nOffset + nWdtOut * n4Height;
199 : 0 : rStream << "BM" // = "BM"
200 : 0 : << SwapDWord(nSize) // Filesize in Bytes
201 : 0 : << SwapWord(0) // Reserved
202 : 0 : << SwapWord(0) // Reserved
203 : 0 : << SwapDWord(nOffset); // Offset?
204 : :
205 : 0 : rStream << SwapDWord(40) // sizeof( BmpInfo )
206 : 0 : << SwapDWord(n4Width)
207 : 0 : << SwapDWord(n4Height)
208 : 0 : << (sal_uInt16)1
209 : 0 : << n4ColBits
210 : 0 : << SwapDWord(0)
211 : 0 : << SwapDWord(0)
212 : : << SwapDWord( rPicType.nGoalWidth
213 : : ? rPicType.nGoalWidth * 1000L / 254L
214 [ # # ]: 0 : : 0 ) // DPI in Pixel per Meter
215 : : << SwapDWord( rPicType.nGoalHeight
216 : : ? rPicType.nGoalHeight * 1000L / 254L // dito
217 [ # # ]: 0 : : 0 )
218 : 0 : << SwapDWord(0)
219 : 0 : << SwapDWord(0);
220 : :
221 : :
222 [ # # # # ]: 0 : switch( rPicType.nBitsPerPixel )
223 : : {
224 : 0 : case 1: rStream.Write( aPal1, sizeof( aPal1 )); break;
225 : 0 : case 4: rStream.Write( aPal4, sizeof( aPal4 )); break;
226 : 0 : case 8: rStream.Write( aPal8, sizeof( aPal8 )); break;
227 : : }
228 : 0 : }
229 : :
230 : : // Converts the ASCII characters to hexadecimal codes in binary.
231 : : // If invalid data is found (eg. characters outside 0-9|a-f|A-F), then
232 : : // USHRT_MAX is returned, else the number of converted charachters.
233 : 0 : xub_StrLen SvxRTFParser::HexToBin( String& rToken )
234 : : {
235 : : // then create "Binary data" from the hex values.
236 : : // (missuse the String as temp Buffer)
237 [ # # ]: 0 : if( rToken.Len() & 1 ) // odd number, fill out with 0
238 : 0 : rToken += '0';
239 : :
240 : : xub_StrLen n, nLen;
241 : : sal_Unicode nVal;
242 : 0 : sal_Bool bValidData = sal_True;
243 : 0 : const sal_Unicode* pStr = rToken.GetBufferAccess();
244 : 0 : sal_Char* pData = (sal_Char*)pStr;
245 [ # # ]: 0 : for( n = 0, nLen = rToken.Len(); n < nLen; ++n, ++pStr )
246 : : {
247 [ # # ][ # # ]: 0 : if( ((nVal = *pStr) >= '0') && ( nVal <= '9') )
[ # # ]
248 : 0 : nVal -= '0';
249 [ # # ][ # # ]: 0 : else if( (nVal >= 'A') && (nVal <= 'F') )
250 : 0 : nVal -= 'A' - 10;
251 [ # # ][ # # ]: 0 : else if( (nVal >= 'a') && (nVal <= 'f') )
252 : 0 : nVal -= 'a' - 10;
253 : : else
254 : : {
255 : : DBG_ASSERT( !this, "invalid Hex value" );
256 : 0 : bValidData = sal_False;
257 : 0 : break;
258 : : }
259 : :
260 [ # # ]: 0 : if( n & 1 )
261 : 0 : *(pData++) |= nVal & 0x0f;
262 : : else
263 : 0 : *(pData) = sal::static_int_cast< char >( ( nVal << 4 ) & 0xf0 );
264 : : }
265 : : // the len div 2, because 2 character are one byte
266 [ # # ]: 0 : return bValidData ? nLen / 2 : STRING_NOTFOUND;
267 : : }
268 : :
269 : 0 : sal_Bool SvxRTFParser::ReadBmpData( Graphic& rGrf, SvxRTFPictureType& rPicType )
270 : : {
271 : : // Delete the old data
272 [ # # ]: 0 : rGrf.Clear();
273 : :
274 : 0 : rtl_TextEncoding eOldEnc = GetSrcEncoding();
275 [ # # ]: 0 : SetSrcEncoding( RTL_TEXTENCODING_MS_1252 );
276 : :
277 : 0 : const sal_Char* pFilterNm = 0;
278 : 0 : boost::scoped_ptr<SvCacheStream> pTmpFile;
279 : :
280 : 0 : int nToken = 0;
281 : 0 : bool bValidBmp = true, bFirstTextToken = true;
282 : 0 : int _nOpenBrakets = 1, // the first was already recognized before!
283 : 0 : nValidDataBraket = 1;
284 : :
285 [ # # ][ # # ]: 0 : if( RTF_SHPPICT == GetStackPtr(0)->nTokenId )
286 : 0 : ++nValidDataBraket;
287 : 0 : OUString sShapePropertyName, sShapePropertyValue;
288 : 0 : int nShapePropertyBracket = -1;
289 [ # # ][ # # ]: 0 : while( _nOpenBrakets && IsParserWorking() && bValidBmp )
[ # # ][ # # ]
290 : : {
291 [ # # ]: 0 : nToken = GetNextToken();
292 : 0 : sal_uInt16 nVal = sal_uInt16( nTokenValue );
293 [ # # # # : 0 : switch( nToken )
# # # # #
# # # # #
# # # # #
# # # #
# ]
294 : : {
295 : : case '}':
296 : 0 : --_nOpenBrakets;
297 [ # # ][ # # ]: 0 : if( nShapePropertyBracket > 0 && nShapePropertyBracket > _nOpenBrakets )
298 : : {
299 : 0 : nShapePropertyBracket = -1;
300 [ # # ]: 0 : if( !sShapePropertyName.isEmpty() )
301 : : {
302 [ # # ]: 0 : rPicType.aPropertyPairs.push_back( ::std::pair< OUString, OUString >( sShapePropertyName, sShapePropertyValue ) );
303 : 0 : sShapePropertyName = sShapePropertyValue = ::rtl::OUString();
304 : : }
305 : : }
306 : 0 : break;
307 : : case '{':
308 : : {
309 [ # # ][ # # ]: 0 : if( RTF_IGNOREFLAG != GetNextToken() )
310 [ # # ]: 0 : nToken = SkipToken( -1 );
311 [ # # ][ # # ]: 0 : else if( RTF_UNKNOWNCONTROL != GetNextToken() )
312 [ # # ]: 0 : nToken = SkipToken( -2 );
313 : : else
314 : : {
315 : : // gleich herausfiltern
316 [ # # ]: 0 : ReadUnknownData();
317 [ # # ]: 0 : nToken = GetNextToken();
318 [ # # ]: 0 : if( '}' != nToken )
319 : 0 : eState = SVPAR_ERROR;
320 : 0 : break;
321 : : }
322 : 0 : ++_nOpenBrakets;
323 : : }
324 : 0 : break;
325 : :
326 : : case RTF_MACPICT:
327 : : {
328 : 0 : rPicType.eStyle = SvxRTFPictureType::MAC_QUICKDRAW;
329 : : // Mac-Pict gets a empty header above
330 [ # # ][ # # ]: 0 : pTmpFile.reset(new SvCacheStream);
[ # # ]
331 [ # # ]: 0 : std::vector<char> a512Zeros(512, '\0');
332 [ # # ][ # # ]: 0 : pTmpFile->Write( &a512Zeros[0], a512Zeros.size() );
333 : 0 : pFilterNm = "PCT";
334 : : }
335 : 0 : break;
336 : :
337 : : case RTF_EMFBLIP:
338 : : case RTF_WMETAFILE:
339 : : case RTF_PNGBLIP:
340 : : case RTF_JPEGBLIP:
341 : : case RTF_WBITMAP:
342 : : case RTF_OSMETAFILE:
343 : : case RTF_DIBITMAP:
344 : : {
345 [ # # # # : 0 : switch( nToken )
# # # # ]
346 : : {
347 : : case RTF_EMFBLIP:
348 : 0 : rPicType.eStyle = SvxRTFPictureType::ENHANCED_MF;
349 : 0 : pFilterNm = "EMF";
350 : 0 : break;
351 : : case RTF_WMETAFILE:
352 : 0 : rPicType.eStyle = SvxRTFPictureType::WIN_METAFILE;
353 : 0 : pFilterNm = "WMF";
354 : 0 : break;
355 : : case RTF_PNGBLIP:
356 : 0 : rPicType.eStyle = SvxRTFPictureType::RTF_PNG;
357 : 0 : pFilterNm = "PNG";
358 : 0 : break;
359 : : case RTF_JPEGBLIP:
360 : 0 : rPicType.eStyle = SvxRTFPictureType::RTF_JPG;
361 : 0 : pFilterNm = "JPG";
362 : 0 : break;
363 : :
364 : : case RTF_WBITMAP:
365 : 0 : rPicType.eStyle = SvxRTFPictureType::RTF_BITMAP;
366 : 0 : break;
367 : : case RTF_OSMETAFILE:
368 : 0 : rPicType.eStyle = SvxRTFPictureType::OS2_METAFILE;
369 : 0 : break;
370 : : case RTF_DIBITMAP:
371 : 0 : rPicType.eStyle = SvxRTFPictureType::RTF_DI_BMP;
372 : 0 : break;
373 : : }
374 : :
375 : 0 : rPicType.nType = nVal;
376 [ # # ][ # # ]: 0 : pTmpFile.reset(new SvCacheStream);
[ # # ]
377 : : }
378 : 0 : break;
379 : :
380 : 0 : case RTF_PICW: rPicType.nWidth = nVal; break;
381 : 0 : case RTF_PICH: rPicType.nHeight = nVal; break;
382 : 0 : case RTF_WBMBITSPIXEL: rPicType.nBitsPerPixel = nVal; break;
383 : 0 : case RTF_WBMPLANES: rPicType.nPlanes = nVal; break;
384 : 0 : case RTF_WBMWIDTHBYTES: rPicType.nWidthBytes = nVal; break;
385 : 0 : case RTF_PICWGOAL: rPicType.nGoalWidth = nVal; break;
386 : 0 : case RTF_PICHGOAL: rPicType.nGoalHeight = nVal; break;
387 : : case RTF_BIN:
388 : 0 : rPicType.nMode = SvxRTFPictureType::BINARY_MODE;
389 : 0 : rPicType.uPicLen = nTokenValue;
390 [ # # ]: 0 : if (rPicType.uPicLen)
391 : : {
392 [ # # ]: 0 : rStrm.SeekRel(-1);
393 : : sal_uInt8 aData[4096];
394 : 0 : sal_uInt32 nSize = sizeof(aData);
395 : :
396 [ # # ]: 0 : while (rPicType.uPicLen > 0)
397 : : {
398 [ # # ]: 0 : if (rPicType.uPicLen < nSize)
399 : 0 : nSize = rPicType.uPicLen;
400 : :
401 [ # # ]: 0 : rStrm.Read(aData, nSize);
402 [ # # ]: 0 : pTmpFile->Write(aData, nSize);
403 : 0 : rPicType.uPicLen -= nSize;
404 : : }
405 [ # # ]: 0 : nNextCh = GetNextChar();
406 : 0 : bValidBmp = !pTmpFile->GetError();
407 : : }
408 : 0 : break;
409 : 0 : case RTF_PICSCALEX: rPicType.nScalX = nVal; break;
410 : 0 : case RTF_PICSCALEY: rPicType.nScalY = nVal; break;
411 : 0 : case RTF_PICSCALED: break;
412 : :
413 : 0 : case RTF_PICCROPT: rPicType.nCropT = (short)nTokenValue; break;
414 : 0 : case RTF_PICCROPB: rPicType.nCropB = (short)nTokenValue; break;
415 : 0 : case RTF_PICCROPL: rPicType.nCropL = (short)nTokenValue; break;
416 : 0 : case RTF_PICCROPR: rPicType.nCropR = (short)nTokenValue; break;
417 : : case RTF_SP:
418 : : //read pairs of {\sn Name}{\sv Value}
419 : 0 : nShapePropertyBracket = _nOpenBrakets;
420 : 0 : break;
421 : : case RTF_SN:
422 [ # # ]: 0 : nToken = GetNextToken();
423 [ # # ]: 0 : if( nToken != '}' )
424 [ # # ]: 0 : sShapePropertyName = aToken;
425 : : else
426 [ # # ]: 0 : nToken = SkipToken( -1 );
427 : 0 : break;
428 : : case RTF_SV:
429 [ # # ]: 0 : nToken = GetNextToken();
430 [ # # ]: 0 : if( nToken != '}' )
431 [ # # ]: 0 : sShapePropertyValue = aToken;
432 : : else
433 [ # # ]: 0 : nToken = SkipToken( -1 );
434 : 0 : break;
435 : : case RTF_TEXTTOKEN:
436 [ # # ]: 0 : if( nValidDataBraket != _nOpenBrakets )
437 : 0 : break;
438 : :
439 [ # # ]: 0 : if( bFirstTextToken )
440 : : {
441 [ # # ]: 0 : switch( rPicType.eStyle )
442 : : {
443 : : case SvxRTFPictureType::RTF_BITMAP:
444 : : // first write the header and the info structure
445 [ # # ]: 0 : if( pTmpFile )
446 [ # # ]: 0 : ::WriteBMPHeader( *pTmpFile, rPicType );
447 : 0 : break;
448 : : default:
449 : 0 : break;
450 : : }
451 : 0 : bFirstTextToken = sal_False;
452 : : }
453 : :
454 [ # # ][ # # ]: 0 : if( pTmpFile && SvxRTFPictureType::HEX_MODE == rPicType.nMode )
[ # # ]
455 : : {
456 [ # # ]: 0 : xub_StrLen nTokenLen = HexToBin( aToken );
457 [ # # ]: 0 : if( STRING_NOTFOUND == nTokenLen )
458 : 0 : bValidBmp = sal_False;
459 : : else
460 : : {
461 : 0 : pTmpFile->Write( (sal_Char*)aToken.GetBuffer(),
462 [ # # ]: 0 : nTokenLen );
463 : 0 : bValidBmp = 0 == pTmpFile->GetError();
464 : : }
465 : : }
466 : 0 : break;
467 : : }
468 : : }
469 : :
470 [ # # ]: 0 : if (pTmpFile)
471 : : {
472 : : //#i20775#
473 [ # # ]: 0 : if (pTmpFile->Tell() == 0)
474 : 0 : bValidBmp = false;
475 : :
476 [ # # ]: 0 : if( bValidBmp )
477 : : {
478 [ # # ]: 0 : GraphicFilter& rGF = GraphicFilter::GetGraphicFilter();
479 : 0 : sal_uInt16 nImportFilter = GRFILTER_FORMAT_DONTKNOW;
480 : :
481 [ # # ]: 0 : if( pFilterNm )
482 : : {
483 [ # # ]: 0 : String sTmp;
484 [ # # ][ # # ]: 0 : for( sal_uInt16 n = rGF.GetImportFormatCount(); n; )
485 : : {
486 [ # # ][ # # ]: 0 : sTmp = rGF.GetImportFormatShortName( --n );
[ # # ]
487 [ # # ][ # # ]: 0 : if( sTmp.EqualsAscii( pFilterNm ))
488 : : {
489 : 0 : nImportFilter = n;
490 : 0 : break;
491 : : }
492 [ # # ]: 0 : }
493 : : }
494 : :
495 [ # # ]: 0 : String sTmpStr;
496 [ # # ]: 0 : pTmpFile->Seek( STREAM_SEEK_TO_BEGIN );
497 [ # # ][ # # ]: 0 : bValidBmp = 0 == rGF.ImportGraphic( rGrf, sTmpStr, *pTmpFile, nImportFilter );
498 : : }
499 : : }
500 : :
501 [ # # ]: 0 : if( !bValidBmp )
502 : : {
503 [ # # ]: 0 : rGrf.Clear();
504 : : // TODO: If nToken were not initialized to 0 above, it would potentially
505 : : // be used uninitialized here (if IsParserWorking() is false at the
506 : : // start of the while loop above):
507 [ # # ]: 0 : if( '}' != nToken )
508 [ # # ]: 0 : SkipGroup();
509 : : }
510 : : else
511 : : {
512 [ # # ]: 0 : switch( rPicType.eStyle )
513 : : {
514 : : case SvxRTFPictureType::RTF_PNG:
515 : : case SvxRTFPictureType::RTF_JPG:
516 : : {
517 [ # # ]: 0 : const MapMode aMap( MAP_100TH_MM );
518 [ # # ]: 0 : Size aSize( rGrf.GetPrefSize() );
519 [ # # ][ # # ]: 0 : if( MAP_PIXEL == rGrf.GetPrefMapMode().GetMapUnit() )
[ # # ]
520 : : aSize = Application::GetDefaultDevice()->PixelToLogic(
521 [ # # ][ # # ]: 0 : aSize, aMap );
522 : : else
523 : : aSize = OutputDevice::LogicToLogic( aSize,
524 [ # # ][ # # ]: 0 : rGrf.GetPrefMapMode(), aMap );
[ # # ]
525 : 0 : rPicType.nWidth = sal::static_int_cast< sal_uInt16 >(aSize.Width());
526 : : rPicType.nHeight = sal::static_int_cast< sal_uInt16 >(
527 [ # # ]: 0 : aSize.Height());
528 : : }
529 : 0 : break;
530 : : default:
531 : 0 : break;
532 : : }
533 : : }
534 [ # # ]: 0 : SetSrcEncoding( eOldEnc );
535 : :
536 [ # # ]: 0 : SkipToken( -1 ); // the closing brace is evaluated "above"
537 [ # # ]: 0 : return bValidBmp;
538 : : }
539 : :
540 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
