chart2/qa/TestCaseOldAPI.java

   1 /*
   2  * This file is part of the LibreOffice project.
   3  *
   4  * This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   7  *
   8  * This file incorporates work covered by the following license notice:
   9  *
  10  *   Licensed to the Apache Software Foundation (ASF) under one or more
  11  *   contributor license agreements. See the NOTICE file distributed
  12  *   with this work for additional information regarding copyright
  13  *   ownership. The ASF licenses this file to you under the Apache
  14  *   License, Version 2.0 (the "License"); you may not use this file
  15  *   except in compliance with the License. You may obtain a copy of
  16  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  17  */
  18
  19 // package name: as default, start with complex
  20 package qa;
  21
  22 // imports
  23 import complexlib.ComplexTestCase;
  24 import com.sun.star.uno.XInterface;
  25 import com.sun.star.uno.UnoRuntime;
  26 import com.sun.star.uno.Type;
  27 import com.sun.star.uno.XComponentContext;
  28
  29 import java.io.PrintWriter;
  30 import com.sun.star.lang.*;
  31 import com.sun.star.beans.*;
  32 import com.sun.star.frame.*;
  33 import com.sun.star.chart.*;
  34 import com.sun.star.drawing.*;
  35 import com.sun.star.awt.*;
  36 import com.sun.star.container.*;
  37 import com.sun.star.util.XCloseable;
  38 import com.sun.star.util.CloseVetoException;
  39
  40 import com.sun.star.uno.AnyConverter;
  41
  42 /**
  43  * The following Complex Test will test the
  44  * com.sun.star.document.IndexedPropertyValues
  45  * service
  46  */
  47
  48 public class TestCaseOldAPI extends ComplexTestCase {
  49
  50     // The name of the tested service
  51     private final String testedServiceName =
  52           "com.sun.star.chart.ChartDocument";
  53
  54     // The first of the mandatory functions:
  55     /**
  56      * Return the name of the test.
  57      * In this case it is the actual name of the service.
  58      * @return The tested service.
  59      */
  60     public String getTestObjectName() {
  61         return testedServiceName;
  62     }
  63
  64     // The second of the mandatory functions: return all test methods as an
  65     // array. There is only one test function in this example.
  66     /**
  67      * Return all test methods.
  68      * @return The test methods.
  69      */
  70     public String[] getTestMethodNames() {
  71         // For some tests a view needs to be created. Accessing the model via
  72         // this program and the view may lead to problems
  73         boolean bAvoidViewCreation = false;
  74
  75         if( bAvoidViewCreation )
  76             return new String[] {
  77                 "testData",
  78                 "testChartType",
  79                 "testArea",
  80                 "testAggregation",
  81                 "testFactory",
  82                 "testDataSeriesAndPoints",
  83                 "testStatistics",
  84                 "testStockProperties"
  85             };
  86
  87         return new String[] {
  88             "testData",
  89             "testChartType",
  90             "testTitle",
  91             "testSubTitle",
  92             "testDiagram",
  93             "testAxis",
  94             "testLegend",
  95             "testArea",
  96             "testAggregation",
  97             "testFactory",
  98             "testDataSeriesAndPoints",
  99             "testStatistics",
 100             "testStockProperties"
 101         };
 102     }
 103
 104     // ____________
 105
 106     public void before()
 107     {
 108         // set to "true" to get a view
 109         mbCreateView = true;
 110
 111         if( mbCreateView )
 112             mxChartModel = createDocument( "schart" );
 113         else
 114             mxChartModel = createChartModel();
 115
 116         mxOldDoc = (XChartDocument) UnoRuntime.queryInterface(
 117             XChartDocument.class, mxChartModel );
 118     }
 119
 120     // ____________
 121
 122     public void after()
 123     {
 124         XCloseable xCloseable = (XCloseable) UnoRuntime.queryInterface(
 125             XCloseable.class, mxChartModel );
 126         assure( "document is no XCloseable", xCloseable != null );
 127
 128         // do not close document if there exists a view
 129         if( ! mbCreateView )
 130         {
 131             try
 132             {
 133                 xCloseable.close( true );
 134             }
 135             catch( CloseVetoException ex )
 136             {
 137                 failed( ex.getMessage() );
 138                 ex.printStackTrace( (PrintWriter)log );
 139             }
 140         }
 141     }
 142
 143     // ____________
 144
 145     public void testTitle()
 146     {
 147         try
 148         {
 149             XPropertySet xDocProp = (XPropertySet) UnoRuntime.queryInterface(
 150                 XPropertySet.class, mxOldDoc );
 151             assure( "Chart Document is no XPropertySet", xDocProp != null );
 152             xDocProp.setPropertyValue( "HasMainTitle", new Boolean( true ));
 153             assure( "Property HasMainTitle", AnyConverter.toBoolean(
 154                         xDocProp.getPropertyValue( "HasMainTitle" )));
 155
 156             XShape xTitleShape = mxOldDoc.getTitle();
 157             XPropertySet xTitleProp = (XPropertySet) UnoRuntime.queryInterface(
 158                 XPropertySet.class, xTitleShape );
 159
 160             // set property via old API
 161             if( xTitleProp != null )
 162             {
 163                 String aTitle = " Overwritten by Old API ";
 164                 float fHeight = (float)17.0;
 165
 166                 xTitleProp.setPropertyValue( "String", aTitle );
 167                 xTitleProp.setPropertyValue( "CharHeight", new Float( fHeight ) );
 168
 169                 float fNewHeight = AnyConverter.toFloat( xTitleProp.getPropertyValue( "CharHeight" ) );
 170                 assure( "Changing CharHeight via old API failed", fNewHeight == fHeight );
 171
 172                 String aNewTitle = AnyConverter.toString( xTitleProp.getPropertyValue( "String" ) );
 173                 assure( "Property \"String\" failed", aNewTitle.equals( aTitle ));
 174             }
 175
 176             // move title
 177             Point aSetPos = new Point();
 178             aSetPos.X = 1000;
 179             aSetPos.Y = 200;
 180             xTitleShape.setPosition( aSetPos );
 181
 182             Point aNewPos = xTitleShape.getPosition();
 183             assure( "Title Position X", approxEqual( aNewPos.X, aSetPos.X, 1 ));
 184             assure( "Title Position Y", approxEqual( aNewPos.Y, aSetPos.Y, 1 ));
 185         }
 186         catch( Exception ex )
 187         {
 188             failed( ex.getMessage() );
 189             ex.printStackTrace( (PrintWriter)log );
 190         }
 191     }
 192
 193     // ____________
 194
 195     public void testSubTitle()
 196     {
 197         try
 198         {
 199             XPropertySet xDocProp = (XPropertySet) UnoRuntime.queryInterface(
 200                 XPropertySet.class, mxOldDoc );
 201             assure( "Chart Document is no XPropertySet", xDocProp != null );
 202             xDocProp.setPropertyValue( "HasSubTitle", new Boolean( true ));
 203             assure( "Property HasSubTitle", AnyConverter.toBoolean(
 204                         xDocProp.getPropertyValue( "HasSubTitle" )));
 205
 206             XShape xTitleShape = mxOldDoc.getSubTitle();
 207             XPropertySet xTitleProp = (XPropertySet) UnoRuntime.queryInterface(
 208                 XPropertySet.class, xTitleShape );
 209
 210             // set Property via old API
 211             if( xTitleProp != null )
 212             {
 213                 int nColor = 0x009acd; // DeepSkyBlue3
 214                 float fWeight = FontWeight.BOLD;
 215                 float fHeight = (float)14.0;
 216
 217                 xTitleProp.setPropertyValue( "CharColor", new Integer( nColor ) );
 218                 xTitleProp.setPropertyValue( "CharWeight", new Float( fWeight ));
 219                 xTitleProp.setPropertyValue( "CharHeight", new Float( fHeight ) );
 220
 221                 int nNewColor = AnyConverter.toInt( xTitleProp.getPropertyValue( "CharColor" ) );
 222                 assure( "Changing CharColor via old API failed", nNewColor == nColor );
 223
 224                 float fNewWeight = AnyConverter.toFloat( xTitleProp.getPropertyValue( "CharWeight" ) );
 225                 assure( "Changing CharWeight via old API failed", fNewWeight == fWeight );
 226
 227                 float fNewHeight = AnyConverter.toFloat( xTitleProp.getPropertyValue( "CharHeight" ) );
 228                 assure( "Changing CharHeight via old API failed", fNewHeight == fHeight );
 229             }
 230         }
 231         catch( Exception ex )
 232         {
 233             failed( ex.getMessage() );
 234             ex.printStackTrace( (PrintWriter)log );
 235         }
 236     }
 237
 238     // ------------
 239
 240     public void testDiagram()
 241     {
 242         try
 243         {
 244             // testing wall
 245             XDiagram xDia = mxOldDoc.getDiagram();
 246             if( xDia != null )
 247             {
 248                 X3DDisplay xDisp = (X3DDisplay) UnoRuntime.queryInterface(
 249                     X3DDisplay.class, xDia );
 250                 assure( "X3DDisplay not supported", xDisp != null );
 251
 252                 // Wall
 253                 XPropertySet xProp = xDisp.getWall();
 254                 if( xProp != null )
 255                 {
 256                     int nColor = 0xffe1ff; // thistle1
 257                     xProp.setPropertyValue( "FillColor", new Integer( nColor ) );
 258                     int nNewColor = AnyConverter.toInt( xProp.getPropertyValue( "FillColor" ) );
 259                     assure( "Changing FillColor via old API failed", nNewColor == nColor );
 260                 }
 261
 262                 assure( "Wrong Diagram Type", xDia.getDiagramType().equals(
 263                             "com.sun.star.chart.BarDiagram" ));
 264
 265                 // Diagram properties
 266                 xProp = (XPropertySet) UnoRuntime.queryInterface( XPropertySet.class, xDia );
 267                 assure( "Diagram is no property set", xProp != null );
 268
 269                 // y-axis
 270                 boolean bFirstYAxisText = false;
 271                 xProp.setPropertyValue( "HasYAxisDescription", new Boolean( bFirstYAxisText ));
 272                 boolean bNewFirstYAxisText = AnyConverter.toBoolean(
 273                     xProp.getPropertyValue( "HasYAxisDescription" ));
 274                 assure( "Removing description of first y-axis", bNewFirstYAxisText == bFirstYAxisText );
 275
 276 //                 boolean bYAxisTitle = true;
 277 //                 xProp.setPropertyValue( "HasYAxisTitle", new Boolean( bYAxisTitle ));
 278 //                 boolean bNewYAxisTitle = AnyConverter.toBoolean(
 279 //                     xProp.getPropertyValue( "HasYAxisTitle" ));
 280 //                 assure( "Adding y-axis title", bNewYAxisTitle == bYAxisTitle );
 281
 282                 // set title text
 283 //                 XAxisYSupplier xYAxisSuppl = (XAxisYSupplier) UnoRuntime.queryInterface(
 284 //                     XAxisYSupplier.class, mxOldDoc.getDiagram() );
 285 //                 assure( "Diagram is no y-axis supplier", xYAxisSuppl != null );
 286 //                 XPropertySet xAxisTitleProp = (XPropertySet) UnoRuntime.queryInterface(
 287 //                     XPropertySet.class, xYAxisSuppl.getYAxisTitle() );
 288 //                 assure( "Y-Axis Title is no XPropertySet", xAxisTitleProp != null );
 289 //                 xAxisTitleProp.setPropertyValue( "String", "New y axis title" );
 290
 291                 // second y-axis
 292                 boolean bSecondaryYAxis = true;
 293                 xProp.setPropertyValue( "HasSecondaryYAxis", new Boolean( bSecondaryYAxis ));
 294                 boolean bNewSecYAxisValue = AnyConverter.toBoolean(
 295                     xProp.getPropertyValue( "HasSecondaryYAxis" ));
 296                 assure( "Adding a second y-axis does not work", bNewSecYAxisValue == bSecondaryYAxis );
 297
 298                 XTwoAxisYSupplier xSecYAxisSuppl = (XTwoAxisYSupplier) UnoRuntime.queryInterface(
 299                     XTwoAxisYSupplier.class, xDia );
 300                 assure( "XTwoAxisYSupplier not implemented", xSecYAxisSuppl != null );
 301                 assure( "No second y-axis found", xSecYAxisSuppl.getSecondaryYAxis() != null );
 302             }
 303
 304             // move diagram
 305             {
 306                 XShape xDiagramShape = (XShape) UnoRuntime.queryInterface(
 307                     XShape.class, xDia );
 308
 309                 Point aOldPos = xDiagramShape.getPosition();
 310                 int xDiff = 20;
 311                 int yDiff = 20;
 312                 Point aSetPos = new Point();
 313                 aSetPos.X = aOldPos.X + xDiff;
 314                 aSetPos.Y = aOldPos.Y + yDiff;
 315                 xDiagramShape.setPosition( aSetPos );
 316
 317                 Point aNewPos = xDiagramShape.getPosition();
 318                 //System.out.println( "set X = " + aSetPos.X + ", new X = " + aNewPos.X );
 319                 //System.out.println( "set Y = " + aSetPos.Y + ", new Y = " + aNewPos.Y );
 320                 assure( "Diagram Position X", approxEqual( aNewPos.X, aSetPos.X, 1 ));
 321                 assure( "Diagram Position Y", approxEqual( aNewPos.Y, aSetPos.Y, 1 ));
 322             }
 323
 324             // size diagram
 325             {
 326                 XShape xDiagramShape = (XShape) UnoRuntime.queryInterface(
 327                     XShape.class, xDia );
 328
 329                 Size aOldSize = xDiagramShape.getSize();
 330                 int xDiff = aOldSize.Width/2+2;
 331                 int yDiff = aOldSize.Height/2+2;
 332                 Size aSetSize = new Size();
 333                 aSetSize.Width = aOldSize.Width - xDiff;
 334                 aSetSize.Height = aOldSize.Height - yDiff;
 335                 xDiagramShape.setSize( aSetSize );
 336
 337                 Size aNewSize = xDiagramShape.getSize();
 338                 //System.out.println( "set width = " + aSetSize.Width + ", new width = " + aNewSize.Width );
 339                 //System.out.println( "set height = " + aSetSize.Height + ", new height = " + aNewSize.Height );
 340                 assure( "Diagram Width", approxEqual( aNewSize.Width, aSetSize.Width, 2 ));
 341                 assure( "Diagram Height", approxEqual( aNewSize.Height, aSetSize.Height, 2 ));
 342             }
 343         }
 344         catch( Exception ex )
 345         {
 346             failed( ex.getMessage() );
 347             ex.printStackTrace( (PrintWriter)log );
 348         }
 349     }
 350
 351     // ------------
 352
 353     public void testAxis()
 354     {
 355         try
 356         {
 357             XAxisYSupplier xYAxisSuppl = (XAxisYSupplier) UnoRuntime.queryInterface(
 358                 XAxisYSupplier.class, mxOldDoc.getDiagram() );
 359             assure( "Diagram is no y-axis supplier", xYAxisSuppl != null );
 360
 361             XPropertySet xProp = xYAxisSuppl.getYAxis();
 362             assure( "No y-axis found", xProp != null );
 363
 364             double fMax1, fMax2;
 365             Object oMax = xProp.getPropertyValue( "Max" );
 366             assure( "No Maximum set", AnyConverter.isDouble( oMax ));
 367             fMax1 = AnyConverter.toDouble( oMax );
 368             log.println( "Maximum retrieved: " + fMax1 );
 369             //todo: the view has to be built before there is an explicit value
 370 //             assure( "Max is 0.0", fMax1 > 0.0 );
 371             xProp.setPropertyValue( "AutoMax", new Boolean( false ));
 372             oMax = xProp.getPropertyValue( "Max" );
 373             assure( "No Maximum set", AnyConverter.isDouble( oMax ));
 374             fMax2 = AnyConverter.toDouble( oMax );
 375             log.println( "Maximum with AutoMax off: " + fMax2 );
 376             assure( "maxima differ", fMax1 == fMax2 );
 377
 378             double nNewMax = 12.3;
 379             double nNewOrigin = 2.7;
 380
 381             xProp.setPropertyValue( "Max", new Double( nNewMax ));
 382             assure( "AutoMax is on", ! AnyConverter.toBoolean( xProp.getPropertyValue( "AutoMax" )) );
 383
 384             assure( "Maximum value invalid",
 385                     approxEqual(
 386                         AnyConverter.toDouble( xProp.getPropertyValue( "Max" )),
 387                         nNewMax ));
 388
 389             xProp.setPropertyValue( "AutoMin", new Boolean( true ));
 390             assure( "AutoMin is off", AnyConverter.toBoolean( xProp.getPropertyValue( "AutoMin" )) );
 391
 392             xProp.setPropertyValue( "Origin", new Double( nNewOrigin ));
 393             assure( "Origin invalid",
 394                     approxEqual(
 395                         AnyConverter.toDouble( xProp.getPropertyValue( "Origin" )),
 396                         nNewOrigin ));
 397             xProp.setPropertyValue( "AutoOrigin", new Boolean( true ));
 398             assure( "AutoOrigin is off", AnyConverter.toBoolean( xProp.getPropertyValue( "AutoOrigin" )) );
 399             Object oOrigin = xProp.getPropertyValue( "Origin" );
 400             assure( "No Origin set", AnyConverter.isDouble( oOrigin ));
 401             log.println( "Origin retrieved: " + AnyConverter.toDouble( oOrigin ));
 402
 403             xProp.setPropertyValue( "Logarithmic", new Boolean( true ));
 404             assure( "Scaling is not logarithmic",
 405                     AnyConverter.toBoolean( xProp.getPropertyValue( "Logarithmic" )) );
 406             xProp.setPropertyValue( "Logarithmic", new Boolean( false ));
 407             assure( "Scaling is not logarithmic",
 408                     ! AnyConverter.toBoolean( xProp.getPropertyValue( "Logarithmic" )) );
 409
 410             int nNewColor =  0xcd853f; // peru
 411             xProp.setPropertyValue( "LineColor", new Integer( nNewColor ));
 412             assure( "Property LineColor",
 413                     AnyConverter.toInt( xProp.getPropertyValue( "LineColor" )) == nNewColor );
 414             float fNewCharHeight = (float)(16.0);
 415             xProp.setPropertyValue( "CharHeight", new Float( fNewCharHeight ));
 416             assure( "Property CharHeight",
 417                     AnyConverter.toFloat( xProp.getPropertyValue( "CharHeight" )) == fNewCharHeight );
 418
 419             int nNewTextRotation = 700; // in 1/100 degrees
 420             xProp.setPropertyValue( "TextRotation", new Integer( nNewTextRotation ));
 421             assure( "Property TextRotation",
 422                     AnyConverter.toInt( xProp.getPropertyValue( "TextRotation" )) == nNewTextRotation );
 423
 424             double fStepMain = 10.0;
 425             xProp.setPropertyValue( "StepMain", new Double( fStepMain ));
 426             assure( "Property StepMain",
 427                     AnyConverter.toDouble( xProp.getPropertyValue( "StepMain" )) == fStepMain );
 428
 429             // note: fStepHelp must be a divider of fStepMain, because
 430             // internally, the help-step is stored as an integer number of
 431             // substeps
 432             double fStepHelp = 5.0;
 433             xProp.setPropertyValue( "StepHelp", new Double( fStepHelp ));
 434             assure( "Property StepHelp",
 435                     AnyConverter.toDouble( xProp.getPropertyValue( "StepHelp" )) == fStepHelp );
 436
 437             xProp.setPropertyValue( "DisplayLabels", new Boolean( false ));
 438             assure( "Property DisplayLabels", ! AnyConverter.toBoolean(
 439                         xProp.getPropertyValue( "DisplayLabels" )));
 440         }
 441         catch( Exception ex )
 442         {
 443             failed( ex.getMessage() );
 444             ex.printStackTrace( (PrintWriter)log );
 445         }
 446     }
 447
 448     // ------------
 449
 450     public void testLegend()
 451     {
 452         XShape xLegend = mxOldDoc.getLegend();
 453         assure( "No Legend returned", xLegend != null );
 454
 455         XPropertySet xLegendProp = (XPropertySet) UnoRuntime.queryInterface(
 456             XPropertySet.class, xLegend );
 457         assure( "Legend is no property set", xLegendProp != null );
 458
 459         try
 460         {
 461             ChartLegendPosition eNewPos = ChartLegendPosition.BOTTOM;
 462             xLegendProp.setPropertyValue( "Alignment", eNewPos );
 463             assure( "Property Alignment",
 464                     AnyConverter.toObject(
 465                         new Type( ChartLegendPosition.class ),
 466                         xLegendProp.getPropertyValue( "Alignment" )) == eNewPos );
 467
 468             float fNewCharHeight = (float)(11.0);
 469             xLegendProp.setPropertyValue( "CharHeight", new Float( fNewCharHeight ));
 470             assure( "Property CharHeight",
 471                     AnyConverter.toFloat( xLegendProp.getPropertyValue( "CharHeight" )) == fNewCharHeight );
 472
 473             // move legend
 474             {
 475                 Point aOldPos = xLegend.getPosition();
 476                 int xDiff = 20;
 477                 int yDiff = 20;
 478                 Point aSetPos = new Point();
 479                 aSetPos.X = aOldPos.X + xDiff;
 480                 aSetPos.Y = aOldPos.Y + yDiff;
 481                 xLegend.setPosition( aSetPos );
 482
 483                 Point aNewPos = xLegend.getPosition();
 484                 assure( "Legend Position X", approxEqual( aNewPos.X, aSetPos.X, 1 ));
 485                 assure( "Legend Position Y", approxEqual( aNewPos.Y, aSetPos.Y, 1 ));
 486             }
 487         }
 488         catch( Exception ex )
 489         {
 490             failed( ex.getMessage() );
 491             ex.printStackTrace( (PrintWriter)log );
 492         }
 493     }
 494
 495     // ------------
 496
 497     public void testArea()
 498     {
 499         XPropertySet xArea = mxOldDoc.getArea();
 500         assure( "No Area", xArea != null );
 501
 502         try
 503         {
 504             int nColor = 0xf5fffa; // mint cream
 505             xArea.setPropertyValue( "FillColor", new Integer( nColor ) );
 506             xArea.setPropertyValue( "FillStyle", FillStyle.SOLID );
 507 //             XPropertySetInfo xInfo = xArea.getPropertySetInfo();
 508 //             assure( "Area does not support ChartUserDefinedAttributes",
 509 //                     xInfo.hasPropertyByName( "ChartUserDefinedAttributes" ));
 510
 511 //             String aTestAttributeName = "test:foo";
 512 //             String aTestAttributeValue = "content";
 513 //             XNameContainer xUserDefAttributes = (XNameContainer) AnyConverter.toObject(
 514 //                 new Type( XNameContainer.class ), xArea.getPropertyValue( "ChartUserDefinedAttributes" ));
 515 //             xUserDefAttributes.insertByName( aTestAttributeName, aTestAttributeValue );
 516
 517 //             String aContent = AnyConverter.toString( xUserDefAttributes.getByName( aTestAttributeName ));
 518 //             assure( "Wrong content in UserDefinedAttributes container",
 519 //                     aContent.equals( aTestAttributeValue ));
 520
 521             int nNewColor = AnyConverter.toInt( xArea.getPropertyValue( "FillColor" ) );
 522             assure( "Changing FillColor of Area failed", nNewColor == nColor );
 523         }
 524         catch( Exception ex )
 525         {
 526             failed( ex.getMessage() );
 527             ex.printStackTrace( (PrintWriter)log );
 528         }
 529     }
 530
 531     // ------------
 532
 533     public void testChartType()
 534     {
 535         XMultiServiceFactory xFact = (XMultiServiceFactory) UnoRuntime.queryInterface(
 536             XMultiServiceFactory.class, mxOldDoc );
 537         assure( "document is no factory", xFact != null );
 538
 539         try
 540         {
 541             String aMyServiceName = new String( "com.sun.star.chart.BarDiagram" );
 542             String aServices[] = xFact.getAvailableServiceNames();
 543             boolean bServiceFound = false;
 544             for( int i = 0; i < aServices.length; ++i )
 545             {
 546                 if( aServices[ i ].equals( aMyServiceName ))
 547                 {
 548                     bServiceFound = true;
 549                     break;
 550                 }
 551             }
 552             assure( "getAvailableServiceNames did not return " + aMyServiceName, bServiceFound );
 553
 554             if( bServiceFound )
 555             {
 556                 XDiagram xDia = (XDiagram) UnoRuntime.queryInterface(
 557                     XDiagram.class, xFact.createInstance( aMyServiceName ));
 558                 assure( aMyServiceName + " could not be created", xDia != null );
 559
 560                 mxOldDoc.setDiagram( xDia );
 561
 562                 XPropertySet xDiaProp = (XPropertySet) UnoRuntime.queryInterface(
 563                     XPropertySet.class, xDia );
 564                 assure( "Diagram is no XPropertySet", xDiaProp != null );
 565
 566                 xDiaProp.setPropertyValue( "Stacked", new Boolean( true ));
 567                 assure( "StackMode could not be set correctly",
 568                         AnyConverter.toBoolean(
 569                             xDiaProp.getPropertyValue( "Stacked" )));
 570
 571                 xDiaProp.setPropertyValue( "Dim3D", new Boolean( false ));
 572                 assure( "Dim3D could not be set correctly",
 573                         ! AnyConverter.toBoolean(
 574                             xDiaProp.getPropertyValue( "Dim3D" )));
 575
 576                 xDiaProp.setPropertyValue( "Vertical", new Boolean( true ));
 577                 assure( "Vertical could not be set correctly",
 578                         AnyConverter.toBoolean(
 579                             xDiaProp.getPropertyValue( "Vertical" )));
 580             }
 581
 582             // reset to bar-chart
 583 //             aMyServiceName = new String( "com.sun.star.chart.BarDiagram" );
 584 //             XDiagram xDia = (XDiagram) UnoRuntime.queryInterface(
 585 //                 XDiagram.class, xFact.createInstance( aMyServiceName ));
 586 //             assure( aMyServiceName + " could not be created", xDia != null );
 587
 588 //             mxOldDoc.setDiagram( xDia );
 589         }
 590         catch( Exception ex )
 591         {
 592             failed( ex.getMessage() );
 593             ex.printStackTrace( (PrintWriter)log );
 594         }
 595     }
 596
 597     // ------------
 598
 599     public void testAggregation()
 600     {
 601         // query to new type
 602         XChartDocument xDiaProv = (XChartDocument) UnoRuntime.queryInterface(
 603             XChartDocument.class, mxOldDoc );
 604         assure( "query to new interface failed", xDiaProv != null );
 605
 606         com.sun.star.chart.XChartDocument xDoc = (com.sun.star.chart.XChartDocument) UnoRuntime.queryInterface(
 607             com.sun.star.chart.XChartDocument.class, xDiaProv );
 608         assure( "querying back to old interface failed", xDoc != null );
 609     }
 610
 611     // ------------
 612
 613     public void testDataSeriesAndPoints()
 614     {
 615         try
 616         {
 617             XDiagram xDia = mxOldDoc.getDiagram();
 618             assure( "Invalid Diagram", xDia != null );
 619             XMultiServiceFactory xFact = (XMultiServiceFactory) UnoRuntime.queryInterface(
 620                 XMultiServiceFactory.class, mxOldDoc );
 621             assure( "document is no factory", xFact != null );
 622
 623             // FillColor
 624             XPropertySet xProp = xDia.getDataRowProperties( 0 );
 625             int nColor = 0xffd700; // gold
 626             xProp.setPropertyValue( "FillColor", new Integer( nColor ));
 627             int nNewColor = AnyConverter.toInt( xProp.getPropertyValue( "FillColor" ) );
 628             assure( "Changing FillColor of Data Series failed", nNewColor == nColor );
 629
 630             // Gradient
 631             assure( "No DataRowProperties for series 0", xProp != null );
 632
 633             // note: the FillGradient property is optional, however it was
 634             // supported in the old chart's API
 635             XNameContainer xGradientTable = (XNameContainer) UnoRuntime.queryInterface(
 636                 XNameContainer.class,
 637                 xFact.createInstance( "com.sun.star.drawing.GradientTable" ));
 638             assure( "no gradient table", xGradientTable != null );
 639             String aGradientName = "NewAPITestGradient";
 640             Gradient aGradient = new Gradient();
 641             aGradient.Style = GradientStyle.LINEAR;
 642             aGradient.StartColor = 0xe0ffff; // light cyan
 643             aGradient.EndColor  = 0xff8c00; // dark orange
 644             aGradient.Angle = 300;          // 30 degrees
 645             aGradient.Border = 15;
 646             aGradient.XOffset = 0;
 647             aGradient.YOffset = 0;
 648             aGradient.StartIntensity = 100;
 649             aGradient.EndIntensity = 80;
 650             aGradient.StepCount = 23;
 651
 652             xGradientTable.insertByName( aGradientName, aGradient );
 653             xProp.setPropertyValue( "FillStyle", FillStyle.GRADIENT );
 654             xProp.setPropertyValue( "FillGradientName", aGradientName );
 655             String aNewGradientName = AnyConverter.toString( xProp.getPropertyValue( "FillGradientName" ));
 656             assure( "GradientName", aNewGradientName.equals( aGradientName ));
 657             Gradient aNewGradient = (Gradient) AnyConverter.toObject(
 658                 new Type( Gradient.class ),
 659                 xGradientTable.getByName( aNewGradientName ));
 660             assure( "Gradient Style", aNewGradient.Style == aGradient.Style );
 661             assure( "Gradient StartColor", aNewGradient.StartColor == aGradient.StartColor );
 662             assure( "Gradient EndColor", aNewGradient.EndColor == aGradient.EndColor );
 663             assure( "Gradient Angle", aNewGradient.Angle == aGradient.Angle );
 664             assure( "Gradient Border", aNewGradient.Border == aGradient.Border );
 665             assure( "Gradient XOffset", aNewGradient.XOffset == aGradient.XOffset );
 666             assure( "Gradient YOffset", aNewGradient.YOffset == aGradient.YOffset );
 667             assure( "Gradient StartIntensity", aNewGradient.StartIntensity == aGradient.StartIntensity );
 668             assure( "Gradient EndIntensity", aNewGradient.EndIntensity == aGradient.EndIntensity );
 669             assure( "Gradient StepCount", aNewGradient.StepCount == aGradient.StepCount );
 670
 671             // Hatch
 672             xProp = xDia.getDataPointProperties( 1, 0 );
 673             assure( "No DataPointProperties for (1,0)", xProp != null );
 674
 675             // note: the FillHatch property is optional, however it was
 676             // supported in the old chart's API
 677             XNameContainer xHatchTable = (XNameContainer) UnoRuntime.queryInterface(
 678                 XNameContainer.class,
 679                 xFact.createInstance( "com.sun.star.drawing.HatchTable" ));
 680             assure( "no hatch table", xHatchTable != null );
 681             String aHatchName = "NewAPITestHatch";
 682             Hatch aHatch = new Hatch();
 683             aHatch.Style = HatchStyle.DOUBLE;
 684             aHatch.Color = 0xd2691e; // chocolate
 685             aHatch.Distance = 200;   // 2 mm (?)
 686             aHatch.Angle = 230;      // 23 degrees
 687
 688             xHatchTable.insertByName( aHatchName, aHatch );
 689             xProp.setPropertyValue( "FillHatchName", aHatchName );
 690             xProp.setPropertyValue( "FillStyle", FillStyle.HATCH );
 691             xProp.setPropertyValue( "FillBackground", new Boolean( true ));
 692             String aNewHatchName = AnyConverter.toString( xProp.getPropertyValue( "FillHatchName" ));
 693             assure( "HatchName", aNewHatchName.equals( aHatchName ));
 694             Hatch aNewHatch = (Hatch) AnyConverter.toObject(
 695                 new Type( Hatch.class ),
 696                 xHatchTable.getByName( aNewHatchName ));
 697             assure( "Hatch Style", aNewHatch.Style == aHatch.Style );
 698             assure( "Hatch Color", aNewHatch.Color == aHatch.Color );
 699             assure( "Hatch Distance", aNewHatch.Distance == aHatch.Distance );
 700             assure( "Hatch Angle", aNewHatch.Angle == aHatch.Angle );
 701             assure( "FillBackground", AnyConverter.toBoolean( xProp.getPropertyValue( "FillBackground" )) );
 702         }
 703         catch( Exception ex )
 704         {
 705             failed( ex.getMessage() );
 706             ex.printStackTrace( (PrintWriter)log );
 707         }
 708     }
 709
 710     // ------------
 711
 712     public void testStatistics()
 713     {
 714         try
 715         {
 716             XDiagram xDia = mxOldDoc.getDiagram();
 717             assure( "Invalid Diagram", xDia != null );
 718
 719             XPropertySet xProp = xDia.getDataRowProperties( 0 );
 720             assure( "No DataRowProperties for first series", xProp != null );
 721
 722             xProp.setPropertyValue( "MeanValue", new Boolean( true ));
 723             assure( "No MeanValue", AnyConverter.toBoolean( xProp.getPropertyValue( "MeanValue" )) );
 724         }
 725         catch( Exception ex )
 726         {
 727             failed( ex.getMessage() );
 728             ex.printStackTrace( (PrintWriter)log );
 729         }
 730     }
 731
 732     // ------------
 733
 734     public void setStockData_Type4()
 735     {
 736         try
 737         {
 738             XPropertySet xDiaProp = (XPropertySet) UnoRuntime.queryInterface(
 739                 XPropertySet.class, mxOldDoc.getDiagram() );
 740
 741             ChartDataRowSource eNewSource = ChartDataRowSource.ROWS;
 742             xDiaProp.setPropertyValue( "DataRowSource", eNewSource );
 743             assure( "Couldn't set \"DataRowSource\" property at Diagram",
 744                     AnyConverter.toObject(
 745                         new Type( ChartDataRowSource.class ),
 746                         xDiaProp.getPropertyValue( "DataRowSource" )) == eNewSource );
 747
 748             double aData[][] =
 749                 {
 750                     { 100.0, 200.0, 300.0, 250.0, 300.0 },
 751                     { 6.5, 4.5, 6.0, 5.5, 3.5 },
 752                     { 1.0, 1.5, 2.0, 2.5, 3.0 },
 753                     { 6.0, 6.5, 7.0, 6.5, 5.0 },
 754                     { 6.0, 5.5, 4.0, 4.5, 4.0 }
 755                 };
 756
 757             String[] aRowDescriptions =
 758                 {
 759                     "Volume", "Open", "Min", "Max", "Close"
 760                 };
 761
 762              String[] aColumnDescriptions =
 763              {
 764                  "First Row", "Second Row", "Third Row", "Fourth Row", "Fifth Row"
 765              };
 766
 767
 768             XChartData xData = mxOldDoc.getData();
 769             XChartDataArray xDataArray = (XChartDataArray) UnoRuntime.queryInterface(
 770                 XChartDataArray.class, xData );
 771             assure( "document has no XChartDataArray", xDataArray != null );
 772
 773             xDataArray.setData( aData );
 774             xDataArray.setRowDescriptions( aRowDescriptions );
 775             xDataArray.setColumnDescriptions( aColumnDescriptions );
 776
 777             mxOldDoc.attachData( xData );
 778         }
 779         catch( Exception ex )
 780         {
 781             failed( ex.getMessage() );
 782             ex.printStackTrace( (PrintWriter)log );
 783         }
 784     }
 785
 786     // ------------
 787
 788     public void testStockProperties()
 789     {
 790         try
 791         {
 792             setStockData_Type4();
 793
 794             XMultiServiceFactory xFact = (XMultiServiceFactory) UnoRuntime.queryInterface(
 795                 XMultiServiceFactory.class, mxOldDoc );
 796             assure( "document is no factory", xFact != null );
 797
 798             String aMyServiceName = new String( "com.sun.star.chart.StockDiagram" );
 799             XDiagram xDia = (XDiagram) UnoRuntime.queryInterface(
 800                 XDiagram.class, xFact.createInstance( aMyServiceName ));
 801             assure( aMyServiceName + " could not be created", xDia != null );
 802
 803             mxOldDoc.setDiagram( xDia );
 804
 805             XPropertySet xDiaProp = (XPropertySet) UnoRuntime.queryInterface(
 806                 XPropertySet.class, xDia );
 807             assure( "Diagram is no XPropertySet", xDiaProp != null );
 808
 809             xDiaProp.setPropertyValue( "Volume", new Boolean( true ));
 810             assure( "Has Volume", AnyConverter.toBoolean( xDiaProp.getPropertyValue( "Volume" )));
 811
 812             xDiaProp.setPropertyValue( "UpDown", new Boolean( true ));
 813             assure( "Has UpDown", AnyConverter.toBoolean( xDiaProp.getPropertyValue( "UpDown" )));
 814
 815             // MinMaxLine
 816             XStatisticDisplay xMinMaxProvider = (XStatisticDisplay) UnoRuntime.queryInterface(
 817                 XStatisticDisplay.class, xDia );
 818             assure( "Diagram is no XStatisticDisplay", xMinMaxProvider != null );
 819             XPropertySet xMinMaxProp = xMinMaxProvider.getMinMaxLine();
 820             assure( "No MinMaxLine", xMinMaxProp != null );
 821
 822             int nLineColor = 0x458b00; // chartreuse4
 823             xMinMaxProp.setPropertyValue( "LineColor", new Integer( nLineColor ));
 824             int nNewColor = AnyConverter.toInt( xMinMaxProp.getPropertyValue( "LineColor" ) );
 825             assure( "Changing LineColor of MinMax Line", nNewColor == nLineColor );
 826         }
 827         catch( Exception ex )
 828         {
 829             failed( ex.getMessage() );
 830             ex.printStackTrace( (PrintWriter)log );
 831         }
 832     }
 833
 834     // ------------
 835
 836     public void testFactory()
 837     {
 838         try
 839         {
 840             XMultiServiceFactory xFact = (XMultiServiceFactory) UnoRuntime.queryInterface(
 841                 XMultiServiceFactory.class, mxOldDoc );
 842             assure( "document is no factory", xFact != null );
 843
 844             Object aTestTable = xFact.createInstance( "com.sun.star.drawing.GradientTable" );
 845             assure( "Couldn't create gradient table via factory", aTestTable != null );
 846         }
 847         catch( Exception ex )
 848         {
 849             failed( ex.getMessage() );
 850             ex.printStackTrace( (PrintWriter)log );
 851         }
 852     }
 853
 854     // ------------
 855
 856     public void testData()
 857     {
 858         try
 859         {
 860             // set data
 861             double aData[][] = {
 862                 { 1.0, 1.5, 2.0, 2.5, 3.0 },
 863                 { 2.0, 2.5, 3.0, 3.5, 4.0 },
 864                 { 3.0, 3.5, 4.0, 4.5, 5.0 }
 865             };
 866
 867             String[] aColumnDescriptions = {
 868                 "First Column", "Second Column", "Third Column",
 869                 "Fourth Column", "Fifth Column"
 870             };
 871
 872             String[] aRowDescriptions = {
 873                 "First Row", "Second Row", "Third Row"
 874             };
 875
 876             XPropertySet xDiaProp = (XPropertySet) UnoRuntime.queryInterface(
 877                     XPropertySet.class, mxOldDoc.getDiagram() );
 878             ChartDataRowSource eNewSource = ChartDataRowSource.ROWS;
 879             xDiaProp.setPropertyValue( "DataRowSource", eNewSource );
 880             assure( "Couldn't set \"DataRowSource\" property at Diagram",
 881                     AnyConverter.toObject(
 882                         new Type( ChartDataRowSource.class ),
 883                         xDiaProp.getPropertyValue( "DataRowSource" )) == eNewSource );
 884
 885             XChartData xData = mxOldDoc.getData();
 886             XChartDataArray xDataArray = (XChartDataArray) UnoRuntime.queryInterface(
 887                 XChartDataArray.class, xData );
 888             assure( "document has no XChartDataArray", xDataArray != null );
 889
 890             xDataArray.setData( aData );
 891             xDataArray.setRowDescriptions( aRowDescriptions );
 892             xDataArray.setColumnDescriptions( aColumnDescriptions );
 893
 894             mxOldDoc.attachData( xData );
 895
 896             // get data
 897             double aReadData[][];
 898             String[] aReadColumnDescriptions;
 899             String[] aReadRowDescriptions;
 900
 901             // refetch data
 902             xData = mxOldDoc.getData();
 903             xDataArray = (XChartDataArray) UnoRuntime.queryInterface(
 904                 XChartDataArray.class, xData );
 905             assure( "document has no XChartDataArray", xDataArray != null );
 906
 907             aReadData = xDataArray.getData();
 908             aReadRowDescriptions = xDataArray.getRowDescriptions();
 909             aReadColumnDescriptions = xDataArray.getColumnDescriptions();
 910
 911             // compare to values set before
 912             assure( "Data size differs", aData.length == aReadData.length );
 913             for( int i=0; i<aReadData.length; ++i )
 914             {
 915                 assure( "Data size differs", aData[i].length == aReadData[i].length );
 916                 for( int j=0; j<aReadData[i].length; ++j )
 917                     assure( "Data differs", aData[i][j] == aReadData[i][j] );
 918             }
 919
 920             assure( "Column Description size differs", aColumnDescriptions.length == aReadColumnDescriptions.length );
 921             for( int i=0; i<aReadColumnDescriptions.length; ++i )
 922                 assure( "Column Descriptions differ", aColumnDescriptions[i].equals( aReadColumnDescriptions[i] ));
 923
 924             assure( "Row Description size differs", aRowDescriptions.length == aReadRowDescriptions.length );
 925             for( int i=0; i<aReadRowDescriptions.length; ++i )
 926                 assure( "Row Descriptions differ", aRowDescriptions[i].equals( aReadRowDescriptions[i] ));
 927         }
 928         catch( Exception ex )
 929         {
 930             failed( ex.getMessage() );
 931             ex.printStackTrace( (PrintWriter)log );
 932         }
 933     }
 934
 935     // ================================================================================
 936
 937     private XModel                    mxChartModel;
 938     private XChartDocument            mxOldDoc;
 939     private boolean                   mbCreateView;
 940
 941     // --------------------------------------------------------------------------------
 942
 943     private XModel createDocument( String sDocType )
 944     {
 945         XModel aResult = null;
 946         try
 947         {
 948             XComponentLoader aLoader = (XComponentLoader) UnoRuntime.queryInterface(
 949                 XComponentLoader.class,
 950                 ((XMultiServiceFactory)param.getMSF()).createInstance( "com.sun.star.frame.Desktop" ) );
 951
 952             aResult = (XModel) UnoRuntime.queryInterface(
 953                 XModel.class,
 954                 aLoader.loadComponentFromURL( "private:factory/" + sDocType,
 955                                               "_blank",
 956                                               0,
 957                                               new PropertyValue[ 0 ] ) );
 958         }
 959         catch( Exception ex )
 960         {
 961             failed( ex.getMessage() );
 962             ex.printStackTrace( (PrintWriter)log );
 963         }
 964
 965         return aResult;
 966     }
 967
 968     // ------------
 969
 970     public XModel createChartModel()
 971     {
 972         XModel aResult = null;
 973         try
 974         {
 975             aResult = (XModel) UnoRuntime.queryInterface(
 976                 XModel.class,
 977                 ((XMultiServiceFactory)param.getMSF()).createInstance( "com.sun.star.comp.chart2.ChartModel" ) );
 978         }
 979         catch( Exception ex )
 980         {
 981             failed( ex.getMessage() );
 982             ex.printStackTrace( (PrintWriter)log );
 983         }
 984
 985         return aResult;
 986     }
 987
 988     // ------------
 989
 990     private XComponentContext getComponentContext( XMultiServiceFactory xFact )
 991     {
 992         XComponentContext xResult = null;
 993
 994         XPropertySet xProp = (XPropertySet) UnoRuntime.queryInterface(
 995             XPropertySet.class, xFact );
 996         if( xProp != null )
 997             try
 998             {
 999                 xResult = (XComponentContext)
1000                     AnyConverter.toObject(
1001                         new Type( XComponentContext.class ),
1002                         xProp.getPropertyValue( "DefaultContext" ) );
1003             }
1004             catch( Exception ex )
1005             {
1006                 failed( ex.getMessage() );
1007                 ex.printStackTrace( (PrintWriter)log );
1008             }
1009
1010         return xResult;
1011     }
1012
1013     // ------------
1014
1015     private void printInterfacesAndServices( Object oObj )
1016     {
1017         log.println( "Services:" );
1018         util.dbg.getSuppServices( oObj );
1019         log.println( "Interfaces:" );
1020         util.dbg.printInterfaces( (XInterface)oObj, true );
1021     }
1022
1023     // ------------
1024
1025     /// see rtl/math.hxx
1026     private boolean approxEqual( double a, double b )
1027     {
1028         if( a == b )
1029             return true;
1030         double x = a - b;
1031         return (x < 0.0 ? -x : x)
1032             < ((a < 0.0 ? -a : a) * (1.0 / (16777216.0 * 16777216.0)));
1033     }
1034
1035     // ------------
1036     /** returns true if a and b differ no more than tolerance.
1037
1038         @param tolerance
1039             must be non-negative
1040      */
1041     private boolean approxEqual( int a, int b, int tolerance )
1042     {
1043         if( a != b )
1044             log.println( "Integer values differ by " + java.lang.Math.abs( a-b ));
1045         return ( ( a - tolerance <= b ) ||
1046                  ( a + tolerance >= b ));
1047     }
1048 }