Attachment #211754 for bug #295425




#include "magick/describe.h"
#include "magick/log.h"
#include "magick/magick.h"
#include "magick/monitor.h"
#include "magick/pixel_cache.h"
#include "magick/resize.h"
#include "magick/shear.h"
#include "magick/tempfile.h"
#include "magick/texture.h"
#include "magick/transform.h"
#include "magick/utility.h"
#include "magick/version.h"

%                                                                             %
%                                                                             %
%                                                                             %
%   M a g i c k X G e t P i x e l P a c k e t                                 %
%                                                                             %
%                                                                             %
%                                                                             %

%
%
*/
static const char *
MagickXImageFormatToString(int xformat)
{
  static const char
    *formats[] = 
    {
      "XYBitmap",
      "XYPixmap",
      "ZPixmap"
    };
  
  const char
    *format = "Unknown";

  if ((size_t) xformat < sizeof(formats)/sizeof(formats[0]))
    format=formats[xformat];

  return format;
}
static const char *
MagickXByteOrderToString(int xbyte_order)
{
  static const char
    *byte_orders[] =
    {
      "LSBFirst",
      "MSBFirst"
    };
  
  const char
    *byte_order = "Unknown";

  if ((size_t) xbyte_order < sizeof(byte_orders)/sizeof(byte_orders[0]))
    byte_order=byte_orders[xbyte_order];

  return byte_order;
}
MagickExport unsigned int
MagickXMakeImage(Display *display,
		 const MagickXResourceInfo *resource_info,

  window->destroy=False;
  if (window->image != (Image *) NULL)
    {
      MonitorHandler
	handler=(MonitorHandler) NULL;

      handler=SetMonitorHandler((MonitorHandler) NULL);
      if (window->crop_geometry)
        {
          Image

              window->destroy=MagickTrue;
            }
        }
      if ((window->image->matte != MagickFalse) &&
	  (window->pixel_info->colors == 0)
	  /* && (window->immutable == MagickFalse) */)
          (window->pixel_info->colors == 0))
        {
          Image
            *texture;

          /*
            Tile background with texture according to opacity
          */
          strlcpy(resource_info->image_info->filename,"image:checkerboard",
		  sizeof(resource_info->image_info->filename));
          texture=ReadImage(resource_info->image_info,&window->image->exception);
          if (texture != (Image *) NULL)
            {
              Image
                *textured_image;

              textured_image=CloneImage(window->image,0,0,MagickTrue,
					&window->image->exception);
              if (textured_image != (Image *) NULL)
                {
                  if (TextureImage(textured_image,texture) != MagickFail)
		    {
		      if (window->image != image)
			DestroyImage(window->image);
		      window->image=textured_image;
		      window->destroy=MagickTrue;
		    }
		  else
		    {
		      DestroyImage(textured_image);
		    }
                }
              DestroyImage(texture);
              texture=(Image *) NULL;
            }
          }
