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 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil -*- */ 25 /// @HTML 26 27 #ifndef SW_WRITERHELPER 28 #define SW_WRITERHELPER 29 30 #include <typeinfo> 31 #include <vector> 32 #include <map> 33 #include <com/sun/star/embed/XEmbeddedObject.hpp> 34 35 #include <sfx2/objsh.hxx> 36 #include "types.hxx" 37 #include <svl/itempool.hxx> //SfxItemPool 38 #include <svl/itemset.hxx> //SfxItemSet 39 #include <format.hxx> //SwFmt 40 #include <node.hxx> //SwCntntNode 41 #include <pam.hxx> //SwPaM 42 #include <tools/poly.hxx> //Polygon, PolyPolygon 43 #include <doc.hxx> //SwDoc 44 45 //Uncomment to dump debugging streams of graphics 46 #if OSL_DEBUG_LEVEL > 1 47 //# define DEBUGDUMP 48 #endif 49 50 class SwTxtFmtColl; 51 class SwCharFmt; 52 class SdrObject; 53 class SdrOle2Obj; 54 class OutlinerParaObject; 55 class SdrTextObj; 56 class SwNumFmt; 57 class SwTxtNode; 58 class SwNoTxtNode; 59 class SwFmtCharFmt; 60 class Graphic; 61 class SwDoc; 62 class SwNumRule; 63 64 namespace sw 65 { 66 namespace util 67 { 68 class ItemSort 69 : public std::binary_function<sal_uInt16, sal_uInt16, bool> 70 { 71 public: 72 bool operator()(sal_uInt16 nA, sal_uInt16 nB) const; 73 }; 74 } 75 } 76 77 namespace sw 78 { 79 /// STL container of Paragraph Styles (SwTxtFmtColl) 80 typedef std::vector<SwTxtFmtColl *> ParaStyles; 81 /// STL iterator for ParaStyles 82 typedef ParaStyles::iterator ParaStyleIter; 83 /// STL container of SfxPoolItems (Attributes) 84 typedef std::map<sal_uInt16, const SfxPoolItem *, sw::util::ItemSort> PoolItems; 85 /// STL const iterator for ParaStyles 86 typedef PoolItems::const_iterator cPoolItemIter; 87 88 89 /** Make exporting a Writer Frame easy 90 91 In word all frames are effectively anchored to character or as 92 character. This is nice and simple, Writer is massively complex in this 93 area, so this sw::Frame simplies matters by providing a single unified 94 view of the multitude of elements in Writer and their differing quirks. 95 96 A sw::Frame wraps a Writer frame and is guaranted to have a suitable 97 anchor position available from it. It hides much of the needless 98 complexity of the multitude of floating/inline elements in Writer, it... 99 100 Guarantees an anchor position for a frame. 101 Provides a readable way to see if we are anchored inline. (as character) 102 Provides a simple way to flag what type of entity this frame describes. 103 Provides the size of the element as drawn by Writer. 104 105 @author 106 <a href="mailto:cmc@openoffice.org">Caolán McNamara</a> 107 */ 108 class Frame 109 { 110 public: 111 enum WriterSource {eTxtBox, eGraphic, eOle, eDrawing, eFormControl,eBulletGrf};//For i120928,add Grf Bul Type 112 private: 113 const SwFrmFmt* mpFlyFrm; 114 SwPosition maPos; 115 Size maSize; 116 // --> OD 2007-04-19 #i43447# 117 // Size of the frame in the layout. 118 // Especially needed for graphics, whose layout size can differ from its 119 // size, because it is scaled into its environment. 120 Size maLayoutSize; 121 // <-- 122 WriterSource meWriterType; 123 const SwNode *mpStartFrameContent; 124 bool mbIsInline; 125 bool mbForBullet:1; 126 Graphic maGrf; 127 public: 128 Frame(const SwFrmFmt &rFlyFrm, const SwPosition &rPos); 129 Frame(const Graphic&, const SwPosition &); 130 //End 131 /** Get the Writer SwFrmFmt that this object describes 132 133 @return 134 The wrapped SwFrmFmt 135 */ GetFrmFmt() const136 const SwFrmFmt &GetFrmFmt() const { return *mpFlyFrm; } 137 138 /** Get the position this frame is anchored at 139 140 @return 141 The anchor position of this frame 142 */ GetPosition() const143 const SwPosition &GetPosition() const { return maPos; } 144 145 /** Get the node this frame is anchored into 146 147 @return 148 The SwTxtNode this frame is anchored inside 149 */ GetCntntNode() const150 const SwCntntNode *GetCntntNode() const 151 { return maPos.nNode.GetNode().GetCntntNode(); } 152 153 /** Get the type of frame that this wraps 154 155 @return 156 a WriterSource which describes the source type of this wrapper 157 */ GetWriterType() const158 WriterSource GetWriterType() const { return meWriterType; } 159 160 /** Is this frame inline (as character) 161 162 @return 163 whether this is inline or not 164 */ 165 bool IsInline() const; 166 167 168 /** Even if the frame isn't an inline frame, force it to behave as one 169 170 There are a variety of circumstances where word cannot have 171 anything except inline elements, e.g. inside frames. So it's easier 172 to force this sw::Frame into behaving as one, instead of special 173 casing export code all over the place. 174 175 */ 176 void ForceTreatAsInline(); 177 178 /** Get the first node of content in the frame 179 180 @return 181 the first node of content in the frame, might not be any at all. 182 */ GetContent() const183 const SwNode *GetContent() const { return mpStartFrameContent; } GetGraphic() const184 const Graphic &GetGraphic() const { return maGrf; } HasGraphic() const185 bool HasGraphic() const { return mbForBullet; } 186 187 188 /** Does this sw::Frame refer to the same Writer content as another 189 190 @return 191 if the two sw::Frames are handling the same Writer frame 192 */ RefersToSameFrameAs(const Frame & rOther) const193 bool RefersToSameFrameAs(const Frame &rOther) const 194 { 195 if (mbForBullet && rOther.mbForBullet) 196 return (maGrf == rOther.maGrf); 197 else if ((!mbForBullet) && (!rOther.mbForBullet)) 198 return (mpFlyFrm == rOther.mpFlyFrm); 199 200 return false; 201 } 202 203 /** The Size of the contained element 204 205 @return 206 the best size to use to export to word 207 */ GetSize() const208 const Size GetSize() const { return maSize; } 209 210 /** The layout size of the contained element 211 212 OD 2007-04-19 #i43447# 213 Needed for graphics, which are scaled into its environment 214 215 @return layout size 216 */ GetLayoutSize() const217 const Size GetLayoutSize() const 218 { 219 return maLayoutSize; 220 } 221 }; 222 223 /// STL container of Frames 224 typedef std::vector<Frame> Frames; 225 /// STL iterator for Frames 226 typedef std::vector<Frame>::iterator FrameIter; 227 } 228 229 namespace sw 230 { 231 namespace util 232 { 233 /** Provide a dynamic_cast style cast for SfxPoolItems 234 235 A SfxPoolItem generally need to be cast back to its original type 236 to be useful, which is both tedious and error prone. So item_cast is 237 a helper template to aid the process and test if the cast is 238 correct. 239 240 @param rItem 241 The SfxPoolItem which is to be casted 242 243 @tplparam T 244 A SfxPoolItem derived class to cast rItem to 245 246 @return A rItem upcasted back to a T 247 248 @exception std::bad_cast Thrown if the rItem was not a T 249 250 @author 251 <a href="mailto:cmc@openoffice.org">Caolán McNamara</a> 252 */ item_cast(const SfxPoolItem & rItem)253 template<class T> const T & item_cast(const SfxPoolItem &rItem) 254 throw(std::bad_cast) 255 { 256 if (!rItem.IsA(STATICTYPE(T))) 257 throw std::bad_cast(); 258 return static_cast<const T &>(rItem); 259 } 260 261 /** Provide a dynamic_cast style cast for SfxPoolItems 262 263 A SfxPoolItem generally need to be cast back to its original type 264 to be useful, which is both tedious and errorprone. So item_cast is 265 a helper template to aid the process and test if the cast is 266 correct. 267 268 @param pItem 269 The SfxPoolItem which is to be casted 270 271 @tplparam T 272 A SfxPoolItem derived class to cast pItem to 273 274 @return A pItem upcasted back to a T or 0 if pItem was not a T 275 276 @author 277 <a href="mailto:cmc@openoffice.org">Caolán McNamara</a> 278 */ item_cast(const SfxPoolItem * pItem)279 template<class T> const T * item_cast(const SfxPoolItem *pItem) 280 { 281 if (pItem && !pItem->IsA(STATICTYPE(T))) 282 pItem = 0; 283 return static_cast<const T *>(pItem); 284 } 285 286 /** Extract a SfxPoolItem derived property from a SwCntntNode 287 288 Writer's attributes are retrieved by passing a numeric identifier 289 and receiving a SfxPoolItem reference which must then typically be 290 cast back to its original type which is both tedious and verbose. 291 292 ItemGet uses item_cast () on the retrieved reference to test that the 293 retrieved property is of the type that the developer thinks it is. 294 295 @param rNode 296 The SwCntntNode to retrieve the property from 297 298 @param eType 299 The numeric identifier of the property to be retrieved 300 301 @tplparam T 302 A SfxPoolItem derived class of the retrieved property 303 304 @exception std::bad_cast Thrown if the property was not a T 305 306 @return The T requested 307 308 @author 309 <a href="mailto:cmc@openoffice.org">Caolán McNamara</a> 310 */ ItemGet(const SwCntntNode & rNode,sal_uInt16 eType)311 template<class T> const T & ItemGet(const SwCntntNode &rNode, 312 sal_uInt16 eType) throw(std::bad_cast) 313 { 314 return item_cast<T>(rNode.GetAttr(eType)); 315 } 316 317 /** Extract a SfxPoolItem derived property from a SwFmt 318 319 Writer's attributes are retrieved by passing a numeric identifier 320 and receiving a SfxPoolItem reference which must then typically be 321 cast back to its original type which is both tedious and verbose. 322 323 ItemGet uses item_cast () on the retrieved reference to test that the 324 retrieved property is of the type that the developer thinks it is. 325 326 @param rFmt 327 The SwFmt to retrieve the property from 328 329 @param eType 330 The numeric identifier of the property to be retrieved 331 332 @tplparam T 333 A SfxPoolItem derived class of the retrieved property 334 335 @exception std::bad_cast Thrown if the property was not a T 336 337 @author 338 <a href="mailto:cmc@openoffice.org">Caolán McNamara</a> 339 */ ItemGet(const SwFmt & rFmt,sal_uInt16 eType)340 template<class T> const T & ItemGet(const SwFmt &rFmt, 341 sal_uInt16 eType) throw(std::bad_cast) 342 { 343 return item_cast<T>(rFmt.GetFmtAttr(eType)); 344 } 345 346 /** Extract a SfxPoolItem derived property from a SfxItemSet 347 348 Writer's attributes are retrieved by passing a numeric identifier 349 and receiving a SfxPoolItem reference which must then typically be 350 cast back to its original type which is both tedious and verbose. 351 352 ItemGet uses item_cast () on the retrieved reference to test that the 353 retrieved property is of the type that the developer thinks it is. 354 355 @param rSet 356 The SfxItemSet to retrieve the property from 357 358 @param eType 359 The numeric identifier of the property to be retrieved 360 361 @tplparam T 362 A SfxPoolItem derived class of the retrieved property 363 364 @exception std::bad_cast Thrown if the property was not a T 365 366 @return The T requested 367 368 @author 369 <a href="mailto:cmc@openoffice.org">Caolán McNamara</a> 370 */ ItemGet(const SfxItemSet & rSet,sal_uInt16 eType)371 template<class T> const T & ItemGet(const SfxItemSet &rSet, 372 sal_uInt16 eType) throw(std::bad_cast) 373 { 374 return item_cast<T>(rSet.Get(eType)); 375 } 376 377 /** Extract a default SfxPoolItem derived property from a SfxItemPool 378 379 Writer's attributes are retrieved by passing a numeric identifier 380 and receiving a SfxPoolItem reference which must then typically be 381 cast back to its original type which is both tedious and verbose. 382 383 DefaultItemGet returns a reference to the default property of a 384 given SfxItemPool for a given property id, e.g. default fontsize 385 386 DefaultItemGet uses item_cast () on the retrieved reference to test 387 that the retrieved property is of the type that the developer thinks 388 it is. 389 390 @param rPool 391 The SfxItemPool whose default property we want 392 393 @param eType 394 The numeric identifier of the default property to be retrieved 395 396 @tplparam T 397 A SfxPoolItem derived class of the retrieved property 398 399 @exception std::bad_cast Thrown if the property was not a T 400 401 @return The T requested 402 403 @author 404 <a href="mailto:cmc@openoffice.org">Caolán McNamara</a> 405 */ DefaultItemGet(const SfxItemPool & rPool,sal_uInt16 eType)406 template<class T> const T & DefaultItemGet(const SfxItemPool &rPool, 407 sal_uInt16 eType) throw(std::bad_cast) 408 { 409 return item_cast<T>(rPool.GetDefaultItem(eType)); 410 } 411 412 /** Extract a default SfxPoolItem derived property from a SwDoc 413 414 Writer's attributes are retrieved by passing a numeric identifier 415 and receiving a SfxPoolItem reference which must then typically be 416 cast back to its original type which is both tedious and verbose. 417 418 DefaultItemGet returns a reference to the default property of a 419 given SwDoc (Writer Document) for a given property id, e.g default 420 fontsize 421 422 DefaultItemGet uses item_cast () on the retrieved reference to test 423 that the retrieved property is of the type that the developer thinks 424 it is. 425 426 @param rPool 427 The SfxItemPool whose default property we want 428 429 @param eType 430 The numeric identifier of the default property to be retrieved 431 432 @tplparam T 433 A SfxPoolItem derived class of the retrieved property 434 435 @exception std::bad_cast Thrown if the property was not a T 436 437 @return The T requested 438 439 @author 440 <a href="mailto:cmc@openoffice.org">Caolán McNamara</a> 441 */ DefaultItemGet(const SwDoc & rDoc,sal_uInt16 eType)442 template<class T> const T & DefaultItemGet(const SwDoc &rDoc, 443 sal_uInt16 eType) throw(std::bad_cast) 444 { 445 return DefaultItemGet<T>(rDoc.GetAttrPool(), eType); 446 } 447 448 /** Return a pointer to a SfxPoolItem derived class if it exists in an 449 SfxItemSet 450 451 Writer's attributes are retrieved by passing a numeric identifier 452 and receiving a SfxPoolItem reference which must then typically be 453 cast back to its original type which is both tedious and verbose. 454 455 HasItem returns a pointer to the requested SfxPoolItem for a given 456 property id if it exists in the SfxItemSet or its chain of parents, 457 e.g. fontsize 458 459 HasItem uses item_cast () on the retrieved pointer to test that the 460 retrieved property is of the type that the developer thinks it is. 461 462 @param rSet 463 The SfxItemSet whose property we want 464 465 @param eType 466 The numeric identifier of the default property to be retrieved 467 468 @tplparam T 469 A SfxPoolItem derived class of the retrieved property 470 471 @return The T requested or 0 if no T found with id eType 472 473 @author 474 <a href="mailto:cmc@openoffice.org">Caolán McNamara</a> 475 */ HasItem(const SfxItemSet & rSet,sal_uInt16 eType)476 template<class T> const T* HasItem(const SfxItemSet &rSet, 477 sal_uInt16 eType) 478 { 479 return item_cast<T>(rSet.GetItem(eType)); 480 } 481 482 /** Return a pointer to a SfxPoolItem derived class if it exists in an 483 SwFmt 484 485 Writer's attributes are retrieved by passing a numeric identifier 486 and receiving a SfxPoolItem reference which must then typically be 487 cast back to its original type which is both tedious and verbose. 488 489 HasItem returns a pointer to the requested SfxPoolItem for a given 490 property id if it exists in the SwFmt e.g. fontsize 491 492 HasItem uses item_cast () on the retrieved pointer to test that the 493 retrieved property is of the type that the developer thinks it is. 494 495 @param rSet 496 The SwFmt whose property we want 497 498 @param eType 499 The numeric identifier of the default property to be retrieved 500 501 @tplparam T 502 A SfxPoolItem derived class of the retrieved property 503 504 @return The T requested or 0 if no T found with id eType 505 506 @author 507 <a href="mailto:cmc@openoffice.org">Caolán McNamara</a> 508 */ HasItem(const SwFmt & rFmt,sal_uInt16 eType)509 template<class T> const T* HasItem(const SwFmt &rFmt, 510 sal_uInt16 eType) 511 { 512 return HasItem<T>(rFmt.GetAttrSet(), eType); 513 } 514 515 /** Get the Paragraph Styles of a SwDoc 516 517 Writer's styles are in one of those dreaded macro based pre-STL 518 containers. Give me an STL container of the paragraph styles 519 instead. 520 521 @param rDoc 522 The SwDoc document to get the styles from 523 524 @return A ParaStyles containing the SwDoc's Paragraph Styles 525 526 @author 527 <a href="mailto:cmc@openoffice.org">Caolán McNamara</a> 528 */ 529 ParaStyles GetParaStyles(const SwDoc &rDoc); 530 531 532 /** Get a Paragraph Style which fits a given name 533 534 Its surprisingly tricky to get a style when all you have is a name, 535 but that's what this does 536 537 @param rDoc 538 The SwDoc document to search in 539 540 @param rName 541 The name of the style to search for 542 543 @return A Paragraph Style if one exists which matches the name 544 545 @author 546 <a href="mailto:cmc@openoffice.org">Caolán McNamara</a> 547 */ 548 SwTxtFmtColl* GetParaStyle(SwDoc &rDoc, const String& rName); 549 550 /** Get a Character Style which fits a given name 551 552 It's surprisingly tricky to get a style when all you have is a name, 553 but that's what this does 554 555 @param rDoc 556 The SwDoc document to search in 557 558 @param rName 559 The name of the style to search for 560 561 @return A Character Style if one exists which matches the name 562 563 @author 564 <a href="mailto:cmc@openoffice.org">Caolán McNamara</a> 565 */ 566 SwCharFmt* GetCharStyle(SwDoc &rDoc, const String& rName); 567 568 /** Sort sequence of Paragraph Styles by assigned outline style list level 569 570 Sort ParaStyles in ascending order of assigned outline style list level, 571 e.g. given Normal/Heading1/Heading2/.../Heading10 at their default 572 assigned outline style list levels of body level/level 1/level 2/.../level 10 573 574 OD 2009-02-04 #i98791# 575 adjust the sorting algorithm due to introduced outline level attribute 576 577 @param rStyles 578 The ParaStyles to sort 579 580 @author 581 <a href="mailto:cmc@openoffice.org">Caolán McNamara</a> 582 */ 583 void SortByAssignedOutlineStyleListLevel(ParaStyles &rStyles); 584 585 /** Get the SfxPoolItems of a SfxItemSet 586 587 Writer's SfxPoolItems (attributes) are in one of those dreaded 588 macro based pre-STL containers. Give me an STL container of the 589 items instead. 590 591 @param rSet 592 The SfxItemSet to get the items from 593 594 @param rItems 595 The sw::PoolItems to put the items into 596 597 @author 598 <a href="mailto:cmc@openoffice.org">Caolán McNamara</a> 599 */ 600 void GetPoolItems(const SfxItemSet &rSet, PoolItems &rItems, bool bExportParentItemSet ); 601 602 const SfxPoolItem *SearchPoolItems(const PoolItems &rItems, 603 sal_uInt16 eType); 604 HasItem(const sw::PoolItems & rItems,sal_uInt16 eType)605 template<class T> const T* HasItem(const sw::PoolItems &rItems, 606 sal_uInt16 eType) 607 { 608 return item_cast<T>(SearchPoolItems(rItems, eType)); 609 } 610 611 612 /** Remove properties from an SfxItemSet which a SwFmtCharFmt overrides 613 614 Given an SfxItemSet and a SwFmtCharFmt remove from the rSet all the 615 properties which the SwFmtCharFmt would override. An SfxItemSet 616 contains attributes, and a SwFmtCharFmt is a "Character Style", 617 so if the SfxItemSet contains bold and so does the character style 618 then delete bold from the SfxItemSet 619 620 @param 621 rFmt the SwFmtCharFmt which describes the Character Style 622 623 @param 624 rSet the SfxItemSet from which we want to remove any properties 625 which the rFmt would override 626 627 @author 628 <a href="mailto:cmc@openoffice.org">Caolán McNamara</a> 629 630 @see #i24291# for examples 631 */ 632 void ClearOverridesFromSet(const SwFmtCharFmt &rFmt, SfxItemSet &rSet); 633 634 /** Get the Floating elements in a SwDoc 635 636 Writer's FrmFmts may or may not be anchored to some text content, 637 e.g. Page Anchored elements will not be. For the winword export we 638 need them to have something to be anchored to. So this method 639 returns all the floating elements in a document as a STL container 640 of sw::Frames which are guaranteed to have an appropriate anchor. 641 642 @param rDoc 643 The SwDoc document to get the styles from 644 645 @param pPaM 646 The SwPam to describe the selection in the document to get the 647 elements from. 0 means the entire document. 648 649 @return A Frames containing the selections Floating elements 650 651 @author 652 <a href="mailto:cmc@openoffice.org">Caolán McNamara</a> 653 */ 654 Frames GetFrames(const SwDoc &rDoc, SwPaM *pPaM = 0); 655 656 /** Get the Frames anchored to a given node 657 658 Given a container of frames, find the ones anchored to a given node 659 660 @param rFrames 661 The container of frames to search in 662 663 @param rNode 664 The SwNode to check for anchors to 665 666 @return the Frames in rFrames anchored to rNode 667 668 @author 669 <a href="mailto:cmc@openoffice.org">Caolán McNamara</a> 670 */ 671 Frames GetFramesInNode(const Frames &rFrames, const SwNode &rNode); 672 673 #if 0 674 /** Get the Frames anchored for all nodes between two points 675 676 Given a container of frames, find the ones anchored to the nodes 677 from start to end. Half open sequence, i.e. those anchored to 678 start, but not those anchored to end 679 680 @param rFrames 681 The container of frames to search in 682 683 @param rStart 684 The SwNode to start check for anchors from 685 686 @param rEnd 687 The SwNode to end check for anchors from 688 689 @return the Frames in rFrames anchored to rNode 690 691 @author 692 <a href="mailto:cmc@openoffice.org">Caolán McNamara</a> 693 */ 694 Frames GetFramesBetweenNodes(const Frames &rFrames, 695 const SwNode &rStart, const SwNode &rEnd); 696 #endif 697 /** Get the Numbering Format used on a paragraph 698 699 There are two differing types of numbering formats that may be on a 700 paragraph, normal and outline. The outline is that numbering you 701 see in tools->outline numbering. Theres no difference in the 702 numbering itself, just how you get it from the SwTxtNode. Needless 703 to say the filter generally couldn't care less what type of 704 numbering is in use. 705 706 @param rTxtNode 707 The SwTxtNode that is the paragraph 708 709 @return A SwNumFmt pointer that describes the numbering level 710 on this paragraph, or 0 if there is none. 711 712 @author 713 <a href="mailto:cmc@openoffice.org">Caolán McNamara</a> 714 */ 715 const SwNumFmt* GetNumFmtFromTxtNode(const SwTxtNode &rTxtNode); 716 717 const SwNumRule* GetNumRuleFromTxtNode(const SwTxtNode &rTxtNd); 718 const SwNumRule* GetNormalNumRuleFromTxtNode(const SwTxtNode &rTxtNd); 719 720 721 /** Get the SwNoTxtNode associated with a SwFrmFmt if here is one 722 723 There are two differing types of numbering formats that may be on a 724 paragraph, normal and outline. The outline is that numbering you 725 see in tools->outline numbering. Theres no difference in the 726 numbering itself, just how you get it from the SwTxtNode. Needless 727 to say the filter generally couldn't care less what type of 728 numbering is in use. 729 730 @param rFmt 731 The SwFrmFmt that may describe a graphic 732 733 @return A SwNoTxtNode pointer that describes the graphic of this 734 frame if there is one, or 0 if there is none. 735 736 @author 737 <a href="mailto:cmc@openoffice.org">Caolán McNamara</a> 738 */ 739 SwNoTxtNode *GetNoTxtNodeFromSwFrmFmt(const SwFrmFmt &rFmt); 740 741 /** Does a node have a "page break before" applied 742 743 Both text nodes and tables in Writer can have "page break before" 744 This function gives a unified view to both entities 745 746 @param rNode 747 The SwNode to query the page break of 748 749 @return true if there is a page break, false otherwise 750 751 @author 752 <a href="mailto:cmc@openoffice.org">Caolán McNamara</a> 753 */ 754 bool HasPageBreak(const SwNode &rNode); 755 756 757 /** Make a best fit Polygon from a PolyPolygon 758 759 For custom contours in Writer we use a PolyPolygon, while word uses 760 a simple polygon, so we need to try and make the best polygon from 761 a PolyPolygon 762 763 @param rPolyPoly 764 The PolyPolygon to try and turn into a Polygon 765 766 @return best fit Polygon from rPolyPoly 767 768 @author 769 <a href="mailto:cmc@openoffice.org">Caolán McNamara</a> 770 */ 771 Polygon PolygonFromPolyPolygon(const PolyPolygon &rPolyPoly); 772 773 /** Determine if the font is the special Star|Open Symbol font 774 775 @param rFontName 776 The FontName to test for being Star|Open Symbol 777 778 @return true if this is Star|Open Symbol 779 780 @author 781 <a href="mailto:cmc@openoffice.org">Caolán McNamara</a> 782 */ 783 bool IsStarSymbol(const String &rFontName); 784 785 /** Make setting a drawing object's layer in a Writer document easy 786 787 788 Word has the simple concept of a drawing object either in the 789 foreground and in the background. We have an additional complexity 790 that form components live in a separate layer, which seems 791 unnecessarily complicated. So in the winword filter we set the 792 object's layer through this class with either SendObjectToHell for 793 the bottom layer and SendObjectToHeaven for the top and we don't 794 worry about the odd form layer design wrinkle. 795 796 @author 797 <a href="mailto:cmc@openoffice.org">Caolán McNamara</a> 798 */ 799 class SetLayer 800 { 801 private: 802 sal_uInt8 mnHeavenLayer, mnHellLayer, mnFormLayer; 803 enum Layer {eHeaven, eHell}; 804 void SetObjectLayer(SdrObject &rObject, Layer eLayer) const; 805 void Swap(SetLayer &rOther) throw(); 806 public: 807 808 /** Make Object live in the bottom drawing layer 809 810 @param rObject 811 The object to be set to the bottom layer 812 */ 813 void SendObjectToHell(SdrObject &rObject) const; 814 815 /** Make Object lives in the top top layer 816 817 @param rObject 818 The object to be set to the bottom layer 819 */ 820 void SendObjectToHeaven(SdrObject &rObject) const; 821 822 /** Normal constructor 823 824 @param rDoc 825 The Writer document whose drawing layers we will be inserting 826 objects into 827 */ 828 SetLayer(const SwDoc &rDoc); 829 830 SetLayer(const SetLayer &rOther) throw(); 831 SetLayer& operator=(const SetLayer &rOther) throw(); 832 }; 833 } 834 835 namespace hack 836 { 837 /** Map an ID valid in one SfxItemPool to its equivalent in another 838 839 Given a WhichId (the id that identifies a property e.g. bold) which 840 is correct in a given SfxItemPool, get the equivalent whichId in 841 another SfxItemPool 842 843 This arises because the drawing layer uses the same properties as 844 Writer e.g. SvxWeight, but for some reason uses different ids 845 for the same properties as Writer. 846 847 @param rDestPool 848 The SfxItemPool in whose terms the Id is returned 849 850 @param rSrcPool 851 The SfxItemPool in whose terms the Id is passed in 852 853 @param nWhich 854 The Id to transform from source to dest 855 856 @return 0 on failure, the correct property Id on success 857 858 @author 859 <a href="mailto:cmc@openoffice.org">Caolán McNamara</a> 860 */ 861 sal_uInt16 TransformWhichBetweenPools(const SfxItemPool &rDestPool, 862 const SfxItemPool &rSrcPool, sal_uInt16 nWhich); 863 864 /** Map a SwDoc WhichId to the equivalent Id for a given SfxItemSet 865 866 Given a WhichId (the id that identifies a property e.g. bold) which 867 is correct for a Writer document, get the equivalent whichId which 868 for a given SfxItemSet. 869 870 This arises because the drawing layer uses the same properties as 871 Writer e.g. SvxWeight, but for some reason uses different ids 872 for the same properties as Writer. 873 874 This is effectively the same as TransformWhichBetweenPools except 875 at a slightly different layer. 876 877 @param rSet 878 The SfxItemSet in whose terms the Id is returned 879 880 @param rDoc 881 The SwDoc in whose terms the Id is passed in 882 883 @param nWhich 884 The Id to transform from Writer to the SfxItemSet's domain 885 886 @return 0 on failure, the correct SfxItemSet Id on success 887 888 @author 889 <a href="mailto:cmc@openoffice.org">Caolán McNamara</a> 890 */ 891 sal_uInt16 GetSetWhichFromSwDocWhich(const SfxItemSet &rSet, 892 const SwDoc &rDoc, sal_uInt16 nWhich); 893 894 895 /** Make inserting an OLE object into a Writer document easy 896 897 The rest of Office uses SdrOle2Obj for their OLE objects, Writer 898 doesn't, which makes things a bit difficult as this is the type of 899 object that the escher import code shared by the MSOffice filters 900 produces when it imports an OLE object. 901 902 This utility class takes ownership of the OLE object away from a 903 SdrOle2Obj and can massage it into the condition best suited to 904 insertion into Writer. 905 906 If the object was not transferred into Writer then it is deleted 907 during destruction. 908 909 @author 910 <a href="mailto:cmc@openoffice.org">Caolán McNamara</a> 911 */ 912 class DrawingOLEAdaptor 913 { 914 private: 915 String msOrigPersistName; 916 com::sun::star::uno::Reference < com::sun::star::embed::XEmbeddedObject > mxIPRef; 917 SfxObjectShell& mrPers; 918 Graphic* mpGraphic; 919 public: 920 /** Take ownership of a SdrOle2Objs OLE object 921 922 @param rObj 923 The SdrOle2Obj whose OLE object we want to take control of 924 925 @param rPers 926 The SvPersist of a SwDoc (SwDoc::GetPersist()) into which we 927 may want to move the object, or remove it from if unwanted. 928 */ 929 DrawingOLEAdaptor(SdrOle2Obj &rObj, SfxObjectShell &rPers); 930 931 /// Destructor will destroy the owned OLE object if not transferred 932 ~DrawingOLEAdaptor(); 933 934 /** Transfer ownership of the OLE object to a document's SvPersist 935 936 TransferToDoc moves the object into the persist under the name 937 passed in. This name is then suitable to be used as an argument 938 to SwDoc::InsertOLE. 939 940 The object is no longer owned by the adaptor after this call, 941 subsequent calls are an error and return false. 942 943 @param rName 944 The name to store the object under in the document. 945 946 @return On success true is returned, otherwise false. On 947 success rName is then suitable for user with SwDoc::InsertOLE 948 */ 949 bool TransferToDoc(::rtl::OUString &rName); 950 private: 951 /// No assigning allowed 952 DrawingOLEAdaptor& operator=(const DrawingOLEAdaptor&); 953 /// No copying allowed 954 DrawingOLEAdaptor(const DrawingOLEAdaptor &rDoc); 955 }; 956 957 #ifdef DEBUGDUMP 958 /** Create a SvStream to dump data to during debugging 959 960 This creates a file in the program dir of AOO, delete the SvStream 961 after you are done with it 962 963 @param rSuffix 964 The suffix that will be appended to this debugging file 965 966 @return a SvStream to dump data to 967 968 @author 969 <a href="mailto:cmc@openoffice.org">Caolán McNamara</a> 970 */ 971 SvStream *CreateDebuggingStream(const String &rSuffix); 972 973 /** Dump one SvStream to another 974 975 @param rSrc 976 The source stream 977 978 @param rDest 979 The destination stream 980 981 @param nLen 982 Optional Length of data to copy from rSrc to rDest, if unused copy 983 all available data from rSrc 984 985 @author 986 <a href="mailto:cmc@openoffice.org">Caolán McNamara</a> 987 */ 988 void DumpStream(const SvStream &rSrc, SvStream &rDest, 989 sal_uInt32 nLen = STREAM_SEEK_TO_END); 990 #endif 991 } 992 } 993 994 #endif 995 /* vi:set tabstop=4 shiftwidth=4 expandtab: */ 996