granicus.if.org Git - imagemagick/blob - MagickCore/nt-feature.c

   1 /*
   2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   3 %                                                                             %
   4 %                                                                             %
   5 %                                                                             %
   6 %                                                                             %
   7 %                                 N   N  TTTTT                                %
   8 %                                 NN  N    T                                  %
   9 %                                 N N N    T                                  %
  10 %                                 N  NN    T                                  %
  11 %                                 N   N    T                                  %
  12 %                                                                             %
  13 %                                                                             %
  14 %                   Windows NT Feature Methods for MagickCore                 %
  15 %                                                                             %
  16 %                               Software Design                               %
  17 %                                 John Cristy                                 %
  18 %                                December 1996                                %
  19 %                                                                             %
  20 %                                                                             %
  21 %  Copyright 1999-2012 ImageMagick Studio LLC, a non-profit organization      %
  22 %  dedicated to making software imaging solutions freely available.           %
  23 %                                                                             %
  24 %  You may not use this file except in compliance with the License.  You may  %
  25 %  obtain a copy of the License at                                            %
  26 %                                                                             %
  27 %    http://www.imagemagick.org/script/license.php                            %
  28 %                                                                             %
  29 %  Unless required by applicable law or agreed to in writing, software        %
  30 %  distributed under the License is distributed on an "AS IS" BASIS,          %
  31 %  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %
  32 %  See the License for the specific language governing permissions and        %
  33 %  limitations under the License.                                             %
  34 %                                                                             %
  35 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  36 %
  37 %
  38 */
  39 \f
  40 /*
  41   Include declarations.
  42 */
  43 #include "MagickCore/studio.h"
  44 #if defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__CYGWIN__)
  45 #define WIN32_LEAN_AND_MEAN
  46 #define VC_EXTRALEAN
  47 #include <windows.h>
  48 #include "MagickCore/cache.h"
  49 #include "MagickCore/colorspace.h"
  50 #include "MagickCore/colorspace-private.h"
  51 #include "MagickCore/draw.h"
  52 #include "MagickCore/exception.h"
  53 #include "MagickCore/exception-private.h"
  54 #include "MagickCore/image-private.h"
  55 #include "MagickCore/memory_.h"
  56 #include "MagickCore/monitor.h"
  57 #include "MagickCore/monitor-private.h"
  58 #include "MagickCore/nt-base.h"
  59 #include "MagickCore/nt-base-private.h"
  60 #include "MagickCore/pixel-accessor.h"
  61 #include "MagickCore/quantum.h"
  62 #include "MagickCore/string_.h"
  63 #include "MagickCore/token.h"
  64 #include "MagickCore/splay-tree.h"
  65 #include "MagickCore/utility.h"
  66 #include "MagickCore/nt-base-private.h"
  67 \f
  68 /*
  69 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  70 %                                                                             %
  71 %                                                                             %
  72 %                                                                             %
  73 %   C r o p I m a g e T o H B i t m a p                                       %
  74 %                                                                             %
  75 %                                                                             %
  76 %                                                                             %
  77 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  78 %
  79 %  CropImageToHBITMAP() extracts a specified region of the image and returns
  80 %  it as a Windows HBITMAP. While the same functionality can be accomplished by
  81 %  invoking CropImage() followed by ImageToHBITMAP(), this method is more
  82 %  efficient since it copies pixels directly to the HBITMAP.
  83 %
  84 %  The format of the CropImageToHBITMAP method is:
  85 %
  86 %      HBITMAP CropImageToHBITMAP(Image* image,const RectangleInfo *geometry,
  87 %        ExceptionInfo *exception)
  88 %
  89 %  A description of each parameter follows:
  90 %
  91 %    o image: the image.
  92 %
  93 %    o geometry: Define the region of the image to crop with members
  94 %      x, y, width, and height.
  95 %
  96 %    o exception: return any errors or warnings in this structure.
  97 %
  98 */
  99 MagickExport void *CropImageToHBITMAP(Image *image,
 100   const RectangleInfo *geometry,ExceptionInfo *exception)
 101 {
 102 #define CropImageTag  "Crop/Image"
 103
 104   BITMAP
 105     bitmap;
 106
 107   HBITMAP
 108     bitmapH;
 109
 110   HANDLE
 111     bitmap_bitsH;
 112
 113   MagickBooleanType
 114     proceed;
 115
 116   RectangleInfo
 117     page;
 118
 119   register const Quantum
 120     *p;
 121
 122   register RGBQUAD
 123     *q;
 124
 125   RGBQUAD
 126     *bitmap_bits;
 127
 128   ssize_t
 129     y;
 130
 131   /*
 132     Check crop geometry.
 133   */
 134   assert(image != (const Image *) NULL);
 135   assert(image->signature == MagickSignature);
 136   if (image->debug != MagickFalse)
 137     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 138   assert(geometry != (const RectangleInfo *) NULL);
 139   assert(exception != (ExceptionInfo *) NULL);
 140   assert(exception->signature == MagickSignature);
 141   if (((geometry->x+(ssize_t) geometry->width) < 0) ||
 142       ((geometry->y+(ssize_t) geometry->height) < 0) ||
 143       (geometry->x >= (ssize_t) image->columns) ||
 144       (geometry->y >= (ssize_t) image->rows))
 145     ThrowImageException(OptionError,"GeometryDoesNotContainImage");
 146   page=(*geometry);
 147   if ((page.x+(ssize_t) page.width) > (ssize_t) image->columns)
 148     page.width=image->columns-page.x;
 149   if ((page.y+(ssize_t) page.height) > (ssize_t) image->rows)
 150     page.height=image->rows-page.y;
 151   if (page.x < 0)
 152     {
 153       page.width+=page.x;
 154       page.x=0;
 155     }
 156   if (page.y < 0)
 157     {
 158       page.height+=page.y;
 159       page.y=0;
 160     }
 161
 162   if ((page.width == 0) || (page.height == 0))
 163     ThrowImageException(OptionError,"GeometryDimensionsAreZero");
 164   /*
 165     Initialize crop image attributes.
 166   */
 167   bitmap.bmType         = 0;
 168   bitmap.bmWidth        = (LONG) page.width;
 169   bitmap.bmHeight       = (LONG) page.height;
 170   bitmap.bmWidthBytes   = bitmap.bmWidth * 4;
 171   bitmap.bmPlanes       = 1;
 172   bitmap.bmBitsPixel    = 32;
 173   bitmap.bmBits         = NULL;
 174
 175   bitmap_bitsH=(HANDLE) GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE,page.width*
 176     page.height*bitmap.bmBitsPixel);
 177   if (bitmap_bitsH == NULL)
 178     return(NULL);
 179   bitmap_bits=(RGBQUAD *) GlobalLock((HGLOBAL) bitmap_bitsH);
 180   if ( bitmap.bmBits == NULL )
 181     bitmap.bmBits = bitmap_bits;
 182   if (IssRGBCompatibleColorspace(image->colorspace) == MagickFalse)
 183     TransformImageColorspace(image,sRGBColorspace,exception);
 184   /*
 185     Extract crop image.
 186   */
 187   q=bitmap_bits;
 188   for (y=0; y < (ssize_t) page.height; y++)
 189   {
 190     register ssize_t
 191       x;
 192
 193     p=GetVirtualPixels(image,page.x,page.y+y,page.width,1,exception);
 194     if (p == (const Quantum *) NULL)
 195       break;
 196
 197     /* Transfer pixels, scaling to Quantum */
 198     for( x=(ssize_t) page.width ; x> 0 ; x-- )
 199     {
 200       q->rgbRed = ScaleQuantumToChar(GetPixelRed(image,p));
 201       q->rgbGreen = ScaleQuantumToChar(GetPixelGreen(image,p));
 202       q->rgbBlue = ScaleQuantumToChar(GetPixelBlue(image,p));
 203       q->rgbReserved = 0;
 204       p+=GetPixelChannels(image);
 205       q++;
 206     }
 207     proceed=SetImageProgress(image,CropImageTag,y,page.height);
 208     if (proceed == MagickFalse)
 209       break;
 210   }
 211   if (y < (ssize_t) page.height)
 212     {
 213       GlobalUnlock((HGLOBAL) bitmap_bitsH);
 214       GlobalFree((HGLOBAL) bitmap_bitsH);
 215       return((void *) NULL);
 216     }
 217   bitmap.bmBits=bitmap_bits;
 218   bitmapH=CreateBitmapIndirect(&bitmap);
 219   GlobalUnlock((HGLOBAL) bitmap_bitsH);
 220   GlobalFree((HGLOBAL) bitmap_bitsH);
 221   return((void *) bitmapH);
 222 }
 223 \f
 224 /*
 225 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 226 %                                                                             %
 227 %                                                                             %
 228 %                                                                             %
 229 %   I s M a g i c k C o n f l i c t                                           %
 230 %                                                                             %
 231 %                                                                             %
 232 %                                                                             %
 233 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 234 %
 235 %  IsMagickConflict() returns true if the image format conflicts with a logical
 236 %  drive (.e.g. X:).
 237 %
 238 %  The format of the IsMagickConflict method is:
 239 %
 240 %      MagickBooleanType IsMagickConflict(const char *magick)
 241 %
 242 %  A description of each parameter follows:
 243 %
 244 %    o magick: Specifies the image format.
 245 %
 246 */
 247 MagickExport MagickBooleanType NTIsMagickConflict(const char *magick)
 248 {
 249   MagickBooleanType
 250     status;
 251
 252   assert(magick != (char *) NULL);
 253   if (strlen(magick) > 1)
 254     return(MagickFalse);
 255   status=(GetLogicalDrives() & (1 << ((toupper((int) (*magick)))-'A'))) != 0 ?
 256     MagickTrue : MagickFalse;
 257   return(status);
 258 }
 259 \f
 260 /*
 261 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 262 %                                                                             %
 263 %                                                                             %
 264 %                                                                             %
 265 +   N T G e t T y pe L i s t                                                  %
 266 %                                                                             %
 267 %                                                                             %
 268 %                                                                             %
 269 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 270 %
 271 %  NTLoadTypeLists() loads a Windows TrueType fonts.
 272 %
 273 %  The format of the NTLoadTypeLists method is:
 274 %
 275 %      MagickBooleanType NTLoadTypeLists(SplayTreeInfo *type_list)
 276 %
 277 %  A description of each parameter follows:
 278 %
 279 %    o type_list: A linked list of fonts.
 280 %
 281 */
 282 MagickExport MagickBooleanType NTLoadTypeLists(SplayTreeInfo *type_list,
 283   ExceptionInfo *exception)
 284 {
 285   HKEY
 286     reg_key = (HKEY) INVALID_HANDLE_VALUE;
 287
 288   LONG
 289     res;
 290
 291   int
 292     list_entries = 0;
 293
 294   char
 295     buffer[MaxTextExtent],
 296     system_root[MaxTextExtent],
 297     font_root[MaxTextExtent];
 298
 299   DWORD
 300     type,
 301     system_root_length;
 302
 303   MagickBooleanType
 304     status;
 305
 306   /*
 307     Try to find the right Windows*\CurrentVersion key, the SystemRoot and
 308     then the Fonts key
 309   */
 310   res = RegOpenKeyExA (HKEY_LOCAL_MACHINE,
 311     "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", 0, KEY_READ, &reg_key);
 312   if (res == ERROR_SUCCESS) {
 313     system_root_length=sizeof(system_root)-1;
 314     res = RegQueryValueExA(reg_key,"SystemRoot",NULL, &type,
 315       (BYTE*) system_root, &system_root_length);
 316   }
 317   if (res != ERROR_SUCCESS) {
 318     res = RegOpenKeyExA (HKEY_LOCAL_MACHINE,
 319       "SOFTWARE\\Microsoft\\Windows\\CurrentVersion", 0, KEY_READ, &reg_key);
 320     if (res == ERROR_SUCCESS) {
 321       system_root_length=sizeof(system_root)-1;
 322       res = RegQueryValueExA(reg_key,"SystemRoot",NULL, &type,
 323         (BYTE*)system_root, &system_root_length);
 324     }
 325   }
 326   if (res == ERROR_SUCCESS)
 327     res = RegOpenKeyExA (reg_key, "Fonts",0, KEY_READ, &reg_key);
 328   if (res != ERROR_SUCCESS)
 329     return(MagickFalse);
 330   *font_root='\0';
 331   (void) CopyMagickString(buffer,system_root,MaxTextExtent);
 332   (void) ConcatenateMagickString(buffer,"\\fonts\\arial.ttf",MaxTextExtent);
 333   if (IsPathAccessible(buffer) != MagickFalse)
 334     {
 335       (void) CopyMagickString(font_root,system_root,MaxTextExtent);
 336       (void) ConcatenateMagickString(font_root,"\\fonts\\",MaxTextExtent);
 337     }
 338   else
 339     {
 340       (void) CopyMagickString(font_root,system_root,MaxTextExtent);
 341       (void) ConcatenateMagickString(font_root,"\\",MaxTextExtent);
 342     }
 343
 344   {
 345     TypeInfo
 346       *type_info;
 347
 348     DWORD
 349       registry_index = 0,
 350       type,
 351       value_data_size,
 352       value_name_length;
 353
 354     char
 355       value_data[MaxTextExtent],
 356       value_name[MaxTextExtent];
 357
 358     res = ERROR_SUCCESS;
 359
 360     while (res != ERROR_NO_MORE_ITEMS)
 361       {
 362         char
 363           *family_extent,
 364           token[MaxTextExtent],
 365           *pos,
 366           *q;
 367
 368         value_name_length = sizeof(value_name) - 1;
 369         value_data_size = sizeof(value_data) - 1;
 370         res = RegEnumValueA ( reg_key, registry_index, value_name,
 371           &value_name_length, 0, &type, (BYTE*)value_data, &value_data_size);
 372         registry_index++;
 373         if (res != ERROR_SUCCESS)
 374           continue;
 375         if ( (pos = strstr(value_name, " (TrueType)")) == (char*) NULL )
 376           continue;
 377         *pos='\0'; /* Remove (TrueType) from string */
 378
 379         type_info=(TypeInfo *) AcquireMagickMemory(sizeof(*type_info));
 380         if (type_info == (TypeInfo *) NULL)
 381           ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
 382         (void) ResetMagickMemory(type_info,0,sizeof(TypeInfo));
 383
 384         type_info->path=ConstantString("Windows Fonts");
 385         type_info->signature=MagickSignature;
 386
 387         /* Name */
 388         (void) CopyMagickString(buffer,value_name,MaxTextExtent);
 389         for(pos = buffer; *pos != 0 ; pos++)
 390           if (*pos == ' ')
 391             *pos = '-';
 392         type_info->name=ConstantString(buffer);
 393
 394         /* Fullname */
 395         type_info->description=ConstantString(value_name);
 396
 397         /* Format */
 398         type_info->format=ConstantString("truetype");
 399
 400         /* Glyphs */
 401         if (strchr(value_data,'\\') != (char *) NULL)
 402           (void) CopyMagickString(buffer,value_data,MaxTextExtent);
 403         else
 404           {
 405             (void) CopyMagickString(buffer,font_root,MaxTextExtent);
 406             (void) ConcatenateMagickString(buffer,value_data,MaxTextExtent);
 407           }
 408
 409         LocaleLower(buffer);
 410         type_info->glyphs=ConstantString(buffer);
 411
 412         type_info->stretch=NormalStretch;
 413         type_info->style=NormalStyle;
 414         type_info->weight=400;
 415
 416         /* Some fonts are known to require special encodings */
 417         if ( (LocaleCompare(type_info->name, "Symbol") == 0 ) ||
 418              (LocaleCompare(type_info->name, "Wingdings") == 0 ) ||
 419              (LocaleCompare(type_info->name, "Wingdings-2") == 0 ) ||
 420              (LocaleCompare(type_info->name, "Wingdings-3") == 0 ) )
 421           type_info->encoding=ConstantString("AppleRoman");
 422
 423         family_extent=value_name;
 424
 425         for (q=value_name; *q != '\0'; )
 426           {
 427             GetMagickToken(q,(const char **) &q,token);
 428             if (*token == '\0')
 429               break;
 430
 431             if (LocaleCompare(token,"Italic") == 0)
 432               {
 433                 type_info->style=ItalicStyle;
 434               }
 435
 436             else if (LocaleCompare(token,"Oblique") == 0)
 437               {
 438                 type_info->style=ObliqueStyle;
 439               }
 440
 441             else if (LocaleCompare(token,"Bold") == 0)
 442               {
 443                 type_info->weight=700;
 444               }
 445
 446             else if (LocaleCompare(token,"Thin") == 0)
 447               {
 448                 type_info->weight=100;
 449               }
 450
 451             else if ( (LocaleCompare(token,"ExtraLight") == 0) ||
 452                       (LocaleCompare(token,"UltraLight") == 0) )
 453               {
 454                 type_info->weight=200;
 455               }
 456
 457             else if (LocaleCompare(token,"Light") == 0)
 458               {
 459                 type_info->weight=300;
 460               }
 461
 462             else if ( (LocaleCompare(token,"Normal") == 0) ||
 463                       (LocaleCompare(token,"Regular") == 0) )
 464               {
 465                 type_info->weight=400;
 466               }
 467
 468             else if (LocaleCompare(token,"Medium") == 0)
 469               {
 470                 type_info->weight=500;
 471               }
 472
 473             else if ( (LocaleCompare(token,"SemiBold") == 0) ||
 474                       (LocaleCompare(token,"DemiBold") == 0) )
 475               {
 476                 type_info->weight=600;
 477               }
 478
 479             else if ( (LocaleCompare(token,"ExtraBold") == 0) ||
 480                       (LocaleCompare(token,"UltraBold") == 0) )
 481               {
 482                 type_info->weight=800;
 483               }
 484
 485             else if ( (LocaleCompare(token,"Heavy") == 0) ||
 486                       (LocaleCompare(token,"Black") == 0) )
 487               {
 488                 type_info->weight=900;
 489               }
 490
 491             else if (LocaleCompare(token,"Condensed") == 0)
 492               {
 493                 type_info->stretch = CondensedStretch;
 494               }
 495
 496             else if (LocaleCompare(token,"Expanded") == 0)
 497               {
 498                 type_info->stretch = ExpandedStretch;
 499               }
 500
 501             else if (LocaleCompare(token,"ExtraCondensed") == 0)
 502               {
 503                 type_info->stretch = ExtraCondensedStretch;
 504               }
 505
 506             else if (LocaleCompare(token,"ExtraExpanded") == 0)
 507               {
 508                 type_info->stretch = ExtraExpandedStretch;
 509               }
 510
 511             else if (LocaleCompare(token,"SemiCondensed") == 0)
 512               {
 513                 type_info->stretch = SemiCondensedStretch;
 514               }
 515
 516             else if (LocaleCompare(token,"SemiExpanded") == 0)
 517               {
 518                 type_info->stretch = SemiExpandedStretch;
 519               }
 520
 521             else if (LocaleCompare(token,"UltraCondensed") == 0)
 522               {
 523                 type_info->stretch = UltraCondensedStretch;
 524               }
 525
 526             else if (LocaleCompare(token,"UltraExpanded") == 0)
 527               {
 528                 type_info->stretch = UltraExpandedStretch;
 529               }
 530
 531             else
 532               {
 533                 family_extent=q;
 534               }
 535           }
 536
 537         (void) CopyMagickString(buffer,value_name,family_extent-value_name+1);
 538         StripString(buffer);
 539         type_info->family=ConstantString(buffer);
 540
 541         list_entries++;
 542         status=AddValueToSplayTree(type_list,ConstantString(type_info->name),
 543           type_info);
 544         if (status == MagickFalse)
 545           (void) ThrowMagickException(exception,GetMagickModule(),
 546             ResourceLimitError,"MemoryAllocationFailed","'%s'",type_info->name);
 547       }
 548   }
 549   RegCloseKey ( reg_key );
 550   return(MagickTrue);
 551 }
 552 \f
 553 /*
 554 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 555 %                                                                             %
 556 %                                                                             %
 557 %                                                                             %
 558 %   I m a g e T o H B i t m a p                                               %
 559 %                                                                             %
 560 %                                                                             %
 561 %                                                                             %
 562 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 563 %
 564 %  ImageToHBITMAP() creates a Windows HBITMAP from an image.
 565 %
 566 %  The format of the ImageToHBITMAP method is:
 567 %
 568 %      HBITMAP ImageToHBITMAP(Image *image,Exceptioninfo *exception)
 569 %
 570 %  A description of each parameter follows:
 571 %
 572 %    o image: the image to convert.
 573 %
 574 */
 575 MagickExport void *ImageToHBITMAP(Image *image,ExceptionInfo *exception)
 576 {
 577   BITMAP
 578     bitmap;
 579
 580   HANDLE
 581     bitmap_bitsH;
 582
 583   HBITMAP
 584     bitmapH;
 585
 586   register ssize_t
 587     x;
 588
 589   register const Quantum
 590     *p;
 591
 592   register RGBQUAD
 593     *q;
 594
 595   RGBQUAD
 596     *bitmap_bits;
 597
 598   size_t
 599     length;
 600
 601   ssize_t
 602     y;
 603
 604   (void) ResetMagickMemory(&bitmap,0,sizeof(bitmap));
 605   bitmap.bmType=0;
 606   bitmap.bmWidth=(LONG) image->columns;
 607   bitmap.bmHeight=(LONG) image->rows;
 608   bitmap.bmWidthBytes=4*bitmap.bmWidth;
 609   bitmap.bmPlanes=1;
 610   bitmap.bmBitsPixel=32;
 611   bitmap.bmBits=NULL;
 612   length=bitmap.bmWidthBytes*bitmap.bmHeight;
 613   bitmap_bitsH=(HANDLE) GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE,length);
 614   if (bitmap_bitsH == NULL)
 615     {
 616       char
 617         *message;
 618
 619       message=GetExceptionMessage(errno);
 620       (void) ThrowMagickException(exception,GetMagickModule(),
 621         ResourceLimitError,"MemoryAllocationFailed","'%s'",message);
 622       message=DestroyString(message);
 623       return(NULL);
 624     }
 625   bitmap_bits=(RGBQUAD *) GlobalLock((HGLOBAL) bitmap_bitsH);
 626   q=bitmap_bits;
 627   if (bitmap.bmBits == NULL)
 628     bitmap.bmBits=bitmap_bits;
 629   (void) TransformImageColorspace(image,sRGBColorspace,exception);
 630   for (y=0; y < (ssize_t) image->rows; y++)
 631   {
 632     p=GetVirtualPixels(image,0,y,image->columns,1,exception);
 633     if (p == (const Quantum *) NULL)
 634       break;
 635     for (x=0; x < (ssize_t) image->columns; x++)
 636     {
 637       q->rgbRed=ScaleQuantumToChar(GetPixelRed(image,p));
 638       q->rgbGreen=ScaleQuantumToChar(GetPixelGreen(image,p));
 639       q->rgbBlue=ScaleQuantumToChar(GetPixelBlue(image,p));
 640       q->rgbReserved=0;
 641       p+=GetPixelChannels(image);
 642       q++;
 643     }
 644   }
 645   bitmap.bmBits=bitmap_bits;
 646   bitmapH=CreateBitmapIndirect(&bitmap);
 647   if (bitmapH == NULL)
 648     {
 649       char
 650         *message;
 651
 652       message=GetExceptionMessage(errno);
 653       (void) ThrowMagickException(exception,GetMagickModule(),
 654         ResourceLimitError,"MemoryAllocationFailed","'%s'",message);
 655       message=DestroyString(message);
 656     }
 657   GlobalUnlock((HGLOBAL) bitmap_bitsH);
 658   GlobalFree((HGLOBAL) bitmap_bitsH);
 659   return((void *) bitmapH);
 660 }
 661 \f
 662 #endif