2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13 % Read Windows Metafile Format %
20 % Copyright 1999-2018 ImageMagick Studio LLC, a non-profit organization %
21 % dedicated to making software imaging solutions freely available. %
23 % You may not use this file except in compliance with the License. You may %
24 % obtain a copy of the License at %
26 % https://www.imagemagick.org/script/license.php %
28 % Unless required by applicable law or agreed to in writing, software %
29 % distributed under the License is distributed on an "AS IS" BASIS, %
30 % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %
31 % See the License for the specific language governing permissions and %
32 % limitations under the License. %
34 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
40 #include "MagickCore/studio.h"
41 #include "MagickCore/property.h"
42 #include "MagickCore/blob.h"
43 #include "MagickCore/blob-private.h"
44 #include "MagickCore/color.h"
45 #include "MagickCore/color-private.h"
46 #include "MagickCore/constitute.h"
47 #include "MagickCore/exception.h"
48 #include "MagickCore/exception-private.h"
49 #include "MagickCore/image.h"
50 #include "MagickCore/image-private.h"
51 #include "MagickCore/list.h"
52 #include "MagickCore/log.h"
53 #include "MagickCore/magick.h"
54 #include "MagickCore/memory_.h"
55 #include "MagickCore/monitor.h"
56 #include "MagickCore/monitor-private.h"
57 #include "MagickCore/paint.h"
58 #include "MagickCore/quantum-private.h"
59 #include "MagickCore/static.h"
60 #include "MagickCore/string_.h"
61 #include "MagickCore/module.h"
62 #include "MagickCore/type.h"
63 #include "MagickCore/module.h"
64 #include "MagickWand/MagickWand.h"
66 #if defined(__CYGWIN__)
67 #undef MAGICKCORE_SANS_DELEGATE
70 #if defined(MAGICKCORE_SANS_DELEGATE)
71 #include "libwmf/api.h"
72 #include "libwmf/eps.h"
75 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
79 % R e a d W M F I m a g e %
83 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
85 % ReadWMFImage() reads an Windows Metafile image file and returns it. It
86 % allocates the memory necessary for the new Image structure and returns a
87 % pointer to the new image.
89 % The format of the ReadWMFImage method is:
91 % Image *ReadWMFImage(const ImageInfo *image_info,ExceptionInfo *exception)
93 % A description of each parameter follows:
95 % o image_info: the image info.
97 % o exception: return any errors or warnings in this structure.
101 static int WMFReadBlob(void *image)
103 return(ReadBlobByte((Image *) image));
106 static int WMFSeekBlob(void *image,long offset)
108 return((int) SeekBlob((Image *) image,(MagickOffsetType) offset,SEEK_SET));
111 static long WMFTellBlob(void *image)
113 return((long) TellBlob((Image*) image));
116 static Image *ReadWMFImage(const ImageInfo *image_info,ExceptionInfo *exception)
119 filename[MagickPathExtent];
157 image=AcquireImage(image_info,exception);
158 status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
159 if (status == MagickFalse)
161 image=DestroyImageList(image);
162 return((Image *) NULL);
164 wmf_info=(wmfAPI *) NULL;
166 flags|=WMF_OPT_IGNORE_NONFATAL;
167 flags|=WMF_OPT_FUNCTION;
168 options.function=wmf_eps_function;
169 wmf_status=wmf_api_create(&wmf_info,(unsigned long) flags,&options);
170 if (wmf_status != wmf_E_None)
172 if (wmf_info != (wmfAPI *) NULL)
173 wmf_api_destroy(wmf_info);
174 ThrowReaderException(DelegateError,"UnableToInitializeWMFLibrary");
176 wmf_status=wmf_bbuf_input(wmf_info,WMFReadBlob,WMFSeekBlob,WMFTellBlob,
178 if (wmf_status != wmf_E_None)
180 ipa_device_close(wmf_info);
181 wmf_api_destroy(wmf_info);
182 ThrowFileException(exception,FileOpenError,"UnableToOpenFile",
184 image=DestroyImageList(image);
185 return((Image *) NULL);
187 wmf_status=wmf_scan(wmf_info,0,&bounding_box);
188 if (wmf_status != wmf_E_None)
190 ipa_device_close(wmf_info);
191 wmf_api_destroy(wmf_info);
192 ThrowReaderException(DelegateError,"FailedToScanFile");
194 eps_info=WMF_EPS_GetData(wmf_info);
196 unique_file=AcquireUniqueFileResource(filename);
197 if (unique_file != -1)
198 file=fdopen(unique_file,"wb");
199 if ((unique_file == -1) || (file == (FILE *) NULL))
201 ipa_device_close(wmf_info);
202 wmf_api_destroy(wmf_info);
203 ThrowReaderException(FileOpenError,"UnableToCreateTemporaryFile");
205 eps_info->out=wmf_stream_create(wmf_info,file);
206 eps_info->bbox=bounding_box;
207 wmf_status=wmf_play(wmf_info,0,&bounding_box);
208 if (wmf_status != wmf_E_None)
210 ipa_device_close(wmf_info);
211 wmf_api_destroy(wmf_info);
212 ThrowReaderException(DelegateError,"FailedToRenderFile");
215 wmf_api_destroy(wmf_info);
216 (void) CloseBlob(image);
217 image=DestroyImage(image);
221 read_info=CloneImageInfo(image_info);
222 SetImageInfoBlob(read_info,(void *) NULL,0);
223 (void) FormatLocaleString(read_info->filename,MagickPathExtent,"eps:%s",
225 image=ReadImage(read_info,exception);
226 read_info=DestroyImageInfo(read_info);
227 if (image != (Image *) NULL)
229 (void) CopyMagickString(image->filename,image_info->filename,
231 (void) CopyMagickString(image->magick_filename,image_info->filename,
233 (void) CopyMagickString(image->magick,"WMF",MagickPathExtent);
235 (void) RelinquishUniqueFileResource(filename);
236 return(GetFirstImageInList(image));
238 #elif defined(MAGICKCORE_WMF_DELEGATE)
240 #define ERR(API) ((API)->err != wmf_E_None)
241 #define XC(x) ((double) x)
242 #define YC(y) ((double) y)
245 # define M_PI MagickPI
248 #if defined(MAGICKCORE_HAVE_FT2BUILD_H)
249 # include <ft2build.h>
252 #include "libwmf/fund.h"
253 #include "libwmf/types.h"
254 #include "libwmf/api.h"
271 /* The following additinal undefs were required for MinGW */
274 #undef PS_ENDCAP_ROUND
275 #undef PS_ENDCAP_SQUARE
276 #undef PS_ENDCAP_FLAT
277 #undef PS_ENDCAP_MASK
284 #undef STRETCH_ANDSCANS
285 #undef STRETCH_ORSCANS
286 #undef STRETCH_DELETESCANS
287 #undef STRETCH_HALFTONE
290 #undef ETO_GLYPH_INDEX
291 #undef ETO_RTLREADING
293 #include "libwmf/defs.h"
294 #include "libwmf/ipa.h"
295 #include "libwmf/color.h"
296 #include "libwmf/macro.h"
298 /* Unit conversions */
299 #define TWIPS_PER_INCH 1440
300 #define CENTIMETERS_PER_INCH 2.54
301 #define POINTS_PER_INCH 72
303 #if defined(MAGICKCORE_WMF_DELEGATE)
304 # define wmf_api_create(api,flags,options) wmf_lite_create(api,flags,options)
305 # define wmf_api_destroy(api) wmf_lite_destroy(api)
306 # undef WMF_FONT_PSNAME
307 # define WMF_FONT_PSNAME(F) ((F)->user_data ? ((wmf_magick_font_t*) (F)->user_data)->ps_name : 0)
309 typedef struct _wmf_magick_font_t wmf_magick_font_t;
311 struct _wmf_magick_font_t
319 typedef struct _wmf_magick_t wmf_magick_t;
327 /* Scale and translation factors */
342 /* ImageMagick image */
372 #define WMF_MAGICK_GetData(Z) ((wmf_magick_t*)((Z)->device_data))
373 #define WMF_MAGICK_GetFontData(Z) \
374 ((wmf_magick_font_t*)((wmfFontData *)Z->font_data)->user_data)
376 #define WmfDrawingWand (((wmf_magick_t*)((API)->device_data))->draw_wand)
378 /* Enum to control whether util_set_brush applies brush to fill or
387 /* Enum to specify arc type */
390 magick_arc_ellipse = 0,
397 #if defined(MAGICKCORE_WMF_DELEGATE)
398 static void lite_font_init (wmfAPI* API, wmfAPI_Options* options);
399 static void lite_font_map(wmfAPI* API,wmfFont* font);
400 static float lite_font_stringwidth(wmfAPI* API, wmfFont* font, char* str);
403 static void draw_fill_color_rgb(wmfAPI* API, const wmfRGB* rgb);
404 static void draw_stroke_color_rgb(wmfAPI* API, const wmfRGB* rgb);
405 static void draw_pattern_push(wmfAPI* API, unsigned long id, unsigned long columns, unsigned long rows);
406 static int ipa_blob_read(void* wand);
407 static int ipa_blob_seek(void* wand,long position);
408 static long ipa_blob_tell(void* wand);
409 static void ipa_bmp_draw(wmfAPI * API, wmfBMP_Draw_t * bmp_draw);
410 static void ipa_bmp_free(wmfAPI * API, wmfBMP * bmp);
411 static void ipa_bmp_read(wmfAPI * API, wmfBMP_Read_t * bmp_read);
412 static void ipa_device_begin(wmfAPI * API);
413 static void ipa_device_close(wmfAPI * API);
414 static void ipa_device_end(wmfAPI * API);
415 static void ipa_device_open(wmfAPI * API);
416 static void ipa_draw_arc(wmfAPI * API, wmfDrawArc_t * draw_arc);
417 static void ipa_draw_chord(wmfAPI * API, wmfDrawArc_t * draw_arc);
418 static void ipa_draw_ellipse(wmfAPI * API, wmfDrawArc_t * draw_arc);
419 static void ipa_draw_line(wmfAPI * API, wmfDrawLine_t * draw_line);
420 static void ipa_draw_pie(wmfAPI * API, wmfDrawArc_t * draw_arc);
421 static void ipa_draw_pixel(wmfAPI * API, wmfDrawPixel_t * draw_pixel);
422 static void ipa_draw_polygon(wmfAPI * API, wmfPolyLine_t * poly_line);
423 #if defined(MAGICKCORE_WMF_DELEGATE)
424 static void ipa_draw_polypolygon(wmfAPI * API, wmfPolyPoly_t* polypolygon);
426 static void ipa_draw_rectangle(wmfAPI * API, wmfDrawRectangle_t * draw_rect);
427 static void ipa_draw_text(wmfAPI * API, wmfDrawText_t * draw_text);
428 static void ipa_flood_exterior(wmfAPI * API, wmfFlood_t * flood);
429 static void ipa_flood_interior(wmfAPI * API, wmfFlood_t * flood);
430 static void ipa_functions(wmfAPI * API);
431 static void ipa_poly_line(wmfAPI * API, wmfPolyLine_t * poly_line);
432 static void ipa_region_clip(wmfAPI * API, wmfPolyRectangle_t * poly_rect);
433 static void ipa_region_frame(wmfAPI * API, wmfPolyRectangle_t * poly_rect);
434 static void ipa_region_paint(wmfAPI * API, wmfPolyRectangle_t * poly_rect);
435 static void ipa_rop_draw(wmfAPI * API, wmfROP_Draw_t * rop_draw);
436 static void ipa_udata_copy(wmfAPI * API, wmfUserData_t * userdata);
437 static void ipa_udata_free(wmfAPI * API, wmfUserData_t * userdata);
438 static void ipa_udata_init(wmfAPI * API, wmfUserData_t * userdata);
439 static void ipa_udata_set(wmfAPI * API, wmfUserData_t * userdata);
440 static int magick_progress_callback(void* wand,float quantum);
441 static void util_draw_arc(wmfAPI * API, wmfDrawArc_t * draw_arc,magick_arc_t finish);
442 #if defined(MAGICKCORE_WMF_DELEGATE)
443 /*static int util_font_weight( const char* font );*/
445 static double util_pointsize( wmfAPI* API, wmfFont* font, char* str, double font_height, ExceptionInfo *);
446 static void util_set_brush(wmfAPI * API, wmfDC * dc, const BrushApply brush_apply);
447 static void util_set_pen(wmfAPI * API, wmfDC * dc);
449 /* Progress callback */
450 int magick_progress_callback(void *context,float quantum)
459 image=(Image *) context;
460 assert(image->signature == MagickCoreSignature);
461 status=SetImageProgress(image,LoadImagesTag,TellBlob(image),
463 return(status != MagickFalse ? 0 : 1);
467 static void draw_fill_color_string(DrawingWand *drawing_wand,const char *color)
472 fill_color=NewPixelWand();
473 PixelSetColor(fill_color,color);
474 DrawSetFillColor(drawing_wand,fill_color);
475 fill_color=DestroyPixelWand(fill_color);
477 static void draw_fill_color_rgb( wmfAPI* API, const wmfRGB* rgb )
482 fill_color=NewPixelWand();
483 PixelSetRedQuantum(fill_color,ScaleCharToQuantum(rgb->r));
484 PixelSetGreenQuantum(fill_color,ScaleCharToQuantum(rgb->g));
485 PixelSetBlueQuantum(fill_color,ScaleCharToQuantum(rgb->b));
486 PixelSetAlphaQuantum(fill_color,OpaqueAlpha);
487 DrawSetFillColor(WmfDrawingWand,fill_color);
488 fill_color=DestroyPixelWand(fill_color);
491 /* Set stroke color */
492 static void draw_stroke_color_string(DrawingWand *drawing_wand,const char *color)
497 stroke_color=NewPixelWand();
498 PixelSetColor(stroke_color,color);
499 DrawSetStrokeColor(drawing_wand,stroke_color);
500 stroke_color=DestroyPixelWand(stroke_color);
503 static void draw_stroke_color_rgb( wmfAPI* API, const wmfRGB* rgb )
508 stroke_color=NewPixelWand();
509 PixelSetRedQuantum(stroke_color,ScaleCharToQuantum(rgb->r));
510 PixelSetGreenQuantum(stroke_color,ScaleCharToQuantum(rgb->g));
511 PixelSetBlueQuantum(stroke_color,ScaleCharToQuantum(rgb->b));
512 PixelSetAlphaQuantum(stroke_color,OpaqueAlpha);
513 DrawSetStrokeColor(WmfDrawingWand,stroke_color);
514 stroke_color=DestroyPixelWand(stroke_color);
517 /* Set under color */
518 static void draw_under_color_string(DrawingWand *drawing_wand,const char *color)
523 under_color=NewPixelWand();
524 PixelSetColor(under_color,color);
525 DrawSetTextUnderColor(drawing_wand,under_color);
526 under_color=DestroyPixelWand(under_color);
529 static void draw_pattern_push( wmfAPI* API,
531 unsigned long columns,
535 pattern_id[MagickPathExtent];
537 (void) FormatLocaleString(pattern_id,MagickPathExtent,"brush_%lu",id);
538 (void) DrawPushPattern(WmfDrawingWand,pattern_id,0,0,columns,rows);
541 /* Pattern/Bit BLT with raster operation (ROP) support. Invoked by
542 META_PATBLT, which is equivalent to Windows PatBlt() call, or by
543 META_DIBBITBLT which is equivalent to Windows BitBlt() call. */
545 /* The BitBlt function transfers pixels from a rectangular area in one
546 device wand called the 'source', to a rectangular area of the
547 same size in another device wand, called the 'destination'. */
549 static void ipa_rop_draw(wmfAPI * API, wmfROP_Draw_t * rop_draw)
552 /* *brush = WMF_DC_BRUSH(rop_draw->dc); */
555 /* *brush_bmp = WMF_BRUSH_BITMAP(brush); */
557 if (TO_FILL(rop_draw) == 0)
560 /* Save graphic wand */
561 (void) PushDrawingWand(WmfDrawingWand);
563 /* FIXME: finish implementing (once we know what it is supposed to do!) */
566 struct _wmfROP_Draw_t
579 /* if (brush_bmp && brush_bmp->data != 0) */
580 /* printf("Have an image!\n"); */
582 switch (rop_draw->ROP) /* Ternary raster operations */
584 case SRCCOPY: /* dest = source */
585 printf("ipa_rop_draw SRCCOPY ROP mode not implemented\n");
587 case SRCPAINT: /* dest = source OR dest */
588 printf("ipa_rop_draw SRCPAINT ROP mode not implemented\n");
590 case SRCAND: /* dest = source AND dest */
591 printf("ipa_rop_draw SRCAND ROP mode not implemented\n");
593 case SRCINVERT: /* dest = source XOR dest */
594 printf("ipa_rop_draw SRCINVERT ROP mode not implemented\n");
596 case SRCERASE: /* dest = source AND (NOT dest) */
597 printf("ipa_rop_draw SRCERASE ROP mode not implemented\n");
599 case NOTSRCCOPY: /* dest = (NOT source) */
600 printf("ipa_rop_draw NOTSRCCOPY ROP mode not implemented\n");
602 case NOTSRCERASE: /* dest = (NOT src) AND (NOT dest) */
603 printf("ipa_rop_draw NOTSRCERASE ROP mode not implemented\n");
605 case MERGECOPY: /* dest = (source AND pattern) */
606 printf("ipa_rop_draw MERGECOPY ROP mode not implemented\n");
608 case MERGEPAINT: /* dest = (NOT source) OR dest */
609 printf("ipa_rop_draw MERGEPAINT ROP mode not implemented\n");
611 case PATCOPY: /* dest = pattern */
612 util_set_brush(API, rop_draw->dc, BrushApplyFill);
614 case PATPAINT: /* dest = DPSnoo */
615 printf("ipa_rop_draw PATPAINT ROP mode not implemented\n");
617 case PATINVERT: /* dest = pattern XOR dest */
618 printf("ipa_rop_draw PATINVERT ROP mode not implemented\n");
620 case DSTINVERT: /* dest = (NOT dest) */
621 printf("ipa_rop_draw DSTINVERT ROP mode not implemented\n");
623 case BLACKNESS: /* dest = BLACK */
624 draw_fill_color_string(WmfDrawingWand,"black");
626 case WHITENESS: /* dest = WHITE */
627 draw_fill_color_string(WmfDrawingWand,"white");
630 printf("ipa_rop_draw 0x%x ROP mode not implemented\n", rop_draw->ROP);
634 DrawRectangle(WmfDrawingWand,
635 XC(rop_draw->TL.x), YC(rop_draw->TL.y),
636 XC(rop_draw->BR.x), YC(rop_draw->BR.y));
638 /* Restore graphic wand */
639 (void) PopDrawingWand(WmfDrawingWand);
642 static void ipa_bmp_draw(wmfAPI *API, wmfBMP_Draw_t *bmp_draw)
645 *ddata = WMF_MAGICK_GetData(API);
663 if (bmp_draw->bmp.data == 0)
666 image = (Image*)bmp_draw->bmp.data;
670 exception=ddata->exception;
671 if (bmp_draw->crop.x || bmp_draw->crop.y ||
672 (bmp_draw->crop.w != bmp_draw->bmp.width) ||
673 (bmp_draw->crop.h != bmp_draw->bmp.height))
675 /* Image needs to be cropped */
682 crop_info.x = bmp_draw->crop.x;
683 crop_info.y = bmp_draw->crop.y;
684 crop_info.width = bmp_draw->crop.w;
685 crop_info.height = bmp_draw->crop.h;
687 crop_image = CropImage( image, &crop_info, exception );
690 image=DestroyImageList(image);
692 bmp_draw->bmp.data = (void*)image;
696 QueryColorCompliance( "white", AllCompliance, &white, exception );
698 if ( ddata->image_info->texture ||
699 !(IsPixelInfoEquivalent(&ddata->image_info->background_color,&white)) ||
700 ddata->image_info->background_color.alpha != OpaqueAlpha )
703 Set image white background to transparent so that it may be
704 overlaid over non-white backgrounds.
706 QueryColorCompliance( "white", AllCompliance, &white, exception );
707 TransparentPaintImage( image, &white, QuantumRange, MagickFalse, exception );
710 width = fabs(bmp_draw->pixel_width * (double) bmp_draw->crop.w);
711 height = fabs(bmp_draw->pixel_height * (double) bmp_draw->crop.h);
712 magick_wand=NewMagickWandFromImage(image);
713 (void) DrawComposite(WmfDrawingWand, CopyCompositeOp,
714 XC(bmp_draw->pt.x) * ddata->scale_x, YC(bmp_draw->pt.y) * ddata->scale_y,
715 width * ddata->scale_x, height * ddata->scale_y, magick_wand);
716 magick_wand=DestroyMagickWand(magick_wand);
719 printf("bmp_draw->bmp.data = 0x%lx\n", (long)bmp_draw->bmp.data);
720 printf("registry id = %li\n", id);
721 /* printf("pixel_width = %g\n", bmp_draw->pixel_width); */
722 /* printf("pixel_height = %g\n", bmp_draw->pixel_height); */
723 printf("bmp_draw->bmp WxH = %ix%i\n", bmp_draw->bmp.width, bmp_draw->bmp.height);
724 printf("bmp_draw->crop WxH = %ix%i\n", bmp_draw->crop.w, bmp_draw->crop.h);
725 printf("bmp_draw->crop x,y = %i,%i\n", bmp_draw->crop.x, bmp_draw->crop.y);
726 printf("image size WxH = %lux%lu\n", image->columns, image->rows);
730 static void ipa_bmp_read(wmfAPI * API, wmfBMP_Read_t * bmp_read) {
732 *ddata = WMF_MAGICK_GetData(API);
743 bmp_read->bmp.data = 0;
745 image_info=CloneImageInfo(ddata->image_info);
746 exception=ddata->exception;
747 (void) CopyMagickString(image_info->magick,"DIB",MagickPathExtent);
748 if (bmp_read->width || bmp_read->height)
751 size[MagickPathExtent];
753 (void) FormatLocaleString(size,MagickPathExtent,"%ux%u",bmp_read->width,
755 CloneString(&image_info->size,size);
758 printf("ipa_bmp_read: buffer=0x%lx length=%ld, width=%i, height=%i\n",
759 (long) bmp_read->buffer, bmp_read->length,
760 bmp_read->width, bmp_read->height);
762 image=BlobToImage(image_info, (const void *) bmp_read->buffer,
763 bmp_read->length, exception);
764 image_info=DestroyImageInfo(image_info);
765 if (image != (Image *) NULL)
768 printf("ipa_bmp_read: rows=%ld,columns=%ld\n\n", image->rows, image->columns);
771 bmp_read->bmp.data = (void*)image;
772 bmp_read->bmp.width = (U16)image->columns;
773 bmp_read->bmp.height = (U16)image->rows;
777 static void ipa_bmp_free(wmfAPI * API, wmfBMP * bmp)
780 DestroyImageList((Image*)bmp->data);
781 bmp->data = (void*) 0;
782 bmp->width = (U16) 0;
783 bmp->height = (U16) 0;
787 This called by wmf_play() the *first* time the meta file is played
789 static void ipa_device_open(wmfAPI * API)
792 *ddata = WMF_MAGICK_GetData (API);
794 ddata->pattern_id = 0;
795 ddata->clipping = MagickFalse;
796 ddata->clip_mask_id = 0;
798 ddata->push_depth = 0;
800 ddata->draw_wand = AcquireDrawingWand(ddata->draw_info,ddata->image);
804 This called by wmf_api_destroy()
806 static void ipa_device_close(wmfAPI * API)
809 *ddata = WMF_MAGICK_GetData(API);
811 if (ddata->draw_wand != (DrawingWand *) NULL)
813 DestroyDrawingWand(ddata->draw_wand);
814 ddata->draw_wand=(DrawingWand *) NULL;
816 if (ddata->draw_info != (DrawInfo *) NULL)
818 DestroyDrawInfo(ddata->draw_info);
819 ddata->draw_info=(DrawInfo *)NULL;
821 if (WMF_MAGICK_GetFontData(API)->ps_name)
822 WMF_MAGICK_GetFontData(API)->ps_name=(char *) RelinquishMagickMemory(
823 WMF_MAGICK_GetFontData(API)->ps_name);
827 This called from the beginning of each play for initial page setup
829 static void ipa_device_begin(wmfAPI * API)
832 comment[MagickPathExtent],
836 *ddata = WMF_MAGICK_GetData(API);
838 /* Make SVG output happy */
839 (void) PushDrawingWand(WmfDrawingWand);
841 DrawSetViewbox(WmfDrawingWand,0,0,ddata->image->columns,ddata->image->rows);
843 url=GetMagickHomeURL();
844 (void) FormatLocaleString(comment,MagickPathExtent,
845 "Created by ImageMagick %s",url);
846 url=DestroyString(url);
847 DrawComment(WmfDrawingWand,comment);
849 /* Scale width and height to image */
850 DrawScale(WmfDrawingWand, ddata->scale_x, ddata->scale_y);
852 /* Translate to TL corner of bounding box */
853 DrawTranslate(WmfDrawingWand, ddata->translate_x, ddata->translate_y);
856 DrawRotate(WmfDrawingWand, ddata->rotate);
858 if (ddata->image_info->texture == NULL)
863 /* Draw rectangle in background color */
864 background_color=NewPixelWand();
865 PixelSetPixelColor(background_color,&ddata->image->background_color);
866 DrawSetFillColor(WmfDrawingWand,background_color);
867 background_color=DestroyPixelWand(background_color);
868 DrawRectangle(WmfDrawingWand,
869 XC(ddata->bbox.TL.x),YC(ddata->bbox.TL.y),
870 XC(ddata->bbox.BR.x),YC(ddata->bbox.BR.y));
874 /* Draw rectangle with texture image the SVG way */
884 exception=AcquireExceptionInfo();
886 image_info = CloneImageInfo((ImageInfo *) 0);
887 (void) CopyMagickString(image_info->filename,ddata->image_info->texture,
889 if ( ddata->image_info->size )
890 CloneString(&image_info->size,ddata->image_info->size);
892 image = ReadImage(image_info,exception);
893 (void) DestroyExceptionInfo(exception);
894 image_info=DestroyImageInfo(image_info);
898 pattern_id[MagickPathExtent];
903 (void) CopyMagickString(image->magick,"MIFF",MagickPathExtent);
904 DrawPushDefs(WmfDrawingWand);
905 draw_pattern_push(API,ddata->pattern_id,image->columns,image->rows);
906 magick_wand=NewMagickWandFromImage(image);
907 (void) DrawComposite(WmfDrawingWand,CopyCompositeOp,0,0,
908 image->columns,image->rows,magick_wand);
909 magick_wand=DestroyMagickWand(magick_wand);
910 (void) DrawPopPattern(WmfDrawingWand);
911 DrawPopDefs(WmfDrawingWand);
912 (void) FormatLocaleString(pattern_id,MagickPathExtent,"#brush_%lu",
914 (void) DrawSetFillPatternURL(WmfDrawingWand,pattern_id);
916 DrawRectangle(WmfDrawingWand,
917 XC(ddata->bbox.TL.x),YC(ddata->bbox.TL.y),
918 XC(ddata->bbox.BR.x),YC(ddata->bbox.BR.y));
919 image=DestroyImageList(image);
923 LogMagickEvent(CoderEvent,GetMagickModule(),
924 "reading texture image failed!");
928 DrawSetClipRule(WmfDrawingWand,EvenOddRule); /* Default for WMF is ALTERNATE polygon fill mode */
929 draw_fill_color_string(WmfDrawingWand,"none"); /* Default brush is WHITE_BRUSH */
930 draw_stroke_color_string(WmfDrawingWand,"none"); /* Default pen is BLACK_PEN */
931 DrawSetStrokeLineCap(WmfDrawingWand,ButtCap); /* Default linecap is PS_ENDCAP_FLAT */
932 DrawSetStrokeLineJoin(WmfDrawingWand,MiterJoin); /* Default linejoin is PS_JOIN_MITER */
933 draw_under_color_string(WmfDrawingWand,"white"); /* Default text box is white */
937 This called from the end of each play for page termination
939 static void ipa_device_end(wmfAPI * API)
942 *ddata = WMF_MAGICK_GetData(API);
944 /* Reset any existing clip paths by popping wand */
946 (void) PopDrawingWand(WmfDrawingWand);
947 ddata->clipping = MagickFalse;
949 /* Make SVG output happy */
950 (void) PopDrawingWand(WmfDrawingWand);
953 static void ipa_flood_interior(wmfAPI * API, wmfFlood_t * flood)
955 /* Save graphic wand */
956 (void) PushDrawingWand(WmfDrawingWand);
958 draw_fill_color_rgb(API,&(flood->color));
960 DrawColor(WmfDrawingWand,XC(flood->pt.x), YC(flood->pt.y),
963 /* Restore graphic wand */
964 (void) PopDrawingWand(WmfDrawingWand);
967 static void ipa_flood_exterior(wmfAPI * API, wmfFlood_t * flood)
969 /* Save graphic wand */
970 (void) PushDrawingWand(WmfDrawingWand);
972 draw_fill_color_rgb(API,&(flood->color));
974 if (flood->type == FLOODFILLSURFACE)
975 DrawColor(WmfDrawingWand, XC(flood->pt.x), YC(flood->pt.y),
978 DrawColor(WmfDrawingWand, XC(flood->pt.x), YC(flood->pt.y),
981 /* Restore graphic wand */
982 (void) PopDrawingWand(WmfDrawingWand);
985 static void ipa_draw_pixel(wmfAPI * API, wmfDrawPixel_t * draw_pixel)
987 /* Save graphic wand */
988 (void) PushDrawingWand(WmfDrawingWand);
990 draw_stroke_color_string(WmfDrawingWand,"none");
992 draw_fill_color_rgb(API,&(draw_pixel->color));
994 DrawRectangle(WmfDrawingWand,
995 XC(draw_pixel->pt.x),
996 YC(draw_pixel->pt.y),
997 XC(draw_pixel->pt.x + draw_pixel->pixel_width),
998 YC(draw_pixel->pt.y + draw_pixel->pixel_height));
1000 /* Restore graphic wand */
1001 (void) PopDrawingWand(WmfDrawingWand);
1004 static void ipa_draw_pie(wmfAPI * API, wmfDrawArc_t * draw_arc)
1006 util_draw_arc(API, draw_arc, magick_arc_pie);
1009 static void ipa_draw_chord(wmfAPI * API, wmfDrawArc_t * draw_arc)
1011 util_draw_arc(API, draw_arc, magick_arc_chord);
1014 static void ipa_draw_arc(wmfAPI * API, wmfDrawArc_t * draw_arc)
1016 util_draw_arc(API, draw_arc, magick_arc_open);
1019 static void ipa_draw_ellipse(wmfAPI * API, wmfDrawArc_t * draw_arc)
1021 util_draw_arc(API, draw_arc, magick_arc_ellipse);
1024 static void util_draw_arc(wmfAPI * API,
1025 wmfDrawArc_t * draw_arc, magick_arc_t finish)
1043 /* Save graphic wand */
1044 (void) PushDrawingWand(WmfDrawingWand);
1046 if (TO_FILL(draw_arc) || TO_DRAW(draw_arc))
1048 center.x = (draw_arc->TL.x + draw_arc->BR.x) / 2;
1049 center.y = (draw_arc->TL.y + draw_arc->BR.y) / 2;
1053 if (finish != magick_arc_ellipse)
1055 draw_arc->start.x += center.x;
1056 draw_arc->start.y += center.y;
1058 draw_arc->end.x += center.x;
1059 draw_arc->end.y += center.y;
1067 if (finish != magick_arc_ellipse)
1069 start = draw_arc->start;
1070 end = draw_arc->end;
1073 Rx = (BR.x - TL.x) / 2;
1074 Ry = (BR.y - TL.y) / 2;
1076 if (finish != magick_arc_ellipse)
1084 phi_s = atan2((double) start.y, (double) start.x) * 180 / MagickPI;
1085 phi_e = atan2((double) end.y, (double) end.x) * 180 / MagickPI;
1091 util_set_pen(API, draw_arc->dc);
1092 if (finish == magick_arc_open)
1093 draw_fill_color_string(WmfDrawingWand,"none");
1095 util_set_brush(API, draw_arc->dc, BrushApplyFill);
1097 if (finish == magick_arc_ellipse)
1098 DrawEllipse(WmfDrawingWand, XC(O.x), YC(O.y), Rx, Ry, 0, 360);
1099 else if (finish == magick_arc_pie)
1101 DrawPathStart(WmfDrawingWand);
1102 DrawPathMoveToAbsolute(WmfDrawingWand, XC(O.x+start.x),
1104 DrawPathEllipticArcAbsolute(WmfDrawingWand, Rx, Ry, 0, MagickFalse,
1105 MagickTrue, XC(O.x+end.x), YC(O.y+end.y));
1106 DrawPathLineToAbsolute(WmfDrawingWand, XC(O.x), YC(O.y));
1107 DrawPathClose(WmfDrawingWand);
1108 DrawPathFinish(WmfDrawingWand);
1110 else if (finish == magick_arc_chord)
1112 DrawArc(WmfDrawingWand, XC(draw_arc->TL.x), YC(draw_arc->TL.y),
1113 XC(draw_arc->BR.x), XC(draw_arc->BR.y), phi_s, phi_e);
1114 DrawLine(WmfDrawingWand, XC(draw_arc->BR.x-start.x),
1115 YC(draw_arc->BR.y-start.y), XC(draw_arc->BR.x-end.x),
1116 YC(draw_arc->BR.y-end.y));
1118 else /* if (finish == magick_arc_open) */
1119 DrawArc(WmfDrawingWand, XC(draw_arc->TL.x), YC(draw_arc->TL.y),
1120 XC(draw_arc->BR.x), XC(draw_arc->BR.y), phi_s, phi_e);
1123 /* Restore graphic wand */
1124 (void) PopDrawingWand(WmfDrawingWand);
1127 static void ipa_draw_line(wmfAPI * API, wmfDrawLine_t * draw_line)
1129 /* Save graphic wand */
1130 (void) PushDrawingWand(WmfDrawingWand);
1132 if (TO_DRAW(draw_line))
1134 util_set_pen(API, draw_line->dc);
1135 DrawLine(WmfDrawingWand,
1136 XC(draw_line->from.x), YC(draw_line->from.y),
1137 XC(draw_line->to.x), YC(draw_line->to.y));
1140 /* Restore graphic wand */
1141 (void) PopDrawingWand(WmfDrawingWand);
1144 static void ipa_poly_line(wmfAPI * API, wmfPolyLine_t * polyline)
1146 if (polyline->count <= 2)
1149 if (TO_DRAW(polyline))
1154 /* Save graphic wand */
1155 (void) PushDrawingWand(WmfDrawingWand);
1157 util_set_pen(API, polyline->dc);
1159 DrawPathStart(WmfDrawingWand);
1160 DrawPathMoveToAbsolute(WmfDrawingWand,
1161 XC(polyline->pt[0].x),
1162 YC(polyline->pt[0].y));
1163 for (point = 1; point < polyline->count; point++)
1165 DrawPathLineToAbsolute(WmfDrawingWand,
1166 XC(polyline->pt[point].x),
1167 YC(polyline->pt[point].y));
1169 DrawPathFinish(WmfDrawingWand);
1171 /* Restore graphic wand */
1172 (void) PopDrawingWand(WmfDrawingWand);
1176 static void ipa_draw_polygon(wmfAPI * API, wmfPolyLine_t * polyline)
1178 if (polyline->count <= 2)
1181 if (TO_FILL(polyline) || TO_DRAW(polyline))
1186 /* Save graphic wand */
1187 (void) PushDrawingWand(WmfDrawingWand);
1189 util_set_pen(API, polyline->dc);
1190 util_set_brush(API, polyline->dc, BrushApplyFill);
1192 DrawPathStart(WmfDrawingWand);
1193 DrawPathMoveToAbsolute(WmfDrawingWand,
1194 XC(polyline->pt[0].x),
1195 YC(polyline->pt[0].y));
1196 for (point = 1; point < polyline->count; point++)
1198 DrawPathLineToAbsolute(WmfDrawingWand,
1199 XC(polyline->pt[point].x),
1200 YC(polyline->pt[point].y));
1202 DrawPathClose(WmfDrawingWand);
1203 DrawPathFinish(WmfDrawingWand);
1205 /* Restore graphic wand */
1206 (void) PopDrawingWand(WmfDrawingWand);
1210 /* Draw a polypolygon. A polypolygon is a list of polygons */
1211 #if defined(MAGICKCORE_WMF_DELEGATE)
1212 static void ipa_draw_polypolygon(wmfAPI * API, wmfPolyPoly_t* polypolygon)
1214 if (TO_FILL(polypolygon) || TO_DRAW(polypolygon))
1223 /* Save graphic wand */
1224 (void) PushDrawingWand(WmfDrawingWand);
1226 util_set_pen(API, polypolygon->dc);
1227 util_set_brush(API, polypolygon->dc, BrushApplyFill);
1229 DrawPathStart(WmfDrawingWand);
1230 for (polygon = 0; polygon < polypolygon->npoly; polygon++)
1232 polyline.dc = polypolygon->dc;
1233 polyline.pt = polypolygon->pt[polygon];
1234 polyline.count = polypolygon->count[polygon];
1235 if ((polyline.count > 2) && polyline.pt)
1237 DrawPathMoveToAbsolute(WmfDrawingWand,
1238 XC(polyline.pt[0].x),
1239 YC(polyline.pt[0].y));
1240 for (point = 1; point < polyline.count; point++)
1242 DrawPathLineToAbsolute(WmfDrawingWand,
1243 XC(polyline.pt[point].x),
1244 YC(polyline.pt[point].y));
1246 DrawPathClose(WmfDrawingWand);
1249 DrawPathFinish(WmfDrawingWand);
1251 /* Restore graphic wand */
1252 (void) PopDrawingWand(WmfDrawingWand);
1257 static void ipa_draw_rectangle(wmfAPI * API, wmfDrawRectangle_t * draw_rect)
1259 /* Save graphic wand */
1260 (void) PushDrawingWand(WmfDrawingWand);
1262 if (TO_FILL(draw_rect) || TO_DRAW(draw_rect))
1264 util_set_pen(API, draw_rect->dc);
1265 util_set_brush(API, draw_rect->dc, BrushApplyFill);
1267 if ((draw_rect->width > 0) || (draw_rect->height > 0))
1268 DrawRoundRectangle(WmfDrawingWand,
1269 XC(draw_rect->TL.x), YC(draw_rect->TL.y),
1270 XC(draw_rect->BR.x), YC(draw_rect->BR.y),
1271 draw_rect->width / 2, draw_rect->height / 2);
1273 DrawRectangle(WmfDrawingWand,
1274 XC(draw_rect->TL.x), YC(draw_rect->TL.y),
1275 XC(draw_rect->BR.x), YC(draw_rect->BR.y));
1278 /* Restore graphic wand */
1279 (void) PopDrawingWand(WmfDrawingWand);
1282 /* Draw an un-filled rectangle using the current brush */
1283 static void ipa_region_frame(wmfAPI * API, wmfPolyRectangle_t * poly_rect)
1285 /* Save graphic wand */
1286 (void) PushDrawingWand(WmfDrawingWand);
1288 if (TO_FILL(poly_rect) || TO_DRAW(poly_rect))
1293 draw_fill_color_string(WmfDrawingWand,"none");
1294 util_set_brush(API, poly_rect->dc, BrushApplyStroke);
1296 for (i = 0; i < (long) poly_rect->count; i++)
1298 DrawRectangle(WmfDrawingWand,
1299 XC(poly_rect->TL[i].x), YC(poly_rect->TL[i].y),
1300 XC(poly_rect->BR[i].x), YC(poly_rect->BR[i].y));
1304 /* Restore graphic wand */
1305 (void) PopDrawingWand(WmfDrawingWand);
1308 static void ipa_region_paint(wmfAPI * API, wmfPolyRectangle_t * poly_rect)
1311 if (poly_rect->count == 0)
1314 /* Save graphic wand */
1315 (void) PushDrawingWand(WmfDrawingWand);
1317 if (TO_FILL (poly_rect))
1322 draw_stroke_color_string(WmfDrawingWand,"none");
1323 util_set_brush(API, poly_rect->dc, BrushApplyFill);
1325 for (i = 0; i < (long) poly_rect->count; i++)
1327 DrawRectangle(WmfDrawingWand,
1328 XC(poly_rect->TL[i].x), YC(poly_rect->TL[i].y),
1329 XC(poly_rect->BR[i].x), YC(poly_rect->BR[i].y));
1333 /* Restore graphic wand */
1334 (void) PopDrawingWand(WmfDrawingWand);
1337 static void ipa_region_clip(wmfAPI *API, wmfPolyRectangle_t *poly_rect)
1343 *ddata = WMF_MAGICK_GetData (API);
1345 /* Reset any existing clip paths by popping wand */
1346 if (ddata->clipping)
1347 (void) PopDrawingWand(WmfDrawingWand);
1348 ddata->clipping = MagickFalse;
1350 if (poly_rect->count > 0)
1353 clip_mask_id[MagickPathExtent];
1355 /* Define clip path */
1356 ddata->clip_mask_id++;
1357 DrawPushDefs(WmfDrawingWand);
1358 (void) FormatLocaleString(clip_mask_id,MagickPathExtent,"clip_%lu",
1359 ddata->clip_mask_id);
1360 DrawPushClipPath(WmfDrawingWand,clip_mask_id);
1361 (void) PushDrawingWand(WmfDrawingWand);
1362 for (i = 0; i < (long) poly_rect->count; i++)
1364 DrawRectangle(WmfDrawingWand,
1365 XC(poly_rect->TL[i].x), YC(poly_rect->TL[i].y),
1366 XC(poly_rect->BR[i].x), YC(poly_rect->BR[i].y));
1368 (void) PopDrawingWand(WmfDrawingWand);
1369 DrawPopClipPath(WmfDrawingWand);
1370 DrawPopDefs(WmfDrawingWand);
1372 /* Push wand for new clip paths */
1373 (void) PushDrawingWand(WmfDrawingWand);
1374 (void) DrawSetClipPath(WmfDrawingWand,clip_mask_id);
1375 ddata->clipping = MagickTrue;
1379 static void ipa_functions(wmfAPI *API)
1384 wmfFunctionReference
1385 *FR = (wmfFunctionReference *) API->function_reference;
1388 IPA function reference links
1390 FR->device_open = ipa_device_open;
1391 FR->device_close = ipa_device_close;
1392 FR->device_begin = ipa_device_begin;
1393 FR->device_end = ipa_device_end;
1394 FR->flood_interior = ipa_flood_interior;
1395 FR->flood_exterior = ipa_flood_exterior;
1396 FR->draw_pixel = ipa_draw_pixel;
1397 FR->draw_pie = ipa_draw_pie;
1398 FR->draw_chord = ipa_draw_chord;
1399 FR->draw_arc = ipa_draw_arc;
1400 FR->draw_ellipse = ipa_draw_ellipse;
1401 FR->draw_line = ipa_draw_line;
1402 FR->poly_line = ipa_poly_line;
1403 FR->draw_polygon = ipa_draw_polygon;
1404 #if defined(MAGICKCORE_WMF_DELEGATE)
1405 FR->draw_polypolygon = ipa_draw_polypolygon;
1407 FR->draw_rectangle = ipa_draw_rectangle;
1408 FR->rop_draw = ipa_rop_draw;
1409 FR->bmp_draw = ipa_bmp_draw;
1410 FR->bmp_read = ipa_bmp_read;
1411 FR->bmp_free = ipa_bmp_free;
1412 FR->draw_text = ipa_draw_text;
1413 FR->udata_init = ipa_udata_init;
1414 FR->udata_copy = ipa_udata_copy;
1415 FR->udata_set = ipa_udata_set;
1416 FR->udata_free = ipa_udata_free;
1417 FR->region_frame = ipa_region_frame;
1418 FR->region_paint = ipa_region_paint;
1419 FR->region_clip = ipa_region_clip;
1422 Allocate device data structure
1424 ddata = (wmf_magick_t *) wmf_malloc(API, sizeof(wmf_magick_t));
1428 (void) memset((void *) ddata, 0, sizeof(wmf_magick_t));
1429 API->device_data = (void *) ddata;
1432 Device data defaults
1437 static void ipa_draw_text(wmfAPI * API, wmfDrawText_t * draw_text)
1440 angle = 0, /* text rotation angle */
1441 bbox_height, /* bounding box height */
1442 bbox_width, /* bounding box width */
1443 pointsize = 0; /* pointsize to output font with desired height */
1452 BL, /* bottom left of bounding box */
1453 BR, /* bottom right of bounding box */
1454 TL, /* top left of bounding box */
1455 TR; /* top right of bounding box */
1458 point; /* text placement point */
1464 * ddata = WMF_MAGICK_GetData(API);
1466 point = draw_text->pt;
1468 /* Choose bounding box and calculate its width and height */
1473 if ( draw_text->flags)
1477 TR.x = draw_text->BR.x;
1478 TR.y = draw_text->TL.y;
1479 BL.x = draw_text->TL.x;
1480 BL.y = draw_text->BR.y;
1484 TL = draw_text->bbox.TL;
1485 BR = draw_text->bbox.BR;
1486 TR = draw_text->bbox.TR;
1487 BL = draw_text->bbox.BL;
1489 dx = ((TR.x - TL.x) + (BR.x - BL.x)) / 2;
1490 dy = ((TR.y - TL.y) + (BR.y - BL.y)) / 2;
1491 bbox_width = hypot(dx,dy);
1492 dx = ((BL.x - TL.x) + (BR.x - TR.x)) / 2;
1493 dy = ((BL.y - TL.y) + (BR.y - TR.y)) / 2;
1494 bbox_height = hypot(dx,dy);
1497 font = WMF_DC_FONT(draw_text->dc);
1499 /* Convert font_height to equivalent pointsize */
1500 exception=ddata->exception;
1501 pointsize = util_pointsize( API, font, draw_text->str, draw_text->font_height, exception);
1503 /* Save graphic wand */
1504 (void) PushDrawingWand(WmfDrawingWand);
1509 printf("\nipa_draw_text\n");
1510 printf("Text = \"%s\"\n", draw_text->str);
1511 /* printf("WMF_FONT_NAME: = \"%s\"\n", WMF_FONT_NAME(font)); */
1512 printf("WMF_FONT_PSNAME: = \"%s\"\n", WMF_FONT_PSNAME(font));
1513 printf("Bounding box TL=%g,%g BR=%g,%g\n",
1514 TL.x, TL.y, BR.x, BR.y );
1515 /* printf("Text box = %gx%g\n", bbox_width, bbox_height); */
1516 /* printf("WMF_FONT_HEIGHT = %i\n", (int)WMF_FONT_HEIGHT(font)); */
1517 printf("Pointsize = %g\n", pointsize);
1522 * Obtain font metrics if required
1525 if ((WMF_DC_TEXTALIGN(draw_text->dc) & TA_CENTER) ||
1526 (WMF_TEXT_UNDERLINE(font)) || (WMF_TEXT_STRIKEOUT(font)))
1529 *image = ddata->image;
1534 draw_info=ddata->draw_info;
1535 draw_info->font=WMF_FONT_PSNAME(font);
1536 draw_info->pointsize = pointsize;
1537 draw_info->text=draw_text->str;
1539 if (GetTypeMetrics(image, draw_info, &metrics, exception) != MagickFalse)
1541 /* Center the text if it is not yet centered and should be */
1542 if ((WMF_DC_TEXTALIGN(draw_text->dc) & TA_CENTER))
1545 text_width = metrics.width * (ddata->scale_y / ddata->scale_x);
1547 #if defined(MAGICKCORE_WMF_DELEGATE)
1548 point.x -= text_width / 2;
1550 point.x += bbox_width / 2 - text_width / 2;
1554 draw_info->font=NULL;
1555 draw_info->text=NULL;
1558 /* Set text background color */
1559 if (draw_text->flags & ETO_OPAQUE)
1561 /* Draw bounding-box background color (META_EXTTEXTOUT mode) */
1562 draw_stroke_color_string(WmfDrawingWand,"none");
1563 draw_fill_color_rgb(API,WMF_DC_BACKGROUND(draw_text->dc));
1564 DrawRectangle(WmfDrawingWand,
1565 XC(draw_text->TL.x),YC(draw_text->TL.y),
1566 XC(draw_text->BR.x),YC(draw_text->BR.y));
1567 draw_fill_color_string(WmfDrawingWand,"none");
1571 /* Set text undercolor */
1572 if (WMF_DC_OPAQUE(draw_text->dc))
1575 *box = WMF_DC_BACKGROUND(draw_text->dc);
1580 under_color=NewPixelWand();
1581 PixelSetRedQuantum(under_color,ScaleCharToQuantum(box->r));
1582 PixelSetGreenQuantum(under_color,ScaleCharToQuantum(box->g));
1583 PixelSetBlueQuantum(under_color,ScaleCharToQuantum(box->b));
1584 PixelSetAlphaQuantum(under_color,OpaqueAlpha);
1585 DrawSetTextUnderColor(WmfDrawingWand,under_color);
1586 under_color=DestroyPixelWand(under_color);
1589 draw_under_color_string(WmfDrawingWand,"none");
1592 /* Set text clipping (META_EXTTEXTOUT mode) */
1593 if ( draw_text->flags & ETO_CLIPPED)
1597 /* Set stroke color */
1598 draw_stroke_color_string(WmfDrawingWand,"none");
1600 /* Set fill color */
1601 draw_fill_color_rgb(API,WMF_DC_TEXTCOLOR(draw_text->dc));
1603 /* Output font size */
1604 (void) DrawSetFontSize(WmfDrawingWand,pointsize);
1606 /* Output Postscript font name */
1607 (void) DrawSetFont(WmfDrawingWand, WMF_FONT_PSNAME(font));
1609 /* Translate coordinates so target is 0,0 */
1610 DrawTranslate(WmfDrawingWand, XC(point.x), YC(point.y));
1612 /* Transform horizontal scale to draw text at 1:1 ratio */
1613 DrawScale(WmfDrawingWand, ddata->scale_y / ddata->scale_x, 1.0);
1615 /* Apply rotation */
1616 /* ImageMagick's drawing rotation is clockwise from horizontal
1617 while WMF drawing rotation is counterclockwise from horizontal */
1618 angle = fabs(RadiansToDegrees(2 * MagickPI - WMF_TEXT_ANGLE(font)));
1622 DrawRotate(WmfDrawingWand, angle);
1630 DrawAnnotation(WmfDrawingWand, 0, 0, (unsigned char*)draw_text->str);
1632 /* Underline text the Windows way (at the bottom) */
1633 if (WMF_TEXT_UNDERLINE(font))
1639 ulBR, /* bottom right of underline rectangle */
1640 ulTL; /* top left of underline rectangle */
1642 line_height = ((double)1/(ddata->scale_x))*metrics.underline_thickness;
1643 if (metrics.underline_thickness < 1.5)
1644 line_height *= 0.55;
1646 ulTL.y = fabs(metrics.descent) - line_height;
1647 ulBR.x = metrics.width;
1648 ulBR.y = fabs(metrics.descent);
1650 DrawRectangle(WmfDrawingWand,
1651 XC(ulTL.x), YC(ulTL.y), XC(ulBR.x), YC(ulBR.y));
1654 /* Strikeout text the Windows way */
1655 if (WMF_TEXT_STRIKEOUT(font))
1660 ulBR, /* bottom right of strikeout rectangle */
1661 ulTL; /* top left of strikeout rectangle */
1663 line_height = ((double)1/(ddata->scale_x))*metrics.underline_thickness;
1665 if (metrics.underline_thickness < 2.0)
1666 line_height *= 0.55;
1668 ulTL.y = -(((double) metrics.ascent) / 2 + line_height / 2);
1669 ulBR.x = metrics.width;
1670 ulBR.y = -(((double) metrics.ascent) / 2 - line_height / 2);
1672 DrawRectangle(WmfDrawingWand,
1673 XC(ulTL.x), YC(ulTL.y), XC(ulBR.x), YC(ulBR.y));
1677 /* Restore graphic wand */
1678 (void) PopDrawingWand(WmfDrawingWand);
1681 (void) PushDrawingWand(WmfDrawingWand);
1682 draw_stroke_color_string(WmfDrawingWand,"red");
1683 draw_fill_color_string(WmfDrawingWand,"none");
1684 DrawRectangle(WmfDrawingWand,
1686 XC(BR.x), YC(BR.y));
1687 draw_stroke_color_string(WmfDrawingWand,"none");
1688 (void) PopDrawingWand(WmfDrawingWand);
1693 static void ipa_udata_init(wmfAPI * API, wmfUserData_t * userdata)
1697 /* wmf_magick_t* ddata = WMF_MAGICK_GetData (API); */
1701 static void ipa_udata_copy(wmfAPI * API, wmfUserData_t * userdata)
1705 /* wmf_magick_t* ddata = WMF_MAGICK_GetData (API); */
1709 static void ipa_udata_set(wmfAPI * API, wmfUserData_t * userdata)
1713 /* wmf_magick_t* ddata = WMF_MAGICK_GetData (API); */
1717 static void ipa_udata_free(wmfAPI *API, wmfUserData_t *userdata)
1721 /* wmf_magick_t* ddata = WMF_MAGICK_GetData (API); */
1725 static void util_set_brush(wmfAPI *API, wmfDC *dc,const BrushApply brush_apply)
1728 *ddata = WMF_MAGICK_GetData(API);
1731 *brush = WMF_DC_BRUSH(dc);
1733 /* Set polygon fill rule */
1734 switch (WMF_DC_POLYFILL(dc)) /* Is this correct ?? */
1737 DrawSetClipRule(WmfDrawingWand,NonZeroRule);
1742 DrawSetClipRule(WmfDrawingWand,EvenOddRule);
1746 switch (WMF_BRUSH_STYLE(brush))
1748 case BS_SOLID /* 0 */:
1749 /* WMF_BRUSH_COLOR specifies brush color, WMF_BRUSH_HATCH
1752 if ( brush_apply == BrushApplyStroke )
1753 draw_stroke_color_rgb(API,WMF_BRUSH_COLOR(brush));
1755 draw_fill_color_rgb(API,WMF_BRUSH_COLOR(brush));
1758 case BS_HOLLOW /* 1 */: /* BS_HOLLOW & BS_NULL share enum */
1759 /* WMF_BRUSH_COLOR and WMF_BRUSH_HATCH ignored */
1761 if ( brush_apply == BrushApplyStroke )
1762 draw_stroke_color_string(WmfDrawingWand,"none");
1764 draw_fill_color_string(WmfDrawingWand,"none");
1767 case BS_HATCHED /* 2 */:
1768 /* WMF_BRUSH_COLOR specifies the hatch color, WMF_BRUSH_HATCH
1769 specifies the hatch brush style. If WMF_DC_OPAQUE, then
1770 WMF_DC_BACKGROUND specifies hatch background color. */
1772 DrawPushDefs(WmfDrawingWand);
1773 draw_pattern_push(API, ddata->pattern_id, 8, 8);
1774 (void) PushDrawingWand(WmfDrawingWand);
1776 if (WMF_DC_OPAQUE(dc))
1778 if ( brush_apply == BrushApplyStroke )
1779 draw_stroke_color_rgb(API,WMF_DC_BACKGROUND(dc));
1781 draw_fill_color_rgb(API,WMF_DC_BACKGROUND(dc));
1783 DrawRectangle(WmfDrawingWand, 0, 0, 7, 7 );
1786 DrawSetStrokeAntialias(WmfDrawingWand, MagickFalse);
1787 DrawSetStrokeWidth(WmfDrawingWand, 1);
1789 draw_stroke_color_rgb(API,WMF_BRUSH_COLOR(brush));
1791 switch ((unsigned int) WMF_BRUSH_HATCH(brush))
1794 case HS_HORIZONTAL: /* ----- */
1796 DrawLine(WmfDrawingWand, 0, 3, 7,3);
1799 case HS_VERTICAL: /* ||||| */
1801 DrawLine(WmfDrawingWand, 3, 0, 3, 7);
1804 case HS_FDIAGONAL: /* \\\\\ */
1806 DrawLine(WmfDrawingWand, 0, 0, 7, 7);
1809 case HS_BDIAGONAL: /* / */
1811 DrawLine(WmfDrawingWand, 0, 7, 7, 0 );
1814 case HS_CROSS: /* +++++ */
1816 DrawLine(WmfDrawingWand, 0, 3, 7, 3 );
1817 DrawLine(WmfDrawingWand, 3, 0, 3, 7 );
1820 case HS_DIAGCROSS: /* xxxxx */
1822 DrawLine(WmfDrawingWand, 0, 0, 7, 7 );
1823 DrawLine(WmfDrawingWand, 0, 7, 7, 0 );
1828 printf("util_set_brush: unexpected brush hatch enumeration %u\n",
1829 (unsigned int)WMF_BRUSH_HATCH(brush));
1832 (void) PopDrawingWand(WmfDrawingWand);
1833 (void) DrawPopPattern(WmfDrawingWand);
1834 DrawPopDefs(WmfDrawingWand);
1837 pattern_id[MagickPathExtent];
1839 (void) FormatLocaleString(pattern_id,MagickPathExtent,"#brush_%lu",
1841 if (brush_apply == BrushApplyStroke )
1842 (void) DrawSetStrokePatternURL(WmfDrawingWand,pattern_id);
1844 (void) DrawSetFillPatternURL(WmfDrawingWand,pattern_id);
1845 ++ddata->pattern_id;
1849 case BS_PATTERN /* 3 */:
1850 /* WMF_BRUSH_COLOR ignored, WMF_BRUSH_HATCH provides handle to
1853 printf("util_set_brush: BS_PATTERN not supported\n");
1856 case BS_INDEXED /* 4 */:
1858 printf("util_set_brush: BS_INDEXED not supported\n");
1861 case BS_DIBPATTERN /* 5 */:
1864 *brush_bmp = WMF_BRUSH_BITMAP(brush);
1866 if (brush_bmp && brush_bmp->data != 0)
1877 image = (Image*)brush_bmp->data;
1879 mode = CopyCompositeOp; /* Default is copy */
1880 switch (WMF_DC_ROP(dc))
1882 /* Binary raster ops */
1884 printf("util_set_brush: R2_BLACK ROP2 mode not supported!\n");
1886 case R2_NOTMERGEPEN:
1887 printf("util_set_brush: R2_NOTMERGEPEN ROP2 mode not supported!\n");
1890 printf("util_set_brush R2_MASKNOTPEN ROP2 mode not supported!\n");
1893 printf("util_set_brush: R2_NOTCOPYPEN ROP2 mode not supported!\n");
1896 printf("util_set_brush: R2_MASKPENNOT ROP2 mode not supported!\n");
1899 printf("util_set_brush: R2_NOT ROP2 mode not supported!\n");
1902 printf("util_set_brush: R2_XORPEN ROP2 mode not supported!\n");
1905 printf("util_set_brush: R2_NOTMASKPEN ROP2 mode not supported!\n");
1908 printf("util_set_brush: R2_MASKPEN ROP2 mode not supported!\n");
1911 printf("util_set_brush: R2_NOTXORPEN ROP2 mode not supported!\n");
1914 printf("util_set_brush: R2_NOP ROP2 mode not supported!\n");
1916 case R2_MERGENOTPEN:
1917 printf("util_set_brush: R2_MERGENOTPEN ROP2 mode not supported!\n");
1920 mode = CopyCompositeOp;
1922 case R2_MERGEPENNOT:
1923 printf("util_set_brush: R2_MERGEPENNOT ROP2 mode not supported!\n");
1926 printf("util_set_brush: R2_MERGEPEN ROP2 mode not supported!\n");
1929 printf("util_set_brush: R2_WHITE ROP2 mode not supported!\n");
1933 printf("util_set_brush: unexpected ROP2 enumeration %u!\n",
1934 (unsigned int)WMF_DC_ROP(dc));
1938 DrawPushDefs(WmfDrawingWand);
1939 draw_pattern_push(API, ddata->pattern_id, brush_bmp->width,
1941 magick_wand=NewMagickWandFromImage(image);
1942 (void) DrawComposite(WmfDrawingWand,mode, 0, 0, brush_bmp->width,
1943 brush_bmp->height, magick_wand);
1944 magick_wand=DestroyMagickWand(magick_wand);
1945 (void) DrawPopPattern(WmfDrawingWand);
1946 DrawPopDefs(WmfDrawingWand);
1950 pattern_id[MagickPathExtent];
1952 (void) FormatLocaleString(pattern_id,MagickPathExtent,"#brush_%lu",
1954 if ( brush_apply == BrushApplyStroke )
1955 (void) DrawSetStrokePatternURL(WmfDrawingWand,pattern_id);
1957 (void) DrawSetFillPatternURL(WmfDrawingWand,pattern_id);
1958 ++ddata->pattern_id;
1962 printf("util_set_brush: no BMP image data!\n");
1966 case BS_DIBPATTERNPT /* 6 */:
1967 /* WMF_BRUSH_COLOR ignored, WMF_BRUSH_HATCH provides pointer to
1970 printf("util_set_brush: BS_DIBPATTERNPT not supported\n");
1973 case BS_PATTERN8X8 /* 7 */:
1975 printf("util_set_brush: BS_PATTERN8X8 not supported\n");
1978 case BS_DIBPATTERN8X8 /* 8 */:
1980 printf("util_set_brush: BS_DIBPATTERN8X8 not supported\n");
1989 static void util_set_pen(wmfAPI * API, wmfDC * dc)
1992 *ddata = WMF_MAGICK_GetData(API);
2004 pen = WMF_DC_PEN(dc);
2006 pen_width = (WMF_PEN_WIDTH(pen) + WMF_PEN_HEIGHT(pen)) / 2;
2008 /* Pixel width is inverse of pixel scale */
2009 pixel_width = (((double) 1 / (ddata->scale_x)) +
2010 ((double) 1 / (ddata->scale_y))) / 2;
2012 /* Don't allow pen_width to be much less than pixel_width in order
2013 to avoid dissapearing or spider-web lines */
2014 pen_width = MagickMax(pen_width, pixel_width*0.8);
2016 pen_style = (unsigned int) WMF_PEN_STYLE(pen);
2018 /* Pen style specified? */
2019 if (pen_style == PS_NULL)
2021 draw_stroke_color_string(WmfDrawingWand,"none");
2025 DrawSetStrokeAntialias(WmfDrawingWand, MagickTrue );
2026 DrawSetStrokeWidth(WmfDrawingWand, (unsigned long) MagickMax(0.0, pen_width));
2032 switch ((unsigned int) WMF_PEN_ENDCAP(pen))
2034 case PS_ENDCAP_SQUARE:
2035 linecap = SquareCap;
2037 case PS_ENDCAP_ROUND:
2040 case PS_ENDCAP_FLAT:
2045 DrawSetStrokeLineCap(WmfDrawingWand, linecap);
2052 switch ((unsigned int) WMF_PEN_JOIN(pen))
2055 linejoin = BevelJoin;
2058 linejoin = RoundJoin;
2062 linejoin = MiterJoin;
2065 DrawSetStrokeLineJoin(WmfDrawingWand,linejoin);
2074 case PS_DASH: /* ------- */
2077 dasharray[0] = pixel_width * 18;
2078 dasharray[1] = pixel_width * 7;
2081 DrawSetStrokeAntialias(WmfDrawingWand,MagickFalse);
2082 (void) DrawSetStrokeDashArray(WmfDrawingWand,2,dasharray);
2086 case PS_DOT: /* ....... */
2089 dasharray[0] = pixel_width * 3;
2090 dasharray[1] = pixel_width * 3;
2093 DrawSetStrokeAntialias(WmfDrawingWand,MagickFalse);
2094 (void) DrawSetStrokeDashArray(WmfDrawingWand,2,dasharray);
2097 case PS_DASHDOT: /* _._._._ */
2099 /* Pattern 9,6,3,6 */
2100 dasharray[0] = pixel_width * 9;
2101 dasharray[1] = pixel_width * 6;
2102 dasharray[2] = pixel_width * 3;
2103 dasharray[3] = pixel_width * 6;
2106 DrawSetStrokeAntialias(WmfDrawingWand,MagickFalse);
2107 (void) DrawSetStrokeDashArray(WmfDrawingWand,4,dasharray);
2110 case PS_DASHDOTDOT: /* _.._.._ */
2112 /* Pattern 9,3,3,3,3,3 */
2113 dasharray[0] = pixel_width * 9;
2114 dasharray[1] = pixel_width * 3;
2115 dasharray[2] = pixel_width * 3;
2116 dasharray[3] = pixel_width * 3;
2117 dasharray[4] = pixel_width * 3;
2118 dasharray[5] = pixel_width * 3;
2121 DrawSetStrokeAntialias(WmfDrawingWand,MagickFalse);
2122 (void) DrawSetStrokeDashArray(WmfDrawingWand,6,dasharray);
2125 case PS_INSIDEFRAME: /* There is nothing to do in this case... */
2129 (void) DrawSetStrokeDashArray(WmfDrawingWand,0,(double *) NULL);
2135 draw_stroke_color_rgb(API,WMF_PEN_COLOR(pen));
2138 /* Estimate font pointsize based on Windows font parameters */
2139 static double util_pointsize( wmfAPI* API, wmfFont* font, char* str, double font_height, ExceptionInfo *exception)
2142 *ddata = WMF_MAGICK_GetData(API);
2145 *image = ddata->image;
2156 draw_info=ddata->draw_info;
2157 if (draw_info == (const DrawInfo *) NULL)
2160 draw_info->font=WMF_FONT_PSNAME(font);
2161 draw_info->pointsize=font_height;
2162 draw_info->text=str;
2164 if (GetTypeMetrics(image, draw_info, &metrics, exception) != MagickFalse)
2167 if (strlen(str) == 1)
2169 pointsize = (font_height *
2170 ( font_height / (metrics.ascent + fabs(metrics.descent))));
2171 draw_info->pointsize = pointsize;
2172 if (GetTypeMetrics(image, draw_info, &metrics, exception) != MagickFalse)
2173 pointsize *= (font_height / ( metrics.ascent + fabs(metrics.descent)));
2177 pointsize = (font_height * (font_height / (metrics.height)));
2178 draw_info->pointsize = pointsize;
2179 if (GetTypeMetrics(image, draw_info, &metrics, exception) != MagickFalse)
2180 pointsize *= (font_height / metrics.height);
2184 draw_info.pointsize = pointsize;
2185 if (GetTypeMetrics(image, &draw_info, &metrics, exception) != MagickFalse)
2186 pointsize *= (font_height / (metrics.ascent + fabs(metrics.descent)));
2187 pointsize *= 1.114286; /* Magic number computed through trial and error */
2191 draw_info->font=NULL;
2192 draw_info->text=NULL;
2194 printf("String = %s\n", str);
2195 printf("Font = %s\n", WMF_FONT_PSNAME(font));
2196 printf("lfHeight = %g\n", font_height);
2197 printf("bounds = %g,%g %g,%g\n", metrics.bounds.x1, metrics.bounds.y1,
2198 metrics.bounds.x2,metrics.bounds.y2);
2199 printf("ascent = %g\n", metrics.ascent);
2200 printf("descent = %g\n", metrics.descent);
2201 printf("height = %g\n", metrics.height);
2202 printf("Pointsize = %g\n", pointsize);
2205 return floor(pointsize);
2208 #if defined(MAGICKCORE_WMF_DELEGATE)
2209 /* Estimate weight based on font name */
2211 static int util_font_weight( const char* font )
2217 if ((strstr(font,"Normal") || strstr(font,"Regular")))
2219 else if ( strstr(font,"Bold") )
2222 if ((strstr(font,"Semi") || strstr(font,"Demi")))
2224 if ( (strstr(font,"Extra") || strstr(font,"Ultra")))
2227 else if ( strstr(font,"Light") )
2230 if ( (strstr(font,"Extra") || strstr(font,"Ultra")))
2233 else if ((strstr(font,"Heavy") || strstr(font,"Black")))
2235 else if ( strstr(font,"Thin") )
2242 * Returns width of string in points, assuming (unstretched) font size of 1pt
2243 * (similar to wmf_ipa_font_stringwidth)
2245 * This extremely odd at best, particularly since player/meta.h has access
2246 * to the corrected font_height (as drawtext.font_height) when it invokes the
2247 * stringwidth callback. It should be possible to compute the real stringwidth!
2249 static float lite_font_stringwidth( wmfAPI* API, wmfFont* font, char* str)
2253 *ddata = WMF_MAGICK_GetData(API);
2256 *image = ddata->image;
2275 orig_resolution_units;
2277 orig_x_resolution = image->resolution.x;
2278 orig_y_resolution = image->resolution.y;
2279 orig_resolution_units = image->units;
2281 draw_info=ddata->draw_info;
2282 if (draw_info == (const DrawInfo *) NULL)
2285 draw_info->font=WMF_FONT_PSNAME(font);
2286 draw_info->pointsize=12;
2287 draw_info->text=str;
2289 image->resolution.x = 72;
2290 image->resolution.y = 72;
2291 image->units = PixelsPerInchResolution;
2293 exception=ddata->exception;
2294 if (GetTypeMetrics(image, draw_info, &metrics, exception) != MagickFalse)
2295 stringwidth = ((metrics.width * 72)/(image->resolution.x * draw_info->pointsize)); /* *0.916348; */
2297 draw_info->font=NULL;
2298 draw_info->text=NULL;
2301 printf("\nlite_font_stringwidth\n");
2302 printf("string = \"%s\"\n", str);
2303 printf("WMF_FONT_NAME = \"%s\"\n", WMF_FONT_NAME(font));
2304 printf("WMF_FONT_PSNAME = \"%s\"\n", WMF_FONT_PSNAME(font));
2305 printf("stringwidth = %g\n", stringwidth);
2306 /* printf("WMF_FONT_HEIGHT = %i\n", (int)WMF_FONT_HEIGHT(font)); */
2307 /* printf("WMF_FONT_WIDTH = %i\n", (int)WMF_FONT_WIDTH(font)); */
2311 image->resolution.x = orig_x_resolution;
2312 image->resolution.y = orig_y_resolution;
2313 image->units = orig_resolution_units;
2325 /* Map font (similar to wmf_ipa_font_map) */
2327 /* Mappings to Postscript fonts: family, normal, italic, bold, bolditalic */
2328 static wmfFontMap WMFFontMap[] = {
2329 { (char *) "Courier", (char *) "Courier",
2330 (char *) "Courier-Oblique", (char *) "Courier-Bold",
2331 (char *) "Courier-BoldOblique" },
2332 { (char *) "Helvetica", (char *) "Helvetica",
2333 (char *) "Helvetica-Oblique", (char *) "Helvetica-Bold",
2334 (char *) "Helvetica-BoldOblique" },
2335 { (char *) "Modern", (char *) "Courier",
2336 (char *) "Courier-Oblique", (char *) "Courier-Bold",
2337 (char *) "Courier-BoldOblique" },
2338 { (char *) "Monotype Corsiva", (char *) "Courier",
2339 (char *) "Courier-Oblique", (char *) "Courier-Bold",
2340 (char *) "Courier-BoldOblique" },
2341 { (char *) "News Gothic", (char *) "Helvetica",
2342 (char *) "Helvetica-Oblique", (char *) "Helvetica-Bold",
2343 (char *) "Helvetica-BoldOblique" },
2344 { (char *) "Symbol", (char *) "Symbol",
2345 (char *) "Symbol", (char *) "Symbol",
2346 (char *) "Symbol" },
2347 { (char *) "System", (char *) "Courier",
2348 (char *) "Courier-Oblique", (char *) "Courier-Bold",
2349 (char *) "Courier-BoldOblique" },
2350 { (char *) "Times", (char *) "Times-Roman",
2351 (char *) "Times-Italic", (char *) "Times-Bold",
2352 (char *) "Times-BoldItalic" },
2353 { (char *) NULL, (char *) NULL,
2354 (char *) NULL, (char *) NULL,
2359 /* Mapping between base name and Ghostscript family name */
2360 static wmfMapping SubFontMap[] =
2362 { (char *) "Arial", (char *) "Helvetica", FT_ENCODING_NONE },
2363 { (char *) "Courier", (char *) "Courier", FT_ENCODING_NONE },
2364 { (char *) "Fixed", (char *) "Courier", FT_ENCODING_NONE },
2365 { (char *) "Helvetica", (char *) "Helvetica", FT_ENCODING_NONE },
2366 { (char *) "Sans", (char *) "Helvetica", FT_ENCODING_NONE },
2367 { (char *) "Sym", (char *) "Symbol", FT_ENCODING_NONE },
2368 { (char *) "Terminal", (char *) "Courier", FT_ENCODING_NONE },
2369 { (char *) "Times", (char *) "Times", FT_ENCODING_NONE },
2370 { (char *) "Wingdings", (char *) "Symbol", FT_ENCODING_NONE },
2371 { (char *) NULL, (char *) NULL, FT_ENCODING_NONE }
2374 static void lite_font_map( wmfAPI* API, wmfFont* font)
2383 *ddata = WMF_MAGICK_GetData(API);
2398 font_data = (wmfFontData*)API->font_data;
2399 font->user_data = font_data->user_data;
2400 magick_font = (wmf_magick_font_t*)font->user_data;
2401 wmf_font_name = WMF_FONT_NAME(font);
2403 if (magick_font->ps_name != (char *) NULL)
2404 magick_font->ps_name=DestroyString(magick_font->ps_name);
2406 exception=ddata->exception;
2407 type_info_base=GetTypeInfo("*",exception);
2408 if (type_info_base == 0)
2411 /* Certain short-hand font names are not the proper Windows names
2412 and should be promoted to the proper names */
2413 if (LocaleCompare(wmf_font_name,"Times") == 0)
2414 wmf_font_name = "Times New Roman";
2415 else if (LocaleCompare(wmf_font_name,"Courier") == 0)
2416 wmf_font_name = "Courier New";
2418 /* Look for a family-based best-match */
2419 if (!magick_font->ps_name)
2424 if (WMF_FONT_WEIGHT(font) == 0)
2425 target_weight = 400;
2427 target_weight = WMF_FONT_WEIGHT(font);
2428 type_info=GetTypeInfoByFamily(wmf_font_name,AnyStyle,AnyStretch,
2429 target_weight,exception);
2430 if (type_info == (const TypeInfo *) NULL)
2431 type_info=GetTypeInfoByFamily(wmf_font_name,AnyStyle,AnyStretch,0,
2433 if (type_info != (const TypeInfo *) NULL)
2434 CloneString(&magick_font->ps_name,type_info->name);
2437 /* Now let's try simple substitution mappings from WMFFontMap */
2438 if (!magick_font->ps_name)
2441 target[MagickPathExtent];
2444 target_weight = 400,
2445 want_italic = MagickFalse,
2446 want_bold = MagickFalse,
2449 if ( WMF_FONT_WEIGHT(font) != 0 )
2450 target_weight = WMF_FONT_WEIGHT(font);
2452 if ( (target_weight > 550) || ((strstr(wmf_font_name,"Bold") ||
2453 strstr(wmf_font_name,"Heavy") ||
2454 strstr(wmf_font_name,"Black"))) )
2455 want_bold = MagickTrue;
2457 if ( (WMF_FONT_ITALIC(font)) || ((strstr(wmf_font_name,"Italic") ||
2458 strstr(wmf_font_name,"Oblique"))) )
2459 want_italic = MagickTrue;
2461 (void) CopyMagickString(target,"Times",MagickPathExtent);
2462 for( i=0; SubFontMap[i].name != NULL; i++ )
2464 if (LocaleCompare(wmf_font_name, SubFontMap[i].name) == 0)
2466 (void) CopyMagickString(target,SubFontMap[i].mapping,
2472 for( i=0; WMFFontMap[i].name != NULL; i++ )
2474 if (LocaleNCompare(WMFFontMap[i].name,target,strlen(WMFFontMap[i].name)) == 0)
2476 if (want_bold && want_italic)
2477 CloneString(&magick_font->ps_name,WMFFontMap[i].bolditalic);
2478 else if (want_italic)
2479 CloneString(&magick_font->ps_name,WMFFontMap[i].italic);
2481 CloneString(&magick_font->ps_name,WMFFontMap[i].bold);
2483 CloneString(&magick_font->ps_name,WMFFontMap[i].normal);
2489 printf("\nlite_font_map\n");
2490 printf("WMF_FONT_NAME = \"%s\"\n", WMF_FONT_NAME(font));
2491 printf("WMF_FONT_WEIGHT = %i\n", WMF_FONT_WEIGHT(font));
2492 printf("WMF_FONT_PSNAME = \"%s\"\n", WMF_FONT_PSNAME(font));
2498 /* Initialize API font structures */
2499 static void lite_font_init( wmfAPI* API, wmfAPI_Options* options)
2507 /* Allocate wmfFontData data structure */
2508 API->font_data = wmf_malloc(API,sizeof(wmfFontData));
2512 font_data = (wmfFontData*)API->font_data;
2514 /* Assign function to map font (type wmfMap) */
2515 font_data->map = lite_font_map;
2517 /* Assign function to return string width in points (type wmfStringWidth) */
2518 font_data->stringwidth = lite_font_stringwidth;
2520 /* Assign user data, not used by libwmflite (type void*) */
2521 font_data->user_data = wmf_malloc(API,sizeof(wmf_magick_font_t));
2524 ((wmf_magick_font_t*)font_data->user_data)->ps_name = 0;
2525 ((wmf_magick_font_t*)font_data->user_data)->pointsize = 0;
2528 #endif /* MAGICKCORE_WMF_DELEGATE */
2530 /* BLOB read byte */
2531 static int ipa_blob_read(void* wand)
2533 return ReadBlobByte((Image*)wand);
2537 static int ipa_blob_seek(void* wand,long position)
2539 return (int)SeekBlob((Image*)wand,(MagickOffsetType) position,SEEK_SET);
2543 static long ipa_blob_tell(void* wand)
2545 return (long)TellBlob((Image*)wand);
2548 static Image *ReadWMFImage(const ImageInfo *image_info,ExceptionInfo *exception)
2572 wmf_options_flags = 0;
2589 image=AcquireImage(image_info,exception);
2590 if (OpenBlob(image_info,image,ReadBinaryBlobMode,exception) == MagickFalse)
2592 if (image->debug != MagickFalse)
2594 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2595 " OpenBlob failed");
2596 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2597 "leave ReadWMFImage()");
2599 image=DestroyImageList(image);
2600 return((Image *) NULL);
2608 /* Register callbacks */
2609 wmf_options_flags |= WMF_OPT_FUNCTION;
2610 (void) memset(&wmf_api_options, 0, sizeof(wmf_api_options));
2611 wmf_api_options.function = ipa_functions;
2613 /* Ignore non-fatal errors */
2614 wmf_options_flags |= WMF_OPT_IGNORE_NONFATAL;
2616 wmf_error = wmf_api_create(&API, wmf_options_flags, &wmf_api_options);
2617 if (wmf_error != wmf_E_None)
2619 if (image->debug != MagickFalse)
2621 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2622 " wmf_api_create failed");
2623 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2624 "leave ReadWMFImage()");
2627 wmf_api_destroy(API);
2628 ThrowReaderException(DelegateError,"UnableToInitializeWMFLibrary");
2631 /* Register progress monitor */
2632 wmf_status_function(API,image,magick_progress_callback);
2634 ddata=WMF_MAGICK_GetData(API);
2636 ddata->image_info=image_info;
2637 ddata->draw_info=CloneDrawInfo(image_info,(const DrawInfo *) NULL);
2638 ddata->exception=exception;
2639 ddata->draw_info->font=(char *)
2640 RelinquishMagickMemory(ddata->draw_info->font);
2641 ddata->draw_info->text=(char *)
2642 RelinquishMagickMemory(ddata->draw_info->text);
2644 #if defined(MAGICKCORE_WMF_DELEGATE)
2645 /* Must initialize font subystem for WMFlite interface */
2646 lite_font_init (API,&wmf_api_options); /* similar to wmf_ipa_font_init in src/font.c */
2647 /* wmf_arg_fontdirs (API,options); */ /* similar to wmf_arg_fontdirs in src/wmf.c */
2652 * Open BLOB input via libwmf API
2655 wmf_error = wmf_bbuf_input(API,ipa_blob_read,ipa_blob_seek,
2656 ipa_blob_tell,(void*)image);
2657 if (wmf_error != wmf_E_None)
2659 if (image->debug != MagickFalse)
2661 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2662 " wmf_bbuf_input failed");
2663 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2664 "leave ReadWMFImage()");
2666 wmf_api_destroy(API);
2667 ThrowFileException(exception,FileOpenError,"UnableToOpenFile",
2669 image=DestroyImageList(image);
2670 return((Image *) NULL);
2677 if (image->debug != MagickFalse)
2678 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2679 " Scanning WMF to obtain bounding box");
2680 wmf_error=wmf_scan(API, 0, &bbox);
2681 if (wmf_error != wmf_E_None)
2683 if (image->debug != MagickFalse)
2685 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2686 " wmf_scan failed with wmf_error %d", wmf_error);
2687 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2688 "leave ReadWMFImage()");
2690 ipa_device_close(API);
2691 wmf_api_destroy(API);
2692 ThrowReaderException(DelegateError,"FailedToScanFile");
2696 * Compute dimensions and scale factors
2702 /* User specified resolution */
2703 resolution_y=DefaultResolution;
2704 if (image->resolution.y != 0.0)
2706 resolution_y = image->resolution.y;
2707 if (image->units == PixelsPerCentimeterResolution)
2708 resolution_y *= CENTIMETERS_PER_INCH;
2710 resolution_x=DefaultResolution;
2711 if (image->resolution.x != 0.0)
2713 resolution_x = image->resolution.x;
2714 if (image->units == PixelsPerCentimeterResolution)
2715 resolution_x *= CENTIMETERS_PER_INCH;
2718 /* Obtain output size expressed in metafile units */
2719 wmf_error=wmf_size(API,&wmf_width,&wmf_height);
2720 if (wmf_error != wmf_E_None)
2722 if (image->debug != MagickFalse)
2724 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2725 " wmf_size failed with wmf_error %d", wmf_error);
2726 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2727 "leave ReadWMFImage()");
2729 wmf_api_destroy(API);
2730 ThrowReaderException(DelegateError,"FailedToComputeOutputSize");
2733 /* Obtain (or guess) metafile units */
2734 if ((API)->File->placeable)
2735 units_per_inch=(API)->File->pmh->Inch;
2736 else if ( (wmf_width*wmf_height) < 1024*1024)
2737 units_per_inch=POINTS_PER_INCH; /* MM_TEXT */
2739 units_per_inch=TWIPS_PER_INCH; /* MM_TWIPS */
2741 /* Calculate image width and height based on specified DPI
2743 image_width_inch = (double) wmf_width / units_per_inch;
2744 image_height_inch = (double) wmf_height / units_per_inch;
2745 image_width = image_width_inch * resolution_x;
2746 image_height = image_height_inch * resolution_y;
2748 /* Compute bounding box scale factors and origin translations
2750 * This all just a hack since libwmf does not currently seem to
2751 * provide the mapping between LOGICAL coordinates and DEVICE
2752 * coordinates. This mapping is necessary in order to know
2753 * where to place the logical bounding box within the image.
2757 bounding_width = bbox.BR.x - bbox.TL.x;
2758 bounding_height = bbox.BR.y - bbox.TL.y;
2760 ddata->scale_x = image_width/bounding_width;
2761 ddata->translate_x = 0-bbox.TL.x;
2764 /* Heuristic: guess that if the vertical coordinates mostly span
2765 negative values, then the image must be inverted. */
2766 if ( fabs(bbox.BR.y) > fabs(bbox.TL.y) )
2768 /* Normal (Origin at top left of image) */
2769 ddata->scale_y = (image_height/bounding_height);
2770 ddata->translate_y = 0-bbox.TL.y;
2774 /* Inverted (Origin at bottom left of image) */
2775 ddata->scale_y = (-image_height/bounding_height);
2776 ddata->translate_y = 0-bbox.BR.y;
2779 if (image->debug != MagickFalse)
2781 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2782 " Placeable metafile: %s",
2783 (API)->File->placeable ? "Yes" : "No");
2785 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2786 " Size in metafile units: %gx%g",wmf_width,wmf_height);
2787 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2788 " Metafile units/inch: %g",units_per_inch);
2789 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2790 " Size in inches: %gx%g",
2791 image_width_inch,image_height_inch);
2792 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2793 " Bounding Box: %g,%g %g,%g",
2794 bbox.TL.x, bbox.TL.y, bbox.BR.x, bbox.BR.y);
2795 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2796 " Bounding width x height: %gx%g",bounding_width,
2798 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2799 " Output resolution: %gx%g",resolution_x,resolution_y);
2800 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2801 " Image size: %gx%g",image_width,image_height);
2802 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2803 " Bounding box scale factor: %g,%g",ddata->scale_x,
2805 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2806 " Translation: %g,%g",
2807 ddata->translate_x, ddata->translate_y);
2813 typedef struct _wmfPlayer_t wmfPlayer_t;
2817 wmfBrush default_brush;
2818 wmfFont default_font;
2820 wmfDC* dc; /* current dc */
2826 #define WMF_ELICIT_DC(API) (((wmfPlayer_t*)((API)->player_data))->dc)
2828 dc = WMF_ELICIT_DC(API);
2830 printf("dc->Window.Ox = %d\n", dc->Window.Ox);
2831 printf("dc->Window.Oy = %d\n", dc->Window.Oy);
2832 printf("dc->Window.width = %d\n", dc->Window.width);
2833 printf("dc->Window.height = %d\n", dc->Window.height);
2834 printf("dc->pixel_width = %g\n", dc->pixel_width);
2835 printf("dc->pixel_height = %g\n", dc->pixel_height);
2836 #if defined(MAGICKCORE_WMF_DELEGATE) /* Only in libwmf 0.3 */
2837 printf("dc->Ox = %.d\n", dc->Ox);
2838 printf("dc->Oy = %.d\n", dc->Oy);
2839 printf("dc->width = %.d\n", dc->width);
2840 printf("dc->height = %.d\n", dc->height);
2849 * Create canvas image
2852 image->rows=(unsigned long) ceil(image_height);
2853 image->columns=(unsigned long) ceil(image_width);
2855 if (image_info->ping != MagickFalse)
2857 wmf_api_destroy(API);
2858 (void) CloseBlob(image);
2859 if (image->debug != MagickFalse)
2860 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2861 "leave ReadWMFImage()");
2862 return(GetFirstImageInList(image));
2864 status=SetImageExtent(image,image->columns,image->rows,exception);
2865 if (status == MagickFalse)
2866 return(DestroyImageList(image));
2867 if (image->debug != MagickFalse)
2868 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2869 " Creating canvas image with size %lux%lu",(unsigned long) image->rows,
2870 (unsigned long) image->columns);
2873 * Set solid background color
2876 image->background_color = image_info->background_color;
2877 if (image->background_color.alpha != OpaqueAlpha)
2878 image->alpha_trait=BlendPixelTrait;
2879 (void) SetImageBackgroundColor(image,exception);
2882 * Play file to generate Vector drawing commands
2886 if (image->debug != MagickFalse)
2887 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2888 " Playing WMF to prepare vectors");
2890 wmf_error = wmf_play(API, 0, &bbox);
2891 if (wmf_error != wmf_E_None)
2893 if (image->debug != MagickFalse)
2895 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2896 " Playing WMF failed with wmf_error %d", wmf_error);
2897 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2898 "leave ReadWMFImage()");
2900 wmf_api_destroy(API);
2901 ThrowReaderException(DelegateError,"FailedToRenderFile");
2905 * Scribble on canvas image
2909 if (image->debug != MagickFalse)
2910 (void) LogMagickEvent(CoderEvent,GetMagickModule(),
2911 " Rendering WMF vectors");
2912 DrawRender(ddata->draw_wand);
2914 if (image->debug != MagickFalse)
2915 (void) LogMagickEvent(CoderEvent,GetMagickModule(),"leave ReadWMFImage()");
2917 /* Cleanup allocated data */
2918 wmf_api_destroy(API);
2919 (void) CloseBlob(image);
2927 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2931 % R e g i s t e r W M F I m a g e %
2935 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2937 % RegisterWMFImage() adds attributes for the WMF image format to
2938 % the list of supported formats. The attributes include the image format
2939 % tag, a method to read and/or write the format, whether the format
2940 % supports the saving of more than one frame to the same file or blob,
2941 % whether the format supports native in-memory I/O, and a brief
2942 % description of the format.
2944 % The format of the RegisterWMFImage method is:
2946 % size_t RegisterWMFImage(void)
2949 ModuleExport size_t RegisterWMFImage(void)
2954 entry = AcquireMagickInfo("WMF","WMZ","Compressed Windows Meta File");
2955 #if defined(MAGICKCORE_SANS_DELEGATE) || defined(MAGICKCORE_WMF_DELEGATE)
2956 entry->decoder=ReadWMFImage;
2958 entry->flags|=CoderDecoderSeekableStreamFlag;
2959 (void) RegisterMagickInfo(entry);
2960 entry=AcquireMagickInfo("WMF","WMF","Windows Meta File");
2961 #if defined(MAGICKCORE_SANS_DELEGATE) || defined(MAGICKCORE_WMF_DELEGATE)
2962 entry->decoder=ReadWMFImage;
2964 (void) RegisterMagickInfo(entry);
2965 return(MagickImageCoderSignature);
2969 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2973 % U n r e g i s t e r W M F I m a g e %
2977 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2979 % UnregisterWMFImage() removes format registrations made by the
2980 % WMF module from the list of supported formats.
2982 % The format of the UnregisterWMFImage method is:
2984 % UnregisterWMFImage(void)
2987 ModuleExport void UnregisterWMFImage(void)
2989 (void) UnregisterMagickInfo("WMZ");
2990 (void) UnregisterMagickInfo("WMF");