/*************************************************************************
Direct3D support method that must be called after a Reset call on the
Direct3DDevice.
*************************************************************************/
void DirectX9Renderer::postD3DReset(void)
{
// Recreate a vertex buffer
if (FAILED(d_device->CreateVertexBuffer((VERTEXBUFFER_CAPACITY * sizeof(QuadVertex)), D3DUSAGE_DYNAMIC|D3DUSAGE_WRITEONLY, VERTEX_FVF, D3DPOOL_DEFAULT, &d_buffer, 0)))
{
throw RendererException("DirectX9Renderer::postD3DReset - Failed to "
"create the VertexBuffer for use by the "
"DirectX9Renderer object.");
}
// perform post-reset operations on all textures
std::list<DirectX9Texture*>::iterator ctex = d_texturelist.begin();
std::list<DirectX9Texture*>::iterator endtex = d_texturelist.end();
for (; ctex != endtex; ++ctex)
{
(*ctex)->postD3DReset();
}
// update display size
setDisplaySize(getViewportSize());
// Now we've come back, we MUST ensure a full redraw is done since the
// textures in the stored quads will have been invalidated.
System::getSingleton().signalRedraw();
}
bool GR_CocoaImage::convertFromBuffer(const UT_ByteBuf* pBB, const std::string & mimetype,
UT_sint32 iDisplayWidth, UT_sint32 iDisplayHeight)
{
const char *buffer = (const char *) pBB->getPointer(0);
UT_uint32 buflen = pBB->getLength();
if(mimetype == "image/png") {
if (buflen < 6) {
return false;
}
char str1[10] = "\211PNG";
char str2[10] = "<89>PNG";
if ( !(strncmp(buffer, str1, 4)) || !(strncmp(buffer, str2, 6)) )
{
m_grtype = GRT_Raster;
if(m_surface) {
cairo_surface_destroy(m_surface);
}
_PNG_read_state closure(pBB);
m_surface = cairo_image_surface_create_from_png_stream (&_UT_ByteBuf_PNG_read, &closure);
if(CAIRO_SURFACE_TYPE_IMAGE == cairo_surface_get_type(m_surface))
{
if((cairo_image_surface_get_width(m_surface) != iDisplayWidth) ||
(cairo_image_surface_get_height(m_surface) != iDisplayHeight)) {
// needs resize.
cairo_surface_t *rescaled = _rescaleTo(m_surface, iDisplayWidth, iDisplayHeight);
cairo_surface_destroy(m_surface);
m_surface = rescaled;
}
}
setDisplaySize(iDisplayWidth, iDisplayHeight);
return true;
}
}
// Otherwise, assume SVG. Do scaling when drawing; save size for then:
m_grtype = GRT_Vector;
setDisplaySize(iDisplayWidth, iDisplayHeight);
return true;
}
bool GR_Win32Image::_convertFromJPEG(const UT_ByteBuf* pBB, UT_sint32 iDisplayWidth, UT_sint32 iDisplayHeight)
{
UT_sint32 iImageWidth;
UT_sint32 iImageHeight;
// Get the size of the jpeg image. This is a bit of a performance
// issue, as it starts decoding the jpeg (though it does not actually decode it)
// while we also do that in UT_JPEG_getRGBData below.
// This however allows us to decode the image data directly into the DIB we
// create below, which saves us a potentially huge memory copy.
if (!UT_JPEG_getDimensions(pBB, iImageWidth, iImageHeight))
return false;
UT_uint32 iBytesInRow = iImageWidth * 3;
if (iBytesInRow % 4)
{
iBytesInRow += (4 - (iBytesInRow % 4));
}
m_pDIB = (BITMAPINFO*) g_try_malloc(sizeof(BITMAPINFOHEADER) + iImageHeight * iBytesInRow);
if (!m_pDIB)
return false;
/*
Note that we do NOT create a DIB of iDisplayWidth,iDisplayHeight, since
DIBs can be stretched automatically by the Win32 API. So we simply remember
the display size for drawing later.
*/
setDisplaySize(iDisplayWidth, iDisplayHeight);
m_pDIB->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
m_pDIB->bmiHeader.biWidth = iImageWidth;
m_pDIB->bmiHeader.biHeight = iImageHeight;
m_pDIB->bmiHeader.biPlanes = 1;
m_pDIB->bmiHeader.biBitCount = 24;
m_pDIB->bmiHeader.biCompression = BI_RGB;
m_pDIB->bmiHeader.biSizeImage = 0;
m_pDIB->bmiHeader.biXPelsPerMeter = 0;
m_pDIB->bmiHeader.biYPelsPerMeter = 0;
m_pDIB->bmiHeader.biClrUsed = 0;
m_pDIB->bmiHeader.biClrImportant = 0;
UT_Byte* pBuf = ((unsigned char*) m_pDIB) + m_pDIB->bmiHeader.biSize;
if (!UT_JPEG_getRGBData(pBB, pBuf, iBytesInRow, true, true))
{
FREEP(m_pDIB);
return false;
}
return true;
}
void ScrollBar :: SetUpDisplay()
{
setDisplaySize(displaySize);
setStoneSize();
if ( currentStonePos == -1 ) currentStonePos = displaySize;
#if(VERBOSE_DEBUG)
if ( alignment == internal::Horizontal ) std::cout << "Horizonatal Scroll Bar " << std::endl;
else std::cout << "Verical Scroll Bar " << std::endl;
std::cout << "WINDOW SCROLL Page Size " << pageSize << " Display Size : " << displaySize << " Scroll POsition " << currentStonePos << " Stone Size " << ( (alignment == internal::Horizontal ) ? stoneWidth : stoneHeight ) << "Display Size ... " << displaySize << std::endl;
#endif
}
GR_UnixImage::GR_UnixImage(const char* szName,GdkPixbuf * pPixbuf )
: m_image(pPixbuf)
{
if (szName)
{
setName ( szName );
}
else
{
setName ( "GdkPixbufImage" );
}
m_ImageType = GR_Image::GRT_Raster;
if(m_image)
setDisplaySize (gdk_pixbuf_get_width (pPixbuf), gdk_pixbuf_get_height (pPixbuf));
}
bool GR_VectorImage::convertFromBuffer(const UT_ByteBuf* pBB,
const std::string& /*mimetype*/,
UT_sint32 iDisplayWidth, UT_sint32 iDisplayHeight)
{
setDisplaySize ( iDisplayWidth, iDisplayHeight );
DELETEP(m_pBB_Image);
m_pBB_Image = new UT_ByteBuf;
bool bCopied = m_pBB_Image->append(pBB->getPointer(0), pBB->getLength());
if (!bCopied) DELETEP(m_pBB_Image);
return bCopied;
}
void ScrollBar :: SetSize()
{
if (alignment == internal::Vertical )
{
if( getInternalHeight() < getInternalWidth() ) throw "Scroll Bar dimensions not compatible with the alignment type.";
stoneWidth = getInternalWidth();
}
else
{
if( getInternalHeight() > getInternalWidth() ) throw "Scroll Bar dimensions not compatible with the alignment type.";
stoneHeight = getInternalHeight();
}
setDisplaySize(displaySize);
setPageSize(pageSize);
stone.setSize(sf::Vector2f(stoneWidth, stoneHeight) );
}
// note that this does take device units, unlike everything else.
void GR_UnixImage::scale (UT_sint32 iDisplayWidth,
UT_sint32 iDisplayHeight)
{
UT_return_if_fail(m_image);
// don't scale if passed -1 for either
if (iDisplayWidth < 0 || iDisplayHeight < 0)
return;
GdkPixbuf * image = 0;
image = gdk_pixbuf_scale_simple (m_image, iDisplayWidth,
iDisplayHeight, GDK_INTERP_BILINEAR);
// UT_ASSERT(G_OBJECT(m_image)->ref_count == 1);
g_object_unref(G_OBJECT(m_image));
m_image = image;
setDisplaySize (iDisplayWidth, iDisplayHeight);
// UT_ASSERT(G_OBJECT(m_image)->ref_count == 1);
}
bool GR_CocoaImage::convertFromBuffer(const UT_ByteBuf* pBB, const std::string & mimetype,
UT_sint32 iDisplayWidth, UT_sint32 iDisplayHeight)
{
const char *buffer = (const char *) pBB->getPointer(0);
UT_uint32 buflen = pBB->getLength();
// We explicitely do not scale the image on load, since cairo can do
// that during rendering. Scaling during loading will result in lost
// image information, which in turns results in bugs like
// in bugs like #12183.
// So simply remember the display size for drawing later.
setDisplaySize(iDisplayWidth, iDisplayHeight);
if(mimetype == "image/png") {
if (buflen < 6) {
return false;
}
char str1[10] = "\211PNG";
char str2[10] = "<89>PNG";
if ( !(strncmp(buffer, str1, 4)) || !(strncmp(buffer, str2, 6)) )
{
m_grtype = GRT_Raster;
if(m_surface) {
cairo_surface_destroy(m_surface);
}
_PNG_read_state closure(pBB);
m_surface = cairo_image_surface_create_from_png_stream (&_UT_ByteBuf_PNG_read, &closure);
}
} else {
m_grtype = GRT_Vector;
}
return true;
}
/*!
* Scale our image to rectangle given by rec. The dimensions of rec
* are calculated in logical units.
* Overriden by platform implementation if needed. Default is to set
* display size.
*/
void GR_Image::scaleImageTo(GR_Graphics * pG, const UT_Rect & rec)
{
setDisplaySize(pG->tdu(rec.width), pG->tdu(rec.height));
}
bool GR_Win32Image::_convertFromPNG(const UT_ByteBuf* pBB, UT_sint32 iDisplayWidth, UT_sint32 iDisplayHeight)
{
png_structp png_ptr;
png_infop info_ptr;
png_uint_32 width, height;
int bit_depth, color_type, interlace_type;
png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, (void*) NULL,
NULL, NULL);
if (png_ptr == NULL)
{
return false;
}
/* Allocate/initialize the memory for image information. REQUIRED. */
info_ptr = png_create_info_struct(png_ptr);
if (info_ptr == NULL)
{
png_destroy_read_struct(&png_ptr, (png_infopp)NULL, (png_infopp)NULL);
return false;
}
/* Set error handling if you are using the setjmp/longjmp method (this is
* the normal method of doing things with libpng). REQUIRED unless you
* set up your own error handlers in the png_create_read_struct() earlier.
*/
if (setjmp(png_jmpbuf(png_ptr)))
{
/* Free all of the memory associated with the png_ptr and info_ptr */
png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
/* If we get here, we had a problem reading the file */
return false;
}
struct _bb myBB;
myBB.pBB = pBB;
myBB.iCurPos = 0;
png_set_read_fn(png_ptr, (void *)&myBB, _png_read);
/* The call to png_read_info() gives us all of the information from the
* PNG file before the first IDAT (image data chunk). REQUIRED
*/
png_read_info(png_ptr, info_ptr);
png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
&interlace_type, NULL, NULL);
/* Extract multiple pixels with bit depths of 1, 2, and 4 from a single
* byte into separate bytes (useful for paletted and grayscale images).
*/
png_set_packing(png_ptr);
/* Expand paletted colors into true RGB triplets */
png_set_expand(png_ptr);
/* If we've got images with 16 bits per channel, we don't need that
much precision. We'll do fine with 8 bits per channel */
png_set_strip_16(png_ptr);
/* For simplicity, treat grayscale as RGB */
png_set_gray_to_rgb(png_ptr);
/* For simplicity, we'll ignore alpha */
png_set_strip_alpha(png_ptr);
/* We want libpng to deinterlace the image for us */
UT_uint32 iInterlacePasses = png_set_interlace_handling(png_ptr);
/* flip the RGB pixels to BGR (or RGBA to BGRA) */
png_set_bgr(png_ptr);
UT_uint32 iBytesInRow = width * 3;
if (iBytesInRow % 4)
{
iBytesInRow += (4 - (iBytesInRow % 4));
}
m_pDIB = (BITMAPINFO*) g_try_malloc(sizeof(BITMAPINFOHEADER) + height * iBytesInRow);
if (!m_pDIB)
{
png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
return false;
}
/*
Note that we do NOT create a DIB of iDisplayWidth,iDisplayHeight, since
DIBs can be stretched automatically by the Win32 API. So we simply remember
the display size for drawing later.
*/
setDisplaySize(iDisplayWidth, iDisplayHeight);
m_pDIB->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
m_pDIB->bmiHeader.biWidth = width;
m_pDIB->bmiHeader.biHeight = height;
m_pDIB->bmiHeader.biPlanes = 1;
m_pDIB->bmiHeader.biBitCount = 24;
m_pDIB->bmiHeader.biCompression = BI_RGB;
m_pDIB->bmiHeader.biSizeImage = 0;
m_pDIB->bmiHeader.biXPelsPerMeter = 0;
m_pDIB->bmiHeader.biYPelsPerMeter = 0;
m_pDIB->bmiHeader.biClrUsed = 0;
m_pDIB->bmiHeader.biClrImportant = 0;
UT_Byte* pBits = ((unsigned char*) m_pDIB) + m_pDIB->bmiHeader.biSize;
for (; iInterlacePasses; iInterlacePasses--)
{
for (UT_uint32 iRow = 0; iRow < height; iRow++)
{
UT_Byte* pRow = pBits + (height - iRow - 1) * iBytesInRow;
png_read_rows(png_ptr, &pRow, NULL, 1);
}
}
/* read rest of file, and get additional chunks in info_ptr - REQUIRED */
png_read_end(png_ptr, info_ptr);
/* clean up after the read, and g_free any memory allocated - REQUIRED */
png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
return true;
}
/*!
Loads an image from from a byte buffer. Note: If the specified width and/or
height does not match the size of the image contained in the byte buffer,
some image information will be lost. WARNING: TODO
@param iDisplayWidth the width to which the image needs to be scaled. Values
are in device units. Setting this to -1 will cause the image not to be scaled.
@param iDisplayheight the height to which the image needs to be scaled. Values
are in device units. Setting this to -1 will cause the image not to be scaled.
@return true if successful, false otherwise
*/
bool GR_UnixImage::convertFromBuffer(const UT_ByteBuf* pBB,
const std::string & /*mimetype */,
UT_sint32 iDisplayWidth,
UT_sint32 iDisplayHeight)
{
// assert no image loaded yet
UT_ASSERT(!m_image);
bool forceScale = (iDisplayWidth != -1 && iDisplayHeight != -1);
GError * err = 0;
GdkPixbufLoader * ldr = gdk_pixbuf_loader_new ();
if (!ldr)
{
UT_DEBUGMSG (("GdkPixbuf: couldn't create loader! WTF?\n"));
UT_ASSERT (ldr);
return false;
}
if (forceScale) {
setDisplaySize(iDisplayWidth, iDisplayHeight);
gdk_pixbuf_loader_set_size(ldr, iDisplayWidth, iDisplayHeight);
}
if ( !gdk_pixbuf_loader_write (ldr, static_cast<const guchar *>(pBB->getPointer (0)),static_cast<gsize>(pBB->getLength ()), &err) )
{
if(err != NULL)
{
UT_DEBUGMSG(("DOM: couldn't write to loader:%s \n", err->message));
g_error_free(err);
}
gdk_pixbuf_loader_close (ldr, NULL);
g_object_unref(G_OBJECT(ldr));
return false;
}
if ( !gdk_pixbuf_loader_close (ldr, &err) )
{
if(err != NULL)
{
UT_DEBUGMSG(("DOM: couldn't close loader:%s \n", err->message));
g_error_free(err);
}
g_object_unref(G_OBJECT(ldr));
return false;
}
//
// This is just pointer to the buffer in the loader. This can be deleted
// when we close the loader.
//
m_image = gdk_pixbuf_loader_get_pixbuf (ldr);
if (!m_image)
{
UT_DEBUGMSG (("GdkPixbuf: couldn't get image from loader!\n"));
gdk_pixbuf_loader_close (ldr, NULL);
g_object_unref(G_OBJECT(ldr));
return false;
}
G_IS_OBJECT(G_OBJECT(m_image));
//
// Have to put a reference on it to prevent it being deleted during the close.
//
g_object_ref(G_OBJECT(m_image));
if ( FALSE == gdk_pixbuf_loader_close (ldr, &err) )
{
UT_DEBUGMSG(("DOM: error closing loader. Corrupt image: %s\n", err->message));
g_error_free(err);
g_object_unref(G_OBJECT(m_image));
return false;
}
g_object_unref(G_OBJECT(ldr));
//
// Adjust the reference count so it's always 1. Unfortunately
// the reference count after the close is undefined.
//
while(G_OBJECT(m_image)->ref_count > 1)
{
g_object_unref(G_OBJECT(m_image));
}
UT_ASSERT(G_OBJECT(m_image)->ref_count == 1);
// if gdk_pixbuf_loader_set_size was not able to scale the image, then do it manually
if (forceScale && (iDisplayWidth != gdk_pixbuf_get_width (m_image) || iDisplayHeight != gdk_pixbuf_get_height(m_image)))
scale (iDisplayWidth, iDisplayHeight);
UT_ASSERT(G_OBJECT(m_image)->ref_count == 1);
return true;
}
