Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : */
9 :
10 : #ifndef _RTFDOCUMENTIMPL_HXX_
11 : #define _RTFDOCUMENTIMPL_HXX_
12 :
13 : #include <stack>
14 : #include <queue>
15 : #include <boost/optional.hpp>
16 : #include <boost/tuple/tuple.hpp>
17 :
18 : #include <com/sun/star/lang/XMultiServiceFactory.hpp>
19 : #include <com/sun/star/beans/XPropertySet.hpp>
20 : #include <com/sun/star/document/XDocumentProperties.hpp>
21 : #include <oox/helper/graphichelper.hxx>
22 : #include <oox/mathml/importutils.hxx>
23 : #include <rtl/strbuf.hxx>
24 :
25 : #include <rtftok/RTFDocument.hxx>
26 : #include <rtfreferencetable.hxx>
27 : #include <rtfsprm.hxx>
28 : #include <rtflistener.hxx>
29 :
30 : class SvStream;
31 :
32 : namespace writerfilter {
33 : namespace rtftok {
34 : enum RTFBorderState
35 : {
36 : BORDER_NONE,
37 : BORDER_PARAGRAPH,
38 : BORDER_PARAGRAPH_BOX,
39 : BORDER_CELL,
40 : BORDER_PAGE,
41 : BORDER_CHARACTER
42 : };
43 :
44 : /// Minimalistic buffer of elements for nested cells.
45 : enum RTFBufferTypes
46 : {
47 : BUFFER_PROPS,
48 : BUFFER_NESTROW,
49 : BUFFER_CELLEND,
50 : BUFFER_STARTRUN,
51 : BUFFER_TEXT,
52 : BUFFER_UTEXT,
53 : BUFFER_ENDRUN,
54 : BUFFER_PAR,
55 : BUFFER_STARTSHAPE,
56 : BUFFER_ENDSHAPE
57 : };
58 :
59 : /// Form field types
60 : enum RTFFormFieldTypes
61 : {
62 : FORMFIELD_NONE,
63 : FORMFIELD_TEXT,
64 : FORMFIELD_CHECKBOX,
65 : FORMFIELD_LIST
66 : };
67 :
68 : enum RTFBmpStyles
69 : {
70 : BMPSTYLE_NONE,
71 : BMPSTYLE_PNG,
72 : BMPSTYLE_JPEG
73 : };
74 :
75 : enum RTFFieldStatus
76 : {
77 : FIELD_NONE,
78 : FIELD_INSTRUCTION,
79 : FIELD_RESULT
80 : };
81 :
82 : struct TableRowBuffer;
83 :
84 : /// A buffer storing dmapper calls.
85 : typedef ::boost::tuple<RTFBufferTypes, RTFValue::Pointer_t,
86 : ::boost::shared_ptr<TableRowBuffer> > Buf_t;
87 : typedef std::deque< Buf_t > RTFBuffer_t;
88 :
89 : /// holds one nested table row
90 0 : struct TableRowBuffer
91 : {
92 : RTFBuffer_t buffer;
93 : ::std::deque<RTFSprms> cellsSprms;
94 : ::std::deque<RTFSprms> cellsAttributes;
95 : int nCells;
96 : writerfilter::Reference<Properties>::Pointer_t pParaProperties;
97 : writerfilter::Reference<Properties>::Pointer_t pFrameProperties;
98 : writerfilter::Reference<Properties>::Pointer_t pRowProperties;
99 :
100 0 : TableRowBuffer(RTFBuffer_t const& rBuffer,
101 : ::std::deque<RTFSprms> const& rSprms,
102 : ::std::deque<RTFSprms> const& rAttributes,
103 : int const i_nCells)
104 : : buffer(rBuffer)
105 : , cellsSprms(rSprms), cellsAttributes(rAttributes)
106 0 : , nCells(i_nCells)
107 0 : {}
108 : };
109 :
110 : /// An entry in the color table.
111 : class RTFColorTableEntry
112 : {
113 : public:
114 : RTFColorTableEntry();
115 : sal_uInt8 nRed;
116 : sal_uInt8 nGreen;
117 : sal_uInt8 nBlue;
118 : };
119 :
120 : /// Stores the properties of a shape.
121 0 : class RTFShape
122 : {
123 : public:
124 : RTFShape();
125 : std::vector< std::pair<OUString, OUString> > aProperties; ///< Properties of a single shape.
126 : std::vector< std::pair<OUString, OUString> > aGroupProperties; ///< Properties applied on the groupshape.
127 : sal_Int32 nLeft;
128 : sal_Int32 nTop;
129 : sal_Int32 nRight;
130 : sal_Int32 nBottom;
131 : boost::optional<sal_Int32> oZ; ///< Z-Order of the shape.
132 : sal_Int16 nHoriOrientRelation; ///< Horizontal text::RelOrientation for drawinglayer shapes.
133 : sal_Int16 nVertOrientRelation; ///< Vertical text::RelOrientation for drawinglayer shapes.
134 : sal_uInt32 nHoriOrientRelationToken; ///< Horizontal dmapper token for Writer pictures.
135 : sal_uInt32 nVertOrientRelationToken; ///< Vertical dmapper token for Writer pictures.
136 : int nWrap;
137 : };
138 :
139 : /// Stores the properties of a drawing object.
140 0 : class RTFDrawingObject : public RTFShape
141 : {
142 : public:
143 : RTFDrawingObject();
144 : uno::Reference<drawing::XShape> xShape;
145 : uno::Reference<beans::XPropertySet> xPropertySet;
146 : std::vector<beans::PropertyValue> aPendingProperties;
147 : sal_uInt8 nLineColorR, nLineColorG, nLineColorB;
148 : bool bHasLineColor;
149 : sal_uInt8 nFillColorR, nFillColorG, nFillColorB;
150 : bool bHasFillColor;
151 : sal_Int32 nDhgt;
152 : sal_Int32 nFLine;
153 : sal_Int32 nPolyLineCount;
154 : uno::Sequence<awt::Point> aPolyLinePoints;
155 : bool bHadShapeText;
156 : };
157 :
158 : /// Stores the properties of a picture.
159 : class RTFPicture
160 : {
161 : public:
162 : RTFPicture();
163 : sal_uInt16 nWidth, nHeight;
164 : sal_uInt16 nGoalWidth, nGoalHeight;
165 : sal_uInt16 nScaleX, nScaleY;
166 : short nCropT, nCropB, nCropL, nCropR;
167 : sal_uInt16 eWMetafile;
168 : RTFBmpStyles nStyle;
169 : };
170 :
171 : class RTFParserState;
172 :
173 : /// Stores the properties of a frame
174 0 : class RTFFrame
175 : {
176 : private:
177 : RTFParserState* m_pParserState;
178 : sal_Int32 nX, nY, nW, nH;
179 : sal_Int32 nHoriPadding, nVertPadding;
180 : sal_Int32 nHoriAlign, nHoriAnchor, nVertAlign, nVertAnchor;
181 : Id nHRule;
182 : boost::optional<Id> oWrap;
183 : public:
184 : RTFFrame(RTFParserState* pParserState);
185 : sal_Int16 nAnchorType;
186 :
187 : /// Convert the stored properties to Sprms
188 : RTFSprms getSprms();
189 : /// Store a property
190 : void setSprm(Id nId, Id nValue);
191 : bool hasProperties();
192 : /// If we got tokens indicating we're in a frame.
193 : bool inFrame();
194 : };
195 :
196 : class RTFDocumentImpl;
197 :
198 : /// State of the parser, which gets saved / restored when changing groups.
199 0 : class RTFParserState
200 : {
201 : public:
202 : RTFParserState(RTFDocumentImpl* pDocumentImpl);
203 : /// Resets aFrame.
204 : void resetFrame();
205 :
206 : RTFDocumentImpl* m_pDocumentImpl;
207 : RTFInternalState nInternalState;
208 : RTFDestinationState nDestinationState;
209 : RTFFieldStatus nFieldStatus;
210 : RTFBorderState nBorderState;
211 : // font table, stylesheet table
212 : RTFSprms aTableSprms;
213 : RTFSprms aTableAttributes;
214 : // reset by plain
215 : RTFSprms aCharacterSprms;
216 : RTFSprms aCharacterAttributes;
217 : // reset by pard
218 : RTFSprms aParagraphSprms;
219 : RTFSprms aParagraphAttributes;
220 : // reset by sectd
221 : RTFSprms aSectionSprms;
222 : RTFSprms aSectionAttributes;
223 : // reset by trowd
224 : RTFSprms aTableRowSprms;
225 : RTFSprms aTableRowAttributes;
226 : // reset by cellx
227 : RTFSprms aTableCellSprms;
228 : RTFSprms aTableCellAttributes;
229 : // reset by tx
230 : RTFSprms aTabAttributes;
231 :
232 : RTFColorTableEntry aCurrentColor;
233 :
234 : rtl_TextEncoding nCurrentEncoding;
235 :
236 : /// Current \uc value.
237 : int nUc;
238 : /// Characters to skip, set to nUc by \u.
239 : int nCharsToSkip;
240 : /// Characters to read, once in binary mode.
241 : int nBinaryToRead;
242 :
243 : /// Next list level index to use when parsing list table.
244 : int nListLevelNum;
245 : /// List level entries, which will form a list entry later.
246 : RTFSprms aListLevelEntries;
247 :
248 : /// List of character positions in leveltext to replace.
249 : std::vector<sal_Int32> aLevelNumbers;
250 :
251 : RTFPicture aPicture;
252 : RTFShape aShape;
253 : RTFDrawingObject aDrawingObject;
254 : RTFFrame aFrame;
255 :
256 : /// CJK or CTL?
257 : bool bIsCjk;
258 :
259 : // Info group.
260 : int nYear;
261 : int nMonth;
262 : int nDay;
263 : int nHour;
264 : int nMinute;
265 :
266 : /// Text from special destinations.
267 : OUStringBuffer aDestinationText;
268 :
269 : /// Index of the current style.
270 : int nCurrentStyleIndex;
271 :
272 : /// Points to the active buffer, if there is one.
273 : RTFBuffer_t* pCurrentBuffer;
274 :
275 : /// If we're inside a \listpicture group.
276 : bool bInListpicture;
277 :
278 : /// If we're inside a \background group.
279 : bool bInBackground;
280 :
281 : bool bHadShapeText;
282 : bool bInShapeGroup; ///< If we're inside a \shpgrp group.
283 : bool bInShape; ///< If we're inside a \shp group.
284 : bool bCreatedShapeGroup; ///< A GroupShape was created and pushed to the parent stack.
285 : bool bStartedTrackchange; ///< Track change is started, need to end it before popping.
286 : };
287 :
288 : /// An RTF stack is similar to std::stack, except that it has an operator[].
289 0 : struct RTFStack : public std::deque<RTFParserState>
290 : {
291 0 : RTFParserState & top() { return back(); }
292 0 : void pop() { return pop_back(); }
293 0 : void push(RTFParserState const& rState) {return push_back(rState);}
294 : };
295 :
296 : class RTFTokenizer;
297 : class RTFSdrImport;
298 :
299 : /// Implementation of the RTFDocument interface.
300 : class RTFDocumentImpl
301 : : public RTFDocument, public RTFListener
302 : {
303 : public:
304 : typedef ::boost::shared_ptr<RTFDocumentImpl> Pointer_t;
305 : RTFDocumentImpl(uno::Reference<uno::XComponentContext> const& xContext,
306 : uno::Reference<io::XInputStream> const& xInputStream,
307 : uno::Reference<lang::XComponent> const& xDstDoc,
308 : uno::Reference<frame::XFrame> const& xFrame,
309 : uno::Reference<task::XStatusIndicator> const& xStatusIndicator);
310 : virtual ~RTFDocumentImpl();
311 :
312 : // RTFDocument
313 : virtual void resolve(Stream & rHandler) SAL_OVERRIDE;
314 : virtual std::string getType() const SAL_OVERRIDE;
315 :
316 : // RTFListener
317 : virtual int dispatchDestination(RTFKeyword nKeyword) SAL_OVERRIDE;
318 : virtual int dispatchFlag(RTFKeyword nKeyword) SAL_OVERRIDE;
319 : virtual int dispatchSymbol(RTFKeyword nKeyword) SAL_OVERRIDE;
320 : virtual int dispatchToggle(RTFKeyword nKeyword, bool bParam, int nParam) SAL_OVERRIDE;
321 : virtual int dispatchValue(RTFKeyword nKeyword, int nParam) SAL_OVERRIDE;
322 : virtual int resolveChars(char ch) SAL_OVERRIDE;
323 : virtual int pushState() SAL_OVERRIDE;
324 : virtual int popState() SAL_OVERRIDE;
325 : virtual RTFDestinationState getDestinationState() SAL_OVERRIDE;
326 : virtual void setDestinationState(RTFDestinationState nDestinationState) SAL_OVERRIDE;
327 : virtual RTFInternalState getInternalState() SAL_OVERRIDE;
328 : virtual void setInternalState(RTFInternalState nInternalState) SAL_OVERRIDE;
329 : virtual bool getSkipUnknown() SAL_OVERRIDE;
330 : virtual void setSkipUnknown(bool bSkipUnknown) SAL_OVERRIDE;
331 : virtual void finishSubstream() SAL_OVERRIDE;
332 : virtual bool isSubstream() const SAL_OVERRIDE;
333 :
334 : Stream& Mapper();
335 : void setSubstream(bool bIsSubtream);
336 : void setSuperstream(RTFDocumentImpl *pSuperstream);
337 : void setStreamType(Id nId);
338 : void setAuthor(OUString& rAuthor);
339 : void setAuthorInitials(OUString& rAuthorInitials);
340 : void setIgnoreFirst(OUString& rIgnoreFirst);
341 : void seek(sal_Size nPos);
342 : uno::Reference<lang::XMultiServiceFactory> getModelFactory();
343 : bool isInBackground();
344 : void setDestinationText(OUString& rString);
345 : /// Resolve a picture: If not inline, then anchored.
346 : int resolvePict(bool bInline);
347 :
348 : /// If this is the first run of the document, starts the initial paragraph.
349 : void checkFirstRun();
350 : /// If the initial paragraph is started.
351 : bool getFirstRun();
352 : /// If we need to add a dummy paragraph before a section break.
353 : void setNeedPar(bool bNeedPar);
354 : /// Return the dmapper index of an RTF index for fonts.
355 : int getFontIndex(int nIndex);
356 : /// Return the name of the font, based on a dmapper index.
357 : OUString getFontName(int nIndex);
358 : /// Return the style name of an RTF style index.
359 : OUString getStyleName(int nIndex);
360 : /// Return the encoding associated with a font index.
361 : rtl_TextEncoding getEncoding(int nFontIndex);
362 : /// Get the default parser state.
363 : RTFParserState& getDefaultState();
364 : oox::GraphicHelper& getGraphicHelper();
365 :
366 : private:
367 : SvStream& Strm();
368 : sal_uInt32 getColorTable(sal_uInt32 nIndex);
369 : RTFSprms mergeSprms();
370 : RTFSprms mergeAttributes();
371 : void resetSprms();
372 : void resetAttributes();
373 : void resolveSubstream(sal_Size nPos, Id nId);
374 : void resolveSubstream(sal_Size nPos, Id nId, OUString& rIgnoreFirst);
375 :
376 : void text(OUString& rString);
377 : // Sends a single character to dmapper, taking care of buffering.
378 : void singleChar(sal_uInt8 nValue, bool bRunProps = false);
379 : // Sends run properties to dmapper, taking care of buffering.
380 : void runProps();
381 : void runBreak();
382 : void parBreak();
383 : void tableBreak();
384 : writerfilter::Reference<Properties>::Pointer_t getProperties(RTFSprms& rAttributes, RTFSprms& rSprms);
385 : void checkNeedPap();
386 : void sectBreak(bool bFinal);
387 : void prepareProperties(
388 : RTFParserState & rState,
389 : writerfilter::Reference<Properties>::Pointer_t &,
390 : writerfilter::Reference<Properties>::Pointer_t &,
391 : writerfilter::Reference<Properties>::Pointer_t &,
392 : int const nCells, int const nCurrentCellX);
393 : /// Send the passed properties to dmapper.
394 : void sendProperties(
395 : writerfilter::Reference<Properties>::Pointer_t const&,
396 : writerfilter::Reference<Properties>::Pointer_t const&,
397 : writerfilter::Reference<Properties>::Pointer_t const&);
398 : void replayRowBuffer(RTFBuffer_t & rBuffer,
399 : ::std::deque<RTFSprms> & rCellsSrpms,
400 : ::std::deque<RTFSprms> & rCellsAttributes,
401 : int const nCells);
402 : void replayBuffer(RTFBuffer_t& rBuffer,
403 : RTFSprms *const pSprms,
404 : RTFSprms const*const pAttributes);
405 : /// If we have some unicode or hex characters to send.
406 : void checkUnicode(bool bUnicode, bool bHex);
407 : /// If we need a final section break at the end of the document.
408 : void setNeedSect(bool bNeedSect = true);
409 : void resetTableRowProperties();
410 : void backupTableRowProperties();
411 : void restoreTableRowProperties();
412 :
413 : uno::Reference<uno::XComponentContext> const& m_xContext;
414 : uno::Reference<io::XInputStream> const& m_xInputStream;
415 : uno::Reference<lang::XComponent> const& m_xDstDoc;
416 : uno::Reference<frame::XFrame> const& m_xFrame;
417 : uno::Reference<task::XStatusIndicator> const& m_xStatusIndicator;
418 : uno::Reference<lang::XMultiServiceFactory> m_xModelFactory;
419 : uno::Reference<document::XDocumentProperties> m_xDocumentProperties;
420 : boost::shared_ptr<SvStream> m_pInStream;
421 : Stream* m_pMapperStream;
422 : boost::shared_ptr<RTFSdrImport> m_pSdrImport;
423 : boost::shared_ptr<RTFTokenizer> m_pTokenizer;
424 : RTFStack m_aStates;
425 : /// Read by RTF_PARD.
426 : RTFParserState m_aDefaultState;
427 : bool m_bSkipUnknown;
428 : /// Font index <-> encoding map, *not* part of the parser state
429 : std::map<int, rtl_TextEncoding> m_aFontEncodings;
430 : /// Font index <-> name map.
431 : std::map<int, OUString> m_aFontNames;
432 : /// Maps the non-continuous font indexes to the continuous dmapper indexes.
433 : std::vector<int> m_aFontIndexes;
434 : /// Maps style indexes to style names.
435 : std::map<int, OUString> m_aStyleNames;
436 : /// Color index <-> RGB color value map
437 : std::vector<sal_uInt32> m_aColorTable;
438 : bool m_bFirstRun;
439 : /// If paragraph properties should be emitted on next run.
440 : bool m_bNeedPap;
441 : /// If we need to emit a CR at the end of substream.
442 : bool m_bNeedCr;
443 : /// Original value of m_bNeedCr -- saved/restored before/after textframes.
444 : bool m_bNeedCrOrig;
445 : bool m_bNeedPar;
446 : /// If set, an empty paragraph will be added at the end of the document.
447 : bool m_bNeedFinalPar;
448 : /// The list table and list override table combined.
449 : RTFSprms m_aListTableSprms;
450 : /// The settings table attributes.
451 : RTFSprms m_aSettingsTableAttributes;
452 : /// The settings table sprms.
453 : RTFSprms m_aSettingsTableSprms;
454 :
455 : oox::StorageRef m_xStorage;
456 : boost::shared_ptr<oox::GraphicHelper> m_pGraphicHelper;
457 :
458 : /// cell props buffer for nested tables, reset by \nestrow
459 : /// the \nesttableprops is a destination and must follow the
460 : /// nested cells, so it should be sufficient to store the
461 : /// currently active one, no need for a stack of them
462 : int m_nNestedCells;
463 : std::deque<RTFSprms> m_aNestedTableCellsSprms;
464 : std::deque<RTFSprms> m_aNestedTableCellsAttributes;
465 : /// cell props buffer for top-level table, reset by \row
466 : int m_nTopLevelCells;
467 : std::deque<RTFSprms> m_aTopLevelTableCellsSprms;
468 : std::deque<RTFSprms> m_aTopLevelTableCellsAttributes;
469 : /// backup of top-level props, to support inheriting cell props
470 : int m_nInheritingCells;
471 : std::deque<RTFSprms> m_aTableInheritingCellsSprms;
472 : std::deque<RTFSprms> m_aTableInheritingCellsAttributes;
473 :
474 : /// Current cellx value (nested table)
475 : int m_nNestedCurrentCellX;
476 : /// Current cellx value (top-level table)
477 : int m_nTopLevelCurrentCellX;
478 :
479 : // Backup of what \trowd clears, to work around invalid input.
480 : RTFSprms m_aBackupTableRowSprms;
481 : RTFSprms m_aBackupTableRowAttributes;
482 : int m_nBackupTopLevelCurrentCellX;
483 :
484 : /// Buffered table cells, till cell definitions are not reached.
485 : /// for nested table, one buffer per table level
486 : std::deque< RTFBuffer_t > m_aTableBufferStack;
487 : /// Buffered superscript, till footnote is reached (or not).
488 : RTFBuffer_t m_aSuperBuffer;
489 :
490 : bool m_bHasFootnote;
491 : /// Superstream of this substream.
492 : RTFDocumentImpl *m_pSuperstream;
493 : /// Type of the stream: header, footer, footnote, etc.
494 : Id m_nStreamType;
495 : std::queue< std::pair<Id, sal_Size> > m_nHeaderFooterPositions;
496 : sal_Size m_nGroupStartPos;
497 : /// Ignore the first occurrence of this text.
498 : OUString m_aIgnoreFirst;
499 : /// Bookmark name <-> index map.
500 : std::map<OUString, int> m_aBookmarks;
501 : /// Revision index <-> author map.
502 : std::map<int, OUString> m_aAuthors;
503 : /// Annotation author of the next annotation.
504 : OUString m_aAuthor;
505 : /// Initials of author of the next annotation.
506 : OUString m_aAuthorInitials;
507 :
508 : RTFSprms m_aFormfieldSprms;
509 : RTFSprms m_aFormfieldAttributes;
510 : RTFFormFieldTypes m_nFormFieldType;
511 :
512 : RTFSprms m_aObjectSprms;
513 : RTFSprms m_aObjectAttributes;
514 : /** If we are in an object group and if the we use its
515 : * \objdata element.
516 : * (if we don't use the \objdata we use the \result element)*/
517 : bool m_bObject;
518 : /// Contents of the objdata group.
519 : boost::shared_ptr<SvStream> m_pObjectData;
520 : /// If the data for a picture is a binary one, it's stored here.
521 : boost::shared_ptr<SvStream> m_pBinaryData;
522 :
523 : RTFReferenceTable::Entries_t m_aFontTableEntries;
524 : int m_nCurrentFontIndex;
525 : /// Used only during font table parsing till we don't know the font name.
526 : int m_nCurrentEncoding;
527 : /// Raw default font index, use getFont() on it to get a real one.
528 : int m_nDefaultFontIndex;
529 :
530 : RTFReferenceTable::Entries_t m_aStyleTableEntries;
531 : int m_nCurrentStyleIndex;
532 : bool m_bFormField;
533 : /// If a frame start token is already sent to dmapper (nesting them is not OK).
534 : bool m_bIsInFrame;
535 : // Unicode characters are collected here so we don't have to send them one by one.
536 : OUStringBuffer m_aUnicodeBuffer;
537 : /// Same for hex characters.
538 : OStringBuffer m_aHexBuffer;
539 : /// Formula import.
540 : oox::formulaimport::XmlStreamBuilder m_aMathBuffer;
541 : /// Normal text property, that is math italic and math spacing are not applied to the current run.
542 : bool m_bMathNor;
543 : /// If the next continuous section break should be ignored.
544 : bool m_bIgnoreNextContSectBreak;
545 : /// clean up a synthetic page break, see RTF_PAGE
546 : /// if inactive value is -1, otherwise the RTF_SKB* to restore
547 : RTFKeyword m_nResetBreakOnSectBreak;
548 : /// If a section break is needed before the end of the doc (false right after a section break).
549 : bool m_bNeedSect;
550 : /// If aFrame.inFrame() was true in the previous state.
551 : bool m_bWasInFrame;
552 : /// A picture was seen in the current paragraph.
553 : bool m_bHadPicture;
554 : /// The document has multiple sections.
555 : bool m_bHadSect;
556 : /// Max width of the rows in the current table.
557 : int m_nCellxMax;
558 : /// ID of the next \listlevel picture.
559 : int m_nListPictureId;
560 : };
561 : } // namespace rtftok
562 : } // namespace writerfilter
563 :
564 : #endif // _RTFDOCUMENTIMPL_HXX_
565 :
566 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
