CWS-TOOLING: integrate CWS canvas06

2008-11-14 18:59:03 +0100 thb  r263697 : Reverted fAlpha setup to previous state, as this was bogus as well - code path is apparently not taken for test, but anyway
2008-11-13 21:32:45 +0100 thb  r263663 : WaE fix (and a bad bug as well - int color would have overflown)
2008-11-13 16:51:37 +0100 pl  r263654 : remove warnings
2008-11-13 09:46:28 +0100 thb  r263623 : #i95317# Fixed typo (thx WaE for finding)
2008-11-12 21:25:19 +0100 thb  r263617 : #i96047# call update() on hidden sprite shape as well, to force actual hiding
2008-11-12 21:23:31 +0100 thb  r263616 : #i95209# Merge from CWS thb11 - revives canvasbitmap unit tests, fixes nasty corner case in x11 salbmp (for 16bpp)
2008-11-12 21:21:46 +0100 thb  r263615 : #i95197# Shuffled code to make valgrind quiet during bmp loading
2008-11-12 21:18:06 +0100 thb  r263614 : #i93382# Make --disable-moz build work
2008-11-12 21:16:55 +0100 thb  r263613 : #i95317# Fixed mis-named traits methods for min and max numbers
2008-11-12 20:59:01 +0100 thb  r263612 : #i95317#, #i92902#: migrate CWS canvas06 to SVN.

3 files changed, 143 insertions, 116 deletions

diff --git a/vcl/test/canvasbitmaptest.cxx b/vcl/test/canvasbitmaptest.cxx
index 18b677659774..ae0e79f0959f 100644
--- a/vcl/test/canvasbitmaptest.cxx
+++ b/vcl/test/canvasbitmaptest.cxx
@@ -32,6 +32,7 @@
 #include "precompiled_vcl.hxx"
 
 // bootstrap stuff
+#include <sal/main.h>
 #include <rtl/bootstrap.hxx>
 #include <rtl/ref.hxx>
 #include <comphelper/processfactory.hxx>
@@ -54,20 +55,45 @@
 #include <cppuhelper/compbase3.hxx>
 
 #include <tools/diagnose_ex.h>
+#include <tools/extendapplicationenvironment.hxx>
 
 #include "vcl/svapp.hxx"
 #include "vcl/canvastools.hxx"
+#include "vcl/canvasbitmap.hxx"
 #include "vcl/dialog.hxx"
 #include "vcl/outdev.hxx"
 #include "vcl/bmpacc.hxx"
 #include "vcl/virdev.hxx"
 #include "vcl/bitmapex.hxx"
-#include "canvasbitmap.hxx"
 
 
 using namespace ::com::sun::star;
 using namespace ::vcl::unotools;
 