#endif
      width=(unsigned int) window->image->columns;
      assert(width == window->image->columns);
      height=(unsigned int) window->image->rows;
      assert(height == window->image->rows);
      (void) SetMonitorHandler(handler);
    }
  /*
    Create X image.

  if (IsEventLogging())
    {
      (void) LogMagickEvent(X11Event,GetMagickModule(),"XImage:");
      (void) LogMagickEvent(X11Event,GetMagickModule(),"  width x height: %dx%d",
        ximage->width,ximage->height);
      (void) LogMagickEvent(X11Event,GetMagickModule(),"  format: %s",
			    MagickXImageFormatToString(ximage->format));
      (void) LogMagickEvent(X11Event,GetMagickModule(),"  byte order: %s",
			    MagickXByteOrderToString(ximage->byte_order));
      (void) LogMagickEvent(X11Event,GetMagickModule(),
        "  bitmap unit, bit order, pad: %d %d %d",ximage->bitmap_unit,
        ximage->bitmap_bit_order,ximage->bitmap_pad);

  if (!window->shared_memory)
    {
      if (ximage->format == XYBitmap)
        ximage->data=
	  MagickAllocateArray(char *,
			      MagickArraySize(ximage->height,ximage->bytes_per_line),
			      ximage->depth);
      else
        ximage->data=
	  MagickAllocateArray(char *,ximage->height,ximage->bytes_per_line);
    }
  if (ximage->data == (char *) NULL)
    {

            /*
              Allocate matte image pixel data.
            */
            length=MagickArraySize(MagickArraySize(matte_image->bytes_per_line,
						   matte_image->height),
				   matte_image->depth);
            matte_image->data=MagickAllocateMemory(char *,length);
            if (matte_image->data == (char *) NULL)
              {

%
%  The format of the MagickXMakePixmap method is:
%
%      unsigned int MagickXMakePixmap(Display *display,
%                                     const MagickXResourceInfo *resource_info,
%                                     MagickXWindowInfo *window)
%
%  A description of each parameter follows:
%

Return to bug 295425

Lines 43-52 Link Here

(-)GraphicsMagick/magick/xwindow.c (-32 / +81 lines)
43	#include "magick/describe.h"	43	#include "magick/describe.h"
44	#include "magick/log.h"	44	#include "magick/log.h"
45	#include "magick/magick.h"	45	#include "magick/magick.h"
		46	#include "magick/monitor.h"
46	#include "magick/pixel_cache.h"	47	#include "magick/pixel_cache.h"
47	#include "magick/resize.h"	48	#include "magick/resize.h"
48	#include "magick/shear.h"	49	#include "magick/shear.h"
49	#include "magick/tempfile.h"	50	#include "magick/tempfile.h"
		51	#include "magick/texture.h"
50	#include "magick/transform.h"	52	#include "magick/transform.h"
51	#include "magick/utility.h"	53	#include "magick/utility.h"
52	#include "magick/version.h"	54	#include "magick/version.h"
Lines 2937-2943 MagickExport void MagickXGetImportInfo(M Link Here
2937	% %	2939	% %
2938	% %	2940	% %
2939	% %	2941	% %
2940	% M a g i c k X G e t P i x e l I n f o %	2942	% M a g i c k X G e t P i x e l P a c k e t %
2941	% %	2943	% %
2942	% %	2944	% %
2943	% %	2945	% %
Lines 5376-5381 MagickExport Cursor MagickXMakeCursor(Di Link Here
5376	%	5378	%
5377	%	5379	%
5378	*/	5380	*/
		5381	static const char *
		5382	MagickXImageFormatToString(int xformat)
		5383	{
		5384	static const char
		5385	*formats[] =
		5386	{
		5387	"XYBitmap",
		5388	"XYPixmap",
		5389	"ZPixmap"
		5390	};
		5391
		5392	const char
		5393	*format = "Unknown";
		5394
		5395	if ((size_t) xformat < sizeof(formats)/sizeof(formats[0]))
		5396	format=formats[xformat];
		5397
		5398	return format;
		5399	}
		5400	static const char *
		5401	MagickXByteOrderToString(int xbyte_order)
		5402	{
		5403	static const char
		5404	*byte_orders[] =
		5405	{
		5406	"LSBFirst",
		5407	"MSBFirst"
		5408	};
		5409
		5410	const char
		5411	*byte_order = "Unknown";
		5412
		5413	if ((size_t) xbyte_order < sizeof(byte_orders)/sizeof(byte_orders[0]))
		5414	byte_order=byte_orders[xbyte_order];
		5415
		5416	return byte_order;
		5417	}
5379	MagickExport unsigned int	5418	MagickExport unsigned int
5380	MagickXMakeImage(Display *display,	5419	MagickXMakeImage(Display *display,
5381	const MagickXResourceInfo *resource_info,	5420	const MagickXResourceInfo *resource_info,
Lines 5413-5418 MagickXMakeImage(Display *display, Link Here
5413	window->destroy=False;	5452	window->destroy=False;
5414	if (window->image != (Image *) NULL)	5453	if (window->image != (Image *) NULL)
5415	{	5454	{
		5455	MonitorHandler
		5456	handler=(MonitorHandler) NULL;
		5457
		5458	handler=SetMonitorHandler((MonitorHandler) NULL);
5416	if (window->crop_geometry)	5459	if (window->crop_geometry)
5417	{	5460	{
5418	Image	5461	Image
Lines 5462-5507 MagickXMakeImage(Display *display, Link Here
5462	window->destroy=MagickTrue;	5505	window->destroy=MagickTrue;
5463	}	5506	}
5464	}	5507	}
5465	#if 0	5508	if ((window->image->matte != MagickFalse) &&
5466	if ((window->immutable == MagickFalse) &&	5509	(window->pixel_info->colors == 0)
5467	(window->image->matte != MagickFalse) &&	5510	/* && (window->immutable == MagickFalse) */)
5468	(window->pixel_info->colors == 0))
5469	{	5511	{
5470	Image	5512	Image
5471	*texture;	5513	*texture;
5472		5514
5473	/*	5515	/*
5474	Tile background with texture.	5516	Tile background with texture according to opacity
5475	*/	5517	*/
5476	strlcpy(resource_info->image_info->filename,"image:checkerboard",MaxTextExtent);	5518	strlcpy(resource_info->image_info->filename,"image:checkerboard",
		5519	sizeof(resource_info->image_info->filename));
5477	texture=ReadImage(resource_info->image_info,&window->image->exception);	5520	texture=ReadImage(resource_info->image_info,&window->image->exception);
5478	if (texture != (Image *) NULL)	5521	if (texture != (Image *) NULL)
5479	{	5522	{
5480	Image	5523	Image
5481	*textured_image;	5524	*textured_image;
5482		5525
5483	textured_image=CloneImage(window->image,window->image->columns,	5526	textured_image=CloneImage(window->image,0,0,MagickTrue,
5484	window->image->rows,MagickTrue,&window->image->exception);	5527	&window->image->exception);
5485	if (textured_image != (Image *) NULL)	5528	if (textured_image != (Image *) NULL)
5486	{	5529	{
5487	/* strlcpy(window->image->filename,"textured_image.miff", MaxTextExtent); */	5530	if (TextureImage(textured_image,texture) != MagickFail)
5488	/* WriteImage(resource_info->image_info,window->image); */	5531	{
5489	TextureImage(textured_image,texture);	5532	if (window->image != image)
5490	textured_image->matte=MagickFalse;	5533	DestroyImage(window->image);
5491	if (window->image != image)	5534	window->image=textured_image;
5492	DestroyImage(window->image);	5535	window->destroy=MagickTrue;
5493	window->image=textured_image;	5536	}
5494	window->destroy=MagickTrue;	5537	else
		5538	{
		5539	DestroyImage(textured_image);
		5540	}
5495	}	5541	}
5496	DestroyImage(texture);	5542	DestroyImage(texture);
5497	texture=(Image *) NULL;	5543	texture=(Image *) NULL;
5498	}	5544	}
5499	}	5545	}
5500	#endif
5501	width=(unsigned int) window->image->columns;	5546	width=(unsigned int) window->image->columns;
5502	assert(width == window->image->columns);	5547	assert(width == window->image->columns);
5503	height=(unsigned int) window->image->rows;	5548	height=(unsigned int) window->image->rows;
5504	assert(height == window->image->rows);	5549	assert(height == window->image->rows);
		5550	(void) SetMonitorHandler(handler);
5505	}	5551	}
5506	/*	5552	/*
5507	Create X image.	5553	Create X image.
Lines 5617-5628 MagickXMakeImage(Display *display, Link Here
5617	if (IsEventLogging())	5663	if (IsEventLogging())
5618	{	5664	{
5619	(void) LogMagickEvent(X11Event,GetMagickModule(),"XImage:");	5665	(void) LogMagickEvent(X11Event,GetMagickModule(),"XImage:");
5620	(void) LogMagickEvent(X11Event,GetMagickModule()," width, height: %dx%d",	5666	(void) LogMagickEvent(X11Event,GetMagickModule()," width x height: %dx%d",
5621	ximage->width,ximage->height);	5667	ximage->width,ximage->height);
5622	(void) LogMagickEvent(X11Event,GetMagickModule()," format: %d",	5668	(void) LogMagickEvent(X11Event,GetMagickModule()," format: %s",
5623	ximage->format);	5669	MagickXImageFormatToString(ximage->format));
5624	(void) LogMagickEvent(X11Event,GetMagickModule()," byte order: %d",	5670	(void) LogMagickEvent(X11Event,GetMagickModule()," byte order: %s",
5625	ximage->byte_order);	5671	MagickXByteOrderToString(ximage->byte_order));
5626	(void) LogMagickEvent(X11Event,GetMagickModule(),	5672	(void) LogMagickEvent(X11Event,GetMagickModule(),
5627	" bitmap unit, bit order, pad: %d %d %d",ximage->bitmap_unit,	5673	" bitmap unit, bit order, pad: %d %d %d",ximage->bitmap_unit,
5628	ximage->bitmap_bit_order,ximage->bitmap_pad);	5674	ximage->bitmap_bit_order,ximage->bitmap_pad);
Lines 5639-5649 MagickXMakeImage(Display *display, Link Here
5639	if (!window->shared_memory)	5685	if (!window->shared_memory)
5640	{	5686	{
5641	if (ximage->format == XYBitmap)	5687	if (ximage->format == XYBitmap)
5642	ximage->data=MagickAllocateArray(char *,	5688	ximage->data=
5643	ximage->height*ximage->depth,ximage->bytes_per_line);	5689	MagickAllocateArray(char *,
		5690	MagickArraySize(ximage->height,ximage->bytes_per_line),
		5691	ximage->depth);
5644	else	5692	else
5645	ximage->data=MagickAllocateArray(char *,	5693	ximage->data=
5646	ximage->height,ximage->bytes_per_line);	5694	MagickAllocateArray(char *,ximage->height,ximage->bytes_per_line);
5647	}	5695	}
5648	if (ximage->data == (char *) NULL)	5696	if (ximage->data == (char *) NULL)
5649	{	5697	{
Lines 5719-5726 MagickXMakeImage(Display *display, Link Here
5719	/*	5767	/*
5720	Allocate matte image pixel data.	5768	Allocate matte image pixel data.
5721	*/	5769	*/
5722	length=matte_image->bytes_per_line*	5770	length=MagickArraySize(MagickArraySize(matte_image->bytes_per_line,
5723	matte_image->height*matte_image->depth;	5771	matte_image->height),
		5772	matte_image->depth);
5724	matte_image->data=MagickAllocateMemory(char *,length);	5773	matte_image->data=MagickAllocateMemory(char *,length);
5725	if (matte_image->data == (char *) NULL)	5774	if (matte_image->data == (char *) NULL)
5726	{	5775	{
Lines 7381-7389 MagickExport void MagickXMakeMagnifyImag Link Here
7381	%	7430	%
7382	% The format of the MagickXMakePixmap method is:	7431	% The format of the MagickXMakePixmap method is:
7383	%	7432	%
7384	% void MagickXMakeStandardColormap(Display display,XVisualInfo visual_info,	7433	% unsigned int MagickXMakePixmap(Display *display,
7385	% MagickXResourceInfo resource_info,Image image,XStandardColormap *map_info,	7434	% const MagickXResourceInfo *resource_info,
7386	% MagickXPixelInfo *pixel)	7435	% MagickXWindowInfo *window)
7387	%	7436	%
7388	% A description of each parameter follows:	7437	% A description of each parameter follows:
7389	%	7438	%