canvas/source/java/CanvasTest_perftest.java

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: CanvasTest_perftest.java,v $
  10  * $Revision: 1.6 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // UNO
  32 import com.sun.star.uno.UnoRuntime;
  33 import com.sun.star.uno.XComponentContext;
  34 import com.sun.star.uno.AnyConverter;
  35 import com.sun.star.uno.IQueryInterface;
  36 import com.sun.star.lang.XInitialization;
  37 import com.sun.star.lib.uno.helper.WeakBase;
  38
  39 // OOo AWT
  40 import com.sun.star.awt.*;
  41
  42 // Canvas
  43 import com.sun.star.rendering.*;
  44
  45 // Java AWT
  46 import java.awt.*;
  47 import java.awt.image.*;
  48 import java.awt.geom.*;
  49
  50 public class CanvasTest
  51     extends CanvasBase
  52     implements com.sun.star.awt.XWindow,
  53                com.sun.star.rendering.XSpriteCanvas,
  54                com.sun.star.lang.XServiceInfo,
  55                com.sun.star.lang.XInitialization
  56 {
  57     private WindowAdapter                                       dummyFrame;
  58     private BackBuffer                                          backBuffer;
  59     private java.awt.image.BufferStrategy       bufferStrategy;
  60
  61     private java.awt.Font                                       fpsFont;
  62     private long                                                        lastTime;
  63
  64
  65     // TEST ONLY {
  66     private static int testWidth = 1600;
  67     private static int testHeight = 1200;
  68     private BufferedImage backgroundBuffer;
  69     private BufferedImage buffer;
  70     private BufferedImage buffer2;
  71     private Graphics2D backBufGraphics;
  72     private Graphics2D bufferGraphics;
  73     private Graphics2D buffer2Graphics;
  74     private float currAlpha;
  75     // TEST ONLY }
  76
  77
  78
  79     public Graphics2D getGraphics()
  80     {
  81         return backBuffer.getGraphics();
  82     }
  83
  84     //----------------------------------------------------------------------------------
  85
  86     //
  87     // XInitialization
  88     // ===============
  89     //
  90     public void initialize( java.lang.Object[] arguments )
  91     {
  92         CanvasUtils.printLog( "CanvasTest.initialize called!" );
  93
  94         // Do that as the very first thing. The Java2D internal
  95         // classes choose their render path at initialization time,
  96         // thus this must happen before doing _any_ GUI.
  97
  98         // TODO: Put those flags into javarc/java.ini, we're maybe
  99         // coming late into a running JVM!
 100
 101         // now, we're getting slightly system dependent here.
 102         String os = (String) System.getProperty("os.name");
 103
 104         CanvasUtils.printLog( "System detected: " + os );
 105
 106         // tweak some speed knobs...
 107         if( os.startsWith("Windows") )
 108         {
 109             System.setProperty("sun.java2d.translaccel", "true");
 110             System.setProperty("sun.java2d.ddforcevram", "true");
 111             //System.setProperty("sun.java2d.accthreshold", "0");
 112
 113             CanvasUtils.printLog( "Optimizing for Windows" );
 114         }
 115         else
 116         {
 117             System.setProperty("sun.java2d.opengl", "true");
 118
 119             CanvasUtils.printLog( "Optimizing for Unix" );
 120         }
 121
 122         /* we're initialized with the following array of anys:
 123
 124            arguments[0] = pointer to VCL window
 125            arguments[1] = Integer (operating system window handle)
 126            arguments[2] = com.sun.star.awt.Rectangle (position and size within that OS window)
 127            arguments[3] = boolean (fullsize window or not)
 128
 129            We then generate a dummy Java frame with that window as the
 130            parent, to fake a root window for the Java implementation.
 131         */
 132         try
 133         {
 134             com.sun.star.awt.Rectangle boundRect = (com.sun.star.awt.Rectangle) arguments[2];
 135
 136             //boolean isFullScreen = arguments[1];
 137             boolean isFullScreen = true;
 138             //AnyConverter.toBoolean( arguments[3] ) );
 139
 140             // fake a root for Java in VCL window. Pass the flag
 141             // whether we shall run fullscreen, too.
 142             dummyFrame = new WindowAdapter( AnyConverter.toInt( arguments[1] ), isFullScreen );
 143
 144             if( isFullScreen )
 145             {
 146                 // blow window up to fullscreen. Otherwise, we cannot clear the whole screen,
 147                 // which results in ugly flickering
 148                 Dimension screenSize = dummyFrame.frame.getToolkit().getScreenSize();
 149                 boundRect.X      = 0;
 150                 boundRect.Y      = 0;
 151                 boundRect.Width  = screenSize.width-1;
 152                 boundRect.Height = screenSize.height-1;
 153             }
 154
 155             dummyFrame.setPosSize( boundRect.X, boundRect.Y, boundRect.Width, boundRect.Height, (short)0 );
 156             CanvasUtils.printLog( "Window size: " + boundRect.Width + ", " + boundRect.Height );
 157
 158             // TEST
 159             if( true )
 160             {
 161                 backBuffer = new BackBuffer( (Graphics2D) dummyFrame.frame.getGraphics(),
 162                                              Math.max(1,boundRect.Width),
 163                                              Math.max(1,boundRect.Height) );
 164             }
 165             else
 166             {
 167                 backBuffer = new BackBuffer( (Graphics2D) dummyFrame.frame.getGraphics(),
 168                                              10, 10 );
 169             }
 170
 171             // TODO: Maybe delay double buffer init until first sprite creation
 172             dummyFrame.frame.createBufferStrategy(2);
 173             bufferStrategy = dummyFrame.frame.getBufferStrategy();
 174
 175             if( bufferStrategy.getCapabilities().isPageFlipping() )
 176                 CanvasUtils.printLog( "CanvasTest.initialize double buffering is using page flipping!" );
 177             else
 178                 CanvasUtils.printLog( "CanvasTest.initialize double buffering is using blitting!" );
 179
 180             lastTime = System.currentTimeMillis();
 181             fpsFont = new java.awt.Font( "Times", Font.PLAIN, 20 );
 182
 183
 184             if( false )
 185             {
 186             // TEST ONLY {
 187             Graphics2D frameGraphics= (Graphics2D) dummyFrame.frame.getGraphics();
 188             backgroundBuffer            = frameGraphics.getDeviceConfiguration().createCompatibleImage(testWidth,testHeight); // TODO: size dynamic
 189             buffer                                      = frameGraphics.getDeviceConfiguration().createCompatibleImage(testWidth,testHeight,
 190                                                                                                    Transparency.TRANSLUCENT);
 191             buffer2                             = frameGraphics.getDeviceConfiguration().createCompatibleImage(testWidth,testHeight,
 192                                                                                                    Transparency.TRANSLUCENT);
 193             bufferGraphics                      = (Graphics2D)buffer.getGraphics();
 194             buffer2Graphics             = (Graphics2D)buffer2.getGraphics();
 195             backBufGraphics             = (Graphics2D)backgroundBuffer.getGraphics();
 196             currAlpha                           = 0.1f;
 197
 198             // init content
 199             Font font = new Font( "Times", Font.PLAIN, 100 );
 200
 201             bufferGraphics.setComposite( AlphaComposite.getInstance(AlphaComposite.CLEAR));
 202             bufferGraphics.fillRect( 0,0,testWidth,testHeight );
 203
 204             bufferGraphics.setComposite( AlphaComposite.getInstance(AlphaComposite.SRC_OVER));
 205             bufferGraphics.setColor( Color.red );
 206             bufferGraphics.fillRect( 0,0,testWidth/2,testHeight/2 );
 207             bufferGraphics.setColor( Color.green );
 208             bufferGraphics.fillRect( testWidth/2,0,testWidth,testHeight/2 );
 209             bufferGraphics.setColor( Color.blue );
 210             bufferGraphics.fillRect( 0,testHeight/2,testWidth/2,testHeight );
 211
 212             buffer2Graphics.setColor( Color.red );
 213             buffer2Graphics.fillRect( 0,0,testWidth/2,testHeight/2 );
 214             buffer2Graphics.setColor( Color.green );
 215             buffer2Graphics.fillRect( testWidth/2,0,testWidth,testHeight/2 );
 216             buffer2Graphics.setColor( Color.blue );
 217             buffer2Graphics.fillRect( 0,testHeight/2,testWidth/2,testHeight );
 218
 219             backBufGraphics.setColor( Color.white );
 220             backBufGraphics.fillRect(0,0,testWidth,testHeight);
 221             backBufGraphics.setColor( Color.red );
 222             backBufGraphics.setFont( font );
 223             int i, turns=15;
 224             for(i=0; i<turns; ++i)
 225             {
 226                 backBufGraphics.drawString( "Crossfade test", testWidth*i/turns, testHeight*i/turns );
 227             }
 228             // TEST ONLY }
 229             }
 230
 231             CanvasUtils.printLog( "CanvasTest.initialize finished!" );
 232         }
 233         catch( com.sun.star.lang.IllegalArgumentException e )
 234         {
 235             CanvasUtils.printLog( "Cannot create EmbeddedFrame within VCL window hierarchy!" );
 236         }
 237     }
 238
 239     //----------------------------------------------------------------------------------
 240
 241     //
 242     // XComponent
 243     // ==========
 244     //
 245     public void dispose()
 246     {
 247         CanvasUtils.printLog( "CanvasTest: disposed!" );
 248
 249         // destroy all active sprites
 250         java.util.Set entries = activeSprites.entrySet();
 251         java.util.Iterator iter = entries.iterator();
 252
 253         while( iter.hasNext() )
 254         {
 255             java.util.Map.Entry entry = (java.util.Map.Entry)iter.next();
 256             if( entry.getValue() != null )
 257                 ((SpriteRep)entry.getValue()).dispose();
 258         }
 259
 260         if( bufferStrategy != null )
 261             bufferStrategy.getDrawGraphics().dispose(); // really necessary?
 262
 263         if( dummyFrame != null )
 264             dummyFrame.dispose();
 265
 266         if( backBuffer != null)
 267             backBuffer.dispose();
 268
 269         bufferStrategy = null;
 270         dummyFrame = null;
 271         backBuffer = null;
 272
 273         super.dispose();
 274     }
 275
 276     //----------------------------------------------------------------------------------
 277
 278     public CanvasTest( XComponentContext xContext )
 279     {
 280         CanvasUtils.printLog( "CanvasTest constructor called!" );
 281         activeSprites = new java.util.HashMap( 33 );
 282     }
 283
 284     //----------------------------------------------------------------------------------
 285
 286     //
 287     // XWindow interface
 288     // =================
 289     //
 290     // This is delegated to WindowAdapter!
 291     //
 292     public synchronized void setPosSize( int X, int Y, int Width, int Height, short Flags )
 293     {
 294         if( dummyFrame != null )
 295         {
 296             dummyFrame.setPosSize( X, Y, Width, Height, Flags );
 297
 298             Width = Math.max(1,Width);
 299             Height= Math.max(1,Height);
 300
 301             CanvasUtils.printLog( "CanvasTest graphics set to " + Width + "," + Height );
 302             backBuffer.setSize(Width,Height);
 303         }
 304     }
 305
 306     public synchronized com.sun.star.awt.Rectangle getPosSize(  )
 307     {
 308         if( dummyFrame != null )
 309             return dummyFrame.getPosSize();
 310
 311         return new com.sun.star.awt.Rectangle();
 312     }
 313
 314     public synchronized void setVisible( boolean visible )
 315     {
 316         if( dummyFrame != null )
 317             dummyFrame.setVisible( visible );
 318     }
 319
 320     public synchronized void setEnable( boolean enable )
 321     {
 322         if( dummyFrame != null )
 323             dummyFrame.setEnable( enable );
 324     }
 325
 326     public synchronized void setFocus()
 327     {
 328         if( dummyFrame != null )
 329             dummyFrame.setFocus();
 330     }
 331
 332     public synchronized void addWindowListener( XWindowListener xListener )
 333     {
 334         if( dummyFrame != null )
 335             dummyFrame.addWindowListener( xListener );
 336     }
 337
 338     public synchronized void removeWindowListener( XWindowListener xListener )
 339     {
 340         if( dummyFrame != null )
 341             dummyFrame.removeWindowListener( xListener );
 342     }
 343
 344     public synchronized void addFocusListener( XFocusListener xListener )
 345     {
 346         if( dummyFrame != null )
 347             dummyFrame.addFocusListener( xListener );
 348     }
 349
 350     public synchronized void removeFocusListener( XFocusListener xListener )
 351     {
 352         if( dummyFrame != null )
 353             dummyFrame.removeFocusListener( xListener );
 354     }
 355
 356     public synchronized void addKeyListener( XKeyListener xListener )
 357     {
 358         if( dummyFrame != null )
 359             dummyFrame.addKeyListener( xListener );
 360     }
 361
 362     public synchronized void removeKeyListener( XKeyListener xListener )
 363     {
 364         if( dummyFrame != null )
 365             dummyFrame.removeKeyListener( xListener );
 366     }
 367
 368     public synchronized void addMouseListener( XMouseListener xListener )
 369     {
 370         if( dummyFrame != null )
 371             dummyFrame.addMouseListener( xListener );
 372     }
 373
 374     public synchronized void removeMouseListener( XMouseListener xListener )
 375     {
 376         if( dummyFrame != null )
 377             dummyFrame.removeMouseListener( xListener );
 378     }
 379
 380     public synchronized void addMouseMotionListener( XMouseMotionListener xListener )
 381     {
 382         if( dummyFrame != null )
 383             dummyFrame.addMouseMotionListener( xListener );
 384     }
 385
 386     public synchronized void removeMouseMotionListener( XMouseMotionListener xListener )
 387     {
 388         if( dummyFrame != null )
 389             dummyFrame.removeMouseMotionListener( xListener );
 390     }
 391
 392     public synchronized void addPaintListener( XPaintListener xListener )
 393     {
 394         if( dummyFrame != null )
 395             dummyFrame.addPaintListener( xListener );
 396     }
 397
 398     public synchronized void removePaintListener( XPaintListener xListener )
 399     {
 400         if( dummyFrame != null )
 401             dummyFrame.removePaintListener( xListener );
 402     }
 403
 404     //----------------------------------------------------------------------------------
 405
 406     //
 407     // XBitmapCanvas impl
 408     // ==================
 409     //
 410
 411     public synchronized void copyRect( com.sun.star.rendering.XBitmapCanvas     sourceCanvas,
 412                                        com.sun.star.rendering.Rectangle2D       sourceRect,
 413                                        com.sun.star.rendering.ViewState                 sourceViewState,
 414                                        com.sun.star.rendering.RenderState       sourceRenderState,
 415                                        com.sun.star.rendering.Rectangle2D       destRect,
 416                                        com.sun.star.rendering.ViewState                 destViewState,
 417                                        com.sun.star.rendering.RenderState       destRenderState )
 418     {
 419         CanvasUtils.printLog( "CanvasTest.copyRect() called" );
 420
 421         // TODO: create temp image when transform is non-trivial
 422
 423         if( sourceCanvas == this )
 424         {
 425             // copy rectangle within the canvas
 426             getGraphics().copyArea((int)sourceRect.x1,
 427                                    (int)sourceRect.y1,
 428                                    (int)(sourceRect.x2 - sourceRect.x1),
 429                                    (int)(sourceRect.y2 - sourceRect.y1),
 430                                    (int)(destRect.x1 - sourceRect.x1),
 431                                    (int)(destRect.y1 - sourceRect.y1) );
 432         }
 433         else
 434         {
 435             if( sourceCanvas instanceof CanvasTest )
 436             {
 437                 // cache
 438                 CanvasUtils.setupGraphicsState( getGraphics(), destViewState, destRenderState, CanvasUtils.alsoSetupPaint );
 439
 440                 java.awt.Image backBuffer = ((CanvasTest)sourceCanvas).backBuffer.getBackBuffer();
 441
 442                 // TODO: really extract correct source rect here
 443                 getGraphics().drawImage( backBuffer, 0, 0, null);
 444                 CanvasUtils.postRenderImageTreatment( backBuffer );
 445             }
 446             // TODO: foreign canvas
 447         }
 448     }
 449
 450     //----------------------------------------------------------------------------------
 451
 452     // a map of SpriteReps, with Sprite object as keys. Contains all
 453     // active (i.e. visible) sprites, the SpriteReps are used to
 454     // repaint the sprite content at any time.
 455     private java.util.HashMap activeSprites;
 456
 457     //
 458     // XSpriteCanvas impl
 459     // ==================
 460     //
 461
 462     public synchronized com.sun.star.rendering.XAnimatedSprite createSpriteFromAnimation( XAnimation animation )
 463     {
 464         CanvasUtils.printLog( "CanvasTest.createSpriteFromAnimation called" );
 465
 466         return new CanvasSprite( animation, this, (Graphics2D)dummyFrame.frame.getGraphics() );
 467     }
 468
 469     public synchronized XAnimatedSprite createSpriteFromBitmaps( com.sun.star.rendering.XBitmap[] animationBitmaps,
 470                                                                  short interpolationMode )
 471     {
 472         return null;
 473     }
 474
 475     public synchronized XCustomSprite createCustomSprite( Size2D spriteSize )
 476     {
 477         CanvasUtils.printLog( "CanvasTest.createCustomSprite called" );
 478
 479         return new CanvasCustomSprite( spriteSize, this, (Graphics2D)dummyFrame.frame.getGraphics() );
 480     }
 481
 482     public synchronized XSprite createClonedSprite( XSprite original )
 483     {
 484         return new CanvasClonedSprite( this, original );
 485     }
 486
 487     public synchronized void updateScreen()
 488     {
 489         redrawAllLayers();
 490     }
 491
 492     //----------------------------------------------------------------------------------
 493
 494     //
 495     // XSpriteCanvas helper
 496     // ====================
 497     //
 498     public synchronized void renderAnimation( CanvasSprite sprite, XAnimation animation, double t )
 499     {
 500         SpriteRep spriteRep = (SpriteRep)activeSprites.get( sprite );
 501         if( spriteRep != null )
 502         {
 503             //Graphics2D graph = getWindowGraphics();
 504
 505             // TODO: ensure update of graphics object externally, e.g. when
 506             // VCL moves the toplevel window.
 507             //java.awt.Rectangle bounds = dummyFrame.frame.getBounds();
 508             //graphics.setGraphics(graph, bounds.width, bounds.height);
 509
 510             spriteRep.renderAnimation( animation, sprite.getViewState(), t );
 511         }
 512         else
 513         {
 514             CanvasUtils.printLog( "CanvasTest.renderAnimation sprite not active!" );
 515         }
 516     }
 517
 518     public synchronized void showSprite( SpriteBase sprite )
 519     {
 520         CanvasUtils.printLog( "CanvasTest.showSprite() called" );
 521
 522         SpriteRep spriteRep = (SpriteRep)activeSprites.get( sprite );
 523         if( spriteRep != null )
 524         {
 525             CanvasUtils.printLog( "CanvasTest.showSprite sprite already active!" );
 526         }
 527         else
 528         {
 529             spriteRep = sprite.getSpriteRep();
 530
 531             // a valid SpriteRep for a given Sprite in the
 532             // activeSprites hash denotes 'sprite active'
 533             activeSprites.put( sprite, spriteRep );
 534
 535             // TODO: TEMP! Just for testing! Set empty cursor for presentation
 536 //             dummyFrame.frame.setCursor( dummyFrame.frame.getToolkit().createCustomCursor(new java.awt.image.BufferedImage(0,0,
 537 //                                                                                                                           java.awt.image.BufferedImage.TYPE_INT_RGB),
 538 //                                                                                          new java.awt.Point(0,0),
 539 //                                                                                          "") );
 540         }
 541     }
 542
 543     public synchronized void hideSprite( SpriteBase sprite )
 544     {
 545         CanvasUtils.printLog( "CanvasTest.hideSprite() called" );
 546
 547         SpriteRep spriteRep = (SpriteRep)activeSprites.get( sprite );
 548         if( spriteRep != null )
 549         {
 550             activeSprites.put( sprite, null );
 551             redrawAllLayers();
 552         }
 553         else
 554         {
 555             CanvasUtils.printLog( "CanvasTest.hideSprite sprite not active!" );
 556         }
 557     }
 558
 559     private void redrawAllLayers()
 560     {
 561         // fetch the Graphics object to draw into (we're doing double
 562         // buffering here, the content is later shown via
 563         // bufferStrategy.show().
 564         Graphics2D graph = null;
 565
 566         try
 567         {
 568             graph = (Graphics2D)bufferStrategy.getDrawGraphics();
 569
 570             GraphicsDevice device = graph.getDeviceConfiguration().getDevice();
 571             CanvasUtils.printLog( "Available vram: " + device.getAvailableAcceleratedMemory() );
 572
 573             if( false )
 574             {
 575             // TEST ONLY {
 576                     // repaint background
 577                     graph.setComposite( AlphaComposite.getInstance(AlphaComposite.SRC_OVER) );
 578                     graph.drawImage(backgroundBuffer, 0, 0, null);
 579                     //backgroundBuffer.flush();
 580
 581                     // alpha-composite foreground on top of that
 582                     graph.setComposite( AlphaComposite.getInstance(AlphaComposite.SRC_OVER, currAlpha) );
 583
 584                     graph.drawImage(buffer, 0, 0, null);
 585                     //buffer.flush();
 586
 587                     currAlpha += 0.1f; if( currAlpha > 1.0 ) currAlpha = 0.1f;
 588             // TEST ONLY }
 589             }
 590
 591             if( true )
 592             {
 593                 // repaint background
 594                 backBuffer.redraw( graph );
 595
 596                 // repaint all active sprites
 597                 java.util.Set entries = activeSprites.entrySet();
 598                 java.util.Iterator iter = entries.iterator();
 599                 while( iter.hasNext() )
 600                 {
 601                     java.util.Map.Entry entry = (java.util.Map.Entry)iter.next();
 602                     if( entry.getValue() != null )
 603                         ((SpriteRep)entry.getValue()).redraw(graph);
 604                 }
 605             }
 606
 607             long currTime = System.currentTimeMillis();
 608             graph.setComposite( AlphaComposite.getInstance(AlphaComposite.SRC_OVER) );
 609             graph.setFont( fpsFont );
 610             graph.setColor( java.awt.Color.black );
 611
 612             try
 613             {
 614                 String fps = new String( String.valueOf(1000.0/(currTime-lastTime)) );
 615                 graph.drawString( fps.substring(0,5) + " fps", 0, 20);
 616                 CanvasUtils.printLog( fps.substring(0,5) + " fps" );
 617             }
 618             catch( Exception e )
 619             {
 620                 graph.drawString( "0 fps", 0, 20);
 621             }
 622
 623             lastTime = currTime;
 624         }
 625         finally
 626         {
 627             if( graph != null )
 628                 graph.dispose();
 629         }
 630
 631         bufferStrategy.show();
 632     }
 633
 634     //----------------------------------------------------------------------------------
 635
 636     private static final String s_implName = "XCanvas.java.impl";
 637     private static final String s_serviceName = "com.sun.star.rendering.Canvas";
 638
 639     //----------------------------------------------------------------------------------
 640
 641     //
 642     // XServiceInfo impl
 643     // =================
 644     //
 645     public synchronized String getImplementationName()
 646     {
 647         return s_implName;
 648     }
 649
 650     public synchronized String [] getSupportedServiceNames()
 651     {
 652         return new String [] { s_serviceName };
 653     }
 654
 655     public synchronized boolean supportsService( String serviceName )
 656     {
 657         return serviceName.equals( s_serviceName );
 658     }
 659
 660     public static com.sun.star.lang.XSingleServiceFactory __getServiceFactory(
 661         String implName,
 662         com.sun.star.lang.XMultiServiceFactory multiFactory,
 663         com.sun.star.registry.XRegistryKey regKey )
 664     {
 665         if (implName.equals( s_implName ))
 666         {
 667             return com.sun.star.comp.loader.FactoryHelper.getServiceFactory(
 668                 CanvasTest.class, s_serviceName, multiFactory, regKey );
 669         }
 670         return null;
 671     }
 672
 673     public static boolean __writeRegistryServiceInfo(
 674         com.sun.star.registry.XRegistryKey regKey )
 675     {
 676         return com.sun.star.comp.loader.FactoryHelper.writeRegistryServiceInfo(
 677             s_implName, s_serviceName, regKey );
 678     }
 679 }