+// -----------------------------------------------------------------------
+
+void Main();
+
+// -----------------------------------------------------------------------
+
+SAL_IMPLEMENT_MAIN()
+{
+    tools::extendApplicationEnvironment();
+
+    uno::Reference< lang::XMultiServiceFactory > xMS;
+    xMS = cppu::createRegistryServiceFactory(
+        rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "applicat.rdb" ) ),
+        sal_True );
+
+    InitVCL( xMS );
+    ::Main();
+    DeInitVCL();
+
+    return 0;
+}
+
+// -----------------------------------------------------------------------
+
 namespace com { namespace sun { namespace star { namespace rendering
 {
 
@@ -258,28 +284,28 @@ void checkCanvasBitmap( const rtl::Reference<VclCanvasBitmap>& xBmp,
     if( nOriginalDepth > 8 )
     {
         const uno::Sequence<sal_Int8> aComponentTags( xBmp->getComponentTags() );
-        uno::Sequence<rendering::ARGBColor> aARGBColors(1);
-        uno::Sequence<rendering::RGBColor>  aRGBColors(1);
+        uno::Sequence<rendering::ARGBColor> aARGBColor(1);
+        uno::Sequence<rendering::RGBColor>  aRGBColor(1);
         uno::Sequence<sal_Int8> aPixel3, aPixel4;
 
         const Color aCol(COL_GREEN);
-        aARGBColors[0].Red   = vcl::unotools::toDoubleColor(aCol.GetRed());
-        aARGBColors[0].Green = vcl::unotools::toDoubleColor(aCol.GetGreen());
-        aARGBColors[0].Blue  = vcl::unotools::toDoubleColor(aCol.GetBlue());
-        aARGBColors[0].Alpha = 1.0;
+        aARGBColor[0].Red   = vcl::unotools::toDoubleColor(aCol.GetRed());
+        aARGBColor[0].Green = vcl::unotools::toDoubleColor(aCol.GetGreen());
+        aARGBColor[0].Blue  = vcl::unotools::toDoubleColor(aCol.GetBlue());
+        aARGBColor[0].Alpha = 1.0;
 
-        aRGBColors[0].Red   = vcl::unotools::toDoubleColor(aCol.GetRed());
-        aRGBColors[0].Green = vcl::unotools::toDoubleColor(aCol.GetGreen());
-        aRGBColors[0].Blue  = vcl::unotools::toDoubleColor(aCol.GetBlue());
+        aRGBColor[0].Red   = vcl::unotools::toDoubleColor(aCol.GetRed());
+        aRGBColor[0].Green = vcl::unotools::toDoubleColor(aCol.GetGreen());
+        aRGBColor[0].Blue  = vcl::unotools::toDoubleColor(aCol.GetBlue());
 
-        aPixel3 = xBmp->convertIntegerFromARGB( aARGBColors );
+        aPixel3 = xBmp->convertIntegerFromARGB( aARGBColor );
         aPixel4 = xBmp->getPixel( aLayout, geometry::IntegerPoint2D(5,0) );
         test( aPixel3 == aPixel4,
               "Green pixel from bitmap matches with manually converted green pixel" );
 
         if( !aContainedBmpEx.IsTransparent() )
         {
-            aPixel3 = xBmp->convertIntegerFromRGB( aRGBColors );
+            aPixel3 = xBmp->convertIntegerFromRGB( aRGBColor );
             test( aPixel3 == aPixel4,
                   "Green pixel from bitmap matches with manually RGB-converted green pixel" );
         }
@@ -409,28 +435,28 @@ void checkBitmapImport( const rtl::Reference<VclCanvasBitmap>& xBmp,
     if( nOriginalDepth > 8 )
     {
         const uno::Sequence<sal_Int8> aComponentTags( xBmp->getComponentTags() );
-        uno::Sequence<rendering::ARGBColor> aARGBColors(1);
-        uno::Sequence<rendering::RGBColor>  aRGBColors(1);
+        uno::Sequence<rendering::ARGBColor> aARGBColor(1);
+        uno::Sequence<rendering::RGBColor>  aRGBColor(1);
         uno::Sequence<sal_Int8> aPixel3, aPixel4;
 
         const Color aCol(COL_GREEN);
-        aARGBColors[0].Red   = vcl::unotools::toDoubleColor(aCol.GetRed());
-        aARGBColors[0].Green = vcl::unotools::toDoubleColor(aCol.GetGreen());
-        aARGBColors[0].Blue  = vcl::unotools::toDoubleColor(aCol.GetBlue());
-        aARGBColors[0].Alpha = 1.0;
+        aARGBColor[0].Red   = vcl::unotools::toDoubleColor(aCol.GetRed());
+        aARGBColor[0].Green = vcl::unotools::toDoubleColor(aCol.GetGreen());
+        aARGBColor[0].Blue  = vcl::unotools::toDoubleColor(aCol.GetBlue());
+        aARGBColor[0].Alpha = 1.0;
 
-        aRGBColors[0].Red   = vcl::unotools::toDoubleColor(aCol.GetRed());
-        aRGBColors[0].Green = vcl::unotools::toDoubleColor(aCol.GetGreen());
-        aRGBColors[0].Blue  = vcl::unotools::toDoubleColor(aCol.GetBlue());
+        aRGBColor[0].Red   = vcl::unotools::toDoubleColor(aCol.GetRed());
+        aRGBColor[0].Green = vcl::unotools::toDoubleColor(aCol.GetGreen());
+        aRGBColor[0].Blue  = vcl::unotools::toDoubleColor(aCol.GetBlue());
 
-        aPixel3 = xBmp->convertIntegerFromARGB( aARGBColors );
+        aPixel3 = xBmp->convertIntegerFromARGB( aARGBColor );
         aPixel4 = xBmp->getPixel( aLayout, geometry::IntegerPoint2D(5,0) );
         test( aPixel3 == aPixel4,
               "Green pixel from bitmap matches with manually converted green pixel" );
 
         if( !aContainedBmpEx.IsTransparent() )
         {
-            aPixel3 = xBmp->convertIntegerFromRGB( aRGBColors );
+            aPixel3 = xBmp->convertIntegerFromRGB( aRGBColor );
             test( aPixel3 == aPixel4,
                   "Green pixel from bitmap matches with manually RGB-converted green pixel" );
         }
@@ -631,6 +657,13 @@ private:
         return uno::Sequence< rendering::ARGBColor >();
     }
 
+    virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertToPARGB( const uno::Sequence< double >& ) throw (lang::IllegalArgumentException,
+                                                                                                                   uno::RuntimeException)
+    {
+        test(false, "Method not implemented");
+        return uno::Sequence< rendering::ARGBColor >();
+    }
+
     virtual uno::Sequence< double > SAL_CALL convertFromRGB( const uno::Sequence< rendering::RGBColor >& ) throw (lang::IllegalArgumentException,
                                                                                                                   uno::RuntimeException)
     {
@@ -645,6 +678,13 @@ private:
         return uno::Sequence< double >();
     }
 
+    virtual uno::Sequence< double > SAL_CALL convertFromPARGB( const uno::Sequence< rendering::ARGBColor >& ) throw (lang::IllegalArgumentException,
+                                                                                                                    uno::RuntimeException)
+    {
+        test(false, "This method is not expected to be called!");
+        return uno::Sequence< double >();
+    }
+
     virtual ::sal_Int32 SAL_CALL getBitsPerPixel(  ) throw (uno::RuntimeException)
     {
         return mnBitsPerPixel;
@@ -660,9 +700,17 @@ private:
         return util::Endianness::LITTLE;
     }
 
-    virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertIntegerColorSpace( const uno::Sequence< ::sal_Int8 >&,
-                                                                           const uno::Reference< rendering::XIntegerBitmapColorSpace >& ) throw (lang::IllegalArgumentException,
-                                                                                                                                                 uno::RuntimeException)
+    virtual uno::Sequence< double > SAL_CALL convertFromIntegerColorSpace( const uno::Sequence< ::sal_Int8 >& ,
+                                                                           const uno::Reference< rendering::XColorSpace >& ) throw (lang::IllegalArgumentException,
+                                                                                                                                    uno::RuntimeException)
+    {
+        test(false, "Method not implemented");
+        return uno::Sequence< double >();
+    }
+
+    virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertToIntegerColorSpace( const uno::Sequence< ::sal_Int8 >& ,
+                                                                             const uno::Reference< rendering::XIntegerBitmapColorSpace >& ) throw (lang::IllegalArgumentException,
+                                                                                                                                                   uno::RuntimeException)
     {
         test(false, "Method not implemented");
         return uno::Sequence< sal_Int8 >();
@@ -722,6 +770,44 @@ private:
         return aRes;
     }
 
+    virtual uno::Sequence< rendering::ARGBColor > SAL_CALL convertIntegerToPARGB( const uno::Sequence< ::sal_Int8 >& deviceColor ) throw (lang::IllegalArgumentException,
+                                                                                                                                         uno::RuntimeException)
+    {
+        const sal_Size  nLen( deviceColor.getLength() );
+        const sal_Int32 nBytesPerPixel(mnBitsPerPixel == 8 ? 1 : 4);
+        test(nLen%nBytesPerPixel==0,
+             "number of channels no multiple of pixel element count");
+
+        uno::Sequence< rendering::ARGBColor > aRes( nLen / nBytesPerPixel );
+        rendering::ARGBColor* pOut( aRes.getArray() );
+
+        if( getPalette().is() )
+        {
+            for( sal_Size i=0; i<nLen; ++i )
+            {
+                *pOut++ = rendering::ARGBColor(
+                    1.0,
+                    vcl::unotools::toDoubleColor(deviceColor[i]),
+                    vcl::unotools::toDoubleColor(deviceColor[i]),
+                    vcl::unotools::toDoubleColor(deviceColor[i]));
+            }
+        }
+        else
+        {
+            for( sal_Size i=0; i<nLen; i+=4 )
+            {
+                const double fAlpha=vcl::unotools::toDoubleColor(deviceColor[i+3]);
+                *pOut++ = rendering::ARGBColor(
+                    fAlpha,
+                    fAlpha*vcl::unotools::toDoubleColor(deviceColor[i+0]),
+                    fAlpha*vcl::unotools::toDoubleColor(deviceColor[i+1]),
+                    fAlpha*vcl::unotools::toDoubleColor(deviceColor[i+2]));
+            }
+        }
+
+        return aRes;
+    }
+
     virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertIntegerFromRGB( const uno::Sequence< rendering::RGBColor >& ) throw (lang::IllegalArgumentException,
                                                                                                                              uno::RuntimeException)
     {
@@ -736,6 +822,13 @@ private:
         return uno::Sequence< sal_Int8 >();
     }
 
+    virtual uno::Sequence< ::sal_Int8 > SAL_CALL convertIntegerFromPARGB( const uno::Sequence< rendering::ARGBColor >& ) throw (lang::IllegalArgumentException,
+                                                                                                                                uno::RuntimeException)
+    {
+        test(false, "Method not implemented");
+        return uno::Sequence< sal_Int8 >();
+    }
+
 public:
     TestBitmap( const geometry::IntegerSize2D& rSize, bool bPalette ) :
         maSize(rSize),
@@ -784,14 +877,14 @@ public:
 
 void TestWindow::Paint( const Rectangle& )
 {
-    static sal_Int8 lcl_depths[]={1,4,8,16,24,32};
+    static sal_Int8 lcl_depths[]={1,4,8,16,24};
 
     try
     {
         // Testing VclCanvasBitmap wrapper
         // ===============================
 
-        for( int i=0; i<sizeof(lcl_depths)/sizeof(*lcl_depths); ++i )
+        for( unsigned int i=0; i<sizeof(lcl_depths)/sizeof(*lcl_depths); ++i )
         {
             const sal_Int8 nDepth( lcl_depths[i] );
             Bitmap aBitmap(Size(200,200),nDepth);
@@ -801,8 +894,8 @@ void TestWindow::Paint( const Rectangle& )
                                              aBitmap);
                 if( pAcc.get() )
                 {
-                    BitmapColor aBlack;
-                    BitmapColor aWhite;
+                    BitmapColor aBlack(0);
+                    BitmapColor aWhite(0);
                     if( pAcc->HasPalette() )
                     {
                         aBlack.SetIndex( sal::static_int_cast<BYTE>(pAcc->GetBestPaletteIndex(BitmapColor(0,0,0))) );
@@ -943,73 +1036,14 @@ void TestWindow::Paint( const Rectangle& )
         exit(2);
 }
 
-USHORT TestApp::Exception( USHORT nError )
-{
-    switch( nError & EXC_MAJORTYPE )
-    {
-        case EXC_RSCNOTLOADED:
-            Abort( String::CreateFromAscii(
-                       "Error: could not load language resources.\nPlease check your installation.\n" ) );
-            break;
-    }
-    return 0;
-}
+} // namespace
 
-void TestApp::Main()
+void Main()
 {
-    bool bHelp = false;
-
-    for( USHORT i = 0; i < GetCommandLineParamCount(); i++ )
-    {
-        ::rtl::OUString aParam = GetCommandLineParam( i );
-
-        if( aParam.equalsAscii( "--help" ) ||
-            aParam.equalsAscii( "-h" ) )
-                bHelp = true;
-    }
-
-    if( bHelp )
-    {
-        printf( "outdevgrind - Profile OutputDevice\n" );
-        return;
-    }
-
-    //-------------------------------------------------
-    // create the global service-manager
-    //-------------------------------------------------
-    uno::Reference< lang::XMultiServiceFactory > xFactory;
-    try
-    {
-        uno::Reference< uno::XComponentContext > xCtx = ::cppu::defaultBootstrap_InitialComponentContext();
-        xFactory = uno::Reference< lang::XMultiServiceFactory >(  xCtx->getServiceManager(),
-                                                                  uno::UNO_QUERY );
-        if( xFactory.is() )
-            ::comphelper::setProcessServiceFactory( xFactory );
-    }
-    catch( uno::Exception& )
-    {
-    }
+    TestWindow aWindow;
+    aWindow.Execute();
+    aWindow.SetText( XubString( RTL_CONSTASCII_USTRINGPARAM( "VCL - canvasbitmaptest" ) ) );
 
-    if( !xFactory.is() )
-    {
-        fprintf( stderr,
-                 "Could not bootstrap UNO, installation must be in disorder. Exiting.\n" );
-        exit( 1 );
-    }
-
-    // Create UCB.
-    uno::Sequence< uno::Any > aArgs( 2 );
-    aArgs[ 0 ] <<= rtl::OUString::createFromAscii( UCB_CONFIGURATION_KEY1_LOCAL );
-    aArgs[ 1 ] <<= rtl::OUString::createFromAscii( UCB_CONFIGURATION_KEY2_OFFICE );
-    ::ucbhelper::ContentBroker::initialize( xFactory, aArgs );
-
-    TestWindow pWindow;
-    pWindow.Execute();
-
-    // clean up UCB
-    ::ucbhelper::ContentBroker::deinitialize();
+    Application::Execute();
 }
 
-} // namespace
-
-TestApp aTestApp;
diff --git a/vcl/test/dndtest.cxx b/vcl/test/dndtest.cxx
index bd912fcdf444..2d426acf84b5 100755
--- a/vcl/test/dndtest.cxx
+++ b/vcl/test/dndtest.cxx
@@ -138,7 +138,7 @@ class StringTransferable : public ::cppu::WeakImplHelper1< XTransferable >
     Sequence< DataFlavor > m_aFlavorList;
 
 public:
-    StringTransferable( const OUString& rString ) : m_aFlavorList( 1 ), m_aData( rString )
+    StringTransferable( const OUString& rString ) : m_aData( rString ), m_aFlavorList( 1 )
     {
         DataFlavor df;
 
@@ -297,7 +297,7 @@ void MyWin::Resize()
 
 void SAL_CALL MyDragAndDropListener::dragGestureRecognized( const DragGestureEvent& dge ) throw(RuntimeException)
 {
-    printf( "XDragGestureListener::dragGestureRecognized called ( Window: %X, %d, %d ).\n", m_pWindow, dge.DragOriginX, dge.DragOriginY );
+    printf( "XDragGestureListener::dragGestureRecognized called ( Window: %p, %"SAL_PRIdINT32", %"SAL_PRIdINT32" ).\n", m_pWindow, dge.DragOriginX, dge.DragOriginY );
 
     Reference< XDragSource > xDragSource( dge.DragSource, UNO_QUERY );
     xDragSource->startDrag( dge, -1, 0, 0, new StringTransferable( OUString::createFromAscii( "TestString" ) ), this );
@@ -308,7 +308,7 @@ void SAL_CALL MyDragAndDropListener::dragGestureRecognized( const DragGestureEve
 
 void SAL_CALL MyDragAndDropListener::drop( const DropTargetDropEvent& dtde ) throw(RuntimeException)
 {
-    printf( "XDropTargetListener::drop called ( Window: %X, %d, %d ).\n", m_pWindow, dtde.LocationX, dtde.LocationY );
+    printf( "XDropTargetListener::drop called ( Window: %p, %"SAL_PRIdINT32", %"SAL_PRIdINT32" ).\n", m_pWindow, dtde.LocationX, dtde.LocationY );
 
     dtde.Context->dropComplete( sal_True );
 }
@@ -317,7 +317,7 @@ void SAL_CALL MyDragAndDropListener::drop( const DropTargetDropEvent& dtde ) thr
 
 void SAL_CALL MyDragAndDropListener::dragEnter( const DropTargetDragEnterEvent& dtdee ) throw(RuntimeException)
 {
-    printf( "XDropTargetListener::dragEnter called ( Window: %X, %d, %d ).\n", m_pWindow, dtdee.LocationX, dtdee.LocationY );
+    printf( "XDropTargetListener::dragEnter called ( Window: %p, %"SAL_PRIdINT32", %"SAL_PRIdINT32" ).\n", m_pWindow, dtdee.LocationX, dtdee.LocationY );
     dtdee.Context->acceptDrag( dtdee.DropAction );
 }
 
@@ -325,14 +325,14 @@ void SAL_CALL MyDragAndDropListener::dragEnter( const DropTargetDragEnterEvent&
 
 void SAL_CALL MyDragAndDropListener::dragExit( const DropTargetEvent& ) throw(RuntimeException)
 {
-    printf( "XDropTargetListener::dragExit called ( Window: %X ).\n", m_pWindow );
+    printf( "XDropTargetListener::dragExit called ( Window: %p ).\n", m_pWindow );
 }
 
 // -----------------------------------------------------------------------
 
 void SAL_CALL MyDragAndDropListener::dragOver( const DropTargetDragEvent& dtde ) throw(RuntimeException)
 {
-    printf( "XDropTargetListener::dragOver called ( Window: %X, %d, %d ).\n", m_pWindow, dtde.LocationX, dtde.LocationY );
+    printf( "XDropTargetListener::dragOver called ( Window: %p, %"SAL_PRIdINT32", %"SAL_PRIdINT32" ).\n", m_pWindow, dtde.LocationX, dtde.LocationY );
     dtde.Context->acceptDrag( dtde.DropAction );
 }
 
@@ -340,7 +340,7 @@ void SAL_CALL MyDragAndDropListener::dragOver( const DropTargetDragEvent& dtde )
 
 void SAL_CALL MyDragAndDropListener::dropActionChanged( const DropTargetDragEvent& dtde ) throw(RuntimeException)
 {
-    printf( "XDropTargetListener::dropActionChanged called ( Window: %X, %d, %d ).\n", m_pWindow, dtde.LocationX, dtde.LocationY );
+    printf( "XDropTargetListener::dropActionChanged called ( Window: %p, %"SAL_PRIdINT32", %"SAL_PRIdINT32" ).\n", m_pWindow, dtde.LocationX, dtde.LocationY );
     dtde.Context->acceptDrag( dtde.DropAction );
 }
 
@@ -348,42 +348,42 @@ void SAL_CALL MyDragAndDropListener::dropActionChanged( const DropTargetDragEven
 
 void SAL_CALL MyDragAndDropListener::dragDropEnd( const DragSourceDropEvent& dsde ) throw(RuntimeException)
 {
-    printf( "XDragSourceListener::dropDropEnd called ( Window: %X, %s ).\n", m_pWindow, dsde.DropSuccess ? "sucess" : "failed" );
+    printf( "XDragSourceListener::dropDropEnd called ( Window: %p, %s ).\n", m_pWindow, dsde.DropSuccess ? "sucess" : "failed" );
 }
 
 // -----------------------------------------------------------------------
 
 void SAL_CALL MyDragAndDropListener::dragEnter( const DragSourceDragEvent& ) throw(RuntimeException)
 {
-    printf( "XDragSourceListener::dragEnter called ( Window: %X ).\n", m_pWindow );
+    printf( "XDragSourceListener::dragEnter called ( Window: %p ).\n", m_pWindow );
 }
 
 // -----------------------------------------------------------------------
 
 void SAL_CALL MyDragAndDropListener::dragExit( const DragSourceEvent& ) throw(RuntimeException)
 {
-    printf( "XDragSourceListener::dragExit called ( Window: %X ).\n", m_pWindow );
+    printf( "XDragSourceListener::dragExit called ( Window: %p ).\n", m_pWindow );
 }
 
 // -----------------------------------------------------------------------
 
 void SAL_CALL MyDragAndDropListener::dragOver( const DragSourceDragEvent& ) throw(RuntimeException)
 {
-    printf( "XDragSourceListener::dragOver called ( Window: %X ).\n", m_pWindow );
+    printf( "XDragSourceListener::dragOver called ( Window: %p ).\n", m_pWindow );
 }
 
 // -----------------------------------------------------------------------
 
 void SAL_CALL MyDragAndDropListener::dropActionChanged( const DragSourceDragEvent& ) throw(RuntimeException)
 {
-    printf( "XDragSourceListener::dropActionChanged called ( Window: %X ).\n", m_pWindow );
+    printf( "XDragSourceListener::dropActionChanged called ( Window: %p ).\n", m_pWindow );
 }
 
 // -----------------------------------------------------------------------
 
 void SAL_CALL MyDragAndDropListener::disposing( const EventObject& ) throw(RuntimeException)
 {
-    printf( "XEventListener::disposing called ( Window: %X ).\n", m_pWindow );
+    printf( "XEventListener::disposing called ( Window: %p ).\n", m_pWindow );
 }
 
 // -----------------------------------------------------------------------
diff --git a/vcl/test/makefile.mk b/vcl/test/makefile.mk
index 45f36555c302..4f10be112d2c 100644
--- a/vcl/test/makefile.mk
+++ b/vcl/test/makefile.mk
@@ -46,13 +46,12 @@ TARGETTYPE=GUI
 
 # --- Files --------------------------------------------------------
 
-OBJFILES= \
+APP1OBJS= \
     $(OBJ)$/dndtest.obj
 
 
 APP1NOSAL=		TRUE
 APP1TARGET= 	$(TARGET)
-APP1OBJS=	    $(OBJFILES)	$(OBJ)$/salmain.obj
 APP1STDLIBS=	$(CPPULIB)			\
                 $(CPPUHELPERLIB)	\
                 $(TOOLSLIB) 		\
@@ -68,12 +67,6 @@ APP2TARGET= canvasbitmaptest
 APP2OBJS=	\
     $(OBJ)$/canvasbitmaptest.obj
 
-.IF "$(GUI)"!="UNX"
-    APP2OBJS += $(OBJ)$/salmain.obj
-.ELSE
-    APP2OBJS += $(SLO)$/salmain.obj
-.ENDIF
-
 APP2NOSAL=		TRUE
 APP2STDLIBS=$(TOOLSLIB) 		\
             $(COMPHELPERLIB)	\