% July 1992 %
% %
% %
-% Copyright 1999-2010 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization %
% dedicated to making software imaging solutions freely available. %
% %
% You may not use this file except in compliance with the License. You may %
#include "magick/client.h"
#include "magick/color.h"
#include "magick/color-private.h"
+#include "magick/colormap.h"
#include "magick/composite.h"
#include "magick/display.h"
#include "magick/exception.h"
#define XBlueGamma(color) ClampToQuantum(blue_gamma == 1.0 ? (double) \
(color) : ((pow(((double) QuantumScale*(color)),1.0/(double) blue_gamma)* \
QuantumRange)))
-#define XGammaPixel(map,color) (unsigned long) (map->base_pixel+ \
+#define XGammaPixel(map,color) (size_t) (map->base_pixel+ \
((ScaleQuantumToShort(XRedGamma((color)->red))*map->red_max/65535L)* \
map->red_mult)+ \
((ScaleQuantumToShort(XGreenGamma((color)->green))*map->green_max/65535L)* \
#define XRedGamma(color) ClampToQuantum(red_gamma == 1.0 ? (double) \
(color) : ((pow(((double) QuantumScale*(color)),1.0/(double) red_gamma)* \
QuantumRange)))
-#define XStandardPixel(map,color) (unsigned long) (map->base_pixel+ \
+#define XStandardPixel(map,color) (size_t) (map->base_pixel+ \
(((color)->red*map->red_max/65535L)*map->red_mult)+ \
(((color)->green*map->green_max/65535L)*map->green_mult)+ \
(((color)->blue*map->blue_max/65535L)*map->blue_mult))
unsigned short
index;
- unsigned long
+ size_t
count;
} DiversityPacket;
\f
MagickExport MagickBooleanType XAnnotateImage(Display *display,
const XPixelInfo *pixel,XAnnotateInfo *annotate_info,Image *image)
{
+ CacheView
+ *annotate_view;
+
GC
annotate_context;
Initialize graphics info.
*/
context_values.background=0;
- context_values.foreground=(unsigned long) (~0);
+ context_values.foreground=(size_t) (~0);
context_values.font=annotate_info->font_info->fid;
annotate_context=XCreateGC(display,root_window,(unsigned long)
- GCBackground | GCFont | GCForeground,&context_values);
+ (GCBackground | GCFont | GCForeground),&context_values);
if (annotate_context == (GC) NULL)
return(MagickFalse);
/*
x=0;
y=0;
(void) XParseGeometry(annotate_info->geometry,&x,&y,&width,&height);
- (void) GetOneVirtualPixel(image,x,y,&annotate_image->background_color,
- &image->exception);
+ (void) GetOneVirtualPixel(image,(ssize_t) x,(ssize_t) y,
+ &annotate_image->background_color,&image->exception);
if (annotate_info->stencil == ForegroundStencil)
annotate_image->matte=MagickTrue;
exception=(&image->exception);
+ annotate_view=AcquireCacheView(annotate_image);
for (y=0; y < (int) annotate_image->rows; y++)
{
- register long
+ register int
x;
register PixelPacket
*restrict q;
- q=GetAuthenticPixels(annotate_image,0,y,annotate_image->columns,1,
- exception);
+ q=GetCacheViewAuthenticPixels(annotate_view,0,(ssize_t) y,
+ annotate_image->columns,1,exception);
if (q == (PixelPacket *) NULL)
break;
- for (x=0; x < (long) annotate_image->columns; x++)
+ for (x=0; x < (int) annotate_image->columns; x++)
{
SetOpacityPixelComponent(q,OpaqueOpacity);
if (XGetPixel(annotate_ximage,x,y) == 0)
}
q++;
}
- if (SyncAuthenticPixels(annotate_image,exception) == MagickFalse)
+ if (SyncCacheViewAuthenticPixels(annotate_view,exception) == MagickFalse)
break;
}
+ annotate_view=DestroyCacheView(annotate_view);
XDestroyImage(annotate_ximage);
/*
Determine annotate geometry.
(void) XParseGeometry(annotate_info->geometry,&x,&y,&width,&height);
matte=image->matte;
(void) CompositeImage(image,annotate_image->matte != MagickFalse ?
- OverCompositeOp : CopyCompositeOp,annotate_image,x,y);
+ OverCompositeOp : CopyCompositeOp,annotate_image,(ssize_t) x,(ssize_t) y);
image->matte=matte;
annotate_image=DestroyImage(annotate_image);
return(MagickTrue);
return;
}
for (i=0; i < (int) number_colors; i++)
- colors[i].pixel=(unsigned long) i;
+ colors[i].pixel=(size_t) i;
if (number_colors > 256)
number_colors=256;
(void) XQueryColors(display,colormap,colors,(int) number_colors);
return(y);
}
-static inline unsigned long MagickMin(const unsigned int x,
+static inline size_t MagickMin(const unsigned int x,
const unsigned int y)
{
if (x < y)
*map_type,
*visual_type;
- long
+ int
visual_mask;
register int
i;
+ size_t
+ one;
+
static int
number_visuals;
visual_mask=VisualScreenMask;
visual_template.screen=XDefaultScreen(display);
visual_template.depth=XDefaultDepth(display,XDefaultScreen(display));
+ one=1;
if ((resource_info->immutable != MagickFalse) && (resource_info->colors != 0))
- if (resource_info->colors <= (1UL << (unsigned long) visual_template.depth))
+ if (resource_info->colors <= (one << (size_t) visual_template.depth))
visual_mask|=VisualDepthMask;
if (visual_type != (char *) NULL)
{
%
% The format of the Delay method is:
%
-% void XDelay(Display *display,const unsigned long milliseconds)
+% void XDelay(Display *display,const size_t milliseconds)
%
% A description of each parameter follows:
%
% returning.
%
*/
-MagickExport void XDelay(Display *display,const unsigned long milliseconds)
+MagickExport void XDelay(Display *display,const size_t milliseconds)
{
assert(display != (Display *) NULL);
(void) XFlush(display);
- if (milliseconds == 0)
- return;
-#if defined(__WINDOWS__)
- Sleep(milliseconds);
-#elif defined(vms)
- {
- float
- timer;
-
- timer=milliseconds/1000.0;
- lib$wait(&timer);
- }
-#elif defined(MAGICKCORE_HAVE_USLEEP)
- usleep(1000*milliseconds);
-#elif defined(MAGICKCORE_HAVE_SELECT)
- {
- struct timeval
- timer;
-
- timer.tv_sec=(long) milliseconds/1000;
- timer.tv_usec=(long) (milliseconds % 1000)*1000;
- (void) select(0,(XFD_SET *) NULL,(XFD_SET *) NULL,(XFD_SET *) NULL,&timer);
- }
-#elif defined(MAGICKCORE_HAVE_POLL)
- (void) poll((struct pollfd *) NULL,0,(int) milliseconds);
-#elif defined(__BEOS__)
- snooze(1000*milliseconds);
-#else
-# error "Time delay method not defined."
-#endif
+ MagickDelay(milliseconds);
}
\f
/*
int
unique_file;
- long
- bytes;
-
- register long
+ register ssize_t
i;
+ size_t
+ number_pixels;
+
+ ssize_t
+ bytes;
+
unsigned int
levels;
- unsigned long
- number_pixels;
-
/*
Write info about the X server to a file.
*/
undo_image=GetPreviousImageInList(undo_image);
}
(void) fprintf(file,"Undo Edit Cache\n levels: %u\n",levels);
- (void) fprintf(file," bytes: %lumb\n",(unsigned long)
- (bytes+(1 << 19)) >> 20);
- (void) fprintf(file," limit: %lumb\n\n",resource_info->undo_cache);
+ (void) fprintf(file," bytes: %.20gmb\n",(double) ((bytes+(1 << 19)) >> 20));
+ (void) fprintf(file," limit: %.20gmb\n\n",(double)
+ resource_info->undo_cache);
/*
Write info about the image to a file.
*/
{ 2,-10, 12, -8, 0,-12, 14, -6, 3, -9, 13, -7, 1,-11, 15, -5}
};
- PixelPacket
- color;
+ CacheView
+ *image_view;
int
+ value,
y;
- long
- value;
+ PixelPacket
+ color;
register char
*q;
unsigned int
scanline_pad;
- register unsigned long
+ register size_t
pixel;
unsigned char
value=x-32;
if (x < 112)
value=x/2+24;
- value+=((unsigned long) dither_blue[i][j] << 1);
+ value+=((size_t) dither_blue[i][j] << 1);
blue_map[i][j][x]=(unsigned char)
((value < 0) ? 0 : (value > 255) ? 255 : value);
}
Dither image.
*/
scanline_pad=(unsigned int) (ximage->bytes_per_line-
- ((unsigned long) (ximage->width*ximage->bits_per_pixel) >> 3));
+ ((size_t) (ximage->width*ximage->bits_per_pixel) >> 3));
i=0;
j=0;
q=ximage->data;
+ image_view=AcquireCacheView(image);
for (y=0; y < (int) image->rows; y++)
{
- p=GetVirtualPixels(image,0,y,image->columns,1,&image->exception);
+ p=GetCacheViewVirtualPixels(image_view,0,(ssize_t) y,image->columns,1,
+ &image->exception);
if (p == (const PixelPacket *) NULL)
break;
for (x=0; x < (int) image->columns; x++)
ScaleQuantumToChar(GetGreenPixelComponent(p))] << 8));
color.blue=ClampToQuantum((MagickRealType) (blue_map[i][j][(int)
ScaleQuantumToChar(GetBluePixelComponent(p))] << 8));
- pixel=(unsigned long) (((unsigned long) color.red & 0xe0) |
- (((unsigned long) color.green & 0xe0) >> 3) |
- (((unsigned long) color.blue & 0xc0) >> 6));
+ pixel=(size_t) (((size_t) color.red & 0xe0) |
+ (((size_t) color.green & 0xe0) >> 3) |
+ (((size_t) color.blue & 0xc0) >> 6));
*q++=(char) pixel;
p++;
j++;
if (i == 2)
i=0;
}
+ image_view=DestroyCacheView(image_view);
/*
Free allocated memory.
*/
MagickExport MagickBooleanType XDrawImage(Display *display,
const XPixelInfo *pixel,XDrawInfo *draw_info,Image *image)
{
+ CacheView
+ *draw_view;
+
ExceptionInfo
*exception;
/*
Initialize graphics info.
*/
- context_values.background=(unsigned long) (~0);
+ context_values.background=(size_t) (~0);
context_values.foreground=0;
context_values.line_width=(int) draw_info->line_width;
- draw_context=XCreateGC(display,root_window,(unsigned long)
+ draw_context=XCreateGC(display,root_window,(size_t)
(GCBackground | GCForeground | GCLineWidth),&context_values);
if (draw_context == (GC) NULL)
return(MagickFalse);
Draw line to pixmap.
*/
(void) XSetBackground(display,draw_context,0);
- (void) XSetForeground(display,draw_context,(unsigned long) (~0));
- (void) XSetFillStyle(display,draw_context,FillOpaqueStippled);
- (void) XSetStipple(display,draw_context,draw_info->stipple);
+ (void) XSetForeground(display,draw_context,(size_t) (~0));
+ if (draw_info->stipple != (Pixmap) NULL)
+ {
+ (void) XSetFillStyle(display,draw_context,FillOpaqueStippled);
+ (void) XSetStipple(display,draw_context,draw_info->stipple);
+ }
switch (draw_info->element)
{
case PointElement:
x=0;
y=0;
(void) XParseGeometry(draw_info->geometry,&x,&y,&width,&height);
- (void) GetOneVirtualPixel(image,x,y,&draw_image->background_color,
- &image->exception);
+ (void) GetOneVirtualPixel(image,(ssize_t) x,(ssize_t) y,
+ &draw_image->background_color,&image->exception);
if (SetImageStorageClass(draw_image,DirectClass) == MagickFalse)
return(MagickFalse);
draw_image->matte=MagickTrue;
exception=(&image->exception);
+ draw_view=AcquireCacheView(draw_image);
for (y=0; y < (int) draw_image->rows; y++)
{
- register long
+ register int
x;
register PixelPacket
*restrict q;
- q=QueueAuthenticPixels(draw_image,0,y,draw_image->columns,1,exception);
+ q=QueueCacheViewAuthenticPixels(draw_view,0,(ssize_t) y,draw_image->columns,
+ 1,exception);
if (q == (PixelPacket *) NULL)
break;
- for (x=0; x < (long) draw_image->columns; x++)
+ for (x=0; x < (int) draw_image->columns; x++)
{
if (XGetPixel(draw_ximage,x,y) == 0)
{
}
q++;
}
- if (SyncAuthenticPixels(draw_image,exception) == MagickFalse)
+ if (SyncCacheViewAuthenticPixels(draw_view,exception) == MagickFalse)
break;
}
+ draw_view=DestroyCacheView(draw_view);
XDestroyImage(draw_ximage);
/*
Determine draw geometry.
/*
Composite text onto the image.
*/
+ draw_view=AcquireCacheView(draw_image);
for (y=0; y < (int) draw_image->rows; y++)
{
- register long
+ register int
x;
register PixelPacket
*restrict q;
- q=GetAuthenticPixels(draw_image,0,y,draw_image->columns,1,exception);
+ q=GetCacheViewAuthenticPixels(draw_view,0,(ssize_t) y,draw_image->columns,1,
+ exception);
if (q == (PixelPacket *) NULL)
break;
- for (x=0; x < (long) draw_image->columns; x++)
+ for (x=0; x < (int) draw_image->columns; x++)
{
if (q->opacity != (Quantum) TransparentOpacity)
SetOpacityPixelComponent(q,OpaqueOpacity);
q++;
}
- if (SyncAuthenticPixels(draw_image,exception) == MagickFalse)
+ if (SyncCacheViewAuthenticPixels(draw_view,exception) == MagickFalse)
break;
}
+ draw_view=DestroyCacheView(draw_view);
(void) XParseGeometry(draw_info->geometry,&x,&y,&width,&height);
if (draw_info->stencil == TransparentStencil)
- (void) CompositeImage(image,CopyOpacityCompositeOp,draw_image,x,y);
+ (void) CompositeImage(image,CopyOpacityCompositeOp,draw_image,(ssize_t) x,
+ (ssize_t) y);
else
{
matte=image->matte;
- (void) CompositeImage(image,OverCompositeOp,draw_image,x,y);
+ (void) CompositeImage(image,OverCompositeOp,draw_image,(ssize_t) x,
+ (ssize_t) y);
image->matte=matte;
}
draw_image=DestroyImage(draw_image);
Free font.
*/
if (font_info != (XFontStruct *) NULL)
- (void) XFreeFont(display,font_info);
+ {
+ (void) XFreeFont(display,font_info);
+ font_info=(XFontStruct *) NULL;
+ }
if (map_info != (XStandardColormap *) NULL)
{
/*
assert(map_info != (XStandardColormap *) NULL);
map_info->colormap=colormap;
map_info->red_max=visual_info->red_mask;
- map_info->red_mult=(unsigned long) (map_info->red_max != 0 ? 1 : 0);
+ map_info->red_mult=(size_t) (map_info->red_max != 0 ? 1 : 0);
if (map_info->red_max != 0)
while ((map_info->red_max & 0x01) == 0)
{
map_info->red_mult<<=1;
}
map_info->green_max=visual_info->green_mask;
- map_info->green_mult=(unsigned long) (map_info->green_max != 0 ? 1 : 0);
+ map_info->green_mult=(size_t) (map_info->green_max != 0 ? 1 : 0);
if (map_info->green_max != 0)
while ((map_info->green_max & 0x01) == 0)
{
map_info->green_mult<<=1;
}
map_info->blue_max=visual_info->blue_mask;
- map_info->blue_mult=(unsigned long) (map_info->blue_max != 0 ? 1 : 0);
+ map_info->blue_mult=(size_t) (map_info->blue_max != 0 ? 1 : 0);
if (map_info->blue_max != 0)
while ((map_info->blue_max & 0x01) == 0)
{
Colormap
colormap;
- register long
+ register ssize_t
i;
Status
pixel->colors=0;
if (image != (Image *) NULL)
if (image->storage_class == PseudoClass)
- pixel->colors=image->colors;
+ pixel->colors=(ssize_t) image->colors;
packets=(unsigned int)
MagickMax((int) pixel->colors,visual_info->colormap_size)+MaxNumberPens;
if (pixel->pixels != (unsigned long *) NULL)
/*
Initialize pixel array for images of type PseudoClass.
*/
- for (i=0; i < (long) image->colors; i++)
- pixel->pixels[i]=
- XGammaPixel(map_info,image->colormap+i);
+ for (i=0; i < (ssize_t) image->colors; i++)
+ pixel->pixels[i]=XGammaPixel(map_info,image->colormap+i);
for (i=0; i < MaxNumberPens; i++)
pixel->pixels[image->colors+i]=pixel->pen_colors[i].pixel;
pixel->colors+=MaxNumberPens;
XrmDatabase database,const char *client_name,XResourceInfo *resource_info)
{
char
- *cwd,
+ *directory,
*resource_value;
/*
"borderColor",BorderColor);
resource_value=XGetResourceClass(database,client_name,"borderWidth",
(char *) "2");
- resource_info->border_width=(unsigned int) StringToUnsignedLong(resource_value);
+ resource_info->border_width=(unsigned int) StringToUnsignedLong(
+ resource_value);
resource_value=XGetResourceClass(database,client_name,"colormap",
(char *) "shared");
resource_info->colormap=UndefinedColormap;
client_name,"geometry",(char *) NULL));
resource_value=XGetResourceClass(database,client_name,"gravity",
(char *) "Center");
- resource_info->gravity=(GravityType) ParseMagickOption(MagickGravityOptions,
+ resource_info->gravity=(GravityType) ParseCommandOption(MagickGravityOptions,
MagickFalse,resource_value);
- cwd=getcwd(resource_info->home_directory,MaxTextExtent);
+ directory=getcwd(resource_info->home_directory,MaxTextExtent);
+ (void) directory;
resource_info->icon_geometry=XGetResourceClass(database,client_name,
"iconGeometry",(char *) NULL);
resource_value=XGetResourceClass(database,client_name,"iconic",
root_window=XRootWindow(display,XDefaultScreen(display));
(void) XTranslateCoordinates(display,window,root_window,0,0,&x_offset,
&y_offset,&child);
- crop_info.x=(long) x_offset;
- crop_info.y=(long) y_offset;
- crop_info.width=(unsigned long) window_attributes.width;
- crop_info.height=(unsigned long) window_attributes.height;
+ crop_info.x=(ssize_t) x_offset;
+ crop_info.y=(ssize_t) y_offset;
+ crop_info.width=(size_t) window_attributes.width;
+ crop_info.height=(size_t) window_attributes.height;
if (borders != MagickFalse)
{
/*
Include border in image.
*/
- crop_info.x-=(long) window_attributes.border_width;
- crop_info.y-=(long) window_attributes.border_width;
- crop_info.width+=(unsigned long) (window_attributes.border_width << 1);
- crop_info.height+=(unsigned long) (window_attributes.border_width << 1);
+ crop_info.x-=(ssize_t) window_attributes.border_width;
+ crop_info.y-=(ssize_t) window_attributes.border_width;
+ crop_info.width+=(size_t) (window_attributes.border_width << 1);
+ crop_info.height+=(size_t) (window_attributes.border_width << 1);
}
/*
Crop to root window.
}
display_width=XDisplayWidth(display,XDefaultScreen(display));
if ((int) (crop_info.x+crop_info.width) > display_width)
- crop_info.width=(unsigned long) (display_width-crop_info.x);
+ crop_info.width=(size_t) (display_width-crop_info.x);
display_height=XDisplayHeight(display,XDefaultScreen(display));
if ((int) (crop_info.y+crop_info.height) > display_height)
- crop_info.height=(unsigned long) (display_height-crop_info.y);
+ crop_info.height=(size_t) (display_height-crop_info.y);
/*
Initialize window info attributes.
*/
}
if (level <= 1)
{
+ CacheView
+ *composite_view;
+
ColormapInfo
*next;
register PixelPacket
*restrict q;
- register unsigned long
+ register size_t
pixel;
unsigned int
(window_info[id].visual->klass != TrueColor))
for (i=0; i < (int) number_colors; i++)
{
- colors[i].pixel=(unsigned long) i;
+ colors[i].pixel=(size_t) i;
colors[i].pad='\0';
}
else
{
- unsigned long
+ size_t
blue,
blue_bit,
green,
(~(window_info[id].visual->blue_mask)+1);
for (i=0; i < (int) number_colors; i++)
{
- colors[i].pixel=red | green | blue;
+ colors[i].pixel=(unsigned long) (red | green | blue);
colors[i].pad='\0';
red+=red_bit;
if (red > window_info[id].visual->red_mask)
/*
Append colormap to colormap list.
*/
- p=(ColormapInfo *) AcquireAlignedMemory(1,sizeof(*p));
+ p=(ColormapInfo *) AcquireMagickMemory(sizeof(*p));
if (p == (ColormapInfo *) NULL)
return((Image *) NULL);
p->colormap=window_info[id].colormap;
if ((window_info[id].visual->klass != TrueColor) &&
(window_info[id].visual->klass != DirectColor))
composite_image->storage_class=PseudoClass;
- composite_image->columns=(unsigned long) ximage->width;
- composite_image->rows=(unsigned long) ximage->height;
+ composite_image->columns=(size_t) ximage->width;
+ composite_image->rows=(size_t) ximage->height;
exception=(&composite_image->exception);
+ composite_view=AcquireCacheView(composite_image);
switch (composite_image->storage_class)
{
case DirectClass:
default:
{
- register unsigned long
+ register size_t
color,
index;
- unsigned long
+ size_t
blue_mask,
blue_shift,
green_mask,
(window_info[id].visual->klass == DirectColor))
for (y=0; y < (int) composite_image->rows; y++)
{
- q=QueueAuthenticPixels(composite_image,0,y,
+ q=QueueCacheViewAuthenticPixels(composite_view,0,(ssize_t) y,
composite_image->columns,1,exception);
if (q == (PixelPacket *) NULL)
break;
q->blue=ScaleShortToQuantum(colors[index].blue);
q++;
}
- if (SyncAuthenticPixels(composite_image,exception) == MagickFalse)
+ if (SyncCacheViewAuthenticPixels(composite_view,exception) == MagickFalse)
break;
}
else
for (y=0; y < (int) composite_image->rows; y++)
{
- q=QueueAuthenticPixels(composite_image,0,y,
+ q=QueueCacheViewAuthenticPixels(composite_view,0,(ssize_t) y,
composite_image->columns,1,exception);
if (q == (PixelPacket *) NULL)
break;
q->blue=ScaleShortToQuantum((unsigned short) color);
q++;
}
- if (SyncAuthenticPixels(composite_image,exception) == MagickFalse)
+ if (SyncCacheViewAuthenticPixels(composite_view,exception) == MagickFalse)
break;
}
break;
*/
for (y=0; y < (int) composite_image->rows; y++)
{
- q=QueueAuthenticPixels(composite_image,0,y,composite_image->columns,1,exception);
+ q=QueueCacheViewAuthenticPixels(composite_view,0,(ssize_t) y,
+ composite_image->columns,1,exception);
if (q == (PixelPacket *) NULL)
break;
- indexes=GetAuthenticIndexQueue(composite_image);
+ indexes=GetCacheViewAuthenticIndexQueue(composite_view);
for (x=0; x < (int) composite_image->columns; x++)
{
index=(IndexPacket) XGetPixel(ximage,x,y);
indexes[x]=index;
- *q++=composite_image->colormap[(long) index];
+ *q++=composite_image->colormap[(ssize_t) index];
}
- if (SyncAuthenticPixels(composite_image,exception) == MagickFalse)
+ if (SyncCacheViewAuthenticPixels(composite_view,exception) == MagickFalse)
break;
}
break;
}
}
+ composite_view=DestroyCacheView(composite_view);
XDestroyImage(ximage);
if (image == (Image *) NULL)
{
y_offset-=(int) crop_info.y;
if (y_offset < 0)
y_offset=0;
- (void) CompositeImage(image,CopyCompositeOp,composite_image,x_offset,
- y_offset);
+ (void) CompositeImage(image,CopyCompositeOp,composite_image,(ssize_t)
+ x_offset,(ssize_t) y_offset);
}
/*
Relinquish resources.
if (resource_info->icon_geometry != (char *) NULL)
(void) CloneString(&window->icon_geometry,resource_info->icon_geometry);
window->crop_geometry=(char *) NULL;
- window->flags=(unsigned long) PSize;
+ window->flags=(size_t) PSize;
window->width=1;
window->height=1;
window->min_width=1;
window->immutable=MagickFalse;
window->shape=MagickFalse;
window->data=0;
- window->mask=(unsigned long) (CWBackingStore | CWBackPixel | CWBackPixmap |
+ window->mask=(int) (CWBackingStore | CWBackPixel | CWBackPixmap |
CWBitGravity | CWBorderPixel | CWColormap | CWCursor | CWDontPropagate |
CWEventMask | CWOverrideRedirect | CWSaveUnder | CWWinGravity);
window->attributes.background_pixel=pixel->background_color.pixel;
return((Image *) NULL);
}
(void) XTranslateCoordinates(display,target,root,0,0,&x,&y,&child);
- crop_info.x=x;
- crop_info.y=y;
- crop_info.width=(unsigned long) window_attributes.width;
- crop_info.height=(unsigned long) window_attributes.height;
- if (ximage_info->borders)
+ crop_info.x=(ssize_t) x;
+ crop_info.y=(ssize_t) y;
+ crop_info.width=(size_t) window_attributes.width;
+ crop_info.height=(size_t) window_attributes.height;
+ if (ximage_info->borders != 0)
{
/*
Include border in image.
/*
Allocate windows structure.
*/
- windows=(XWindows *) AcquireAlignedMemory(1,sizeof(*windows));
+ windows=(XWindows *) AcquireMagickMemory(sizeof(*windows));
if (windows == (XWindows *) NULL)
{
ThrowXWindowFatalException(XServerFatalError,"MemoryAllocationFailed",
windows->im_retain_colors=XInternAtom(display,"IM_RETAIN_COLORS",MagickFalse);
windows->im_exit=XInternAtom(display,"IM_EXIT",MagickFalse);
windows->dnd_protocols=XInternAtom(display,"DndProtocol",MagickFalse);
-#if defined(__WINDOWS__)
+#if defined(MAGICKCORE_WINDOWS_SUPPORT)
(void) XSynchronize(display,IsWindows95());
#endif
if (IsEventLogging())
{
(void) XSynchronize(display,MagickTrue);
(void) LogMagickEvent(X11Event,GetMagickModule(),"Version: %s",
- GetMagickVersion((unsigned long *) NULL));
+ GetMagickVersion((size_t *) NULL));
(void) LogMagickEvent(X11Event,GetMagickModule(),"Protocols:");
(void) LogMagickEvent(X11Event,GetMagickModule(),
" Window Manager: 0x%lx",windows->wm_protocols);
}
}
width=(unsigned int) window->image->columns;
- assert((unsigned long) width == window->image->columns);
+ assert((size_t) width == window->image->columns);
height=(unsigned int) window->image->rows;
- assert((unsigned long) height == window->image->rows);
+ assert((size_t) height == window->image->rows);
}
/*
Create X image.
matte_image=(XImage *) NULL;
if ((window->shape != MagickFalse) && (window->image != (Image *) NULL))
if ((window->image->matte != MagickFalse) &&
- ((long) width <= XDisplayWidth(display,window->screen)) &&
- ((long) height <= XDisplayHeight(display,window->screen)))
+ ((int) width <= XDisplayWidth(display,window->screen)) &&
+ ((int) height <= XDisplayHeight(display,window->screen)))
{
/*
Create matte image.
context_values.background=1;
context_values.foreground=0;
graphics_context=XCreateGC(display,window->matte_pixmap,
- (unsigned long) (GCBackground | GCForeground),&context_values);
+ (size_t) (GCBackground | GCForeground),&context_values);
(void) XPutImage(display,window->matte_pixmap,graphics_context,
window->matte_image,0,0,0,0,width,height);
(void) XFreeGC(display,graphics_context);
static void XMakeImageLSBFirst(const XResourceInfo *resource_info,
const XWindowInfo *window,Image *image,XImage *ximage,XImage *matte_image)
{
+ CacheView
+ *canvas_view;
+
Image
*canvas;
resource_info->image_info->texture != (char *) NULL ?
resource_info->image_info->texture : "pattern:checkerboard",
MaxTextExtent);
- (void) FormatMagickString(size,MaxTextExtent,"%lux%lu",image->columns,
- image->rows);
+ (void) FormatMagickString(size,MaxTextExtent,"%.20gx%.20g",(double)
+ image->columns,(double) image->rows);
image_info->size=ConstantString(size);
pattern=ReadImage(image_info,&image->exception);
image_info=DestroyImageInfo(image_info);
pixels=window->pixel_info->pixels;
q=(unsigned char *) ximage->data;
x=0;
+ canvas_view=AcquireCacheView(canvas);
if (ximage->format == XYBitmap)
{
register unsigned short
PixelIntensity(&canvas->colormap[1]);
for (y=0; y < (int) canvas->rows; y++)
{
- p=GetVirtualPixels(canvas,0,y,canvas->columns,1,&canvas->exception);
+ p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,canvas->columns,1,
+ &canvas->exception);
if (p == (const PixelPacket *) NULL)
break;
- indexes=GetVirtualIndexQueue(canvas);
+ indexes=GetCacheViewVirtualIndexQueue(canvas_view);
bit=0;
byte=0;
for (x=0; x < (int) canvas->columns; x++)
*/
for (y=0; y < (int) canvas->rows; y++)
{
- p=GetVirtualPixels(canvas,0,y,canvas->columns,1,&canvas->exception);
+ p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
+ canvas->columns,1,&canvas->exception);
if (p == (const PixelPacket *) NULL)
break;
- indexes=GetVirtualIndexQueue(canvas);
+ indexes=GetCacheViewVirtualIndexQueue(canvas_view);
nibble=0;
for (x=0; x < (int) canvas->columns; x++)
{
- pixel=pixels[(long) indexes[x]] & 0x0f;
+ pixel=pixels[(ssize_t) indexes[x]] & 0x0f;
switch (nibble)
{
case 0:
*/
for (y=0; y < (int) canvas->rows; y++)
{
- p=GetVirtualPixels(canvas,0,y,canvas->columns,1,&canvas->exception);
+ p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
+ canvas->columns,1,&canvas->exception);
if (p == (const PixelPacket *) NULL)
break;
- indexes=GetVirtualIndexQueue(canvas);
+ indexes=GetCacheViewVirtualIndexQueue(canvas_view);
nibble=0;
for (x=0; x < (int) canvas->columns; x++)
{
- pixel=pixels[(long) indexes[x]] & 0xf;
+ pixel=pixels[(ssize_t) indexes[x]] & 0xf;
switch (nibble)
{
case 0:
}
for (y=0; y < (int) canvas->rows; y++)
{
- p=GetVirtualPixels(canvas,0,y,canvas->columns,1,&canvas->exception);
+ p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
+ canvas->columns,1,&canvas->exception);
if (p == (const PixelPacket *) NULL)
break;
- indexes=GetVirtualIndexQueue(canvas);
+ indexes=GetCacheViewVirtualIndexQueue(canvas_view);
for (x=0; x < (int) canvas->columns; x++)
{
- pixel=pixels[(long) indexes[x]];
+ pixel=pixels[(ssize_t) indexes[x]];
*q++=(unsigned char) pixel;
}
q+=scanline_pad;
bytes_per_pixel;
unsigned char
- channel[sizeof(unsigned long)];
+ channel[sizeof(size_t)];
/*
Convert to multi-byte color-mapped X canvas.
bytes_per_pixel=(unsigned int) (ximage->bits_per_pixel >> 3);
for (y=0; y < (int) canvas->rows; y++)
{
- p=GetVirtualPixels(canvas,0,y,canvas->columns,1,&canvas->exception);
+ p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
+ canvas->columns,1,&canvas->exception);
if (p == (const PixelPacket *) NULL)
break;
- indexes=GetVirtualIndexQueue(canvas);
+ indexes=GetCacheViewVirtualIndexQueue(canvas_view);
for (x=0; x < (int) canvas->columns; x++)
{
- pixel=pixels[(long) indexes[x]];
+ pixel=pixels[(ssize_t) indexes[x]];
for (k=0; k < (int) bytes_per_pixel; k++)
{
channel[k]=(unsigned char) pixel;
for (y=0; y < (int) canvas->rows; y++)
{
nibble=0;
- p=GetVirtualPixels(canvas,0,y,canvas->columns,1,&canvas->exception);
+ p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
+ canvas->columns,1,&canvas->exception);
if (p == (const PixelPacket *) NULL)
break;
for (x=0; x < (int) canvas->columns; x++)
*/
for (y=0; y < (int) canvas->rows; y++)
{
- p=GetVirtualPixels(canvas,0,y,canvas->columns,1,&canvas->exception);
+ p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
+ canvas->columns,1,&canvas->exception);
if (p == (const PixelPacket *) NULL)
break;
nibble=0;
}
for (y=0; y < (int) canvas->rows; y++)
{
- p=GetVirtualPixels(canvas,0,y,canvas->columns,1,&canvas->exception);
+ p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
+ canvas->columns,1,&canvas->exception);
if (p == (const PixelPacket *) NULL)
break;
for (x=0; x < (int) canvas->columns; x++)
*/
for (y=0; y < (int) canvas->rows; y++)
{
- p=GetVirtualPixels(canvas,0,y,canvas->columns,1,
- &canvas->exception);
+ p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
+ canvas->columns,1,&canvas->exception);
if (p == (const PixelPacket *) NULL)
break;
if ((red_gamma != 1.0) || (green_gamma != 1.0) ||
*/
for (y=0; y < (int) canvas->rows; y++)
{
- p=GetVirtualPixels(canvas,0,y,canvas->columns,1,
- &canvas->exception);
+ p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
+ canvas->columns,1,&canvas->exception);
if (p == (const PixelPacket *) NULL)
break;
if ((red_gamma != 1.0) || (green_gamma != 1.0) ||
bytes_per_pixel;
unsigned char
- channel[sizeof(unsigned long)];
+ channel[sizeof(size_t)];
/*
Convert to multi-byte continuous-tone X canvas.
bytes_per_pixel=(unsigned int) (ximage->bits_per_pixel >> 3);
for (y=0; y < (int) canvas->rows; y++)
{
- p=GetVirtualPixels(canvas,0,y,canvas->columns,1,
- &canvas->exception);
+ p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
+ canvas->columns,1,&canvas->exception);
if (p == (PixelPacket *) NULL)
break;
- for (x=0; x < (long) canvas->columns; x++)
+ for (x=0; x < (int) canvas->columns; x++)
{
pixel=XGammaPixel(map_info,p);
for (k=0; k < (int) bytes_per_pixel; k++)
q=(unsigned char *) matte_image->data;
for (y=0; y < (int) canvas->rows; y++)
{
- p=GetVirtualPixels(canvas,0,y,canvas->columns,1,&canvas->exception);
+ p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,canvas->columns,1,
+ &canvas->exception);
if (p == (const PixelPacket *) NULL)
break;
bit=0;
for (x=(int) canvas->columns-1; x >= 0; x--)
{
byte>>=1;
- if (p->opacity > (long) (QuantumRange/2))
+ if (GetOpacityPixelComponent(p) > (QuantumRange/2))
byte|=0x80;
bit++;
if (bit == 8)
q+=scanline_pad;
}
}
+ canvas_view=DestroyCacheView(canvas_view);
if (canvas != image)
canvas=DestroyImage(canvas);
}
static void XMakeImageMSBFirst(const XResourceInfo *resource_info,
const XWindowInfo *window,Image *image,XImage *ximage,XImage *matte_image)
{
+ CacheView
+ *canvas_view;
+
Image
*canvas;
resource_info->image_info->texture != (char *) NULL ?
resource_info->image_info->texture : "pattern:checkerboard",
MaxTextExtent);
- (void) FormatMagickString(size,MaxTextExtent,"%lux%lu",image->columns,
- image->rows);
+ (void) FormatMagickString(size,MaxTextExtent,"%.20gx%.20g",(double)
+ image->columns,(double) image->rows);
image_info->size=ConstantString(size);
pattern=ReadImage(image_info,&image->exception);
image_info=DestroyImageInfo(image_info);
pixels=window->pixel_info->pixels;
q=(unsigned char *) ximage->data;
x=0;
+ canvas_view=AcquireCacheView(canvas);
if (ximage->format == XYBitmap)
{
register unsigned short
PixelIntensity(&canvas->colormap[1]);
for (y=0; y < (int) canvas->rows; y++)
{
- p=GetVirtualPixels(canvas,0,y,canvas->columns,1,&canvas->exception);
+ p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,canvas->columns,1,
+ &canvas->exception);
if (p == (const PixelPacket *) NULL)
break;
- indexes=GetVirtualIndexQueue(canvas);
+ indexes=GetCacheViewVirtualIndexQueue(canvas_view);
bit=0;
byte=0;
for (x=(int) canvas->columns-1; x >= 0; x--)
*/
for (y=0; y < (int) canvas->rows; y++)
{
- p=GetVirtualPixels(canvas,0,y,canvas->columns,1,&canvas->exception);
+ p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
+ canvas->columns,1,&canvas->exception);
if (p == (const PixelPacket *) NULL)
break;
- indexes=GetVirtualIndexQueue(canvas);
+ indexes=GetCacheViewVirtualIndexQueue(canvas_view);
nibble=0;
for (x=0; x < (int) canvas->columns; x++)
{
- pixel=pixels[(long) indexes[x]] & 0xf;
+ pixel=pixels[(ssize_t) indexes[x]] & 0xf;
switch (nibble)
{
case 0:
*/
for (y=0; y < (int) canvas->rows; y++)
{
- p=GetVirtualPixels(canvas,0,y,canvas->columns,1,&canvas->exception);
+ p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
+ canvas->columns,1,&canvas->exception);
if (p == (const PixelPacket *) NULL)
break;
- indexes=GetVirtualIndexQueue(canvas);
+ indexes=GetCacheViewVirtualIndexQueue(canvas_view);
nibble=0;
for (x=0; x < (int) canvas->columns; x++)
{
- pixel=pixels[(long) indexes[x]] & 0xf;
+ pixel=pixels[(ssize_t) indexes[x]] & 0xf;
switch (nibble)
{
case 0:
}
for (y=0; y < (int) canvas->rows; y++)
{
- p=GetVirtualPixels(canvas,0,y,canvas->columns,1,&canvas->exception);
+ p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
+ canvas->columns,1,&canvas->exception);
if (p == (const PixelPacket *) NULL)
break;
- indexes=GetVirtualIndexQueue(canvas);
+ indexes=GetCacheViewVirtualIndexQueue(canvas_view);
for (x=0; x < (int) canvas->columns; x++)
{
- pixel=pixels[(long) indexes[x]];
+ pixel=pixels[(ssize_t) indexes[x]];
*q++=(unsigned char) pixel;
}
q+=scanline_pad;
bytes_per_pixel;
unsigned char
- channel[sizeof(unsigned long)];
+ channel[sizeof(size_t)];
/*
Convert to 8 bit color-mapped X canvas.
bytes_per_pixel=(unsigned int) (ximage->bits_per_pixel >> 3);
for (y=0; y < (int) canvas->rows; y++)
{
- p=GetVirtualPixels(canvas,0,y,canvas->columns,1,&canvas->exception);
+ p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
+ canvas->columns,1,&canvas->exception);
if (p == (const PixelPacket *) NULL)
break;
- indexes=GetVirtualIndexQueue(canvas);
+ indexes=GetCacheViewVirtualIndexQueue(canvas_view);
for (x=0; x < (int) canvas->columns; x++)
{
- pixel=pixels[(long) indexes[x]];
+ pixel=pixels[(ssize_t) indexes[x]];
for (k=(int) bytes_per_pixel-1; k >= 0; k--)
{
channel[k]=(unsigned char) pixel;
*/
for (y=0; y < (int) canvas->rows; y++)
{
- p=GetVirtualPixels(canvas,0,y,canvas->columns,1,&canvas->exception);
+ p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
+ canvas->columns,1,&canvas->exception);
if (p == (const PixelPacket *) NULL)
break;
nibble=0;
*/
for (y=0; y < (int) canvas->rows; y++)
{
- p=GetVirtualPixels(canvas,0,y,canvas->columns,1,&canvas->exception);
+ p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
+ canvas->columns,1,&canvas->exception);
if (p == (const PixelPacket *) NULL)
break;
nibble=0;
}
for (y=0; y < (int) canvas->rows; y++)
{
- p=GetVirtualPixels(canvas,0,y,canvas->columns,1,&canvas->exception);
+ p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
+ canvas->columns,1,&canvas->exception);
if (p == (const PixelPacket *) NULL)
break;
for (x=(int) canvas->columns-1; x >= 0; x--)
*/
for (y=0; y < (int) canvas->rows; y++)
{
- p=GetVirtualPixels(canvas,0,y,canvas->columns,1,
- &canvas->exception);
+ p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
+ canvas->columns,1,&canvas->exception);
if (p == (const PixelPacket *) NULL)
break;
if ((red_gamma != 1.0) || (green_gamma != 1.0) ||
*/
for (y=0; y < (int) canvas->rows; y++)
{
- p=GetVirtualPixels(canvas,0,y,canvas->columns,1,
- &canvas->exception);
+ p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
+ canvas->columns,1,&canvas->exception);
if (p == (const PixelPacket *) NULL)
break;
if ((red_gamma != 1.0) || (green_gamma != 1.0) ||
bytes_per_pixel;
unsigned char
- channel[sizeof(unsigned long)];
+ channel[sizeof(size_t)];
/*
Convert to multi-byte continuous-tone X canvas.
bytes_per_pixel=(unsigned int) (ximage->bits_per_pixel >> 3);
for (y=0; y < (int) canvas->rows; y++)
{
- p=GetVirtualPixels(canvas,0,y,canvas->columns,1,
- &canvas->exception);
+ p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,
+ canvas->columns,1,&canvas->exception);
if (p == (const PixelPacket *) NULL)
break;
for (x=(int) canvas->columns-1; x >= 0; x--)
q=(unsigned char *) matte_image->data;
for (y=0; y < (int) canvas->rows; y++)
{
- p=GetVirtualPixels(canvas,0,y,canvas->columns,1,&canvas->exception);
+ p=GetCacheViewVirtualPixels(canvas_view,0,(ssize_t) y,canvas->columns,1,
+ &canvas->exception);
if (p == (const PixelPacket *) NULL)
break;
bit=0;
for (x=(int) canvas->columns-1; x >= 0; x--)
{
byte<<=1;
- if (p->opacity > (long) (QuantumRange/2))
+ if (GetOpacityPixelComponent(p) > (QuantumRange/2))
byte|=0x01;
bit++;
if (bit == 8)
q+=scanline_pad;
}
}
+ canvas_view=DestroyCacheView(canvas_view);
if (canvas != image)
canvas=DestroyImage(canvas);
}
int
y;
- long
- n;
-
MagickPixelPacket
pixel;
register int
x;
- register long
+ register ssize_t
i;
register unsigned char
*p,
*q;
+ ssize_t
+ n;
+
static unsigned int
previous_magnify = 0;
assert(display != (Display *) NULL);
assert(windows != (XWindows *) NULL);
magnify=1;
- for (n=1; n < (long) windows->magnify.data; n++)
+ for (n=1; n < (ssize_t) windows->magnify.data; n++)
magnify<<=1;
while ((magnify*windows->image.ximage->width) < windows->magnify.width)
magnify<<=1;
while ((1 << i) <= (int) magnify)
i++;
(void) FormatMagickString(windows->magnify.name,MaxTextExtent,
- "Magnify %luX",i);
+ "Magnify %.20gX",(double) i);
status=XStringListToTextProperty(&windows->magnify.name,1,&window_name);
if (status != False)
{
if (windows->magnify.depth > 1)
Swap(background,foreground);
}
- for (i=0; i < (long) height; i+=magnify)
+ for (i=0; i < (ssize_t) height; i+=magnify)
{
/*
Propogate pixel magnify rows.
if (windows->magnify.depth > 1)
Swap(background,foreground);
}
- for (i=0; i < (long) height; i+=magnify)
+ for (i=0; i < (ssize_t) height; i+=magnify)
{
/*
Propogate pixel magnify rows.
/*
Magnify 8 bit X image.
*/
- for (i=0; i < (long) height; i+=magnify)
+ for (i=0; i < (ssize_t) height; i+=magnify)
{
/*
Propogate pixel magnify rows.
Magnify multi-byte X image.
*/
bytes_per_pixel=(unsigned int) ximage->bits_per_pixel >> 3;
- for (i=0; i < (long) height; i+=magnify)
+ for (i=0; i < (ssize_t) height; i+=magnify)
{
/*
Propogate pixel magnify rows.
/*
Highlight center pixel.
*/
- highlight_info.x=(long) windows->magnify.width >> 1;
- highlight_info.y=(long) windows->magnify.height >> 1;
+ highlight_info.x=(ssize_t) windows->magnify.width >> 1;
+ highlight_info.y=(ssize_t) windows->magnify.height >> 1;
highlight_info.width=magnify;
highlight_info.height=magnify;
(void) XDrawRectangle(display,windows->magnify.pixmap,
/*
Show center pixel color.
*/
- (void) GetOneVirtualMagickPixel(windows->image.image,windows->magnify.x,
- windows->magnify.y,&pixel,&windows->image.image->exception);
+ (void) GetOneVirtualMagickPixel(windows->image.image,(ssize_t)
+ windows->magnify.x,(ssize_t) windows->magnify.y,&pixel,
+ &windows->image.image->exception);
(void) FormatMagickString(tuple,MaxTextExtent,"%d,%d: ",
windows->magnify.x,windows->magnify.y);
(void) ConcatenateMagickString(tuple,"(",MaxTextExtent);
}
#endif
-static inline Quantum ScaleXToQuantum(const unsigned long x,
- const unsigned long scale)
+static inline Quantum ScaleXToQuantum(const size_t x,
+ const size_t scale)
{
return((Quantum) (((MagickRealType) QuantumRange*x)/scale+0.5));
}
register IndexPacket
*indexes;
- register long
+ register ssize_t
i;
Status
status;
- unsigned long
+ size_t
number_colors,
retain_colors;
1,exception);
if (q != (PixelPacket *) NULL)
{
- for (i=0; i < (long) number_colors; i++)
+ for (i=0; i < (ssize_t) number_colors; i++)
{
q->red=(Quantum) 0;
if (map_info->red_max != 0)
- q->red=ScaleXToQuantum((unsigned long) (i/
+ q->red=ScaleXToQuantum((size_t) (i/
map_info->red_mult),map_info->red_max);
q->green=(Quantum) 0;
if (map_info->green_max != 0)
- q->green=ScaleXToQuantum((unsigned long) ((i/
+ q->green=ScaleXToQuantum((size_t) ((i/
map_info->green_mult) % (map_info->green_max+1)),
map_info->green_max);
q->blue=(Quantum) 0;
if (map_info->blue_max != 0)
- q->blue=ScaleXToQuantum((unsigned long) (i %
+ q->blue=ScaleXToQuantum((size_t) (i %
map_info->green_mult),map_info->blue_max);
q->opacity=(Quantum) TransparentOpacity;
q++;
Image has more colors than the visual supports.
*/
quantize_info=(*resource_info->quantize_info);
- quantize_info.number_colors=(unsigned long) visual_info->colormap_size;
+ quantize_info.number_colors=(size_t) visual_info->colormap_size;
(void) QuantizeImage(&quantize_info,image);
}
/*
"UnableToCreateColormap",image->filename);
p=colors;
color.flags=(char) (DoRed | DoGreen | DoBlue);
- for (i=0; i < (long) image->colors; i++)
+ for (i=0; i < (ssize_t) image->colors; i++)
{
color.red=ScaleQuantumToShort(XRedGamma(image->colormap[i].red));
color.green=ScaleQuantumToShort(XGreenGamma(image->colormap[i].green));
colormap_type=PrivateColormap;
if (colormap_type == SharedColormap)
{
+ CacheView
+ *image_view;
+
DiversityPacket
*diversity;
if (diversity == (DiversityPacket *) NULL)
ThrowXWindowFatalException(ResourceLimitFatalError,
"UnableToCreateColormap",image->filename);
- for (i=0; i < (long) image->colors; i++)
+ for (i=0; i < (ssize_t) image->colors; i++)
{
diversity[i].red=image->colormap[i].red;
diversity[i].green=image->colormap[i].green;
diversity[i].index=(unsigned short) i;
diversity[i].count=0;
}
+ image_view=AcquireCacheView(image);
for (y=0; y < (int) image->rows; y++)
{
- register long
+ register int
x;
- register PixelPacket
- *restrict q;
+ register const PixelPacket
+ *restrict p;
- q=GetAuthenticPixels(image,0,y,image->columns,1,exception);
- if (q == (PixelPacket *) NULL)
+ p=GetCacheViewAuthenticPixels(image_view,0,(ssize_t) y,
+ image->columns,1,exception);
+ if (p == (const PixelPacket *) NULL)
break;
- indexes=GetAuthenticIndexQueue(image);
- for (x=(long) image->columns-1; x >= 0; x--)
- diversity[(long) indexes[x]].count++;
+ indexes=GetCacheViewAuthenticIndexQueue(image_view);
+ for (x=(int) image->columns-1; x >= 0; x--)
+ diversity[(ssize_t) indexes[x]].count++;
}
+ image_view=DestroyCacheView(image_view);
/*
Sort colors by decreasing intensity.
*/
qsort((void *) diversity,image->colors,sizeof(*diversity),
IntensityCompare);
- for (i=0; i < (long) image->colors; )
+ for (i=0; i < (ssize_t) image->colors; )
{
diversity[i].count<<=4; /* increase this colors popularity */
- i+=MagickMax((long) (image->colors >> 4),2);
+ i+=MagickMax((int) (image->colors >> 4),2);
}
diversity[image->colors-1].count<<=4;
qsort((void *) diversity,image->colors,sizeof(*diversity),
*/
p=colors;
color.flags=(char) (DoRed | DoGreen | DoBlue);
- for (i=0; i < (long) image->colors; i++)
+ for (i=0; i < (ssize_t) image->colors; i++)
{
index=diversity[i].index;
color.red=
ThrowXWindowFatalException(ResourceLimitFatalError,
"UnableToCreateColormap",image->filename);
for (x=visual_info->colormap_size-1; x >= 0; x--)
- server_colors[x].pixel=(unsigned long) x;
+ server_colors[x].pixel=(size_t) x;
(void) XQueryColors(display,colormap,server_colors,
(int) MagickMin((unsigned int) visual_info->colormap_size,256));
/*
Select remaining colors from X server colormap.
*/
- for (; i < (long) image->colors; i++)
+ for (; i < (ssize_t) image->colors; i++)
{
index=diversity[i].index;
color.red=
*/
retain_colors=MagickMin((unsigned int)
(visual_info->colormap_size-image->colors),256);
- for (i=0; i < (long) retain_colors; i++)
+ for (i=0; i < (ssize_t) retain_colors; i++)
*p++=server_colors[i];
number_colors+=retain_colors;
}
retain_colors=MagickMin((unsigned int)
(visual_info->colormap_size-image->colors),256);
p=colors+image->colors;
- for (i=0; i < (long) retain_colors; i++)
+ for (i=0; i < (ssize_t) retain_colors; i++)
{
p->pixel=(unsigned long) i;
p++;
(unsigned long *) NULL,0,pixel->pixels,(unsigned int)
retain_colors);
p=colors+image->colors;
- for (i=0; i < (long) retain_colors; i++)
+ for (i=0; i < (ssize_t) retain_colors; i++)
{
p->pixel=pixel->pixels[i];
p++;
*/
p=colors;
color.flags=(char) (DoRed | DoGreen | DoBlue);
- for (i=0; i < (long) image->colors; i++)
+ for (i=0; i < (ssize_t) image->colors; i++)
{
color.red=ScaleQuantumToShort(XRedGamma(image->colormap[i].red));
color.green=ScaleQuantumToShort(XGreenGamma(image->colormap[i].green));
((int) (map_info->blue_max+1) == visual_info->colormap_size)) ?
MagickTrue : MagickFalse;
if (linear_colormap != MagickFalse)
- number_colors=(unsigned long) visual_info->colormap_size;
+ number_colors=(size_t) visual_info->colormap_size;
/*
Allocate color array.
*/
p=colors;
color.flags=(char) (DoRed | DoGreen | DoBlue);
if (linear_colormap != MagickFalse)
- for (i=0; i < (long) number_colors; i++)
+ for (i=0; i < (ssize_t) number_colors; i++)
{
color.blue=(unsigned short) 0;
if (map_info->blue_max != 0)
- color.blue=(unsigned short) ((unsigned long)
+ color.blue=(unsigned short) ((size_t)
((65535L*(i % map_info->green_mult))/map_info->blue_max));
color.green=color.blue;
color.red=color.blue;
*p++=color;
}
else
- for (i=0; i < (long) number_colors; i++)
+ for (i=0; i < (ssize_t) number_colors; i++)
{
color.red=(unsigned short) 0;
if (map_info->red_max != 0)
- color.red=(unsigned short) ((unsigned long)
+ color.red=(unsigned short) ((size_t)
((65535L*(i/map_info->red_mult))/map_info->red_max));
color.green=(unsigned int) 0;
if (map_info->green_max != 0)
- color.green=(unsigned short) ((unsigned long)
+ color.green=(unsigned short) ((size_t)
((65535L*((i/map_info->green_mult) % (map_info->green_max+1)))/
map_info->green_max));
color.blue=(unsigned short) 0;
if (map_info->blue_max != 0)
- color.blue=(unsigned short) ((unsigned long)
+ color.blue=(unsigned short) ((size_t)
((65535L*(i % map_info->green_mult))/map_info->blue_max));
color.pixel=XStandardPixel(map_info,&color);
*p++=color;
(colormap != XDefaultColormap(display,visual_info->screen)))
(void) XStoreColors(display,colormap,colors,(int) number_colors);
else
- for (i=0; i < (long) number_colors; i++)
+ for (i=0; i < (ssize_t) number_colors; i++)
(void) XAllocColor(display,colormap,&colors[i]);
break;
}
&pixel->pen_colors[i]);
pixel->pixels[image->colors+i]=pixel->pen_colors[i].pixel;
}
- pixel->colors=image->colors+MaxNumberPens;
+ pixel->colors=(ssize_t) (image->colors+MaxNumberPens);
}
colors=(XColor *) RelinquishMagickMemory(colors);
if (IsEventLogging())
size_hints=XAllocSizeHints();
if (size_hints == (XSizeHints *) NULL)
ThrowXWindowFatalException(XServerFatalError,"UnableToMakeXWindow",argv[0]);
- size_hints->flags=(long) window_info->flags;
+ size_hints->flags=(int) window_info->flags;
size_hints->x=window_info->x;
size_hints->y=window_info->y;
size_hints->width=(int) window_info->width;
window_info->id=XCreateWindow(display,parent,window_info->x,window_info->y,
(unsigned int) size_hints->width,(unsigned int) size_hints->height,
window_info->border_width,(int) window_info->depth,InputOutput,
- window_info->visual,window_info->mask,&window_info->attributes);
+ window_info->visual,(unsigned long) window_info->mask,
+ &window_info->attributes);
else
{
MagickStatusType
/*
Window already exists; change relevant attributes.
*/
- (void) XChangeWindowAttributes(display,window_info->id,window_info->mask,
- &window_info->attributes);
+ (void) XChangeWindowAttributes(display,window_info->id,(unsigned long)
+ window_info->mask,&window_info->attributes);
mask=ConfigureNotify;
while (XCheckTypedWindowEvent(display,window_info->id,(int) mask,&sans_event)) ;
window_changes.x=window_info->x;
context_values.plane_mask=
context_values.background ^ context_values.foreground;
context_values.subwindow_mode=IncludeInferiors;
- annotate_context=XCreateGC(display,root_window,(unsigned long) (GCBackground |
+ annotate_context=XCreateGC(display,root_window,(size_t) (GCBackground |
GCForeground | GCFunction | GCSubwindowMode),&context_values);
if (annotate_context == (GC) NULL)
return(MagickFalse);
target_window=root_window;
x_offset=event.xbutton.x_root;
y_offset=event.xbutton.y_root;
- crop_info->x=x_offset;
- crop_info->y=y_offset;
+ crop_info->x=(ssize_t) x_offset;
+ crop_info->y=(ssize_t) y_offset;
crop_info->width=0;
crop_info->height=0;
presses++;
Discard pending button motion events.
*/
while (XCheckMaskEvent(display,ButtonMotionMask,&event)) ;
- crop_info->x=event.xmotion.x;
- crop_info->y=event.xmotion.y;
+ crop_info->x=(ssize_t) event.xmotion.x;
+ crop_info->y=(ssize_t) event.xmotion.y;
/*
Check boundary conditions.
*/
if ((int) crop_info->x < x_offset)
- crop_info->width=(unsigned int) (x_offset-crop_info->x);
+ crop_info->width=(size_t) (x_offset-crop_info->x);
else
{
- crop_info->width=(unsigned int) (crop_info->x-x_offset);
- crop_info->x=x_offset;
+ crop_info->width=(size_t) (crop_info->x-x_offset);
+ crop_info->x=(ssize_t) x_offset;
}
if ((int) crop_info->y < y_offset)
- crop_info->height=(unsigned int) (y_offset-crop_info->y);
+ crop_info->height=(size_t) (y_offset-crop_info->y);
else
{
- crop_info->height=(unsigned int) (crop_info->y-y_offset);
- crop_info->y=y_offset;
+ crop_info->height=(size_t) (crop_info->y-y_offset);
+ crop_info->y=(ssize_t) y_offset;
}
}
default:
value=resource_info->gamma_correct ? "True" : "False";
XrmPutStringResource(&preferences_database,specifier,(char *) value);
(void) FormatMagickString(specifier,MaxTextExtent,"%s.undoCache",client_name);
- (void) FormatMagickString(cache,MaxTextExtent,"%lu",
+ (void) FormatMagickString(cache,MaxTextExtent,"%.20g",(double)
resource_info->undo_cache);
XrmPutStringResource(&preferences_database,specifier,cache);
(void) FormatMagickString(specifier,MaxTextExtent,"%s.usePixmap",client_name);
%
*/
MagickExport Window XWindowByID(Display *display,const Window root_window,
- const unsigned long id)
+ const size_t id)
{
RectangleInfo
rectangle_info;
if (id == 0)
return(XSelectWindow(display,&rectangle_info));
if (root_window == id)
- return(id);
+ return(root_window);
status=XQueryTree(display,root_window,&child,&child,&children,
&number_children);
if (status == False)
projects / imagemagick / blobdiff