/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2000, 2010 Oracle and/or its affiliates.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
#define GLX_GLXEXT_PROTOTYPES 1
#include "OGLTrans_TransitionImpl.hxx"
#include <com/sun/star/beans/XFastPropertySet.hpp>
#include <com/sun/star/rendering/IntegerBitmapLayout.hpp>
#include <com/sun/star/rendering/ColorComponentTag.hpp>
#include <com/sun/star/rendering/ColorSpaceType.hpp>
#include <com/sun/star/animations/TransitionType.hpp>
#include <com/sun/star/animations/TransitionSubType.hpp>
#include <com/sun/star/presentation/XTransitionFactory.hpp>
#include <com/sun/star/presentation/XTransition.hpp>
#include <com/sun/star/presentation/XSlideShowView.hpp>
#include <com/sun/star/uno/XComponentContext.hpp>
#include <com/sun/star/rendering/XIntegerBitmap.hpp>
#include <com/sun/star/geometry/IntegerSize2D.hpp>
#include <cppuhelper/compbase1.hxx>
#include <cppuhelper/basemutex.hxx>
#include <cppuhelper/factory.hxx>
#include <rtl/ref.hxx>
#include <comphelper/servicedecl.hxx>
#include <canvas/canvastools.hxx>
#include <tools/gen.hxx>
#include <vcl/window.hxx>
#include <vcl/syschild.hxx>
#include <boost/noncopyable.hpp>
#include <GL/gl.h>
#include <GL/glu.h>
#if defined( WNT )
#include <tools/prewin.h>
#include <windows.h>
#include <tools/postwin.h>
#define GL_TEXTURE_MAX_ANISOTROPY_EXT 0x84FE
#define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF
#elif defined( OS2 )
#elif defined( QUARTZ )
#include "premac.h"
#include <Cocoa/Cocoa.h>
#include "postmac.h"
#elif defined( UNX )
namespace unx
{
#include <X11/keysym.h>
#include <X11/X.h>
#include <GL/glx.h>
#include <GL/glxext.h>
}
#endif
#include <vcl/sysdata.hxx>
#ifdef DEBUG
#include <boost/date_time/posix_time/posix_time.hpp>
using namespace ::boost::posix_time;
static ptime t1;
static ptime t2;
#define DBG(x) x
#else
#define DBG(x)
#endif
using namespace ::com::sun::star;
using ::com::sun::star::beans::XFastPropertySet;
using ::com::sun::star::uno::Any;
using ::com::sun::star::uno::Reference;
using ::com::sun::star::uno::Sequence;
using ::com::sun::star::uno::UNO_QUERY;
using ::com::sun::star::uno::UNO_QUERY_THROW;
namespace
{
typedef cppu::WeakComponentImplHelper1<presentation::XTransition> OGLTransitionerImplBase;
namespace
{
struct OGLFormat
{
GLint nInternalFormat;
GLenum eFormat;
GLenum eType;
};
/* channel ordering: (0:rgba, 1:bgra, 2:argb, 3:abgr)
*/
int calcComponentOrderIndex(const uno::Sequence<sal_Int8>& rTags)
{
using namespace rendering::ColorComponentTag;
static const sal_Int8 aOrderTable[] =
{
RGB_RED, RGB_GREEN, RGB_BLUE, ALPHA,
RGB_BLUE, RGB_GREEN, RGB_RED, ALPHA,
ALPHA, RGB_RED, RGB_GREEN, RGB_BLUE,
ALPHA, RGB_BLUE, RGB_GREEN, RGB_RED,
};
const sal_Int32 nNumComps(rTags.getLength());
const sal_Int8* pLine=aOrderTable;
for(int i=0; i<4; ++i)
{
int j=0;
while( j<4 && j<nNumComps && pLine[j] == rTags[j] )
++j;
// all of the line passed, this is a match!
if( j==nNumComps )
return i;
pLine+=4;
}
return -1;
}
}
// not thread safe
static bool errorTriggered;
int oglErrorHandler( unx::Display* /*dpy*/, unx::XErrorEvent* /*evnt*/ )
{
errorTriggered = true;
return 0;
}
/** This is the Transitioner class for OpenGL 3D transitions in
* slideshow. At the moment, it's Linux only. This class is implicitly
* constructed from XTransitionFactory.
*/
class OGLTransitionerImpl : private cppu::BaseMutex, private boost::noncopyable, public OGLTransitionerImplBase
{
public:
explicit OGLTransitionerImpl(OGLTransitionImpl* pOGLTransition);
bool initWindowFromSlideShowView( const uno::Reference< presentation::XSlideShowView >& xView );
void setSlides( const Reference< rendering::XBitmap >& xLeavingSlide , const uno::Reference< rendering::XBitmap >& xEnteringSlide );
static bool initialize( const Reference< presentation::XSlideShowView >& xView );
// XTransition
virtual void SAL_CALL update( double nTime )
throw (uno::RuntimeException);
virtual void SAL_CALL viewChanged( const Reference< presentation::XSlideShowView >& rView,
const Reference< rendering::XBitmap >& rLeavingBitmap,
const Reference< rendering::XBitmap >& rEnteringBitmap )
throw (uno::RuntimeException);
protected:
void disposeContextAndWindow();
void disposeTextures();
// WeakComponentImplHelperBase
virtual void SAL_CALL disposing();
bool isDisposed() const
{
return (rBHelper.bDisposed || rBHelper.bInDispose);
}
bool createWindow( Window* pPWindow );
void createTexture( unsigned int* texID,
#if defined( GLX_VERSION_1_3 ) && defined( GLX_EXT_texture_from_pixmap )
unx::GLXPixmap pixmap,
bool usePixmap,
#endif
bool useMipmap,
uno::Sequence<sal_Int8>& data,
const OGLFormat* pFormat );
void prepareEnvironment ();
const OGLFormat* chooseFormats();
private:
/** After the window has been created, and the slides have been set, we'll initialize the slides with OpenGL.
*/
void GLInitSlides();
/// Holds the information of our new child window
struct GLWindow
{
#if defined( WNT )
HWND hWnd;
HDC hDC;
HGLRC hRC;
#elif defined( OS2 )
#elif defined( QUARTZ )
#elif defined( UNX )
unx::Display* dpy;
int screen;
unx::Window win;
#if defined( GLX_VERSION_1_3 ) && defined( GLX_EXT_texture_from_pixmap )
unx::GLXFBConfig fbc;
#endif
unx::XVisualInfo* vi;
unx::GLXContext ctx;
#endif
unsigned int bpp;
unsigned int Width;
unsigned int Height;
const char* GLXExtensions;
const GLubyte* GLExtensions;
bool HasGLXExtension( const char* name ) { return gluCheckExtension( (const GLubyte*) name, (const GLubyte*) GLXExtensions ); }
bool HasGLExtension( const char* name ) { return gluCheckExtension( (const GLubyte*) name, GLExtensions ); }
} GLWin;
/** OpenGL handle to the leaving slide's texture
*/
unsigned int GLleavingSlide;
/** OpenGL handle to the entering slide's texture
*/
unsigned int GLenteringSlide;
/** pointer to our window which we MIGHT create.
*/
class SystemChildWindow* pWindow;
Reference< presentation::XSlideShowView > mxView;
Reference< rendering::XIntegerBitmap > mxLeavingBitmap;
Reference< rendering::XIntegerBitmap > mxEnteringBitmap;
/** raw bytes of the entering bitmap
*/
uno::Sequence<sal_Int8> EnteringBytes;
/** raw bytes of the leaving bitmap
*/
uno::Sequence<sal_Int8> LeavingBytes;
#if defined( GLX_VERSION_1_3 ) && defined( GLX_EXT_texture_from_pixmap )
unx::GLXPixmap LeavingPixmap;
unx::GLXPixmap EnteringPixmap;
#endif
bool mbRestoreSync;
bool mbUseLeavingPixmap;
bool mbUseEnteringPixmap;
bool mbFreeLeavingPixmap;
bool mbFreeEnteringPixmap;
unx::Pixmap maLeavingPixmap;
unx::Pixmap maEnteringPixmap;
/** the form the raw bytes are in for the bitmaps
*/
rendering::IntegerBitmapLayout SlideBitmapLayout;
/** the size of the slides
*/
geometry::IntegerSize2D SlideSize;
/** Our Transition to be used.
*/
OGLTransitionImpl* pTransition;
public:
/** whether we are running on ATI fglrx with bug related to textures
*/
static bool cbBrokenTexturesATI;
/** GL version
*/
static float cnGLVersion;
float mnGLXVersion;
/** Whether Mesa is the OpenGL vendor
*/
static bool cbMesa;
/**
whether the display has GLX extension
*/
static bool cbGLXPresent;
/**
whether texture from pixmap extension is available
*/
bool mbTextureFromPixmap;
/**
whether to generate mipmaped textures
*/
bool mbGenerateMipmap;
/**
whether we have visual which can be used for texture_from_pixmap extension
*/
bool mbHasTFPVisual;
#ifdef DEBUG
ptime t3;
ptime t4;
ptime t5;
ptime t6;
time_duration total_update;
int frame_count;
#endif
};
// declare the static variables as some gcc versions have problems declaring them automaticaly
bool OGLTransitionerImpl::cbBrokenTexturesATI;
float OGLTransitionerImpl::cnGLVersion;
bool OGLTransitionerImpl::cbMesa;
bool OGLTransitionerImpl::cbGLXPresent;
bool OGLTransitionerImpl::initialize( const Reference< presentation::XSlideShowView >& xView )
{
// not thread safe
static bool initialized = false;
if( !initialized ) {
OGLTransitionerImpl *instance;
instance = new OGLTransitionerImpl( NULL );
if( instance->initWindowFromSlideShowView( xView ) ) {
const GLubyte* version = glGetString( GL_VERSION );
if( version && version[0] ) {
cnGLVersion = version[0] - '0';
if( version[1] == '.' && version[2] )
cnGLVersion += (version[2] - '0')/10.0;
} else
cnGLVersion = 1.0;
OSL_TRACE("GL version: %s parsed: %f", version, cnGLVersion );
const GLubyte* vendor = glGetString( GL_VENDOR );
cbMesa = ( vendor && strstr( (const char *) vendor, "Mesa" ) );
OSL_TRACE("GL vendor: %s identified as Mesa: %d", vendor, cbMesa );
/* TODO: check for version once the bug in fglrx driver is fixed */
cbBrokenTexturesATI = (vendor && strcmp( (const char *) vendor, "ATI Technologies Inc." ) == 0 );
instance->disposing();
cbGLXPresent = true;
} else
cbGLXPresent = false;
delete instance;
initialized = true;
}
return cbGLXPresent;
}
bool OGLTransitionerImpl::createWindow( Window* pPWindow )
{
const SystemEnvData* sysData(pPWindow->GetSystemData());
#if defined( WNT )
GLWin.hWnd = sysData->hWnd;
#elif defined( UNX )
GLWin.dpy = reinterpret_cast<unx::Display*>(sysData->pDisplay);
if( unx::glXQueryExtension( GLWin.dpy, NULL, NULL ) == false )
return false;
GLWin.win = sysData->aWindow;
OSL_TRACE("parent window: %d", GLWin.win);
unx::XWindowAttributes xattr;
unx::XGetWindowAttributes( GLWin.dpy, GLWin.win, &xattr );
GLWin.screen = XScreenNumberOfScreen( xattr.screen );
unx::XVisualInfo* vi( NULL );
#if defined( GLX_VERSION_1_3 ) && defined( GLX_EXT_texture_from_pixmap )
unx::XVisualInfo* visinfo;
unx::XVisualInfo* firstVisual( NULL );
#endif
static int attrList3[] =
{
GLX_RGBA,//only TrueColor or DirectColor
//single buffered
GLX_RED_SIZE,4,//use the maximum red bits, with a minimum of 4 bits
GLX_GREEN_SIZE,4,//use the maximum green bits, with a minimum of 4 bits
GLX_BLUE_SIZE,4,//use the maximum blue bits, with a minimum of 4 bits
GLX_DEPTH_SIZE,0,//no depth buffer
None
};
static int attrList2[] =
{
GLX_RGBA,//only TrueColor or DirectColor
/// single buffered
GLX_RED_SIZE,4,/// use the maximum red bits, with a minimum of 4 bits
GLX_GREEN_SIZE,4,/// use the maximum green bits, with a minimum of 4 bits
GLX_BLUE_SIZE,4,/// use the maximum blue bits, with a minimum of 4 bits
GLX_DEPTH_SIZE,1,/// use the maximum depth bits, making sure there is a depth buffer
None
};
static int attrList1[] =
{
GLX_RGBA,//only TrueColor or DirectColor
GLX_DOUBLEBUFFER,/// only double buffer
GLX_RED_SIZE,4,/// use the maximum red bits, with a minimum of 4 bits
GLX_GREEN_SIZE,4,/// use the maximum green bits, with a minimum of 4 bits
GLX_BLUE_SIZE,4,/// use the maximum blue bits, with a minimum of 4 bits
GLX_DEPTH_SIZE,0,/// no depth buffer
None
};
static int attrList0[] =
{
GLX_RGBA,//only TrueColor or DirectColor
GLX_DOUBLEBUFFER,/// only double buffer
GLX_RED_SIZE,4,/// use the maximum red bits, with a minimum of 4 bits
GLX_GREEN_SIZE,4,/// use the maximum green bits, with a minimum of 4 bits
GLX_BLUE_SIZE,4,/// use the maximum blue bits, with a minimum of 4 bits
GLX_DEPTH_SIZE,1,/// use the maximum depth bits, making sure there is a depth buffer
None
};
static int* attrTable[] =
{
attrList0,
attrList1,
attrList2,
attrList3,
NULL
};
int** pAttributeTable = attrTable;
const SystemEnvData* pChildSysData = NULL;
delete pWindow;
pWindow=NULL;
#if defined( GLX_VERSION_1_3 ) && defined( GLX_EXT_texture_from_pixmap )
unx::GLXFBConfig* fbconfigs = NULL;
int nfbconfigs, value, i = 0;
#endif
while( *pAttributeTable )
{
// try to find a visual for the current set of attributes
vi = unx::glXChooseVisual( GLWin.dpy,
GLWin.screen,
*pAttributeTable );
#if defined( GLX_VERSION_1_3 ) && defined( GLX_EXT_texture_from_pixmap )
if( vi ) {
if( !firstVisual )
firstVisual = vi;
OSL_TRACE("trying VisualID %08X", vi->visualid);
fbconfigs = glXGetFBConfigs (GLWin.dpy, GLWin.screen, &nfbconfigs);
for ( ; i < nfbconfigs; i++)
{
visinfo = glXGetVisualFromFBConfig (GLWin.dpy, fbconfigs[i]);
if( !visinfo || visinfo->visualid != vi->visualid )
continue;
glXGetFBConfigAttrib (GLWin.dpy, fbconfigs[i], GLX_DRAWABLE_TYPE, &value);
if (!(value & GLX_PIXMAP_BIT))
continue;
glXGetFBConfigAttrib (GLWin.dpy, fbconfigs[i],
GLX_BIND_TO_TEXTURE_TARGETS_EXT,
&value);
if (!(value & GLX_TEXTURE_2D_BIT_EXT))
continue;
glXGetFBConfigAttrib (GLWin.dpy, fbconfigs[i],
GLX_BIND_TO_TEXTURE_RGB_EXT,
&value);
if (value == FALSE)
continue;
glXGetFBConfigAttrib (GLWin.dpy, fbconfigs[i],
GLX_BIND_TO_MIPMAP_TEXTURE_EXT,
&value);
if (value == FALSE)
continue;
/* TODO: handle non Y inverted cases */
break;
}
if( i != nfbconfigs || ( firstVisual && pAttributeTable[1] == NULL ) ) {
if( i != nfbconfigs ) {
vi = glXGetVisualFromFBConfig( GLWin.dpy, fbconfigs[i] );
mbHasTFPVisual = true;
OSL_TRACE("found visual suitable for texture_from_pixmap");
} else {
vi = firstVisual;
mbHasTFPVisual = false;
OSL_TRACE("did not find visual suitable for texture_from_pixmap, using %08X", vi->visualid);
}
#else
if( vi ) {
#endif
SystemWindowData winData;
winData.nSize = sizeof(winData);
OSL_TRACE("using VisualID %08X", vi->visualid);
winData.pVisual = (void*)(vi->visual);
pWindow=new SystemChildWindow(pPWindow, 0, &winData, FALSE);
pChildSysData = pWindow->GetSystemData();
if( pChildSysData ) {
break;
} else {
delete pWindow, pWindow=NULL;
}
}
#if defined( GLX_VERSION_1_3 ) && defined( GLX_EXT_texture_from_pixmap )
}
#endif
++pAttributeTable;
}
#endif
#if defined( WNT )
const SystemEnvData* pChildSysData = NULL;
SystemWindowData winData;
winData.nSize = sizeof(winData);
pWindow=new SystemChildWindow(pPWindow, 0, &winData, FALSE);
pChildSysData = pWindow->GetSystemData();
#endif
if( pWindow )
{
pWindow->SetMouseTransparent( TRUE );
pWindow->SetParentClipMode( PARENTCLIPMODE_NOCLIP );
pWindow->EnableEraseBackground( FALSE );
pWindow->SetControlForeground();
pWindow->SetControlBackground();
pWindow->EnablePaint(FALSE);
#if defined( WNT )
GLWin.hWnd = sysData->hWnd;
#elif defined( UNX )
GLWin.dpy = reinterpret_cast<unx::Display*>(pChildSysData->pDisplay);
GLWin.win = pChildSysData->aWindow;
#if defined( GLX_VERSION_1_3 ) && defined( GLX_EXT_texture_from_pixmap )
if( mbHasTFPVisual )
GLWin.fbc = fbconfigs[i];
#endif
GLWin.vi = vi;
GLWin.GLXExtensions = unx::glXQueryExtensionsString( GLWin.dpy, GLWin.screen );
OSL_TRACE("available GLX extensions: %s", GLWin.GLXExtensions);
#endif
return true;
}
return false;
}
bool OGLTransitionerImpl::initWindowFromSlideShowView( const Reference< presentation::XSlideShowView >& xView )
{
osl::MutexGuard const guard( m_aMutex );
if (isDisposed())
return false;
mxView.set( xView, UNO_QUERY );
if( !mxView.is() )
return false;
/// take the XSlideShowView and extract the parent window from it. see viewmediashape.cxx
uno::Reference< rendering::XCanvas > xCanvas(mxView->getCanvas(), uno::UNO_QUERY_THROW);
uno::Sequence< uno::Any > aDeviceParams;
::canvas::tools::getDeviceInfo( xCanvas, aDeviceParams );
::rtl::OUString aImplName;
aDeviceParams[ 0 ] >>= aImplName;
sal_Int64 aVal = 0;
aDeviceParams[1] >>= aVal;
if( !createWindow( reinterpret_cast< Window* >( aVal ) ) )
return false;
awt::Rectangle aCanvasArea = mxView->getCanvasArea();
pWindow->SetPosSizePixel(aCanvasArea.X, aCanvasArea.Y, aCanvasArea.Width, aCanvasArea.Height);
GLWin.Width = aCanvasArea.Width;
GLWin.Height = aCanvasArea.Height;
OSL_TRACE("canvas area: %d,%d - %dx%d", aCanvasArea.X, aCanvasArea.Y, aCanvasArea.Width, aCanvasArea.Height);
#if defined( WNT )
GLWin.hDC = GetDC(GLWin.hWnd);
#elif defined( UNX )
GLWin.ctx = glXCreateContext(GLWin.dpy,
GLWin.vi,
0,
GL_TRUE);
if( GLWin.ctx == NULL ) {
OSL_TRACE("unable to create GLX context");
return false;
}
#endif
#if defined( WNT )
PIXELFORMATDESCRIPTOR PixelFormatFront = // PixelFormat Tells Windows How We Want Things To Be
{
sizeof(PIXELFORMATDESCRIPTOR),
1, // Version Number
PFD_DRAW_TO_WINDOW |
PFD_SUPPORT_OPENGL |
PFD_DOUBLEBUFFER,
PFD_TYPE_RGBA, // Request An RGBA Format
(BYTE)32, // Select Our Color Depth
0, 0, 0, 0, 0, 0, // Color Bits Ignored
0, // No Alpha Buffer
0, // Shift Bit Ignored
0, // No Accumulation Buffer
0, 0, 0, 0, // Accumulation Bits Ignored
64, // 32 bit Z-BUFFER
0, // 0 bit stencil buffer
0, // No Auxiliary Buffer
0, // now ignored
0, // Reserved
0, 0, 0 // Layer Masks Ignored
};
int WindowPix = ChoosePixelFormat(GLWin.hDC,&PixelFormatFront);
SetPixelFormat(GLWin.hDC,WindowPix,&PixelFormatFront);
GLWin.hRC = wglCreateContext(GLWin.hDC);
wglMakeCurrent(GLWin.hDC,GLWin.hRC);
#elif defined( UNX )
if( !glXMakeCurrent( GLWin.dpy, GLWin.win, GLWin.ctx ) ) {
OSL_TRACE("unable to select current GLX context");
return false;
}
int glxMinor, glxMajor;
mnGLXVersion = 0;
if( glXQueryVersion( GLWin.dpy, &glxMajor, &glxMinor ) )
mnGLXVersion = glxMajor + 0.1*glxMinor;
OSL_TRACE("available GLX version: %f", mnGLXVersion);
GLWin.GLExtensions = glGetString( GL_EXTENSIONS );
OSL_TRACE("available GL extensions: %s", GLWin.GLExtensions);
mbTextureFromPixmap = GLWin.HasGLXExtension( "GLX_EXT_texture_from_pixmap" );
mbGenerateMipmap = GLWin.HasGLExtension( "GL_SGIS_generate_mipmap" );
if( GLWin.HasGLXExtension("GLX_SGI_swap_control" ) ) {
// enable vsync
typedef GLint (*glXSwapIntervalProc)(GLint);
glXSwapIntervalProc glXSwapInterval = (glXSwapIntervalProc) unx::glXGetProcAddress( (const GLubyte*) "glXSwapIntervalSGI" );
if( glXSwapInterval ) {
int (*oldHandler)(unx::Display* /*dpy*/, unx::XErrorEvent* /*evnt*/);
// replace error handler temporarily
oldHandler = unx::XSetErrorHandler( oglErrorHandler );
errorTriggered = false;
glXSwapInterval( 1 );
// sync so that we possibly get an XError
unx::glXWaitGL();
XSync(GLWin.dpy, false);
if( errorTriggered )
OSL_TRACE("error when trying to set swap interval, NVIDIA or Mesa bug?");
else
OSL_TRACE("set swap interval to 1 (enable vsync)");
// restore the error handler
unx::XSetErrorHandler( oldHandler );
}
}
#endif
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glClearColor (0, 0, 0, 0);
glClear(GL_COLOR_BUFFER_BIT);
#if defined( WNT )
SwapBuffers(GLWin.hDC);
#elif defined( UNX )
unx::glXSwapBuffers(GLWin.dpy, GLWin.win);
#endif
glEnable(GL_LIGHTING);
GLfloat light_direction[] = { 0.0 , 0.0 , 1.0 };
GLfloat materialDiffuse[] = { 1.0 , 1.0 , 1.0 , 1.0};
glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, light_direction);
glMaterialfv(GL_FRONT,GL_DIFFUSE,materialDiffuse);
glEnable(GL_LIGHT0);
glEnable(GL_NORMALIZE);
if( LeavingBytes.hasElements() && EnteringBytes.hasElements())
GLInitSlides();//we already have uninitialized slides, let's initialize
if( pTransition && pTransition->mnRequiredGLVersion <= cnGLVersion )
pTransition->prepare( GLleavingSlide, GLenteringSlide );
return true;
}
void OGLTransitionerImpl::setSlides( const uno::Reference< rendering::XBitmap >& xLeavingSlide,
const uno::Reference< rendering::XBitmap >& xEnteringSlide )
{
osl::MutexGuard const guard( m_aMutex );
if (isDisposed())
return;
mxLeavingBitmap.set( xLeavingSlide , UNO_QUERY_THROW );
mxEnteringBitmap.set( xEnteringSlide , UNO_QUERY_THROW );
Reference< XFastPropertySet > xLeavingSet( xLeavingSlide , UNO_QUERY );
Reference< XFastPropertySet > xEnteringSet( xEnteringSlide , UNO_QUERY );
geometry::IntegerRectangle2D SlideRect;
SlideSize = mxLeavingBitmap->getSize();
SlideRect.X1 = 0;
SlideRect.X2 = SlideSize.Width;
SlideRect.Y1 = 0;
SlideRect.Y2 = SlideSize.Height;
OSL_TRACE("leaving bitmap area: %dx%d", SlideSize.Width, SlideSize.Height);
SlideSize = mxEnteringBitmap->getSize();
OSL_TRACE("entering bitmap area: %dx%d", SlideSize.Width, SlideSize.Height);
#ifdef UNX
unx::glXWaitGL();
XSync(GLWin.dpy, false);
#endif
#ifdef DEBUG
t1 = microsec_clock::local_time();
#endif
mbUseLeavingPixmap = false;
mbUseEnteringPixmap = false;
#ifdef UNX
#if defined( GLX_VERSION_1_3 ) && defined( GLX_EXT_texture_from_pixmap )
if( mnGLXVersion >= 1.2999 && mbTextureFromPixmap && xLeavingSet.is() && xEnteringSet.is() && mbHasTFPVisual ) {
Sequence< Any > leaveArgs;
Sequence< Any > enterArgs;
if( (xLeavingSet->getFastPropertyValue( 1 ) >>= leaveArgs) &&
(xEnteringSet->getFastPropertyValue( 1 ) >>= enterArgs) ) {
OSL_TRACE ("pixmaps available");
sal_Int32 depth;
leaveArgs[0] >>= mbFreeLeavingPixmap;
enterArgs[0] >>= mbFreeEnteringPixmap;
leaveArgs[1] >>= maLeavingPixmap;
enterArgs[1] >>= maEnteringPixmap;
leaveArgs[2] >>= depth;
int pixmapAttribs[] = { GLX_TEXTURE_TARGET_EXT, GLX_TEXTURE_2D_EXT,
GLX_TEXTURE_FORMAT_EXT, GLX_TEXTURE_FORMAT_RGB_EXT,
GLX_MIPMAP_TEXTURE_EXT, True,
None };
// sync so that we possibly get an pending XError, before we set our handler.
// this way we will not miss any error from other code
unx::glXWaitGL();
XSync(GLWin.dpy, false);
int (*oldHandler)(unx::Display* /*dpy*/, unx::XErrorEvent* /*evnt*/);
// replace error handler temporarily
oldHandler = unx::XSetErrorHandler( oglErrorHandler );
errorTriggered = false;
LeavingPixmap = glXCreatePixmap( GLWin.dpy, GLWin.fbc, maLeavingPixmap, pixmapAttribs );
// sync so that we possibly get an XError
unx::glXWaitGL();
XSync(GLWin.dpy, false);
if( !errorTriggered )
mbUseLeavingPixmap = true;
else {
OSL_TRACE("XError triggered");
if( mbFreeLeavingPixmap ) {
unx::XFreePixmap( GLWin.dpy, maLeavingPixmap );
mbFreeLeavingPixmap = false;
}
errorTriggered = false;
}
EnteringPixmap = glXCreatePixmap( GLWin.dpy, GLWin.fbc, maEnteringPixmap, pixmapAttribs );
// sync so that we possibly get an XError
unx::glXWaitGL();
XSync(GLWin.dpy, false);
OSL_TRACE("created glx pixmap %p and %p depth: %d", LeavingPixmap, EnteringPixmap, depth);
if( !errorTriggered )
mbUseEnteringPixmap = true;
else {
OSL_TRACE("XError triggered");
if( mbFreeEnteringPixmap ) {
unx::XFreePixmap( GLWin.dpy, maEnteringPixmap );
mbFreeEnteringPixmap = false;
}
}
// restore the error handler
unx::XSetErrorHandler( oldHandler );
}
}
#endif
#endif
if( !mbUseLeavingPixmap )
LeavingBytes = mxLeavingBitmap->getData(SlideBitmapLayout,SlideRect);
if( !mbUseEnteringPixmap )
EnteringBytes = mxEnteringBitmap->getData(SlideBitmapLayout,SlideRect);
// TODO
#ifdef UNX
if(GLWin.ctx)//if we have a rendering context, let's init the slides
#endif
GLInitSlides();
OSL_ENSURE(SlideBitmapLayout.PlaneStride == 0,"only handle no plane stride now");
#ifdef UNX
/* flush & sync */
unx::glXWaitGL();
XSync( GLWin.dpy, false );
// synchronized X still gives us much smoother play
// I suspect some issues in above code in slideshow
// synchronize whole transition for now
XSynchronize( GLWin.dpy, true );
mbRestoreSync = true;
#endif
}
void OGLTransitionerImpl::createTexture( unsigned int* texID,
#if defined( GLX_VERSION_1_3 ) && defined( GLX_EXT_texture_from_pixmap )
unx::GLXPixmap pixmap,
bool usePixmap,
#endif
bool useMipmap,
uno::Sequence<sal_Int8>& data,
const OGLFormat* pFormat )
{
glDeleteTextures( 1, texID );
glGenTextures( 1, texID );
glBindTexture( GL_TEXTURE_2D, *texID );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
#if defined( GLX_VERSION_1_3 ) && defined( GLX_EXT_texture_from_pixmap )
unx::PFNGLXBINDTEXIMAGEEXTPROC myglXBindTexImageEXT = (unx::PFNGLXBINDTEXIMAGEEXTPROC) unx::glXGetProcAddress( (const GLubyte*) "glXBindTexImageEXT" );
if( usePixmap ) {
if( mbGenerateMipmap )
glTexParameteri( GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS, True);
myglXBindTexImageEXT (GLWin.dpy, pixmap, GLX_FRONT_LEFT_EXT, NULL);
if( mbGenerateMipmap && useMipmap ) {
OSL_TRACE("use mipmaps");
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR); //TRILINEAR FILTERING
} else {
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
}
} else {
#endif
if( !pFormat )
{
// force-convert color to ARGB8888 int color space
uno::Sequence<sal_Int8> tempBytes(
SlideBitmapLayout.ColorSpace->convertToIntegerColorSpace(
data,
canvas::tools::getStdColorSpace()));
gluBuild2DMipmaps(GL_TEXTURE_2D,
4,
SlideSize.Width,
SlideSize.Height,
GL_RGBA,
GL_UNSIGNED_BYTE,
&tempBytes[0]);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR); //TRILINEAR FILTERING
//anistropic filtering (to make texturing not suck when looking at polygons from oblique angles)
GLfloat largest_supported_anisotropy;
glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &largest_supported_anisotropy);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, largest_supported_anisotropy);
} else {
if( pTransition && !cbBrokenTexturesATI && !useMipmap) {
glTexImage2D( GL_TEXTURE_2D, 0, pFormat->nInternalFormat, SlideSize.Width, SlideSize.Height, 0, pFormat->eFormat, pFormat->eType, &data[0] );
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
} else {
gluBuild2DMipmaps( GL_TEXTURE_2D, pFormat->nInternalFormat, SlideSize.Width, SlideSize.Height, pFormat->eFormat, pFormat->eType, &data[0] );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR ); //TRILINEAR FILTERING
//anistropic filtering (to make texturing not suck when looking at polygons from oblique angles)
GLfloat largest_supported_anisotropy;
glGetFloatv( GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &largest_supported_anisotropy );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, largest_supported_anisotropy );
}
}
#if defined( GLX_VERSION_1_3 ) && defined( GLX_EXT_texture_from_pixmap )
}
#endif
OSL_ENSURE(glIsTexture(*texID), "Can't generate Leaving slide textures in OpenGL");
}
void OGLTransitionerImpl::prepareEnvironment()
{
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
double EyePos(10.0);
double RealF(1.0);
double RealN(-1.0);
double RealL(-1.0);
double RealR(1.0);
double RealB(-1.0);
double RealT(1.0);
double ClipN(EyePos+5.0*RealN);
double ClipF(EyePos+15.0*RealF);
double ClipL(RealL*8.0);
double ClipR(RealR*8.0);
double ClipB(RealB*8.0);
double ClipT(RealT*8.0);
//This scaling is to take the plane with BottomLeftCorner(-1,-1,0) and TopRightCorner(1,1,0) and map it to the screen after the perspective division.
glScaled( 1.0 / ( ( ( RealR * 2.0 * ClipN ) / ( EyePos * ( ClipR - ClipL ) ) ) - ( ( ClipR + ClipL ) / ( ClipR - ClipL ) ) ),
1.0 / ( ( ( RealT * 2.0 * ClipN ) / ( EyePos * ( ClipT - ClipB ) ) ) - ( ( ClipT + ClipB ) / ( ClipT - ClipB ) ) ),
1.0 );
glFrustum(ClipL,ClipR,ClipB,ClipT,ClipN,ClipF);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslated(0,0,-EyePos);
}
const OGLFormat* OGLTransitionerImpl::chooseFormats()
{
const OGLFormat* pDetectedFormat=NULL;
uno::Reference<rendering::XIntegerBitmapColorSpace> xIntColorSpace(
SlideBitmapLayout.ColorSpace);
if( (xIntColorSpace->getType() == rendering::ColorSpaceType::RGB ||
xIntColorSpace->getType() == rendering::ColorSpaceType::SRGB) )
{
/* table for canvas->OGL format mapping. outer index is number
of color components (0:3, 1:4), then comes bits per pixel
(0:16, 1:24, 2:32), then channel ordering: (0:rgba, 1:bgra,
2:argb, 3:abgr)
*/
static const OGLFormat lcl_RGB24[] =
{
// 24 bit RGB
{3, GL_BGR, GL_UNSIGNED_BYTE},
{3, GL_RGB, GL_UNSIGNED_BYTE},
{3, GL_BGR, GL_UNSIGNED_BYTE},
{3, GL_RGB, GL_UNSIGNED_BYTE}
};
#if defined(GL_VERSION_1_2) && defined(GLU_VERSION_1_3)
// more format constants available
static const OGLFormat lcl_RGB16[] =
{
// 16 bit RGB
{3, GL_RGB, GL_UNSIGNED_SHORT_5_6_5_REV},
{3, GL_RGB, GL_UNSIGNED_SHORT_5_6_5},
{3, GL_RGB, GL_UNSIGNED_SHORT_5_6_5_REV},
{3, GL_RGB, GL_UNSIGNED_SHORT_5_6_5}
};
static const OGLFormat lcl_ARGB16_4[] =
{
// 16 bit ARGB
{4, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4_REV},
{4, GL_BGRA, GL_UNSIGNED_SHORT_4_4_4_4_REV},
{4, GL_BGRA, GL_UNSIGNED_SHORT_4_4_4_4},
{4, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4}
};
static const OGLFormat lcl_ARGB16_5[] =
{
// 16 bit ARGB
{4, GL_RGBA, GL_UNSIGNED_SHORT_1_5_5_5_REV},
{4, GL_BGRA, GL_UNSIGNED_SHORT_1_5_5_5_REV},
{4, GL_BGRA, GL_UNSIGNED_SHORT_5_5_5_1},
{4, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1}
};
static const OGLFormat lcl_ARGB32[] =
{
// 32 bit ARGB
{4, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV},
{4, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV},
{4, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8},
{4, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8}
};
const uno::Sequence<sal_Int8> aComponentTags(
xIntColorSpace->getComponentTags());
const uno::Sequence<sal_Int32> aComponentBitcounts(
xIntColorSpace->getComponentBitCounts());
const sal_Int32 nNumComponents( aComponentBitcounts.getLength() );
const sal_Int32 nBitsPerPixel( xIntColorSpace->getBitsPerPixel() );
// supported component ordering?
const int nComponentOrderIndex(
calcComponentOrderIndex(aComponentTags));
if( nComponentOrderIndex != -1 )
{
switch( nBitsPerPixel )
{
case 16:
if( nNumComponents == 3 )
{
pDetectedFormat = &lcl_RGB16[nComponentOrderIndex];
}
else if( nNumComponents == 4 )
{
if( aComponentBitcounts[1] == 4 )
{
pDetectedFormat = &lcl_ARGB16_4[nComponentOrderIndex];
}
else if( aComponentBitcounts[1] == 5 )
{
pDetectedFormat = &lcl_ARGB16_5[nComponentOrderIndex];
}
}
break;
case 24:
if( nNumComponents == 3 )
{
pDetectedFormat = &lcl_RGB24[nComponentOrderIndex];
}
break;
case 32:
pDetectedFormat = &lcl_ARGB32[nComponentOrderIndex];
break;
}
}
#else
const uno::Sequence<sal_Int8> aComponentTags(
xIntColorSpace->getComponentTags());
const int nComponentOrderIndex(calcComponentOrderIndex(aComponentTags));
if( aComponentTags.getLength() == 3 &&
nComponentOrderIndex != -1 &&
xIntColorSpace->getBitsPerPixel() == 24 )
{
pDetectedFormat = &lcl_RGB24[nComponentOrderIndex];
}
#endif
}
return pDetectedFormat;
}
void OGLTransitionerImpl::GLInitSlides()
{
osl::MutexGuard const guard( m_aMutex );
if (isDisposed() || pTransition->mnRequiredGLVersion > cnGLVersion)
return;
prepareEnvironment();
const OGLFormat* pFormat = NULL;
if( !mbUseLeavingPixmap || !mbUseEnteringPixmap )
pFormat = chooseFormats();
createTexture( &GLleavingSlide,
#if defined( GLX_VERSION_1_3 ) && defined( GLX_EXT_texture_from_pixmap )
LeavingPixmap,
mbUseLeavingPixmap,
#endif
pTransition->mbUseMipMapLeaving,
LeavingBytes,
pFormat );
createTexture( &GLenteringSlide,
#if defined( GLX_VERSION_1_3 ) && defined( GLX_EXT_texture_from_pixmap )
EnteringPixmap,
mbUseEnteringPixmap,
#endif
pTransition->mbUseMipMapEntering,
EnteringBytes,
pFormat );
#ifdef UNX
unx::glXWaitGL();
XSync(GLWin.dpy, false);
#endif
#ifdef DEBUG
t2 = microsec_clock::local_time();
OSL_TRACE("textures created in: %s", to_simple_string( t2 - t1 ).c_str());
#endif
}
void SAL_CALL OGLTransitionerImpl::update( double nTime ) throw (uno::RuntimeException)
{
#ifdef DEBUG
frame_count ++;
t3 = microsec_clock::local_time();
if( frame_count == 1 ) {
t5 = t3;
total_update = seconds (0);
}
#endif
osl::MutexGuard const guard( m_aMutex );
if (isDisposed() || !cbGLXPresent || pTransition->mnRequiredGLVersion > cnGLVersion)
return;
#ifdef WNT
wglMakeCurrent(GLWin.hDC,GLWin.hRC);
#endif
#ifdef UNX
glXMakeCurrent( GLWin.dpy, GLWin.win, GLWin.ctx );
#endif
glEnable(GL_DEPTH_TEST);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if(pTransition)
pTransition->display( nTime, GLleavingSlide, GLenteringSlide,
SlideSize.Width, SlideSize.Height,
static_cast<double>(GLWin.Width),
static_cast<double>(GLWin.Height) );
#if defined( WNT )
SwapBuffers(GLWin.hDC);
#elif defined( UNX )
unx::glXSwapBuffers(GLWin.dpy, GLWin.win);
#endif
if( pWindow )
pWindow->Show();
#ifdef UNX
/* flush & sync */
unx::glXWaitGL();
XSync( GLWin.dpy, false );
#endif
#ifdef DEBUG
t4 = microsec_clock::local_time();
OSL_TRACE("update time: %f", nTime);
OSL_TRACE("update took: %s", to_simple_string( t4 - t3 ).c_str());
total_update += (t4 - t3);
#endif
}
void SAL_CALL OGLTransitionerImpl::viewChanged( const Reference< presentation::XSlideShowView >& rView,
const Reference< rendering::XBitmap >& rLeavingBitmap,
const Reference< rendering::XBitmap >& rEnteringBitmap )
throw (uno::RuntimeException)
{
OSL_TRACE("transitioner: view changed");
disposeTextures();
disposeContextAndWindow();
initWindowFromSlideShowView( rView );
setSlides( rLeavingBitmap, rEnteringBitmap );
}
void OGLTransitionerImpl::disposeContextAndWindow()
{
#if defined( WNT )
if (GLWin.hRC)
{
wglMakeCurrent( GLWin.hDC, 0 ); // kill Device Context
wglDeleteContext( GLWin.hRC ); // Kill Render Context
ReleaseDC( GLWin.hWnd, GLWin.hDC ); // Release Window
}
#elif defined( UNX )
if(GLWin.ctx)
{
glXMakeCurrent(GLWin.dpy, None, NULL);
if( glGetError() != GL_NO_ERROR ) {
OSL_TRACE("glError: %s", (char *)gluErrorString(glGetError()));
}
glXDestroyContext(GLWin.dpy, GLWin.ctx);
GLWin.ctx = NULL;
}
#endif
if( pWindow ) {
delete pWindow;
pWindow = NULL;
GLWin.win = 0;
}
}
void OGLTransitionerImpl::disposeTextures()
{
#ifdef WNT
wglMakeCurrent(GLWin.hDC,GLWin.hRC);
#endif
#ifdef UNX
glXMakeCurrent( GLWin.dpy, GLWin.win, GLWin.ctx );
#endif
#if defined( GLX_VERSION_1_3 ) && defined( GLX_EXT_texture_from_pixmap )
unx::PFNGLXRELEASETEXIMAGEEXTPROC myglXReleaseTexImageEXT = (unx::PFNGLXRELEASETEXIMAGEEXTPROC) unx::glXGetProcAddress( (const GLubyte*) "glXReleaseTexImageEXT" );
if( mbUseLeavingPixmap ) {
myglXReleaseTexImageEXT( GLWin.dpy, LeavingPixmap, GLX_FRONT_LEFT_EXT );
glXDestroyGLXPixmap( GLWin.dpy, LeavingPixmap );
LeavingPixmap = 0;
if( mbFreeLeavingPixmap ) {
unx::XFreePixmap( GLWin.dpy, maLeavingPixmap );
mbFreeLeavingPixmap = false;
maLeavingPixmap = 0;
}
}
if( mbUseEnteringPixmap ) {
myglXReleaseTexImageEXT( GLWin.dpy, EnteringPixmap, GLX_FRONT_LEFT_EXT );
glXDestroyGLXPixmap( GLWin.dpy, EnteringPixmap );
EnteringPixmap = 0;
if( mbFreeEnteringPixmap ) {
unx::XFreePixmap( GLWin.dpy, maEnteringPixmap );
mbFreeEnteringPixmap = false;
maEnteringPixmap = 0;
}
}
#endif
if( !mbUseLeavingPixmap ) {
glDeleteTextures(1,&GLleavingSlide);
GLleavingSlide = 0;
}
if( !mbUseEnteringPixmap ) {
glDeleteTextures(1,&GLenteringSlide);
GLleavingSlide = 0;
}
mbUseLeavingPixmap = false;
mbUseEnteringPixmap = false;
}
// we are about to be disposed (someone call dispose() on us)
void OGLTransitionerImpl::disposing()
{
osl::MutexGuard const guard( m_aMutex );
#ifdef DEBUG
OSL_TRACE("dispose %p\n", this);
if( frame_count ) {
t6 = microsec_clock::local_time();
time_duration duration = t6 - t5;
OSL_TRACE("whole transition (frames: %d) took: %s fps: %f time spent in updates: %s percentage of transition time: %f%%",
frame_count, to_simple_string( duration ).c_str(),
((double)frame_count*1000000000.0)/duration.total_nanoseconds(),
to_simple_string( total_update ).c_str(),
100*(((double)total_update.total_nanoseconds())/((double)duration.total_nanoseconds()))
);
}
#endif
if( pWindow ) {
disposeTextures();
if (pTransition)
pTransition->finish();
#ifdef UNX
if( mbRestoreSync ) {
// try to reestablish synchronize state
char* sal_synchronize = getenv("SAL_SYNCHRONIZE");
XSynchronize( GLWin.dpy, sal_synchronize && *sal_synchronize == '1' );
}
#endif
disposeContextAndWindow();
}
if (pTransition)
delete pTransition;
mxLeavingBitmap.clear();
mxEnteringBitmap.clear();
mxView.clear();
}
OGLTransitionerImpl::OGLTransitionerImpl(OGLTransitionImpl* pOGLTransition) :
OGLTransitionerImplBase(m_aMutex),
GLWin(),
GLleavingSlide( 0 ),
GLenteringSlide( 0 ),
pWindow( NULL ),
mxView(),
EnteringBytes(),
LeavingBytes(),
mbRestoreSync( false ),
mbUseLeavingPixmap( false ),
mbUseEnteringPixmap( false ),
SlideBitmapLayout(),
SlideSize(),
pTransition(pOGLTransition)
{
#if defined( WNT )
GLWin.hWnd = 0;
#elif defined( UNX )
GLWin.ctx = 0;
#endif
DBG(frame_count = 0);
}
typedef cppu::WeakComponentImplHelper1<presentation::XTransitionFactory> OGLTransitionFactoryImplBase;
class OGLTransitionFactoryImpl : private cppu::BaseMutex, public OGLTransitionFactoryImplBase
{
public:
explicit OGLTransitionFactoryImpl( const uno::Reference< uno::XComponentContext >& ) :
OGLTransitionFactoryImplBase(m_aMutex)
{}
// XTransitionFactory
virtual ::sal_Bool SAL_CALL hasTransition( ::sal_Int16 transitionType, ::sal_Int16 transitionSubType ) throw (uno::RuntimeException)
{
if( transitionType == animations::TransitionType::MISCSHAPEWIPE ) {
switch( transitionSubType )
{
case animations::TransitionSubType::ACROSS:
case animations::TransitionSubType::CORNERSOUT:
case animations::TransitionSubType::CIRCLE:
case animations::TransitionSubType::FANOUTHORIZONTAL:
case animations::TransitionSubType::CORNERSIN:
case animations::TransitionSubType::LEFTTORIGHT:
case animations::TransitionSubType::TOPTOBOTTOM:
case animations::TransitionSubType::TOPRIGHT:
case animations::TransitionSubType::TOPLEFT:
case animations::TransitionSubType::BOTTOMRIGHT:
case animations::TransitionSubType::BOTTOMLEFT:
case animations::TransitionSubType::TOPCENTER:
case animations::TransitionSubType::RIGHTCENTER:
case animations::TransitionSubType::BOTTOMCENTER:
return sal_True;
default:
return sal_False;
}
} else if( transitionType == animations::TransitionType::FADE && transitionSubType == animations::TransitionSubType::CROSSFADE ) {
return sal_True;
} else if( transitionType == animations::TransitionType::FADE && transitionSubType == animations::TransitionSubType::FADEOVERCOLOR ) {
return sal_True;
} else if( transitionType == animations::TransitionType::IRISWIPE && transitionSubType == animations::TransitionSubType::DIAMOND ) {
return sal_True;
} else if( transitionType == animations::TransitionType::ZOOM && transitionSubType == animations::TransitionSubType::ROTATEIN ) {
return sal_True;
} else
return sal_False;
}
virtual uno::Reference< presentation::XTransition > SAL_CALL createTransition(
::sal_Int16 transitionType,
::sal_Int16 transitionSubType,
const uno::Reference< presentation::XSlideShowView >& view,
const uno::Reference< rendering::XBitmap >& leavingBitmap,
const uno::Reference< rendering::XBitmap >& enteringBitmap )
throw (uno::RuntimeException)
{
if( !hasTransition( transitionType, transitionSubType ) )
return uno::Reference< presentation::XTransition >();
bool bGLXPresent = OGLTransitionerImpl::initialize( view );
if( OGLTransitionerImpl::cbMesa && (
( transitionType == animations::TransitionType::FADE && transitionSubType == animations::TransitionSubType::CROSSFADE ) ||
( transitionType == animations::TransitionType::FADE && transitionSubType == animations::TransitionSubType::FADEOVERCOLOR ) ||
( transitionType == animations::TransitionType::IRISWIPE && transitionSubType == animations::TransitionSubType::DIAMOND ) ) )
return uno::Reference< presentation::XTransition >();
OGLTransitionImpl* pTransition = NULL;
if( transitionType == animations::TransitionType::MISCSHAPEWIPE ) {
pTransition = new OGLTransitionImpl();
switch( transitionSubType )
{
case animations::TransitionSubType::ACROSS:
pTransition->makeNByMTileFlip(8,6);
break;
case animations::TransitionSubType::CORNERSOUT:
pTransition->makeOutsideCubeFaceToLeft();
break;
case animations::TransitionSubType::CIRCLE:
pTransition->makeRevolvingCircles(8,128);
break;
case animations::TransitionSubType::FANOUTHORIZONTAL:
pTransition->makeHelix(20);
break;
case animations::TransitionSubType::CORNERSIN:
pTransition->makeInsideCubeFaceToLeft();
break;
case animations::TransitionSubType::LEFTTORIGHT:
pTransition->makeFallLeaving();
break;
case animations::TransitionSubType::TOPTOBOTTOM:
pTransition->makeTurnAround();
break;
case animations::TransitionSubType::TOPRIGHT:
pTransition->makeTurnDown();
break;
case animations::TransitionSubType::TOPLEFT:
pTransition->makeIris();
break;
case animations::TransitionSubType::BOTTOMRIGHT:
pTransition->makeRochade();
break;
case animations::TransitionSubType::BOTTOMLEFT:
pTransition->makeVenetianBlinds( true, 8 );
break;
case animations::TransitionSubType::TOPCENTER:
pTransition->makeVenetianBlinds( false, 6 );
break;
case animations::TransitionSubType::RIGHTCENTER:
pTransition->makeStatic();
break;
case animations::TransitionSubType::BOTTOMCENTER:
pTransition->makeDissolve();
break;
}
} else if( transitionType == animations::TransitionType::FADE && transitionSubType == animations::TransitionSubType::CROSSFADE ) {
pTransition = new OGLTransitionImpl();
pTransition->makeFadeSmoothly();
} else if( transitionType == animations::TransitionType::FADE && transitionSubType == animations::TransitionSubType::FADEOVERCOLOR ) {
pTransition = new OGLTransitionImpl();
pTransition->makeFadeThroughBlack();
} else if( transitionType == animations::TransitionType::IRISWIPE && transitionSubType == animations::TransitionSubType::DIAMOND ) {
pTransition = new OGLTransitionImpl();
pTransition->makeDiamond();
} else if( transitionType == animations::TransitionType::ZOOM && transitionSubType == animations::TransitionSubType::ROTATEIN ) {
pTransition = new OGLTransitionImpl();
pTransition->makeNewsflash();
}
rtl::Reference<OGLTransitionerImpl> xRes(
new OGLTransitionerImpl(pTransition) );
if( bGLXPresent ) {
if( !xRes->initWindowFromSlideShowView(view))
return uno::Reference< presentation::XTransition >();
xRes->setSlides(leavingBitmap,enteringBitmap);
}
return uno::Reference<presentation::XTransition>(xRes.get());
}
};
}
namespace sdecl = comphelper::service_decl;
#if defined (__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ <= 3)
sdecl::class_<OGLTransitionFactoryImpl> serviceImpl;
const sdecl::ServiceDecl OGLTransitionFactoryDecl(
serviceImpl,
#else
const sdecl::ServiceDecl OGLTransitionFactoryDecl(
sdecl::class_<OGLTransitionFactoryImpl>(),
#endif
"com.sun.star.comp.presentation.OGLTransitionFactory",
"com.sun.star.presentation.TransitionFactory" );
// The C shared lib entry points
COMPHELPER_SERVICEDECL_EXPORTS1(OGLTransitionFactoryDecl)