sw/qa/extras/globalfilter/globalfilter.cxx

   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 #include <swmodeltestbase.hxx>
  11
  12 #include <com/sun/star/awt/XBitmap.hpp>
  13 #include <com/sun/star/graphic/XGraphic.hpp>
  14 #include <officecfg/Office/Common.hxx>
  15 #include <comphelper/processfactory.hxx>
  16 #include <unotxdoc.hxx>
  17 #include <docsh.hxx>
  18 #include <doc.hxx>
  19 #include <ndgrf.hxx>
  20 #include <drawdoc.hxx>
  21 #include <unotools/fltrcfg.hxx>
  22
  23 class Test : public SwModelTestBase
  24 {
  25 public:
  26     Test() : SwModelTestBase() {}
  27
  28     void testSwappedOutImageExport();
  29     void testLinkedGraphicRT();
  30     void testImageWithSpecialID();
  31     void testGraphicShape();
  32     void testCharHighlight();
  33     void testCharHighlightBody();
  34     void testMSCharBackgroundEditing();
  35     void testCharBackgroundToHighlighting();
  36     void testSkipImages();
  37
  38     CPPUNIT_TEST_SUITE(Test);
  39     CPPUNIT_TEST(testSwappedOutImageExport);
  40     CPPUNIT_TEST(testLinkedGraphicRT);
  41     CPPUNIT_TEST(testImageWithSpecialID);
  42     CPPUNIT_TEST(testGraphicShape);
  43     CPPUNIT_TEST(testCharHighlight);
  44     CPPUNIT_TEST(testMSCharBackgroundEditing);
  45     CPPUNIT_TEST(testCharBackgroundToHighlighting);
  46 #if !defined(WNT)
  47     CPPUNIT_TEST(testSkipImages);
  48 #endif
  49     CPPUNIT_TEST_SUITE_END();
  50 };
  51
  52 void Test::testSwappedOutImageExport()
  53 {
  54     const char* aFilterNames[] = {
  55         "writer8",
  56         "Rich Text Format",
  57         "MS Word 97",
  58         "Office Open XML Text",
  59     };
  60
  61     for( size_t nFilter = 0; nFilter < SAL_N_ELEMENTS(aFilterNames); ++nFilter )
  62     {
  63         // Check whether the export code swaps in the image which was swapped out before by auto mechanism
  64
  65         // Set cache size to a very small value to make sure one of the images is swapped out
  66         std::shared_ptr< comphelper::ConfigurationChanges > batch(comphelper::ConfigurationChanges::create());
  67         officecfg::Office::Common::Cache::GraphicManager::TotalCacheSize::set(static_cast<sal_Int32>(1), batch);
  68         batch->commit();
  69
  70         if (mxComponent.is())
  71             mxComponent->dispose();
  72         mxComponent = loadFromDesktop(getURLFromSrc("/sw/qa/extras/globalfilter/data/document_with_two_images.odt"), "com.sun.star.text.TextDocument");
  73
  74         // Export the document and import again for a check
  75         uno::Reference<frame::XStorable> xStorable(mxComponent, uno::UNO_QUERY);
  76
  77         utl::MediaDescriptor aMediaDescriptor;
  78         aMediaDescriptor["FilterName"] <<= OUString::createFromAscii(aFilterNames[nFilter]);
  79
  80         utl::TempFile aTempFile;
  81         aTempFile.EnableKillingFile();
  82         xStorable->storeToURL(aTempFile.GetURL(), aMediaDescriptor.getAsConstPropertyValueList());
  83         uno::Reference< lang::XComponent > xComponent(xStorable, uno::UNO_QUERY);
  84         xComponent->dispose();
  85         mxComponent = loadFromDesktop(aTempFile.GetURL(), "com.sun.star.text.TextDocument");
  86
  87         // Check whether graphic exported well after it was swapped out
  88         uno::Reference<drawing::XDrawPageSupplier> xDrawPageSupplier(mxComponent, uno::UNO_QUERY);
  89         uno::Reference<container::XIndexAccess> xDraws(xDrawPageSupplier->getDrawPage(), uno::UNO_QUERY);
  90
  91         const OString sFailedMessage = OString("Failed on filter: ") + aFilterNames[nFilter];
  92         CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(2), xDraws->getCount());
  93
  94         // First image
  95         uno::Reference<drawing::XShape> xImage(xDraws->getByIndex(0), uno::UNO_QUERY);
  96         uno::Reference< beans::XPropertySet > XPropSet( xImage, uno::UNO_QUERY_THROW );
  97         // Check URL
  98         {
  99             OUString sURL;
 100             XPropSet->getPropertyValue("GraphicURL") >>= sURL;
 101             CPPUNIT_ASSERT_MESSAGE(sFailedMessage.getStr(), sURL != "vnd.sun.star.GraphicObject:00000000000000000000000000000000");
 102         }
 103         // Check size
 104         {
 105             uno::Reference<graphic::XGraphic> xGraphic;
 106             XPropSet->getPropertyValue("Graphic") >>= xGraphic;
 107             uno::Reference<awt::XBitmap> xBitmap(xGraphic, uno::UNO_QUERY);
 108             CPPUNIT_ASSERT_MESSAGE(sFailedMessage.getStr(), xBitmap.is());
 109             CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(610), xBitmap->getSize().Width );
 110             CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(381), xBitmap->getSize().Height );
 111         }
 112
 113         // Second Image
 114         xImage.set(xDraws->getByIndex(1), uno::UNO_QUERY);
 115         XPropSet.set( xImage, uno::UNO_QUERY_THROW );
 116         // Check URL
 117         {
 118             OUString sURL;
 119             XPropSet->getPropertyValue("GraphicURL") >>= sURL;
 120             CPPUNIT_ASSERT_MESSAGE(
 121                 sFailedMessage.getStr(), sURL != "vnd.sun.star.GraphicObject:00000000000000000000000000000000");
 122         }
 123         // Check size
 124         {
 125             uno::Reference<graphic::XGraphic> xGraphic;
 126             XPropSet->getPropertyValue("Graphic") >>= xGraphic;
 127             uno::Reference<awt::XBitmap> xBitmap(xGraphic, uno::UNO_QUERY);
 128             CPPUNIT_ASSERT_MESSAGE(sFailedMessage.getStr(), xBitmap.is());
 129             CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(900), xBitmap->getSize().Width );
 130             CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(600), xBitmap->getSize().Height );
 131         }
 132     }
 133 }
 134
 135 void Test::testLinkedGraphicRT()
 136 {
 137     const std::vector<OUString> aFilterNames = {
 138         "writer8",
 139 //        "Rich Text Format",  Note: picture is there, but SwGrfNode is not found?
 140         "MS Word 97",
 141         "Office Open XML Text",
 142     };
 143
 144     for( size_t nFilter = 0; nFilter < aFilterNames.size(); ++nFilter )
 145     {
 146         if (mxComponent.is())
 147             mxComponent->dispose();
 148         mxComponent = loadFromDesktop(getURLFromSrc("/sw/qa/extras/globalfilter/data/document_with_linked_graphic.odt"), "com.sun.star.text.TextDocument");
 149
 150         const OString sFailedMessage = OString("Failed on filter: ")
 151             + OUStringToOString(aFilterNames[nFilter], RTL_TEXTENCODING_ASCII_US);
 152
 153
 154         // Export the document and import again for a check
 155         uno::Reference<frame::XStorable> xStorable(mxComponent, uno::UNO_QUERY);
 156
 157         utl::MediaDescriptor aMediaDescriptor;
 158         aMediaDescriptor["FilterName"] <<= aFilterNames[nFilter];
 159
 160         utl::TempFile aTempFile;
 161         aTempFile.EnableKillingFile();
 162         xStorable->storeToURL(aTempFile.GetURL(), aMediaDescriptor.getAsConstPropertyValueList());
 163         uno::Reference< lang::XComponent > xComponent(xStorable, uno::UNO_QUERY);
 164         xComponent->dispose();
 165         mxComponent = loadFromDesktop(aTempFile.GetURL(), "com.sun.star.text.TextDocument");
 166
 167         SwXTextDocument* pTextDoc = dynamic_cast<SwXTextDocument *>(mxComponent.get());
 168         CPPUNIT_ASSERT_MESSAGE(sFailedMessage.getStr(), pTextDoc);
 169         SwDoc* pDoc = pTextDoc->GetDocShell()->GetDoc();
 170         CPPUNIT_ASSERT_MESSAGE(sFailedMessage.getStr(), pDoc);
 171         SwNodes& aNodes = pDoc->GetNodes();
 172
 173         // Find the image
 174         bool bImageFound = false;
 175         for( sal_uLong nIndex = 0; nIndex < aNodes.Count(); ++nIndex)
 176         {
 177             if( aNodes[nIndex]->IsGrfNode() )
 178             {
 179                 SwGrfNode* pGrfNode = aNodes[nIndex]->GetGrfNode();
 180                 CPPUNIT_ASSERT(pGrfNode);
 181                 // RT via DOCX makes linked graphic embedded?!
 182                 if( aFilterNames[nFilter] != "Office Open XML Text" )
 183                 {
 184                     CPPUNIT_ASSERT_MESSAGE( sFailedMessage.getStr(), pGrfNode->IsGrfLink());
 185                 }
 186                 const GraphicObject& rGraphicObj = pGrfNode->GetGrfObj(true);
 187                 CPPUNIT_ASSERT_MESSAGE( sFailedMessage.getStr(), !rGraphicObj.IsSwappedOut());
 188                 CPPUNIT_ASSERT_EQUAL_MESSAGE( sFailedMessage.getStr(), GRAPHIC_BITMAP, rGraphicObj.GetType());
 189                 CPPUNIT_ASSERT_EQUAL_MESSAGE( sFailedMessage.getStr(), static_cast<sal_uLong>(864900), rGraphicObj.GetSizeBytes());
 190                 bImageFound = true;
 191             }
 192         }
 193         CPPUNIT_ASSERT_MESSAGE(sFailedMessage.getStr(), bImageFound);
 194     }
 195 }
 196
 197 void Test::testImageWithSpecialID()
 198 {
 199     // Check how LO handles when the imported graphic's ID is different from that one
 200     // which is generated by LO.
 201
 202     const char* aFilterNames[] = {
 203         "writer8",
 204         "Rich Text Format",
 205         "MS Word 97",
 206         "Office Open XML Text",
 207     };
 208
 209     // Trigger swap out mechanism to test swapped state factor too.
 210     std::shared_ptr< comphelper::ConfigurationChanges > batch(comphelper::ConfigurationChanges::create());
 211     officecfg::Office::Common::Cache::GraphicManager::TotalCacheSize::set(static_cast<sal_Int32>(1), batch);
 212     batch->commit();
 213
 214     for( size_t nFilter = 0; nFilter < SAL_N_ELEMENTS(aFilterNames); ++nFilter )
 215     {
 216         if (mxComponent.is())
 217             mxComponent->dispose();
 218         mxComponent = loadFromDesktop(getURLFromSrc("/sw/qa/extras/globalfilter/data/images_with_special_IDs.odt"), "com.sun.star.text.TextDocument");
 219
 220         // Export the document and import again for a check
 221         uno::Reference<frame::XStorable> xStorable(mxComponent, uno::UNO_QUERY);
 222
 223         utl::MediaDescriptor aMediaDescriptor;
 224         aMediaDescriptor["FilterName"] <<= OUString::createFromAscii(aFilterNames[nFilter]);
 225
 226         utl::TempFile aTempFile;
 227         aTempFile.EnableKillingFile();
 228         xStorable->storeToURL(aTempFile.GetURL(), aMediaDescriptor.getAsConstPropertyValueList());
 229         uno::Reference< lang::XComponent > xComponent(xStorable, uno::UNO_QUERY);
 230         xComponent->dispose();
 231         mxComponent = loadFromDesktop(aTempFile.GetURL(), "com.sun.star.text.TextDocument");
 232
 233         // Check whether graphic exported well
 234         uno::Reference<drawing::XDrawPageSupplier> xDrawPageSupplier(mxComponent, uno::UNO_QUERY);
 235         uno::Reference<container::XIndexAccess> xDraws(xDrawPageSupplier->getDrawPage(), uno::UNO_QUERY);
 236
 237         const OString sFailedMessage = OString("Failed on filter: ") + aFilterNames[nFilter];
 238         CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(2), xDraws->getCount());
 239
 240         uno::Reference<drawing::XShape> xImage = getShape(1);
 241         uno::Reference< beans::XPropertySet > XPropSet( xImage, uno::UNO_QUERY_THROW );
 242         // Check URL
 243         {
 244             OUString sURL;
 245             XPropSet->getPropertyValue("GraphicURL") >>= sURL;
 246             CPPUNIT_ASSERT(sURL != "vnd.sun.star.GraphicObject:00000000000000000000000000000000");
 247         }
 248         // Check size
 249         {
 250             uno::Reference<graphic::XGraphic> xGraphic;
 251             XPropSet->getPropertyValue("Graphic") >>= xGraphic;
 252             uno::Reference<awt::XBitmap> xBitmap(xGraphic, uno::UNO_QUERY);
 253             CPPUNIT_ASSERT(xBitmap.is());
 254             CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(610), xBitmap->getSize().Width );
 255             CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(381), xBitmap->getSize().Height );
 256         }
 257         // Second Image
 258         xImage = getShape(2);
 259         XPropSet.set( xImage, uno::UNO_QUERY_THROW );
 260         // Check URL
 261         {
 262             OUString sURL;
 263             XPropSet->getPropertyValue("GraphicURL") >>= sURL;
 264             CPPUNIT_ASSERT(sURL != "vnd.sun.star.GraphicObject:00000000000000000000000000000000");
 265         }
 266         // Check size
 267         {
 268             uno::Reference<graphic::XGraphic> xGraphic;
 269             XPropSet->getPropertyValue("Graphic") >>= xGraphic;
 270             uno::Reference<awt::XBitmap> xBitmap(xGraphic, uno::UNO_QUERY);
 271             CPPUNIT_ASSERT(xBitmap.is());
 272             CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(900), xBitmap->getSize().Width );
 273             CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(600), xBitmap->getSize().Height );
 274         }
 275     }
 276 }
 277
 278 void Test::testGraphicShape()
 279 {
 280     // There are two kind of images in Writer: 1) Writer specific handled by SwGrfNode and
 281     // 2) graphic shape handled by SdrGrafObj (e.g. after copy&paste from Impress).
 282
 283     const char* aFilterNames[] = {
 284         "writer8",
 285         "Rich Text Format",
 286         "MS Word 97",
 287         "Office Open XML Text",
 288     };
 289
 290     // Trigger swap out mechanism to test swapped state factor too.
 291     std::shared_ptr< comphelper::ConfigurationChanges > batch(comphelper::ConfigurationChanges::create());
 292     officecfg::Office::Common::Cache::GraphicManager::TotalCacheSize::set(static_cast<sal_Int32>(1), batch);
 293     batch->commit();
 294
 295     for( size_t nFilter = 0; nFilter < SAL_N_ELEMENTS(aFilterNames); ++nFilter )
 296     {
 297         if (mxComponent.is())
 298             mxComponent->dispose();
 299         mxComponent = loadFromDesktop(getURLFromSrc("/sw/qa/extras/globalfilter/data/graphic_shape.odt"), "com.sun.star.text.TextDocument");
 300
 301         // Export the document and import again for a check
 302         uno::Reference<frame::XStorable> xStorable(mxComponent, uno::UNO_QUERY);
 303
 304         utl::MediaDescriptor aMediaDescriptor;
 305         aMediaDescriptor["FilterName"] <<= OUString::createFromAscii(aFilterNames[nFilter]);
 306
 307         utl::TempFile aTempFile;
 308         aTempFile.EnableKillingFile();
 309         xStorable->storeToURL(aTempFile.GetURL(), aMediaDescriptor.getAsConstPropertyValueList());
 310         uno::Reference< lang::XComponent > xComponent(xStorable, uno::UNO_QUERY);
 311         xComponent->dispose();
 312         mxComponent = loadFromDesktop(aTempFile.GetURL(), "com.sun.star.text.TextDocument");
 313
 314         // Check whether graphic exported well
 315         uno::Reference<drawing::XDrawPageSupplier> xDrawPageSupplier(mxComponent, uno::UNO_QUERY);
 316         uno::Reference<container::XIndexAccess> xDraws(xDrawPageSupplier->getDrawPage(), uno::UNO_QUERY);
 317
 318         const OString sFailedMessage = OString("Failed on filter: ") + aFilterNames[nFilter];
 319         CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(2), xDraws->getCount());
 320
 321         uno::Reference<drawing::XShape> xImage = getShape(1);
 322         uno::Reference< beans::XPropertySet > XPropSet( xImage, uno::UNO_QUERY_THROW );
 323         // First image is embedded
 324         // Check URL
 325         {
 326             OUString sURL;
 327             XPropSet->getPropertyValue("GraphicURL") >>= sURL;
 328             CPPUNIT_ASSERT_MESSAGE(sFailedMessage.getStr(), sURL != "vnd.sun.star.GraphicObject:00000000000000000000000000000000");
 329         }
 330         // Check size
 331         {
 332             uno::Reference<graphic::XGraphic> xGraphic;
 333             XPropSet->getPropertyValue("Graphic") >>= xGraphic;
 334             uno::Reference<awt::XBitmap> xBitmap(xGraphic, uno::UNO_QUERY);
 335             CPPUNIT_ASSERT_MESSAGE(sFailedMessage.getStr(), xBitmap.is());
 336             CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(610), xBitmap->getSize().Width );
 337             CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(381), xBitmap->getSize().Height );
 338         }
 339
 340         // MS filters make this kind of linked images broken !?
 341         if( OUString::createFromAscii(aFilterNames[nFilter]) != "writer8" )
 342             return;
 343
 344         // Second image is a linked one
 345         xImage = getShape(2);
 346         XPropSet.set( xImage, uno::UNO_QUERY_THROW );
 347         // Check URL
 348         {
 349             OUString sURL;
 350             XPropSet->getPropertyValue("GraphicURL") >>= sURL;
 351             CPPUNIT_ASSERT_MESSAGE(sFailedMessage.getStr(), sURL.endsWith("linked_graphic.jpg"));
 352         }
 353         // Check size
 354         {
 355             uno::Reference<graphic::XGraphic> xGraphic;
 356             XPropSet->getPropertyValue("Graphic") >>= xGraphic;
 357             uno::Reference<awt::XBitmap> xBitmap(xGraphic, uno::UNO_QUERY);
 358             CPPUNIT_ASSERT_MESSAGE(sFailedMessage.getStr(), xBitmap.is());
 359             CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(620), xBitmap->getSize().Width );
 360             CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(465), xBitmap->getSize().Height );
 361         }
 362     }
 363 }
 364
 365 void Test::testCharHighlightBody()
 366 {
 367     // MS Word has two kind of character backgrounds called character shading and highlighting
 368     // MS filters handle these attributes separately, but ODF export merges them into one background attribute
 369
 370     const char* aFilterNames[] = {
 371         "writer8",
 372         "Rich Text Format",
 373         "MS Word 97",
 374         "Office Open XML Text",
 375     };
 376
 377     for( size_t nFilter = 0; nFilter < SAL_N_ELEMENTS(aFilterNames); ++nFilter )
 378     {
 379         if (mxComponent.is())
 380             mxComponent->dispose();
 381         mxComponent = loadFromDesktop(getURLFromSrc("/sw/qa/extras/globalfilter/data/char_highlight.docx"),
 382                                       "com.sun.star.text.TextDocument");
 383
 384         const OString sFailedMessage = OString("Failed on filter: ") + aFilterNames[nFilter];
 385
 386         // Export the document and import again for a check
 387         uno::Reference<frame::XStorable> xStorable(mxComponent, uno::UNO_QUERY);
 388
 389         utl::MediaDescriptor aMediaDescriptor;
 390         aMediaDescriptor["FilterName"] <<= OUString::createFromAscii(aFilterNames[nFilter]);
 391
 392         utl::TempFile aTempFile;
 393         aTempFile.EnableKillingFile();
 394         xStorable->storeToURL(aTempFile.GetURL(), aMediaDescriptor.getAsConstPropertyValueList());
 395         uno::Reference< lang::XComponent > xComponent(xStorable, uno::UNO_QUERY);
 396         xComponent->dispose();
 397         mxComponent = loadFromDesktop(aTempFile.GetURL(), "com.sun.star.text.TextDocument");
 398
 399         const uno::Reference< text::XTextRange > xPara = getParagraph(1);
 400         // Both highlight and background
 401         const sal_Int32 nBackColor(0x4F81BD);
 402         for( int nRun = 1; nRun <= 16; ++nRun )
 403         {
 404             const uno::Reference<beans::XPropertySet> xRun(getRun(xPara,nRun), uno::UNO_QUERY);
 405             sal_Int32 nHighlightColor = 0;
 406             switch( nRun )
 407             {
 408                 case 1: nHighlightColor = 0x000000; break; //black
 409                 case 2: nHighlightColor = 0x0000ff; break; //blue
 410                 case 3: nHighlightColor = 0x00ffff; break; //cyan
 411                 case 4: nHighlightColor = 0x00ff00; break; //green
 412                 case 5: nHighlightColor = 0xff00ff; break; //magenta
 413                 case 6: nHighlightColor = 0xff0000; break; //red
 414                 case 7: nHighlightColor = 0xffff00; break; //yellow
 415                 case 8: nHighlightColor = 0xffffff; break; //white
 416                 case 9: nHighlightColor = 0x000080;  break;//dark blue
 417                 case 10: nHighlightColor = 0x008080; break; //dark cyan
 418                 case 11: nHighlightColor = 0x008000; break; //dark green
 419                 case 12: nHighlightColor = 0x800080; break; //dark magenta
 420                 case 13: nHighlightColor = 0x800000; break; //dark red
 421                 case 14: nHighlightColor = 0x808000; break; //dark yellow
 422                 case 15: nHighlightColor = 0x808080; break; //dark gray
 423                 case 16: nHighlightColor = 0xC0C0C0; break; //light gray
 424             }
 425
 426             if( strcmp(aFilterNames[nFilter], "writer8") == 0 )
 427             {
 428                 CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(COL_TRANSPARENT), getProperty<sal_Int32>(xRun,"CharHighlight"));
 429                 CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), nHighlightColor, getProperty<sal_Int32>(xRun,"CharBackColor"));
 430             }
 431             else // MS filters
 432             {
 433                 CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), nHighlightColor, getProperty<sal_Int32>(xRun,"CharHighlight"));
 434                 CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), nBackColor, getProperty<sal_Int32>(xRun,"CharBackColor"));
 435             }
 436         }
 437
 438         // Only highlight
 439         {
 440             const uno::Reference<beans::XPropertySet> xRun(getRun(xPara,18), uno::UNO_QUERY);
 441             if( strcmp(aFilterNames[nFilter], "writer8") == 0 )
 442             {
 443                 CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(COL_TRANSPARENT), getProperty<sal_Int32>(xRun,"CharHighlight"));
 444                 CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(0xff0000), getProperty<sal_Int32>(xRun,"CharBackColor"));
 445             }
 446             else
 447             {
 448                 CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(0xff0000), getProperty<sal_Int32>(xRun,"CharHighlight"));
 449                 CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(COL_TRANSPARENT), getProperty<sal_Int32>(xRun,"CharBackColor"));
 450             }
 451         }
 452
 453         // Only background
 454         {
 455             const uno::Reference<beans::XPropertySet> xRun(getRun(xPara,19), uno::UNO_QUERY);
 456             CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(COL_TRANSPARENT), getProperty<sal_Int32>(xRun,"CharHighlight"));
 457             CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(0x0000ff), getProperty<sal_Int32>(xRun,"CharBackColor"));
 458         }
 459     }
 460 }
 461
 462 void Test::testCharHighlight()
 463 {
 464     SvtFilterOptions& rOpt = SvtFilterOptions::Get();
 465     rOpt.SetCharBackground2Shading();
 466
 467     testCharHighlightBody();
 468
 469     rOpt.SetCharBackground2Highlighting();
 470
 471     testCharHighlightBody();
 472 }
 473
 474 void Test::testMSCharBackgroundEditing()
 475 {
 476     // Simulate the editing process of imported MSO character background attributes
 477     // and check how export behaves.
 478
 479     const char* aFilterNames[] = {
 480         "writer8",
 481         "Rich Text Format",
 482         "MS Word 97",
 483         "Office Open XML Text",
 484     };
 485
 486     for( size_t nFilter = 0; nFilter < SAL_N_ELEMENTS(aFilterNames); ++nFilter )
 487     {
 488         if (mxComponent.is())
 489             mxComponent->dispose();
 490
 491         mxComponent = loadFromDesktop(getURLFromSrc("/sw/qa/extras/globalfilter/data/char_background_editing.docx"),
 492                                       "com.sun.star.text.TextDocument");
 493
 494         const OString sFailedMessage = OString("Failed on filter: ") + aFilterNames[nFilter];
 495
 496         // Check whether import was done on the right way
 497         uno::Reference< text::XTextRange > xPara = getParagraph(1);
 498         {
 499             uno::Reference<beans::XPropertySet> xRun(getRun(xPara,1), uno::UNO_QUERY);
 500             CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(COL_TRANSPARENT), getProperty<sal_Int32>(xRun,"CharHighlight"));
 501             CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(0xff0000), getProperty<sal_Int32>(xRun,"CharBackColor"));
 502
 503             xRun.set(getRun(xPara,2), uno::UNO_QUERY);
 504             CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(0x0000ff), getProperty<sal_Int32>(xRun,"CharHighlight"));
 505             CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(COL_TRANSPARENT), getProperty<sal_Int32>(xRun,"CharBackColor"));
 506
 507             xRun.set(getRun(xPara,3), uno::UNO_QUERY);
 508             CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(0x0000ff), getProperty<sal_Int32>(xRun,"CharHighlight"));
 509             CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(0xff0000), getProperty<sal_Int32>(xRun,"CharBackColor"));
 510
 511             xRun.set(getRun(xPara,4), uno::UNO_QUERY);
 512             CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(COL_TRANSPARENT), getProperty<sal_Int32>(xRun,"CharHighlight"));
 513             CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(COL_TRANSPARENT), getProperty<sal_Int32>(xRun,"CharBackColor"));
 514         }
 515
 516         // Simulate editing
 517         for( int i = 1; i <= 4; ++i )
 518         {
 519             uno::Reference<beans::XPropertySet> xRun(getRun(xPara,i), uno::UNO_QUERY);
 520             // Change background
 521             sal_Int32 nBackColor = 0;
 522             switch( i )
 523             {
 524                 case 1: nBackColor = 0x000000; break; //black
 525                 case 2: nBackColor = 0x00ffff; break; //cyan
 526                 case 3: nBackColor = 0x00ff00; break; //green
 527                 case 4: nBackColor = 0xff00ff; break; //magenta
 528             }
 529             xRun->setPropertyValue("CharBackColor", uno::makeAny(static_cast<sal_Int32>(nBackColor)));
 530             // Remove highlighting
 531             xRun->setPropertyValue("CharHighlight", uno::makeAny(static_cast<sal_Int32>(COL_TRANSPARENT)));
 532             // Remove shading marker
 533             uno::Sequence<beans::PropertyValue> aGrabBag = getProperty<uno::Sequence<beans::PropertyValue> >(xRun,"CharInteropGrabBag");
 534             for (int j = 0; j < aGrabBag.getLength(); ++j)
 535             {
 536                 beans::PropertyValue& rProp = aGrabBag[j];
 537                 if (rProp.Name == "CharShadingMarker")
 538                 {
 539                     CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), true, rProp.Value.get<bool>());
 540                     rProp.Value = uno::makeAny(false);
 541                 }
 542             }
 543             xRun->setPropertyValue("CharInteropGrabBag", uno::makeAny(aGrabBag));
 544         }
 545
 546         SvtFilterOptions& rOpt = SvtFilterOptions::Get();
 547         rOpt.SetCharBackground2Highlighting();
 548
 549         // Export the document and import again for a check
 550         uno::Reference<frame::XStorable> xStorable(mxComponent, uno::UNO_QUERY);
 551
 552         utl::MediaDescriptor aMediaDescriptor;
 553         aMediaDescriptor["FilterName"] <<= OUString::createFromAscii(aFilterNames[nFilter]);
 554
 555         utl::TempFile aTempFile;
 556         aTempFile.EnableKillingFile();
 557         xStorable->storeToURL(aTempFile.GetURL(), aMediaDescriptor.getAsConstPropertyValueList());
 558         uno::Reference< lang::XComponent > xComponent(xStorable, uno::UNO_QUERY);
 559         xComponent->dispose();
 560         mxComponent = loadFromDesktop(aTempFile.GetURL(), "com.sun.star.text.TextDocument");
 561
 562         // Check whether background was exported as highlighting
 563         xPara.set(getParagraph(1));
 564         for( int i = 1; i <= 4; ++i )
 565         {
 566             sal_Int32 nBackColor = 0;
 567             switch( i )
 568             {
 569                 case 1: nBackColor = 0x000000; break; //black
 570                 case 2: nBackColor = 0x00ffff; break; //cyan
 571                 case 3: nBackColor = 0x00ff00; break; //green
 572                 case 4: nBackColor = 0xff00ff; break; //magenta
 573             }
 574             const uno::Reference<beans::XPropertySet> xRun(getRun(xPara,i), uno::UNO_QUERY);
 575             if( strcmp(aFilterNames[nFilter], "writer8") == 0 )
 576             {
 577                 CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(COL_TRANSPARENT), getProperty<sal_Int32>(xRun,"CharHighlight"));
 578                 CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(nBackColor), getProperty<sal_Int32>(xRun,"CharBackColor"));
 579             }
 580             else
 581             {
 582                 CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(nBackColor), getProperty<sal_Int32>(xRun,"CharHighlight"));
 583                 CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(COL_TRANSPARENT), getProperty<sal_Int32>(xRun,"CharBackColor"));
 584             }
 585         }
 586     }
 587 }
 588
 589 void Test::testCharBackgroundToHighlighting()
 590 {
 591     // MSO highlighting has less kind of values so let's see how LO character background is converted
 592     // to these values
 593
 594     const char* aFilterNames[] = {
 595         "Rich Text Format",
 596         "MS Word 97",
 597         "Office Open XML Text",
 598     };
 599
 600     for( size_t nFilter = 0; nFilter < SAL_N_ELEMENTS(aFilterNames); ++nFilter )
 601     {
 602         if (mxComponent.is())
 603             mxComponent->dispose();
 604         mxComponent = loadFromDesktop(getURLFromSrc("/sw/qa/extras/globalfilter/data/char_background.odt"),
 605                                       "com.sun.star.text.TextDocument");
 606
 607         OString sFailedMessage = OString("Failed on filter: ") + aFilterNames[nFilter];
 608
 609
 610         SvtFilterOptions& rOpt = SvtFilterOptions::Get();
 611         rOpt.SetCharBackground2Highlighting();
 612
 613         // Export the document and import again for a check
 614         uno::Reference<frame::XStorable> xStorable(mxComponent, uno::UNO_QUERY);
 615
 616         utl::MediaDescriptor aMediaDescriptor;
 617         aMediaDescriptor["FilterName"] <<= OUString::createFromAscii(aFilterNames[nFilter]);
 618
 619         utl::TempFile aTempFile;
 620         aTempFile.EnableKillingFile();
 621         xStorable->storeToURL(aTempFile.GetURL(), aMediaDescriptor.getAsConstPropertyValueList());
 622         uno::Reference< lang::XComponent > xComponent(xStorable, uno::UNO_QUERY);
 623         xComponent->dispose();
 624         mxComponent = loadFromDesktop(aTempFile.GetURL(), "com.sun.star.text.TextDocument");
 625
 626         // Check highlight color
 627         const uno::Reference< text::XTextRange > xPara = getParagraph(1);
 628         for( int nRun = 1; nRun <= 19; ++nRun )
 629         {
 630             const uno::Reference<beans::XPropertySet> xRun(getRun(xPara,nRun), uno::UNO_QUERY);
 631             sal_Int32 nHighlightColor = 0;
 632             switch( nRun )
 633             {
 634                 case 1: nHighlightColor = 0x000000; break; //black
 635                 case 2: nHighlightColor = 0xffff00; break; //yellow
 636                 case 3: nHighlightColor = 0xff00ff; break; //magenta
 637                 case 4: nHighlightColor = 0x00ffff; break; //cyan
 638                 case 5: nHighlightColor = 0xffff00; break; //yellow
 639                 case 6: nHighlightColor = 0xff0000; break; //red
 640                 case 7: nHighlightColor = 0x0000ff; break; //blue
 641                 case 8: nHighlightColor = 0x00ff00; break; //green
 642                 case 9: nHighlightColor = 0x008000; break; //dark green
 643                 case 10: nHighlightColor = 0x800080; break; //dark magenta
 644                 case 11: nHighlightColor = 0x000080; break; //dark blue
 645                 case 12: nHighlightColor = 0x808000; break; //dark yellow
 646                 case 13: nHighlightColor = 0x808080; break; //dark gray
 647                 case 14: nHighlightColor = 0x000000; break; //black
 648                 case 15: nHighlightColor = 0xff0000; break; //red
 649                 case 16: nHighlightColor = 0xC0C0C0; break; //light gray
 650                 case 17: nHighlightColor = 0x800000; break; //dark red
 651                 case 18: nHighlightColor = 0x808080; break; //dark gray
 652                 case 19: nHighlightColor = 0xffff00; break; //yellow
 653             }
 654             const OString sMessage = sFailedMessage +". Index of run with unmatched color: " + OString::number(nRun);
 655             CPPUNIT_ASSERT_EQUAL_MESSAGE(sMessage.getStr(), nHighlightColor, getProperty<sal_Int32>(xRun,"CharHighlight"));
 656         }
 657     }
 658 }
 659
 660 void Test::testSkipImages()
 661 {
 662     // Check how LO skips image loading (but not texts of textboxes and custom shapes)
 663     // during DOC and DOCX import, using the "SkipImages" FilterOptions.
 664
 665     const char* aFilterNames[][2] = {
 666         { "/sw/qa/extras/globalfilter/data/skipimages.doc", NULL },
 667         { "/sw/qa/extras/globalfilter/data/skipimages.doc", "SkipImages" },
 668         { "/sw/qa/extras/globalfilter/data/skipimages.docx", NULL },
 669         { "/sw/qa/extras/globalfilter/data/skipimages.docx", "SkipImages" }
 670     };
 671
 672     for( size_t nFilter = 0; nFilter < SAL_N_ELEMENTS(aFilterNames); ++nFilter )
 673     {
 674         bool bSkipImages = aFilterNames[nFilter][1] != NULL;
 675         OString sFailedMessage = OString("Failed on filter: ") + aFilterNames[nFilter][0];
 676
 677         if (mxComponent.is())
 678             mxComponent->dispose();
 679
 680         if (bSkipImages)
 681         {
 682             // FilterOptions parameter
 683             uno::Sequence<beans::PropertyValue> args(1);
 684             args[0].Name = "FilterOptions";
 685             args[0].Handle = -1;
 686             args[0].Value <<= OUString::createFromAscii(aFilterNames[nFilter][1]);
 687             args[0].State = beans::PropertyState_DIRECT_VALUE;
 688             mxComponent = loadFromDesktop(getURLFromSrc(aFilterNames[nFilter][0]), "com.sun.star.text.TextDocument", args);
 689             sFailedMessage = sFailedMessage + " - " + aFilterNames[nFilter][1];
 690         } else
 691             mxComponent = loadFromDesktop(getURLFromSrc(aFilterNames[nFilter][0]), "com.sun.star.text.TextDocument");
 692
 693         // Check shapes (images, textboxes, custom shapes)
 694         uno::Reference<drawing::XDrawPageSupplier> xDrawPageSupplier(mxComponent, uno::UNO_QUERY);
 695         uno::Reference<container::XIndexAccess> xDraws(xDrawPageSupplier->getDrawPage(), uno::UNO_QUERY);
 696         uno::Reference<drawing::XShape> xShape;
 697         uno::Reference<graphic::XGraphic> xGraphic;
 698         uno::Reference< beans::XPropertySet > XPropSet;
 699         uno::Reference<awt::XBitmap> xBitmap;
 700
 701         bool bHasTextboxText = false;
 702         bool bHasCustomShapeText = false;
 703         sal_Int32 nImageCount = 0;
 704
 705         for (int i = 1; i<= xDraws->getCount(); i++)
 706         {
 707             xShape = getShape(i);
 708             XPropSet.set( xShape, uno::UNO_QUERY_THROW );
 709             try
 710             {
 711                 XPropSet->getPropertyValue("Graphic") >>= xGraphic;
 712                 xBitmap.set(xGraphic, uno::UNO_QUERY);
 713                 if (xBitmap.is())
 714                     nImageCount++;
 715             }
 716             catch (beans::UnknownPropertyException &)
 717             { /* ignore */ }
 718
 719             uno::Reference<text::XTextRange> xText(xShape, uno::UNO_QUERY);
 720             if (xText.is())
 721             {
 722                 OUString shapeText = xText->getString();
 723                 if (shapeText.startsWith("Lorem ipsum"))
 724                     bHasTextboxText = true;
 725                 else if (shapeText.startsWith("Nam pretium"))
 726                     bHasCustomShapeText = true;
 727             }
 728         }
 729
 730         CPPUNIT_ASSERT_MESSAGE(sFailedMessage.getStr(), bHasTextboxText);
 731         CPPUNIT_ASSERT_MESSAGE(sFailedMessage.getStr(), bHasCustomShapeText);
 732         CPPUNIT_ASSERT_EQUAL_MESSAGE(sFailedMessage.getStr(), static_cast<sal_Int32>(bSkipImages ? 0 : 3), nImageCount );
 733     }
 734 }
 735
 736
 737 CPPUNIT_TEST_SUITE_REGISTRATION(Test);
 738
 739 CPPUNIT_PLUGIN_IMPLEMENT();
 740
 741 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */