diff --git a/ChangeLog b/ChangeLog
index 3e7b668..96d6d58 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -5,6 +5,8 @@
     -background lightblue show:).
   * Do not annotate directory paths in ListFiles().
   * Reset the image matte for png:color-type=2.
+  * Add the ImageView API.
+  * Fix DJVU coder to read one page (e.g. 'image.djvu[2]').
 
 2010-06-17  6.6.2-7 Cristy  <quetzlzacatenango@image...>
   * Support new label:pointsize property.
diff --git a/coders/djvu.c b/coders/djvu.c
index 73234d9..6503f00 100644
--- a/coders/djvu.c
+++ b/coders/djvu.c
@@ -865,6 +865,7 @@
     image=ReadOneDJVUImage(lc,i,image_info,exception);
     if (image == (Image *) NULL)
       break;
+    image->scene=i;
     AppendImageToList(&images,CloneImageList(image,exception));
     if (image_info->number_scenes != 0)
       if (image->scene >= (image_info->scene+image_info->number_scenes-1))
diff --git a/index.html b/index.html
index dcfcab7..3715571 100644
--- a/index.html
+++ b/index.html
@@ -141,9 +141,6 @@
 <div  class="sponsor">
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
-<div  class="sponsor">
-   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
-</div>
 </div>
 </div>
 
diff --git a/magick/image-view.c b/magick/image-view.c
index 136830e..3958ad0 100644
--- a/magick/image-view.c
+++ b/magick/image-view.c
@@ -56,8 +56,11 @@
 */
 struct _ImageView
 {
-  ExceptionInfo
-    *exception;
+  char
+    *description;
+
+  RectangleInfo
+    extent;
 
   Image
     *image;
@@ -65,12 +68,12 @@
   CacheView
     *view;
 
-  RectangleInfo
-    region;
-
   size_t
     number_threads;
 
+  ExceptionInfo
+    *exception;
+
   MagickBooleanType
     debug;
 
@@ -111,11 +114,12 @@
   if (clone_view == (ImageView *) NULL)
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   (void) ResetMagickMemory(clone_view,0,sizeof(*clone_view));
+  clone_view->description=ConstantString(image_view->description);
+  clone_view->extent=image_view->extent;
+  clone_view->view=CloneCacheView(image_view->view);
+  clone_view->number_threads=image_view->number_threads;
   clone_view->exception=AcquireExceptionInfo();
   InheritException(clone_view->exception,image_view->exception);
-  clone_view->view=CloneCacheView(image_view->view);
-  clone_view->region=image_view->region;
-  clone_view->number_threads=image_view->number_threads;
   clone_view->debug=image_view->debug;
   clone_view->signature=MagickSignature;
   return(clone_view);
@@ -147,6 +151,8 @@
 {
   assert(image_view != (ImageView *) NULL);
   assert(image_view->signature == MagickSignature);
+  if (image_view->description != (char *) NULL)
+    image_view->description=DestroyString(image_view->description);
   image_view->view=DestroyCacheView(image_view->view);
   image_view->exception=DestroyExceptionInfo(image_view->exception);
   image_view->signature=(~MagickSignature);
@@ -167,7 +173,7 @@
 %
 %  DuplexTransferImageViewIterator() iterates over three image views in
 %  parallel and calls your transfer method for each scanline of the view.  The
-%  source and duplex pixel region is not confined to the image canvas-- that is
+%  source and duplex pixel extent is not confined to the image canvas-- that is
 %  you can include negative offsets or widths or heights that exceed the image
 %  dimension.  However, the destination image view is confined to the image
 %  canvas-- that is no negative offsets or widths or heights that exceed the
@@ -203,8 +209,6 @@
   ImageView *source,ImageView *duplex,ImageView *destination,
   DuplexTransferImageViewMethod transfer,void *context)
 {
-#define DuplexTransferImageViewTag  "ImageView/DuplexTransfer"
-
   ExceptionInfo
     *exception;
 
@@ -237,7 +241,7 @@
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,1) shared(progress,status)
 #endif
-  for (y=source->region.y; y < (ssize_t) source->region.height; y++)
+  for (y=source->extent.y; y < (ssize_t) source->extent.height; y++)
   {
     MagickBooleanType
       sync;
@@ -262,16 +266,16 @@
     if (status == MagickFalse)
       continue;
     id=GetOpenMPThreadId();
-    pixels=GetCacheViewVirtualPixels(source->view,source->region.x,y,
-      source->region.width,1,source->exception);
+    pixels=GetCacheViewVirtualPixels(source->view,source->extent.x,y,
+      source->extent.width,1,source->exception);
     if (pixels == (const PixelPacket *) NULL)
       {
         status=MagickFalse;
         continue;
       }
     indexes=GetCacheViewVirtualIndexQueue(source->view);
-    duplex_pixels=GetCacheViewVirtualPixels(duplex->view,duplex->region.x,y,
-      duplex->region.width,1,duplex->exception);
+    duplex_pixels=GetCacheViewVirtualPixels(duplex->view,duplex->extent.x,y,
+      duplex->extent.width,1,duplex->exception);
     if (duplex_pixels == (const PixelPacket *) NULL)
       {
         status=MagickFalse;
@@ -279,14 +283,14 @@
       }
     duplex_indexes=GetCacheViewVirtualIndexQueue(duplex->view);
     destination_pixels=GetCacheViewAuthenticPixels(destination->view,
-      destination->region.x,y,destination->region.width,1,exception);
+      destination->extent.x,y,destination->extent.width,1,exception);
     if (destination_pixels == (PixelPacket *) NULL)
       {
         status=MagickFalse;
         continue;
       }
     destination_indexes=GetCacheViewAuthenticIndexQueue(destination->view);
-    if (transfer(source,duplex,destination,context) == MagickFalse)
+    if (transfer(source,duplex,destination,y,id,context) == MagickFalse)
       status=MagickFalse;
     sync=SyncCacheViewAuthenticPixels(destination->view,exception);
     if (sync == MagickFalse)
@@ -303,8 +307,8 @@
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp critical (MagickCore_DuplexTransferImageViewIterator)
 #endif
-        proceed=SetImageProgress(source_image,DuplexTransferImageViewTag,
-          progress++,source->region.height);
+        proceed=SetImageProgress(source_image,source->description,progress++,
+          source->extent.height);
         if (proceed == MagickFalse)
           status=MagickFalse;
       }
@@ -433,28 +437,28 @@
 %                                                                             %
 %                                                                             %
 %                                                                             %
-%   G e t I m a g e V i e w H e i g h t                                       %
+%   G e t I m a g e V i e w E x t e n t                                       %
 %                                                                             %
 %                                                                             %
 %                                                                             %
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %
-%  GetImageViewHeight() returns the image view height.
+%  GetImageViewExtent() returns the image view extent.
 %
-%  The format of the GetImageViewHeight method is:
+%  The format of the GetImageViewExtent method is:
 %
-%      size_t GetImageViewHeight(const ImageView *image_view)
+%      RectangleInfo GetImageViewExtent(const ImageView *image_view)
 %
 %  A description of each parameter follows:
 %
 %    o image_view: the image view.
 %
 */
-MagickExport size_t GetImageViewHeight(const ImageView *image_view)
+MagickExport RectangleInfo GetImageViewExtent(const ImageView *image_view)
 {
   assert(image_view != (ImageView *) NULL);
   assert(image_view->signature == MagickSignature);
-  return(image_view->region.height);
+  return(image_view->extent);
 }
 
 /*
@@ -498,7 +502,7 @@
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %
 %  GetImageViewIterator() iterates over the image view in parallel and calls
-%  your get method for each scanline of the view.  The pixel region is
+%  your get method for each scanline of the view.  The pixel extent is
 %  not confined to the image canvas-- that is you can include negative offsets
 %  or widths or heights that exceed the image dimension.  Any updates to
 %  the pixels in your callback are ignored.
@@ -527,8 +531,6 @@
 MagickExport MagickBooleanType GetImageViewIterator(ImageView *source,
   GetImageViewMethod get,void *context)
 {
-#define GetImageViewTag  "ImageView/Get"
-
   Image
     *source_image;
 
@@ -551,7 +553,7 @@
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,1) shared(progress,status)
 #endif
-  for (y=source->region.y; y < (ssize_t) source->region.height; y++)
+  for (y=source->extent.y; y < (ssize_t) source->extent.height; y++)
   {
     register const IndexPacket
       *indexes;
@@ -565,8 +567,8 @@
     if (status == MagickFalse)
       continue;
     id=GetOpenMPThreadId();
-    pixels=GetCacheViewVirtualPixels(source->view,source->region.x,y,
-      source->region.width,1,source->exception);
+    pixels=GetCacheViewVirtualPixels(source->view,source->extent.x,y,
+      source->extent.width,1,source->exception);
     if (pixels == (const PixelPacket *) NULL)
       {
         status=MagickFalse;
@@ -583,8 +585,8 @@
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp critical (MagickCore_GetImageViewIterator)
 #endif
-        proceed=SetImageProgress(source_image,GetImageViewTag,progress++,
-          source->region.height);
+        proceed=SetImageProgress(source_image,source->description,progress++,
+          source->extent.height);
         if (proceed == MagickFalse)
           status=MagickFalse;
       }
@@ -658,93 +660,6 @@
 %                                                                             %
 %                                                                             %
 %                                                                             %
-%   G e t I m a g e V i e w W i d t h                                         %
-%                                                                             %
-%                                                                             %
-%                                                                             %
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%
-%  GetImageViewWidth() returns the image view width.
-%
-%  The format of the GetImageViewWidth method is:
-%
-%      size_t GetImageViewWidth(const ImageView *image_view)
-%
-%  A description of each parameter follows:
-%
-%    o image_view: the image view.
-%
-*/
-MagickExport size_t GetImageViewWidth(const ImageView *image_view)
-{
-  assert(image_view != (ImageView *) NULL);
-  assert(image_view->signature == MagickSignature);
-  return(image_view->region.width);
-}
-
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%                                                                             %
-%                                                                             %
-%                                                                             %
-%   G e t I m a g e V i e w X                                                 %
-%                                                                             %
-%                                                                             %
-%                                                                             %
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%
-%  GetImageViewX() returns the image view x offset.
-%
-%  The format of the GetImageViewX method is:
-%
-%      ssize_t GetImageViewX(const ImageView *image_view)
-%
-%  A description of each parameter follows:
-%
-%    o image_view: the image view.
-%
-*/
-MagickExport ssize_t GetImageViewX(const ImageView *image_view)
-{
-  assert(image_view != (ImageView *) NULL);
-  assert(image_view->signature == MagickSignature);
-  return(image_view->region.x);
-}
-
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%                                                                             %
-%                                                                             %
-%                                                                             %
-%   G e t I m a g e V i e w Y                                                 %
-%                                                                             %
-%                                                                             %
-%                                                                             %
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%
-%  GetImageViewY() returns the image view y offset.
-%
-%  The format of the GetImageViewY method is:
-%
-%      ssize_t GetImageViewY(const ImageView *image_view)
-%
-%  A description of each parameter follows:
-%
-%    o image_view: the image view.
-%
-*/
-MagickExport ssize_t GetImageViewY(const ImageView *image_view)
-{
-  assert(image_view != (ImageView *) NULL);
-  assert(image_view->signature == MagickSignature);
-  return(image_view->region.y);
-}
-
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%                                                                             %
-%                                                                             %
-%                                                                             %
 %   I s I m a g e V i e w                                                     %
 %                                                                             %
 %                                                                             %
@@ -806,12 +721,15 @@
   if (image_view == (ImageView *) NULL)
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   (void) ResetMagickMemory(image_view,0,sizeof(*image_view));
-  image_view->exception=AcquireExceptionInfo();
+  image_view->description=ConstantString("ImageView");
   image_view->image=image;
   image_view->view=AcquireCacheView(image_view->image);
-  image_view->region.width=image->columns;
-  image_view->region.height=image->rows;
+  image_view->extent.width=image->columns;
+  image_view->extent.height=image->rows;
+  image_view->extent.x=0;
+  image_view->extent.y=0;
   image_view->number_threads=GetOpenMPMaximumThreads();
+  image_view->exception=AcquireExceptionInfo();
   image_view->debug=IsEventLogging();
   image_view->signature=MagickSignature;
   return(image_view);
@@ -840,7 +758,7 @@
 %
 %    o wand: the magick wand.
 %
-%    o x,y,columns,rows:  These values define the perimeter of a region of
+%    o x,y,columns,rows:  These values define the perimeter of a extent of
 %      pixel_wands view.
 %
 */
@@ -856,14 +774,15 @@
   if (image_view == (ImageView *) NULL)
     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
   (void) ResetMagickMemory(image_view,0,sizeof(*image_view));
-  image_view->exception=AcquireExceptionInfo();
+  image_view->description=ConstantString("ImageView");
   image_view->view=AcquireCacheView(image_view->image);
   image_view->image=image;
-  image_view->region.width=width;
-  image_view->region.height=height;
-  image_view->region.x=x;
-  image_view->region.y=y;
+  image_view->extent.width=width;
+  image_view->extent.height=height;
+  image_view->extent.x=x;
+  image_view->extent.y=y;
   image_view->number_threads=GetOpenMPMaximumThreads();
+  image_view->exception=AcquireExceptionInfo();
   image_view->debug=IsEventLogging();
   image_view->signature=MagickSignature;
   return(image_view);
@@ -874,6 +793,39 @@
 %                                                                             %
 %                                                                             %
 %                                                                             %
+%   S e t I m a g e V i e w D e s c r i p t i o n                             %
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+%  SetImageViewDescription() associates a description with an image view.
+%
+%  The format of the SetImageViewDescription method is:
+%
+%      void SetImageViewDescription(ImageView *image_view,
+%        const char *description)
+%
+%  A description of each parameter follows:
+%
+%    o image_view: the image view.
+%
+%    o description: the image view description.
+%
+*/
+MagickExport void SetImageViewDescription(ImageView *image_view,
+  const char *description)
+{
+  assert(image_view != (ImageView *) NULL);
+  assert(image_view->signature == MagickSignature);
+  image_view->description=ConstantString(description);
+}
+
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                                                                             %
+%                                                                             %
+%                                                                             %
 %   S e t I m a g e V i e w I t e r a t o r                                   %
 %                                                                             %
 %                                                                             %
@@ -881,7 +833,7 @@
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %
 %  SetImageViewIterator() iterates over the image view in parallel and calls
-%  your set method for each scanline of the view.  The pixel region is
+%  your set method for each scanline of the view.  The pixel extent is
 %  confined to the image canvas-- that is no negative offsets or widths or
 %  heights that exceed the image dimension.  The pixels are initiallly
 %  undefined and any settings you make in the callback method are automagically
@@ -911,8 +863,6 @@
 MagickExport MagickBooleanType SetImageViewIterator(ImageView *destination,
   SetImageViewMethod set,void *context)
 {
-#define SetImageViewTag  "ImageView/Set"
-
   ExceptionInfo
     *exception;
 
@@ -941,7 +891,7 @@
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,1) shared(progress,status)
 #endif
-  for (y=destination->region.y; y < (ssize_t) destination->region.height; y++)
+  for (y=destination->extent.y; y < (ssize_t) destination->extent.height; y++)
   {
     MagickBooleanType
       sync;
@@ -958,8 +908,8 @@
     if (status == MagickFalse)
       continue;
     id=GetOpenMPThreadId();
-    pixels=GetCacheViewAuthenticPixels(destination->view,destination->region.x,
-      y,destination->region.width,1,exception);
+    pixels=GetCacheViewAuthenticPixels(destination->view,destination->extent.x,
+      y,destination->extent.width,1,exception);
     if (pixels == (PixelPacket *) NULL)
       {
         InheritException(destination->exception,GetCacheViewException(
@@ -985,8 +935,8 @@
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp critical (MagickCore_SetImageViewIterator)
 #endif
-        proceed=SetImageProgress(destination_image,SetImageViewTag,progress++,
-          destination->region.height);
+        proceed=SetImageProgress(destination_image,destination->description,
+          progress++,destination->extent.height);
         if (proceed == MagickFalse)
           status=MagickFalse;
       }
@@ -1007,7 +957,7 @@
 %
 %  TransferImageViewIterator() iterates over two image views in parallel and
 %  calls your transfer method for each scanline of the view.  The source pixel
-%  region is not confined to the image canvas-- that is you can include
+%  extent is not confined to the image canvas-- that is you can include
 %  negative offsets or widths or heights that exceed the image dimension.
 %  However, the destination image view is confined to the image canvas-- that
 %  is no negative offsets or widths or heights that exceed the image dimension
@@ -1039,8 +989,6 @@
 MagickExport MagickBooleanType TransferImageViewIterator(ImageView *source,
   ImageView *destination,TransferImageViewMethod transfer,void *context)
 {
-#define TransferImageViewTag  "ImageView/Transfer"
-
   ExceptionInfo
     *exception;
 
@@ -1071,7 +1019,7 @@
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,1) shared(progress,status)
 #endif
-  for (y=source->region.y; y < (ssize_t) source->region.height; y++)
+  for (y=source->extent.y; y < (ssize_t) source->extent.height; y++)
   {
     MagickBooleanType
       sync;
@@ -1094,8 +1042,8 @@
     if (status == MagickFalse)
       continue;
     id=GetOpenMPThreadId();
-    pixels=GetCacheViewVirtualPixels(source->view,source->region.x,y,
-      source->region.width,1,source->exception);
+    pixels=GetCacheViewVirtualPixels(source->view,source->extent.x,y,
+      source->extent.width,1,source->exception);
     if (pixels == (const PixelPacket *) NULL)
       {
         status=MagickFalse;
@@ -1103,14 +1051,14 @@
       }
     indexes=GetCacheViewVirtualIndexQueue(source->view);
     destination_pixels=GetCacheViewAuthenticPixels(destination->view,
-      destination->region.x,y,destination->region.width,1,exception);
+      destination->extent.x,y,destination->extent.width,1,exception);
     if (destination_pixels == (PixelPacket *) NULL)
       {
         status=MagickFalse;
         continue;
       }
     destination_indexes=GetCacheViewAuthenticIndexQueue(destination->view);
-    if (transfer(source,destination,context) == MagickFalse)
+    if (transfer(source,destination,y,id,context) == MagickFalse)
       status=MagickFalse;
     sync=SyncCacheViewAuthenticPixels(destination->view,exception);
     if (sync == MagickFalse)
@@ -1127,8 +1075,8 @@
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp critical (MagickCore_TransferImageViewIterator)
 #endif
-        proceed=SetImageProgress(source_image,TransferImageViewTag,progress++,
-          source->region.height);
+        proceed=SetImageProgress(source_image,source->description,progress++,
+          source->extent.height);
         if (proceed == MagickFalse)
           status=MagickFalse;
       }
@@ -1148,7 +1096,7 @@
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %
 %  UpdateImageViewIterator() iterates over the image view in parallel and calls
-%  your update method for each scanline of the view.  The pixel region is
+%  your update method for each scanline of the view.  The pixel extent is
 %  confined to the image canvas-- that is no negative offsets or widths or
 %  heights that exceed the image dimension are permitted.  Updates to pixels
 %  in your callback are automagically synced back to the image.
@@ -1177,8 +1125,6 @@
 MagickExport MagickBooleanType UpdateImageViewIterator(ImageView *source,
   UpdateImageViewMethod update,void *context)
 {
-#define UpdateImageViewTag  "ImageView/Update"
-
   ExceptionInfo
     *exception;
 
@@ -1207,7 +1153,7 @@
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,1) shared(progress,status)
 #endif
-  for (y=source->region.y; y < (ssize_t) source->region.height; y++)
+  for (y=source->extent.y; y < (ssize_t) source->extent.height; y++)
   {
     register IndexPacket
       *restrict indexes;
@@ -1221,8 +1167,8 @@
     if (status == MagickFalse)
       continue;
     id=GetOpenMPThreadId();
-    pixels=GetCacheViewAuthenticPixels(source->view,source->region.x,y,
-      source->region.width,1,exception);
+    pixels=GetCacheViewAuthenticPixels(source->view,source->extent.x,y,
+      source->extent.width,1,exception);
     if (pixels == (PixelPacket *) NULL)
       {
         InheritException(source->exception,GetCacheViewException(source->view));
@@ -1230,7 +1176,7 @@
         continue;
       }
     indexes=GetCacheViewAuthenticIndexQueue(source->view);
-    if (update(source,context) == MagickFalse)
+    if (update(source,y,id,context) == MagickFalse)
       status=MagickFalse;
     if (SyncCacheViewAuthenticPixels(source->view,exception) == MagickFalse)
       {
@@ -1245,8 +1191,8 @@
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp critical (MagickCore_UpdateImageViewIterator)
 #endif
-        proceed=SetImageProgress(source_image,UpdateImageViewTag,progress++,
-          source->region.height);
+        proceed=SetImageProgress(source_image,source->description,progress++,
+          source->extent.height);
         if (proceed == MagickFalse)
           status=MagickFalse;
       }
diff --git a/magick/image-view.h b/magick/image-view.h
index 04cd787..3a1dc21 100644
--- a/magick/image-view.h
+++ b/magick/image-view.h
@@ -27,11 +27,12 @@
 
 typedef MagickBooleanType
   (*DuplexTransferImageViewMethod)(const ImageView *,const ImageView *,
-    ImageView *,void *),
+    ImageView *,const ssize_t,const int,void *),
   (*GetImageViewMethod)(const ImageView *,void *),
   (*SetImageViewMethod)(ImageView *,void *),
-  (*TransferImageViewMethod)(const ImageView *,ImageView *,void *),
-  (*UpdateImageViewMethod)(ImageView *,void *);
+  (*TransferImageViewMethod)(const ImageView *,ImageView *,const ssize_t,
+    const int,void *),
+  (*UpdateImageViewMethod)(ImageView *,const ssize_t,const int,void *);
 
 extern MagickExport char
   *GetImageViewException(const ImageView *,ExceptionType *);
@@ -68,13 +69,11 @@
 extern MagickExport PixelPacket
   *GetImageViewAuthenticPixels(const ImageView *);
 
-extern MagickExport size_t
-  GetImageViewHeight(const ImageView *),
-  GetImageViewWidth(const ImageView *);
+extern MagickExport RectangleInfo
+  GetImageViewExtent(const ImageView *);
 
-extern MagickExport ssize_t
-  GetImageViewX(const ImageView *),
-  GetImageViewY(const ImageView *);
+extern MagickExport void
+  SetImageViewDescription(ImageView *,const char *);
 
 #if defined(__cplusplus) || defined(c_plusplus)
 }
diff --git a/magick/thread-private.h b/magick/thread-private.h
index 58be557..9275625 100644
--- a/magick/thread-private.h
+++ b/magick/thread-private.h
@@ -108,7 +108,7 @@
 #endif
 }
 
-static inline ssize_t GetOpenMPThreadId(void)
+static inline int GetOpenMPThreadId(void)
 {
 #if defined(MAGICKCORE_OPENMP_SUPPORT) && (_OPENMP >= 200203)
   return(omp_get_thread_num());
diff --git a/wand/wand-view.c b/wand/wand-view.c
index 921a6e9..14c4bdf 100644
--- a/wand/wand-view.c
+++ b/wand/wand-view.c
@@ -65,10 +65,11 @@
     id;
 
   char
-    name[MaxTextExtent];
+    name[MaxTextExtent],
+    *description;
 
-  ExceptionInfo
-    *exception;
+  RectangleInfo
+    extent;
 
   MagickWand
     *wand;
@@ -76,15 +77,15 @@
   CacheView
     *view;
 
-  RectangleInfo
-    region;
-
   size_t
     number_threads;
 
   PixelWand
     ***pixel_wands;
 
+  ExceptionInfo
+    *exception;
+
   MagickBooleanType
     debug;
 
@@ -134,14 +135,15 @@
   clone_view->id=AcquireWandId();
   (void) FormatMagickString(clone_view->name,MaxTextExtent,"%s-%.20g",
     WandViewId,(double) clone_view->id);
+  clone_view->description=ConstantString(wand_view->description);
+  clone_view->view=CloneCacheView(wand_view->view);
+  clone_view->extent=wand_view->extent;
+  clone_view->number_threads=wand_view->number_threads;
   clone_view->exception=AcquireExceptionInfo();
   InheritException(clone_view->exception,wand_view->exception);
-  clone_view->view=CloneCacheView(wand_view->view);
-  clone_view->region=wand_view->region;
-  clone_view->number_threads=wand_view->number_threads;
   for (i=0; i < (ssize_t) wand_view->number_threads; i++)
     clone_view->pixel_wands[i]=ClonePixelWands((const PixelWand **)
-      wand_view->pixel_wands[i],wand_view->region.width);
+      wand_view->pixel_wands[i],wand_view->extent.width);
   clone_view->debug=wand_view->debug;
   if (clone_view->debug != MagickFalse)
     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",clone_view->name);
@@ -191,7 +193,7 @@
   assert(wand_view != (WandView *) NULL);
   assert(wand_view->signature == WandSignature);
   wand_view->pixel_wands=DestroyPixelsThreadSet(wand_view->pixel_wands,
-    wand_view->region.width,wand_view->number_threads);
+    wand_view->extent.width,wand_view->number_threads);
   wand_view->view=DestroyCacheView(wand_view->view);
   wand_view->exception=DestroyExceptionInfo(wand_view->exception);
   wand_view->signature=(~WandSignature);
@@ -213,7 +215,7 @@
 %
 %  DuplexTransferWandViewIterator() iterates over three wand views in
 %  parallel and calls your transfer method for each scanline of the view.  The
-%  source and duplex pixel region is not confined to the image canvas-- that is
+%  source and duplex pixel extent is not confined to the image canvas-- that is
 %  you can include negative offsets or widths or heights that exceed the image
 %  dimension.  However, the destination wand view is confined to the image
 %  canvas-- that is no negative offsets or widths or heights that exceed the
@@ -249,8 +251,6 @@
   WandView *duplex,WandView *destination,DuplexTransferWandViewMethod transfer,
   void *context)
 {
-#define DuplexTransferWandViewTag  "WandView/DuplexTransfer"
-
   ExceptionInfo
     *exception;
 
@@ -283,7 +283,7 @@
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,1) shared(progress,status)
 #endif
-  for (y=source->region.y; y < (ssize_t) source->region.height; y++)
+  for (y=source->extent.y; y < (ssize_t) source->extent.height; y++)
   {
     MagickBooleanType
       sync;
@@ -309,63 +309,63 @@
     if (status == MagickFalse)
       continue;
     id=GetOpenMPThreadId();
-    pixels=GetCacheViewVirtualPixels(source->view,source->region.x,y,
-      source->region.width,1,source->exception);
+    pixels=GetCacheViewVirtualPixels(source->view,source->extent.x,y,
+      source->extent.width,1,source->exception);
     if (pixels == (const PixelPacket *) NULL)
       {
         status=MagickFalse;
         continue;
       }
     indexes=GetCacheViewVirtualIndexQueue(source->view);
-    for (x=0; x < (ssize_t) source->region.width; x++)
+    for (x=0; x < (ssize_t) source->extent.width; x++)
       PixelSetQuantumColor(source->pixel_wands[id][x],pixels+x);
     if (source_image->colorspace == CMYKColorspace)
-      for (x=0; x < (ssize_t) source->region.width; x++)
+      for (x=0; x < (ssize_t) source->extent.width; x++)
         PixelSetBlackQuantum(source->pixel_wands[id][x],indexes[x]);
     if (source_image->storage_class == PseudoClass)
-      for (x=0; x < (ssize_t) source->region.width; x++)
+      for (x=0; x < (ssize_t) source->extent.width; x++)
         PixelSetIndex(source->pixel_wands[id][x],indexes[x]);
-    duplex_pixels=GetCacheViewVirtualPixels(duplex->view,duplex->region.x,y,
-      duplex->region.width,1,duplex->exception);
+    duplex_pixels=GetCacheViewVirtualPixels(duplex->view,duplex->extent.x,y,
+      duplex->extent.width,1,duplex->exception);
     if (duplex_pixels == (const PixelPacket *) NULL)
       {
         status=MagickFalse;
         continue;
       }
     duplex_indexes=GetCacheViewVirtualIndexQueue(duplex->view);
-    for (x=0; x < (ssize_t) duplex->region.width; x++)
+    for (x=0; x < (ssize_t) duplex->extent.width; x++)
       PixelSetQuantumColor(duplex->pixel_wands[id][x],duplex_pixels+x);
     if (duplex_image->colorspace == CMYKColorspace)
-      for (x=0; x < (ssize_t) duplex->region.width; x++)
+      for (x=0; x < (ssize_t) duplex->extent.width; x++)
         PixelSetBlackQuantum(duplex->pixel_wands[id][x],duplex_indexes[x]);
     if (duplex_image->storage_class == PseudoClass)
-      for (x=0; x < (ssize_t) duplex->region.width; x++)
+      for (x=0; x < (ssize_t) duplex->extent.width; x++)
         PixelSetIndex(duplex->pixel_wands[id][x],duplex_indexes[x]);
     destination_pixels=GetCacheViewAuthenticPixels(destination->view,
-      destination->region.x,y,destination->region.width,1,exception);
+      destination->extent.x,y,destination->extent.width,1,exception);
     if (destination_pixels == (PixelPacket *) NULL)
       {
         status=MagickFalse;
         continue;
       }
     destination_indexes=GetCacheViewAuthenticIndexQueue(destination->view);
-    for (x=0; x < (ssize_t) destination->region.width; x++)
+    for (x=0; x < (ssize_t) destination->extent.width; x++)
       PixelSetQuantumColor(destination->pixel_wands[id][x],
         destination_pixels+x);
     if (destination_image->colorspace == CMYKColorspace)
-      for (x=0; x < (ssize_t) destination->region.width; x++)
+      for (x=0; x < (ssize_t) destination->extent.width; x++)
         PixelSetBlackQuantum(destination->pixel_wands[id][x],
           destination_indexes[x]);
     if (destination_image->storage_class == PseudoClass)
-      for (x=0; x < (ssize_t) destination->region.width; x++)
+      for (x=0; x < (ssize_t) destination->extent.width; x++)
         PixelSetIndex(destination->pixel_wands[id][x],destination_indexes[x]);
-    if (transfer(source,duplex,destination,context) == MagickFalse)
+    if (transfer(source,duplex,destination,y,id,context) == MagickFalse)
       status=MagickFalse;
-    for (x=0; x < (ssize_t) destination->region.width; x++)
+    for (x=0; x < (ssize_t) destination->extent.width; x++)
       PixelGetQuantumColor(destination->pixel_wands[id][x],
         destination_pixels+x);
     if (destination_image->colorspace == CMYKColorspace)
-      for (x=0; x < (ssize_t) destination->region.width; x++)
+      for (x=0; x < (ssize_t) destination->extent.width; x++)
         destination_indexes[x]=PixelGetBlackQuantum(
           destination->pixel_wands[id][x]);
     sync=SyncCacheViewAuthenticPixels(destination->view,exception);
@@ -383,8 +383,8 @@
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp critical (MagickWand_DuplexTransferWandViewIterator)
 #endif
-        proceed=SetImageProgress(source_image,DuplexTransferWandViewTag,
-          progress++,source->region.height);
+        proceed=SetImageProgress(source_image,source->description,progress++,
+          source->extent.height);
         if (proceed == MagickFalse)
           status=MagickFalse;
       }
@@ -456,28 +456,28 @@
 %                                                                             %
 %                                                                             %
 %                                                                             %
-%   G e t W a n d V i e w H e i g h t                                         %
+%   G e t W a n d V i e w E x t e n t                                         %
 %                                                                             %
 %                                                                             %
 %                                                                             %
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %
-%  GetWandViewHeight() returns the wand view height.
+%  GetWandViewExtent() returns the wand view extent.
 %
-%  The format of the GetWandViewHeight method is:
+%  The format of the GetWandViewExtent method is:
 %
-%      size_t GetWandViewHeight(const WandView *wand_view)
+%      RectangleInfo GetWandViewExtent(const WandView *wand_view)
 %
 %  A description of each parameter follows:
 %
 %    o wand_view: the wand view.
 %
 */
-WandExport size_t GetWandViewHeight(const WandView *wand_view)
+WandExport RectangleInfo GetWandViewExtent(const WandView *wand_view)
 {
   assert(wand_view != (WandView *) NULL);
   assert(wand_view->signature == WandSignature);
-  return(wand_view->region.height);
+  return(wand_view->extent);
 }
 
 /*
@@ -492,7 +492,7 @@
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %
 %  GetWandViewIterator() iterates over the wand view in parallel and calls
-%  your get method for each scanline of the view.  The pixel region is
+%  your get method for each scanline of the view.  The pixel extent is
 %  not confined to the image canvas-- that is you can include negative offsets
 %  or widths or heights that exceed the image dimension.  Any updates to
 %  the pixels in your callback are ignored.
@@ -521,8 +521,6 @@
 WandExport MagickBooleanType GetWandViewIterator(WandView *source,
   GetWandViewMethod get,void *context)
 {
-#define GetWandViewTag  "WandView/Get"
-
   Image
     *source_image;
 
@@ -545,7 +543,7 @@
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,1) shared(progress,status)
 #endif
-  for (y=source->region.y; y < (ssize_t) source->region.height; y++)
+  for (y=source->extent.y; y < (ssize_t) source->extent.height; y++)
   {
     register const IndexPacket
       *indexes;
@@ -560,21 +558,21 @@
     if (status == MagickFalse)
       continue;
     id=GetOpenMPThreadId();
-    pixels=GetCacheViewVirtualPixels(source->view,source->region.x,y,
-      source->region.width,1,source->exception);
+    pixels=GetCacheViewVirtualPixels(source->view,source->extent.x,y,
+      source->extent.width,1,source->exception);
     if (pixels == (const PixelPacket *) NULL)
       {
         status=MagickFalse;
         continue;
       }
     indexes=GetCacheViewVirtualIndexQueue(source->view);
-    for (x=0; x < (ssize_t) source->region.width; x++)
+    for (x=0; x < (ssize_t) source->extent.width; x++)
       PixelSetQuantumColor(source->pixel_wands[id][x],pixels+x);
     if (source_image->colorspace == CMYKColorspace)
-      for (x=0; x < (ssize_t) source->region.width; x++)
+      for (x=0; x < (ssize_t) source->extent.width; x++)
         PixelSetBlackQuantum(source->pixel_wands[id][x],indexes[x]);
     if (source_image->storage_class == PseudoClass)
-      for (x=0; x < (ssize_t) source->region.width; x++)
+      for (x=0; x < (ssize_t) source->extent.width; x++)
         PixelSetIndex(source->pixel_wands[id][x],indexes[x]);
     if (get(source,context) == MagickFalse)
       status=MagickFalse;
@@ -586,8 +584,8 @@
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp critical (MagickWand_GetWandViewIterator)
 #endif
-        proceed=SetImageProgress(source_image,GetWandViewTag,progress++,
-          source->region.height);
+        proceed=SetImageProgress(source_image,source->description,progress++,
+          source->extent.height);
         if (proceed == MagickFalse)
           status=MagickFalse;
       }
@@ -662,93 +660,6 @@
 %                                                                             %
 %                                                                             %
 %                                                                             %
-%   G e t W a n d V i e w W i d t h                                           %
-%                                                                             %
-%                                                                             %
-%                                                                             %
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%
-%  GetWandViewWidth() returns the wand view width.
-%
-%  The format of the GetWandViewWidth method is:
-%
-%      size_t GetWandViewWidth(const WandView *wand_view)
-%
-%  A description of each parameter follows:
-%
-%    o wand_view: the wand view.
-%
-*/
-WandExport size_t GetWandViewWidth(const WandView *wand_view)
-{
-  assert(wand_view != (WandView *) NULL);
-  assert(wand_view->signature == WandSignature);
-  return(wand_view->region.width);
-}
-
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%                                                                             %
-%                                                                             %
-%                                                                             %
-%   G e t W a n d V i e w X                                                   %
-%                                                                             %
-%                                                                             %
-%                                                                             %
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%
-%  GetWandViewX() returns the wand view x offset.
-%
-%  The format of the GetWandViewX method is:
-%
-%      ssize_t GetWandViewX(const WandView *wand_view)
-%
-%  A description of each parameter follows:
-%
-%    o wand_view: the wand view.
-%
-*/
-WandExport ssize_t GetWandViewX(const WandView *wand_view)
-{
-  assert(wand_view != (WandView *) NULL);
-  assert(wand_view->signature == WandSignature);
-  return(wand_view->region.x);
-}
-
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%                                                                             %
-%                                                                             %
-%                                                                             %
-%   G e t W a n d V i e w Y                                                   %
-%                                                                             %
-%                                                                             %
-%                                                                             %
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%
-%  GetWandViewY() returns the wand view y offset.
-%
-%  The format of the GetWandViewY method is:
-%
-%      ssize_t GetWandViewY(const WandView *wand_view)
-%
-%  A description of each parameter follows:
-%
-%    o wand_view: the wand view.
-%
-*/
-WandExport ssize_t GetWandViewY(const WandView *wand_view)
-{
-  assert(wand_view != (WandView *) NULL);
-  assert(wand_view->signature == WandSignature);
-  return(wand_view->region.y);
-}
-
-/*
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%                                                                             %
-%                                                                             %
-%                                                                             %
 %   I s W a n d V i e w                                                       %
 %                                                                             %
 %                                                                             %
@@ -835,7 +746,7 @@
     *wand_view;
 
   assert(wand != (MagickWand *) NULL);
-  assert(wand->signature == MagickSignature);
+  assert(wand->signature == WandSignature);
   wand_view=(WandView *) AcquireAlignedMemory(1,sizeof(*wand_view));
   if (wand_view == (WandView *) NULL)
     ThrowWandFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
@@ -844,13 +755,76 @@
   wand_view->id=AcquireWandId();
   (void) FormatMagickString(wand_view->name,MaxTextExtent,"%s-%.20g",
     WandViewId,(double) wand_view->id);
-  wand_view->exception=AcquireExceptionInfo();
+  wand_view->description=ConstantString("WandView");
   wand_view->wand=wand;
   wand_view->view=AcquireCacheView(wand_view->wand->images);
-  wand_view->region.width=wand->images->columns;
-  wand_view->region.height=wand->images->rows;
+  wand_view->extent.width=wand->images->columns;
+  wand_view->extent.height=wand->images->rows;
   wand_view->number_threads=GetOpenMPMaximumThreads();
-  wand_view->pixel_wands=AcquirePixelsThreadSet(wand_view->region.width,
+  wand_view->pixel_wands=AcquirePixelsThreadSet(wand_view->extent.width,
+    wand_view->number_threads);
+  wand_view->exception=AcquireExceptionInfo();
+  if (wand_view->pixel_wands == (PixelWand ***) NULL)
+    ThrowWandFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
+      GetExceptionMessage(errno));
+  wand_view->debug=IsEventLogging();
+  wand_view->signature=WandSignature;
+  return(wand_view);
+}
+
+/*
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%   N e w W a n d V i e w E x t e n t                                         %
+%                                                                             %
+%                                                                             %
+%                                                                             %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%
+%  NewWandViewExtent() returns a wand view required for all other methods
+%  in the Wand View API.
+%
+%  The format of the NewWandViewExtent method is:
+%
+%      WandView *NewWandViewExtent(MagickWand *wand,const ssize_t x,
+%        const ssize_t y,const size_t width,const size_t height)
+%
+%  A description of each parameter follows:
+%
+%    o wand: the magick wand.
+%
+%    o x,y,columns,rows:  These values define the perimeter of a extent of
+%      pixel_wands view.
+%
+*/
+WandExport WandView *NewWandViewExtent(MagickWand *wand,const ssize_t x,
+  const ssize_t y,const size_t width,const size_t height)
+{
+  WandView
+    *wand_view;
+
+  assert(wand != (MagickWand *) NULL);
+  assert(wand->signature == WandSignature);
+  wand_view=(WandView *) AcquireAlignedMemory(1,sizeof(*wand_view));
+  if (wand_view == (WandView *) NULL)
+    ThrowWandFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
+      GetExceptionMessage(errno));
+  (void) ResetMagickMemory(wand_view,0,sizeof(*wand_view));
+  wand_view->id=AcquireWandId();
+  (void) FormatMagickString(wand_view->name,MaxTextExtent,"%s-%.20g",
+    WandViewId,(double) wand_view->id);
+  wand_view->description=ConstantString("WandView");
+  wand_view->view=AcquireCacheView(wand_view->wand->images);
+  wand_view->wand=wand;
+  wand_view->extent.width=width;
+  wand_view->extent.height=height;
+  wand_view->extent.x=x;
+  wand_view->extent.y=y;
+  wand_view->number_threads=GetOpenMPMaximumThreads();
+  wand_view->exception=AcquireExceptionInfo();
+  wand_view->pixel_wands=AcquirePixelsThreadSet(wand_view->extent.width,
     wand_view->number_threads);
   if (wand_view->pixel_wands == (PixelWand ***) NULL)
     ThrowWandFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
@@ -865,60 +839,31 @@
 %                                                                             %
 %                                                                             %
 %                                                                             %
-%   N e w W a n d V i e w R e g i o n                                         %
+%   S e t W a n d V i e w D e s c r i p t i o n                               %
 %                                                                             %
 %                                                                             %
 %                                                                             %
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %
-%  NewWandViewRegion() returns a wand view required for all other methods
-%  in the Wand View API.
+%  SetWandViewDescription() associates a description with an image view.
 %
-%  The format of the NewWandViewRegion method is:
+%  The format of the SetWandViewDescription method is:
 %
-%      WandView *NewWandViewRegion(MagickWand *wand,const ssize_t x,
-%        const ssize_t y,const size_t width,const size_t height)
+%      void SetWandViewDescription(WandView *image_view,const char *description)
 %
 %  A description of each parameter follows:
 %
-%    o wand: the magick wand.
+%    o wand_view: the wand view.
 %
-%    o x,y,columns,rows:  These values define the perimeter of a region of
-%      pixel_wands view.
+%    o description: the wand view description.
 %
 */
-WandExport WandView *NewWandViewRegion(MagickWand *wand,const ssize_t x,
-  const ssize_t y,const size_t width,const size_t height)
+MagickExport void SetWandViewDescription(WandView *wand_view,
+  const char *description)
 {
-  WandView
-    *wand_view;
-
-  assert(wand != (MagickWand *) NULL);
-  assert(wand->signature == MagickSignature);
-  wand_view=(WandView *) AcquireAlignedMemory(1,sizeof(*wand_view));
-  if (wand_view == (WandView *) NULL)
-    ThrowWandFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
-      GetExceptionMessage(errno));
-  (void) ResetMagickMemory(wand_view,0,sizeof(*wand_view));
-  wand_view->id=AcquireWandId();
-  (void) FormatMagickString(wand_view->name,MaxTextExtent,"%s-%.20g",
-    WandViewId,(double) wand_view->id);
-  wand_view->exception=AcquireExceptionInfo();
-  wand_view->view=AcquireCacheView(wand_view->wand->images);
-  wand_view->wand=wand;
-  wand_view->region.width=width;
-  wand_view->region.height=height;
-  wand_view->region.x=x;
-  wand_view->region.y=y;
-  wand_view->number_threads=GetOpenMPMaximumThreads();
-  wand_view->pixel_wands=AcquirePixelsThreadSet(wand_view->region.width,
-    wand_view->number_threads);
-  if (wand_view->pixel_wands == (PixelWand ***) NULL)
-    ThrowWandFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
-      GetExceptionMessage(errno));
-  wand_view->debug=IsEventLogging();
-  wand_view->signature=WandSignature;
-  return(wand_view);
+  assert(wand_view != (WandView *) NULL);
+  assert(wand_view->signature == WandSignature);
+  wand_view->description=ConstantString(description);
 }
 
 /*
@@ -933,7 +878,7 @@
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %
 %  SetWandViewIterator() iterates over the wand view in parallel and calls
-%  your set method for each scanline of the view.  The pixel region is
+%  your set method for each scanline of the view.  The pixel extent is
 %  confined to the image canvas-- that is no negative offsets or widths or
 %  heights that exceed the image dimension.  The pixels are initiallly
 %  undefined and any settings you make in the callback method are automagically
@@ -963,8 +908,6 @@
 WandExport MagickBooleanType SetWandViewIterator(WandView *destination,
   SetWandViewMethod set,void *context)
 {
-#define SetWandViewTag  "WandView/Set"
-
   ExceptionInfo
     *exception;
 
@@ -993,7 +936,7 @@
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,1) shared(progress,status)
 #endif
-  for (y=destination->region.y; y < (ssize_t) destination->region.height; y++)
+  for (y=destination->extent.y; y < (ssize_t) destination->extent.height; y++)
   {
     MagickBooleanType
       sync;
@@ -1011,8 +954,8 @@
     if (status == MagickFalse)
       continue;
     id=GetOpenMPThreadId();
-    pixels=GetCacheViewAuthenticPixels(destination->view,destination->region.x,
-      y,destination->region.width,1,exception);
+    pixels=GetCacheViewAuthenticPixels(destination->view,destination->extent.x,
+      y,destination->extent.width,1,exception);
     if (pixels == (PixelPacket *) NULL)
       {
         InheritException(destination->exception,GetCacheViewException(
@@ -1023,10 +966,10 @@
     indexes=GetCacheViewAuthenticIndexQueue(destination->view);
     if (set(destination,context) == MagickFalse)
       status=MagickFalse;
-    for (x=0; x < (ssize_t) destination->region.width; x++)
+    for (x=0; x < (ssize_t) destination->extent.width; x++)
       PixelGetQuantumColor(destination->pixel_wands[id][x],pixels+x);
     if (destination_image->colorspace == CMYKColorspace)
-      for (x=0; x < (ssize_t) destination->region.width; x++)
+      for (x=0; x < (ssize_t) destination->extent.width; x++)
         indexes[x]=PixelGetBlackQuantum(destination->pixel_wands[id][x]);
     sync=SyncCacheViewAuthenticPixels(destination->view,exception);
     if (sync == MagickFalse)
@@ -1043,8 +986,8 @@
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp critical (MagickWand_SetWandViewIterator)
 #endif
-        proceed=SetImageProgress(destination_image,SetWandViewTag,progress++,
-          destination->region.height);
+        proceed=SetImageProgress(destination_image,destination->description,
+          progress++,destination->extent.height);
         if (proceed == MagickFalse)
           status=MagickFalse;
       }
@@ -1065,7 +1008,7 @@
 %
 %  TransferWandViewIterator() iterates over two wand views in parallel and
 %  calls your transfer method for each scanline of the view.  The source pixel
-%  region is not confined to the image canvas-- that is you can include
+%  extent is not confined to the image canvas-- that is you can include
 %  negative offsets or widths or heights that exceed the image dimension.
 %  However, the destination wand view is confined to the image canvas-- that
 %  is no negative offsets or widths or heights that exceed the image dimension
@@ -1097,8 +1040,6 @@
 WandExport MagickBooleanType TransferWandViewIterator(WandView *source,
   WandView *destination,TransferWandViewMethod transfer,void *context)
 {
-#define TransferWandViewTag  "WandView/Transfer"
-
   ExceptionInfo
     *exception;
 
@@ -1129,7 +1070,7 @@
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,1) shared(progress,status)
 #endif
-  for (y=source->region.y; y < (ssize_t) source->region.height; y++)
+  for (y=source->extent.y; y < (ssize_t) source->extent.height; y++)
   {
     MagickBooleanType
       sync;
@@ -1153,45 +1094,45 @@
     if (status == MagickFalse)
       continue;
     id=GetOpenMPThreadId();
-    pixels=GetCacheViewVirtualPixels(source->view,source->region.x,y,
-      source->region.width,1,source->exception);
+    pixels=GetCacheViewVirtualPixels(source->view,source->extent.x,y,
+      source->extent.width,1,source->exception);
     if (pixels == (const PixelPacket *) NULL)
       {
         status=MagickFalse;
         continue;
       }
     indexes=GetCacheViewVirtualIndexQueue(source->view);
-    for (x=0; x < (ssize_t) source->region.width; x++)
+    for (x=0; x < (ssize_t) source->extent.width; x++)
       PixelSetQuantumColor(source->pixel_wands[id][x],pixels+x);
     if (source_image->colorspace == CMYKColorspace)
-      for (x=0; x < (ssize_t) source->region.width; x++)
+      for (x=0; x < (ssize_t) source->extent.width; x++)
         PixelSetBlackQuantum(source->pixel_wands[id][x],indexes[x]);
     if (source_image->storage_class == PseudoClass)
-      for (x=0; x < (ssize_t) source->region.width; x++)
+      for (x=0; x < (ssize_t) source->extent.width; x++)
         PixelSetIndex(source->pixel_wands[id][x],indexes[x]);
     destination_pixels=GetCacheViewAuthenticPixels(destination->view,
-      destination->region.x,y,destination->region.width,1,exception);
+      destination->extent.x,y,destination->extent.width,1,exception);
     if (destination_pixels == (PixelPacket *) NULL)
       {
         status=MagickFalse;
         continue;
       }
     destination_indexes=GetCacheViewAuthenticIndexQueue(destination->view);
-    for (x=0; x < (ssize_t) destination->region.width; x++)
+    for (x=0; x < (ssize_t) destination->extent.width; x++)
       PixelSetQuantumColor(destination->pixel_wands[id][x],pixels+x);
     if (destination_image->colorspace == CMYKColorspace)
-      for (x=0; x < (ssize_t) destination->region.width; x++)
+      for (x=0; x < (ssize_t) destination->extent.width; x++)
         PixelSetBlackQuantum(destination->pixel_wands[id][x],indexes[x]);
     if (destination_image->storage_class == PseudoClass)
-      for (x=0; x < (ssize_t) destination->region.width; x++)
+      for (x=0; x < (ssize_t) destination->extent.width; x++)
         PixelSetIndex(destination->pixel_wands[id][x],indexes[x]);
-    if (transfer(source,destination,context) == MagickFalse)
+    if (transfer(source,destination,y,id,context) == MagickFalse)
       status=MagickFalse;
-    for (x=0; x < (ssize_t) destination->region.width; x++)
+    for (x=0; x < (ssize_t) destination->extent.width; x++)
       PixelGetQuantumColor(destination->pixel_wands[id][x],
         destination_pixels+x);
     if (destination_image->colorspace == CMYKColorspace)
-      for (x=0; x < (ssize_t) destination->region.width; x++)
+      for (x=0; x < (ssize_t) destination->extent.width; x++)
         destination_indexes[x]=PixelGetBlackQuantum(
           destination->pixel_wands[id][x]);
     sync=SyncCacheViewAuthenticPixels(destination->view,exception);
@@ -1209,8 +1150,8 @@
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp critical (MagickWand_TransferWandViewIterator)
 #endif
-        proceed=SetImageProgress(source_image,TransferWandViewTag,progress++,
-          source->region.height);
+        proceed=SetImageProgress(source_image,source->description,progress++,
+          source->extent.height);
         if (proceed == MagickFalse)
           status=MagickFalse;
       }
@@ -1230,7 +1171,7 @@
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %
 %  UpdateWandViewIterator() iterates over the wand view in parallel and calls
-%  your update method for each scanline of the view.  The pixel region is
+%  your update method for each scanline of the view.  The pixel extent is
 %  confined to the image canvas-- that is no negative offsets or widths or
 %  heights that exceed the image dimension are permitted.  Updates to pixels
 %  in your callback are automagically synced back to the image.
@@ -1259,8 +1200,6 @@
 WandExport MagickBooleanType UpdateWandViewIterator(WandView *source,
   UpdateWandViewMethod update,void *context)
 {
-#define UpdateWandViewTag  "WandView/Update"
-
   ExceptionInfo
     *exception;
 
@@ -1289,7 +1228,7 @@
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp parallel for schedule(static,1) shared(progress,status)
 #endif
-  for (y=source->region.y; y < (ssize_t) source->region.height; y++)
+  for (y=source->extent.y; y < (ssize_t) source->extent.height; y++)
   {
     register IndexPacket
       *restrict indexes;
@@ -1304,8 +1243,8 @@
     if (status == MagickFalse)
       continue;
     id=GetOpenMPThreadId();
-    pixels=GetCacheViewAuthenticPixels(source->view,source->region.x,y,
-      source->region.width,1,exception);
+    pixels=GetCacheViewAuthenticPixels(source->view,source->extent.x,y,
+      source->extent.width,1,exception);
     if (pixels == (PixelPacket *) NULL)
       {
         InheritException(source->exception,GetCacheViewException(
@@ -1314,17 +1253,17 @@
         continue;
       }
     indexes=GetCacheViewAuthenticIndexQueue(source->view);
-    for (x=0; x < (ssize_t) source->region.width; x++)
+    for (x=0; x < (ssize_t) source->extent.width; x++)
       PixelSetQuantumColor(source->pixel_wands[id][x],pixels+x);
     if (source_image->colorspace == CMYKColorspace)
-      for (x=0; x < (ssize_t) source->region.width; x++)
+      for (x=0; x < (ssize_t) source->extent.width; x++)
         PixelSetBlackQuantum(source->pixel_wands[id][x],indexes[x]);
-    if (update(source,context) == MagickFalse)
+    if (update(source,y,id,context) == MagickFalse)
       status=MagickFalse;
-    for (x=0; x < (ssize_t) source->region.width; x++)
+    for (x=0; x < (ssize_t) source->extent.width; x++)
       PixelGetQuantumColor(source->pixel_wands[id][x],pixels+x);
     if (source_image->colorspace == CMYKColorspace)
-      for (x=0; x < (ssize_t) source->region.width; x++)
+      for (x=0; x < (ssize_t) source->extent.width; x++)
         indexes[x]=PixelGetBlackQuantum(source->pixel_wands[id][x]);
     if (SyncCacheViewAuthenticPixels(source->view,exception) == MagickFalse)
       {
@@ -1339,8 +1278,8 @@
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
   #pragma omp critical (MagickWand_UpdateWandViewIterator)
 #endif
-        proceed=SetImageProgress(source_image,UpdateWandViewTag,progress++,
-          source->region.height);
+        proceed=SetImageProgress(source_image,source->description,progress++,
+          source->extent.height);
         if (proceed == MagickFalse)
           status=MagickFalse;
       }
diff --git a/wand/wand-view.h b/wand/wand-view.h
index 2c6dc23..121afac 100644
--- a/wand/wand-view.h
+++ b/wand/wand-view.h
@@ -27,11 +27,12 @@
 
 typedef MagickBooleanType
   (*DuplexTransferWandViewMethod)(const WandView *,const WandView *,WandView *,
-    void *),
+    const ssize_t,const int,void *),
   (*GetWandViewMethod)(const WandView *,void *),
   (*SetWandViewMethod)(WandView *,void *),
-  (*TransferWandViewMethod)(const WandView *,WandView *,void *),
-  (*UpdateWandViewMethod)(WandView *,void *);
+  (*TransferWandViewMethod)(const WandView *,WandView *,const ssize_t,
+    const int,void *),
+  (*UpdateWandViewMethod)(WandView *,const ssize_t,const int,void *);
 
 extern WandExport char
   *GetWandViewException(const WandView *,ExceptionType *);
@@ -48,24 +49,22 @@
 extern WandExport MagickWand
   *GetWandViewWand(const WandView *);
 
+extern WandExport PixelWand
+  **GetWandViewPixels(const WandView *);
+
+extern WandExport RectangleInfo
+  GetWandViewExtent(const WandView *);
+
+extern WandExport void
+  SetWandViewDescription(WandView *,const char *);
+
 extern WandExport WandView
   *CloneWandView(const WandView *),
   *DestroyWandView(WandView *),
   *NewWandView(MagickWand *),
-  *NewWandViewRegion(MagickWand *,const ssize_t,const ssize_t,const size_t,
+  *NewWandViewExtent(MagickWand *,const ssize_t,const ssize_t,const size_t,
     const size_t);
 
-extern WandExport PixelWand
-  **GetWandViewPixels(const WandView *);
-
-extern WandExport size_t
-  GetWandViewHeight(const WandView *),
-  GetWandViewWidth(const WandView *);
-
-extern WandExport ssize_t
-  GetWandViewX(const WandView *),
-  GetWandViewY(const WandView *);
-
 #if defined(__cplusplus) || defined(c_plusplus)
 }
 #endif
diff --git a/www/ImageMagickObject.html b/www/ImageMagickObject.html
index 4e42c50..e82574b 100644
--- a/www/ImageMagickObject.html
+++ b/www/ImageMagickObject.html
@@ -207,7 +207,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/advanced-unix-installation.html b/www/advanced-unix-installation.html
index 7be4a09..42232fc 100644
--- a/www/advanced-unix-installation.html
+++ b/www/advanced-unix-installation.html
@@ -142,7 +142,7 @@
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
 <div  class="sponsor">
-   <a title="Sponsor: Online-Magazin" href="http://www.unkostenbeitrag.de/" title="Online-Magazin">Online-Magazin</a><!-- 20101101000200 -->
+   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
 </div>
 </div>
 </div>
@@ -593,7 +593,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/advanced-windows-installation.html b/www/advanced-windows-installation.html
index b80d812..a5fbea8 100644
--- a/www/advanced-windows-installation.html
+++ b/www/advanced-windows-installation.html
@@ -142,7 +142,7 @@
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
 <div  class="sponsor">
-   <a title="Sponsor: Online-Magazin" href="http://www.unkostenbeitrag.de/" title="Online-Magazin">Online-Magazin</a><!-- 20101101000200 -->
+   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
 </div>
 </div>
 </div>
diff --git a/www/animate.html b/www/animate.html
index 5cd320e..e087122 100644
--- a/www/animate.html
+++ b/www/animate.html
@@ -612,7 +612,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/api.html b/www/api.html
index cbd5821..caed8f9 100644
--- a/www/api.html
+++ b/www/api.html
@@ -141,9 +141,6 @@
 <div  class="sponsor">
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
-<div  class="sponsor">
-   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
-</div>
 </div>
 </div>
 
@@ -160,7 +157,7 @@
   <h2><a name="ada"></a>Ada</h2>
 </div>
 
-<p><a href="https://gna.org/projects/g2f/" target="47810688">G2F</a> implements an Ada 95 binding to a subset of the low-level MagickCore library.</p>
+<p><a href="https://gna.org/projects/g2f/" target="2061929515">G2F</a> implements an Ada 95 binding to a subset of the low-level MagickCore library.</p>
 
 <div style="margin: auto;">
   <h2><a name="c"></a>C</h2>
@@ -172,7 +169,7 @@
   <h2><a name="ch"></a>Ch</h2>
 </div>
 
-<p><a href="http://www.imagemagick.org/ChMagick" target="2090328326">ChMagick</a> is a <a href="http://www.softintegration.com/" target="1672899526">Ch</a> binding to the MagickCore and MagickWand API.  Ch is an embeddable C/C++ interpreter for cross-platform scripting.</p>
+<p><a href="http://www.imagemagick.org/ChMagick" target="1864245311">ChMagick</a> is a <a href="http://www.softintegration.com/" target="1600165702">Ch</a> binding to the MagickCore and MagickWand API.  Ch is an embeddable C/C++ interpreter for cross-platform scripting.</p>
 
 <div style="margin: auto;">
   <h2><a name="com+"></a>COM+</h2>
@@ -184,31 +181,31 @@
   <h2><a name="c++"></a>C++</h2>
 </div>
 
-<p><a href="http://www.imagemagick.org/Magick++" target="1644265884">Magick++</a> provides an object-oriented C++ interface to ImageMagick.  See <a href="http://www.imagemagick.org/Magick++/tutorial/Magick++_tutorial.pdf" target="796317481">A Gentle Introduction to Magick++</a> for an introductory tutorial to Magick++.  We include the <a href="http://www.imagemagick.org/Magick++/tutorial/Magick++_tutorial.odt" target="1778244380">source</a> if you want to correct, enhance, or expand the tutorial.</p>
+<p><a href="http://www.imagemagick.org/Magick++" target="1543287628">Magick++</a> provides an object-oriented C++ interface to ImageMagick.  See <a href="http://www.imagemagick.org/Magick++/tutorial/Magick++_tutorial.pdf" target="1569302200">A Gentle Introduction to Magick++</a> for an introductory tutorial to Magick++.  We include the <a href="http://www.imagemagick.org/Magick++/tutorial/Magick++_tutorial.odt" target="1836325497">source</a> if you want to correct, enhance, or expand the tutorial.</p>
 
 <div style="margin: auto;">
   <h2><a name="java"></a>Java</h2>
 </div>
 
-<p><a href="http://www.jmagick.org" target="1190666296">JMagick</a> provides an object-oriented Java interface to ImageMagick.  <a href="http://im4java.sourceforge.net" target="1207747543">Im4java</a> is a pure-java interface to the ImageMagick command-line.</p>
+<p><a href="http://www.jmagick.org" target="1234985553">JMagick</a> provides an object-oriented Java interface to ImageMagick.  <a href="http://im4java.sourceforge.net" target="1882585836">Im4java</a> is a pure-java interface to the ImageMagick command-line.</p>
 
 <div style="margin: auto;">
   <h2><a name="labview"></a>LabVIEW</h2>
 </div>
 
-<p><a href="http://forums.lavag.org/downloads-file90.html" target="1108645374">LVOOP ImageMagick</a> is an object-oriented LabVIEW interface to ImageMagick.</p>
+<p><a href="http://forums.lavag.org/downloads-file90.html" target="1617838397">LVOOP ImageMagick</a> is an object-oriented LabVIEW interface to ImageMagick.</p>
 
 <div style="margin: auto;">
   <h2><a name="lisp"></a>Lisp</h2>
 </div>
 
-<p><a href="http://common-lisp.net/project/cl-magick/" target="1288812207">CL-Magick</a> provides a Common Lisp interface to the ImageMagick library.</p>
+<p><a href="http://common-lisp.net/project/cl-magick/" target="1056694913">CL-Magick</a> provides a Common Lisp interface to the ImageMagick library.</p>
 
 <div style="margin: auto;">
   <h2><a name="neko"></a>Neko</h2>
 </div>
 
-<p><a href="http://code.google.com/p/nmagick" target="683562817">NMagick</a> is a port of the ImageMagick library to the haXe and Neko platforms. It provides image manipulation capabilities to both web and desktop applications using Neko.</p>
+<p><a href="http://code.google.com/p/nmagick" target="620089209">NMagick</a> is a port of the ImageMagick library to the haXe and Neko platforms. It provides image manipulation capabilities to both web and desktop applications using Neko.</p>
 
 <div style="margin: auto;">
   <h2><a name="dot-net"></a>.NET</h2>
@@ -222,7 +219,7 @@
   <h2><a name="pascal"></a>Pascal</h2>
 </div>
 
-<p><a href="http://wiki.lazarus.freepascal.org/PascalMagick" target="38372465">PascalMagick</a> a Pascal binding for the MagickWand API and also the low-level MagickCore library. It works with Free Pascal / Lazarus and Delphi.</p>
+<p><a href="http://wiki.lazarus.freepascal.org/PascalMagick" target="2021859163">PascalMagick</a> a Pascal binding for the MagickWand API and also the low-level MagickCore library. It works with Free Pascal / Lazarus and Delphi.</p>
 
 <div style="margin: auto;">
   <h2><a name="perl"></a>Perl</h2>
@@ -234,50 +231,50 @@
   <h2><a name="php"></a>PHP</h2>
 </div>
 
-<p><a href="http://www.magickwand.org/" target="1382678625">MagickWand for PHP</a> a native PHP-extension to the ImageMagick MagickWand API.</p>
+<p><a href="http://www.magickwand.org/" target="1165764962">MagickWand for PHP</a> a native PHP-extension to the ImageMagick MagickWand API.</p>
 
-<p><a href="http://pecl.php.net/package/imagick" target="2134164939">IMagick</a> is a native PHP extension to create and modify images using the ImageMagick API.  Documentation for the extension is available <a href="http://php.net/imagick" target="948988437">here</a>.</p>
+<p><a href="http://pecl.php.net/package/imagick" target="1247875051">IMagick</a> is a native PHP extension to create and modify images using the ImageMagick API.  Documentation for the extension is available <a href="http://php.net/imagick" target="1125808605">here</a>.</p>
 
-<p><a href="http://www.francodacosta.com/phmagick" target="1432895023">phMagick</a> is a wrapper class for ImageMagick, wrapping the most common web image manipulation actions in easy to use functions, but allowing full access to ImageMagick's power by issuing system calls to it's command-line programs.</p>
+<p><a href="http://www.francodacosta.com/phmagick" target="569980696">phMagick</a> is a wrapper class for ImageMagick, wrapping the most common web image manipulation actions in easy to use functions, but allowing full access to ImageMagick's power by issuing system calls to it's command-line programs.</p>
 
 <div style="margin: auto;">
 
   <h2><a name="python"></a>Python</h2>
 </div>
 
-<p><a href="http://www.assembla.com/wiki/show/pythonmagickwand" target="310395953">PythonMagickWand</a> is an object-oriented Python interface to MagickWand based on ctypes.</p>
+<p><a href="http://www.assembla.com/wiki/show/pythonmagickwand" target="1518042962">PythonMagickWand</a> is an object-oriented Python interface to MagickWand based on ctypes.</p>
 
-<p><a href="http://www.imagemagick.org/download/python/" target="1614461733">PythonMagick</a> is an object-oriented Python interface to ImageMagick.</p>
+<p><a href="http://www.imagemagick.org/download/python/" target="661094729">PythonMagick</a> is an object-oriented Python interface to ImageMagick.</p>
 
 <div style="margin: auto;">
   <h2><a name="realbasic"></a>REALbasic</h2>
 </div>
 
-<p>The <a href="http://www.monkeybreadsoftware.de/realbasic/plugin-imagemagick.shtml" target="1149098175">MBS Realbasic ImageMagick</a> is a plugin that utilizes the power of ImageMagick from within the RealBasic environment.</p>
+<p>The <a href="http://www.monkeybreadsoftware.de/realbasic/plugin-imagemagick.shtml" target="278737946">MBS Realbasic ImageMagick</a> is a plugin that utilizes the power of ImageMagick from within the RealBasic environment.</p>
 
 <div style="margin: auto;">
   <h2><a name="ruby"></a>Ruby</h2>
 </div>
 
-<p><a href="http://rmagick.rubyforge.org/" target="488208851">RMagick</a> is an interface between the Ruby programming language and the <a href="../www/magick-core.html">MagickCore</a> image processing libraries.  Get started with RMagick by perusing the <a href="http://www.imagemagick.org/RMagick/doc/" target="1965733756">documentation</a>.</p>
+<p><a href="http://rmagick.rubyforge.org/" target="1627332362">RMagick</a> is an interface between the Ruby programming language and the <a href="../www/magick-core.html">MagickCore</a> image processing libraries.  Get started with RMagick by perusing the <a href="http://www.imagemagick.org/RMagick/doc/" target="404592085">documentation</a>.</p>
 
-<p><a href="http://magickwand.rubyforge.org/" target="2134342351">MagickWand for Ruby</a> is an interface between the Ruby programming language and the <a href="../www/magick-wand.html">MagickWand</a> image processing libraries.  Get started with MagickWand for PHP by perusing the <a href="http://magickwand.rubyforge.org/" target="670930352">documentation</a>.</p>
+<p><a href="http://magickwand.rubyforge.org/" target="914493322">MagickWand for Ruby</a> is an interface between the Ruby programming language and the <a href="../www/magick-wand.html">MagickWand</a> image processing libraries.  Get started with MagickWand for PHP by perusing the <a href="http://magickwand.rubyforge.org/" target="1106110652">documentation</a>.</p>
 
-<p><a href="http://rubyforge.org/projects/mini-magick" target="414261429">MiniMagick</a> is a Ruby wrapper for ImageMagick command line. MiniMagick gives you convenient access to all the command line options ImageMagick supports.</p>
+<p><a href="http://rubyforge.org/projects/mini-magick" target="1773289403">MiniMagick</a> is a Ruby wrapper for ImageMagick command line. MiniMagick gives you convenient access to all the command line options ImageMagick supports.</p>
 
-<p><a href="http://quickmagick.rubyforge.org/quick_magick" target="1474611175">QuickMagick</a> is a gem for easily accessing ImageMagick command line tools from Ruby programs.</p>
+<p><a href="http://quickmagick.rubyforge.org/quick_magick" target="247475522">QuickMagick</a> is a gem for easily accessing ImageMagick command line tools from Ruby programs.</p>
 
 <div style="margin: auto;">
   <h2><a name="tcl"></a>Tcl/Tk</h2>
 </div>
 
-<p><a href="http://tclmagick.sourceforge.net/" target="1650272146">TclMagick</a> a native Tcl-extension to the ImageMagick MagickWand API.</p>
+<p><a href="http://tclmagick.sourceforge.net/" target="1774035703">TclMagick</a> a native Tcl-extension to the ImageMagick MagickWand API.</p>
 
 <div style="margin: auto;">
   <h2><a name="xml-rpc"></a>XML RPC</h2>
 </div>
 
-<p><a href="http://code.google.com/p/remotemagick/" target="763659111">RemoteMagick</a> is an XML-RPC web service that creates image thumbnails.</p>
+<p><a href="http://code.google.com/p/remotemagick/" target="1719311691">RemoteMagick</a> is an XML-RPC web service that creates image thumbnails.</p>
 
 </div>
 
diff --git a/www/api/attribute.html b/www/api/attribute.html
index c97b69b..dd6d997 100644
--- a/www/api/attribute.html
+++ b/www/api/attribute.html
@@ -141,9 +141,6 @@
 <div  class="sponsor">
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
-<div  class="sponsor">
-   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
-</div>
 </div>
 </div>
 
@@ -330,7 +327,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/api/cache-view.html b/www/api/cache-view.html
index c781c02..12f0901 100644
--- a/www/api/cache-view.html
+++ b/www/api/cache-view.html
@@ -142,7 +142,7 @@
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
 <div  class="sponsor">
-   <a title="Sponsor: Online-Magazin" href="http://www.unkostenbeitrag.de/" title="Online-Magazin">Online-Magazin</a><!-- 20101101000200 -->
+   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
 </div>
 </div>
 </div>
@@ -576,7 +576,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/api/cache.html b/www/api/cache.html
index c328f5a..199f488 100644
--- a/www/api/cache.html
+++ b/www/api/cache.html
@@ -141,9 +141,6 @@
 <div  class="sponsor">
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
-<div  class="sponsor">
-   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
-</div>
 </div>
 </div>
 
diff --git a/www/api/color.html b/www/api/color.html
index efaa22b..322f8b8 100644
--- a/www/api/color.html
+++ b/www/api/color.html
@@ -368,7 +368,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/api/colormap.html b/www/api/colormap.html
index a232358..3c6af74 100644
--- a/www/api/colormap.html
+++ b/www/api/colormap.html
@@ -204,7 +204,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/api/compare.html b/www/api/compare.html
index 287133b..5087367 100644
--- a/www/api/compare.html
+++ b/www/api/compare.html
@@ -325,7 +325,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/api/composite.html b/www/api/composite.html
index 04e239e..75f98e4 100644
--- a/www/api/composite.html
+++ b/www/api/composite.html
@@ -232,7 +232,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/api/constitute.html b/www/api/constitute.html
index 14eb4a5..c01c87f 100644
--- a/www/api/constitute.html
+++ b/www/api/constitute.html
@@ -142,7 +142,7 @@
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
 <div  class="sponsor">
-   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
+   <a title="Sponsor: Online-Magazin" href="http://www.unkostenbeitrag.de/" title="Online-Magazin">Online-Magazin</a><!-- 20101101000200 -->
 </div>
 </div>
 </div>
@@ -333,7 +333,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/api/decorate.html b/www/api/decorate.html
index 389dc7b..720d992 100644
--- a/www/api/decorate.html
+++ b/www/api/decorate.html
@@ -141,9 +141,6 @@
 <div  class="sponsor">
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
-<div  class="sponsor">
-   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
-</div>
 </div>
 </div>
 
@@ -236,7 +233,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/api/display.html b/www/api/display.html
index 38bceab..ecc321e 100644
--- a/www/api/display.html
+++ b/www/api/display.html
@@ -236,7 +236,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/api/distort.html b/www/api/distort.html
index 11236f9..fcf6016 100644
--- a/www/api/distort.html
+++ b/www/api/distort.html
@@ -257,7 +257,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/api/drawing-wand.html b/www/api/drawing-wand.html
index 22cd2f2..4e74886 100644
--- a/www/api/drawing-wand.html
+++ b/www/api/drawing-wand.html
@@ -3067,7 +3067,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/api/effect.html b/www/api/effect.html
index f5cdf51..b9163e1 100644
--- a/www/api/effect.html
+++ b/www/api/effect.html
@@ -142,7 +142,7 @@
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
 <div  class="sponsor">
-   <a title="Sponsor: Online-Magazin" href="http://www.unkostenbeitrag.de/" title="Online-Magazin">Online-Magazin</a><!-- 20101101000200 -->
+   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
 </div>
 </div>
 </div>
diff --git a/www/api/enhance.html b/www/api/enhance.html
index f67b859..1652577 100644
--- a/www/api/enhance.html
+++ b/www/api/enhance.html
@@ -142,7 +142,7 @@
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
 <div  class="sponsor">
-   <a title="Sponsor: Online-Magazin" href="http://www.unkostenbeitrag.de/" title="Online-Magazin">Online-Magazin</a><!-- 20101101000200 -->
+   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
 </div>
 </div>
 </div>
diff --git a/www/api/exception.html b/www/api/exception.html
index 5c90e95..33a70ea 100644
--- a/www/api/exception.html
+++ b/www/api/exception.html
@@ -465,7 +465,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/api/feature.html b/www/api/feature.html
index c71c4b5..d07b78f 100644
--- a/www/api/feature.html
+++ b/www/api/feature.html
@@ -142,7 +142,7 @@
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
 <div  class="sponsor">
-   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
+   <a title="Sponsor: Online-Magazin" href="http://www.unkostenbeitrag.de/" title="Online-Magazin">Online-Magazin</a><!-- 20101101000200 -->
 </div>
 </div>
 </div>
@@ -193,7 +193,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/api/fx.html b/www/api/fx.html
index 3e5a29f..2236831 100644
--- a/www/api/fx.html
+++ b/www/api/fx.html
@@ -717,7 +717,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/api/image-view.html b/www/api/image-view.html
index 4c129be..399de42 100644
--- a/www/api/image-view.html
+++ b/www/api/image-view.html
@@ -141,9 +141,6 @@
 <div  class="sponsor">
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
-<div  class="sponsor">
-   <a title="Sponsor: Online-Magazin" href="http://www.unkostenbeitrag.de/" title="Online-Magazin">Online-Magazin</a><!-- 20101101000200 -->
-</div>
 </div>
 </div>
 
@@ -152,7 +149,7 @@
 
 <div class="main">
 
-<p class="navigation-index">[<a href="#CloneImageView">CloneImageView</a> &bull; <a href="#DestroyImageView">DestroyImageView</a> &bull; <a href="#DuplexTransferImageViewIterator">DuplexTransferImageViewIterator</a> &bull; <a href="#GetImageViewAuthenticIndexes">GetImageViewAuthenticIndexes</a> &bull; <a href="#GetImageViewAuthenticPixels">GetImageViewAuthenticPixels</a> &bull; <a href="#GetImageViewException">GetImageViewException</a> &bull; <a href="#GetImageViewHeight">GetImageViewHeight</a> &bull; <a href="#GetImageViewImage">GetImageViewImage</a> &bull; <a href="#GetImageViewIterator">GetImageViewIterator</a> &bull; <a href="#GetImageViewVirtualIndexes">GetImageViewVirtualIndexes</a> &bull; <a href="#GetImageViewVirtualPixels">GetImageViewVirtualPixels</a> &bull; <a href="#GetImageViewWidth">GetImageViewWidth</a> &bull; <a href="#GetImageViewX">GetImageViewX</a> &bull; <a href="#GetImageViewY">GetImageViewY</a> &bull; <a href="#IsImageView">IsImageView</a> &bull; <a href="#NewImageView">NewImageView</a> &bull; <a href="#NewImageViewRegion">NewImageViewRegion</a> &bull; <a href="#SetImageViewIterator">SetImageViewIterator</a> &bull; <a href="#TransferImageViewIterator">TransferImageViewIterator</a> &bull; <a href="#UpdateImageViewIterator">UpdateImageViewIterator</a>]</p>
+<p class="navigation-index">[<a href="#CloneImageView">CloneImageView</a> &bull; <a href="#DestroyImageView">DestroyImageView</a> &bull; <a href="#DuplexTransferImageViewIterator">DuplexTransferImageViewIterator</a> &bull; <a href="#GetImageViewAuthenticIndexes">GetImageViewAuthenticIndexes</a> &bull; <a href="#GetImageViewAuthenticPixels">GetImageViewAuthenticPixels</a> &bull; <a href="#GetImageViewException">GetImageViewException</a> &bull; <a href="#GetImageViewExtent">GetImageViewExtent</a> &bull; <a href="#GetImageViewImage">GetImageViewImage</a> &bull; <a href="#GetImageViewIterator">GetImageViewIterator</a> &bull; <a href="#GetImageViewVirtualIndexes">GetImageViewVirtualIndexes</a> &bull; <a href="#GetImageViewVirtualPixels">GetImageViewVirtualPixels</a> &bull; <a href="#IsImageView">IsImageView</a> &bull; <a href="#NewImageView">NewImageView</a> &bull; <a href="#NewImageViewRegion">NewImageViewRegion</a> &bull; <a href="#SetImageViewIterator">SetImageViewIterator</a> &bull; <a href="#TransferImageViewIterator">TransferImageViewIterator</a> &bull; <a href="#UpdateImageViewIterator">UpdateImageViewIterator</a>]</p>
 
 <h2><a href="http://www.imagemagick.org/api/MagickCore/image-view
 _8c.html" target="source" name="CloneImageView">CloneImageView</a></h2>
@@ -194,7 +191,7 @@
 _8c.html" target="source" name="DuplexTransferImageViewIterator">DuplexTransferImageViewIterator</a></h2>
 <div class="doc-section">
 
-<p>DuplexTransferImageViewIterator() iterates over three image views in parallel and calls your transfer method for each scanline of the view.  The source and duplex pixel region is not confined to the image canvas-- that is you can include negative offsets or widths or heights that exceed the image dimension.  However, the destination image view is confined to the image canvas-- that is no negative offsets or widths or heights that exceed the image dimension are permitted.</p></ol>
+<p>DuplexTransferImageViewIterator() iterates over three image views in parallel and calls your transfer method for each scanline of the view.  The source and duplex pixel extent is not confined to the image canvas-- that is you can include negative offsets or widths or heights that exceed the image dimension.  However, the destination image view is confined to the image canvas-- that is no negative offsets or widths or heights that exceed the image dimension are permitted.</p></ol>
 
 <p>Use this pragma if the view is not single threaded:</p>
 
@@ -289,15 +286,15 @@
 
  </div>
 <h2><a href="http://www.imagemagick.org/api/MagickCore/image-view
-_8c.html" target="source" name="GetImageViewHeight">GetImageViewHeight</a></h2>
+_8c.html" target="source" name="GetImageViewExtent">GetImageViewExtent</a></h2>
 <div class="doc-section">
 
-<p>GetImageViewHeight() returns the image view height.</p></ol>
+<p>GetImageViewExtent() returns the image view extent.</p></ol>
 
-<p>The format of the GetImageViewHeight method is:</p>
+<p>The format of the GetImageViewExtent method is:</p>
 
 <pre class="code">
-  size_t GetImageViewHeight(const ImageView *image_view)
+  RectangleInfo GetImageViewExtent(const ImageView *image_view)
 </pre>
 
 <p>A description of each parameter follows:</p></ol>
@@ -328,7 +325,7 @@
 _8c.html" target="source" name="GetImageViewIterator">GetImageViewIterator</a></h2>
 <div class="doc-section">
 
-<p>GetImageViewIterator() iterates over the image view in parallel and calls your get method for each scanline of the view.  The pixel region is not confined to the image canvas-- that is you can include negative offsets or widths or heights that exceed the image dimension.  Any updates to the pixels in your callback are ignored.</p></ol>
+<p>GetImageViewIterator() iterates over the image view in parallel and calls your get method for each scanline of the view.  The pixel extent is not confined to the image canvas-- that is you can include negative offsets or widths or heights that exceed the image dimension.  Any updates to the pixels in your callback are ignored.</p></ol>
 
 <p>Use this pragma if the view is not single threaded:</p>
 
@@ -395,60 +392,6 @@
 
  </div>
 <h2><a href="http://www.imagemagick.org/api/MagickCore/image-view
-_8c.html" target="source" name="GetImageViewWidth">GetImageViewWidth</a></h2>
-<div class="doc-section">
-
-<p>GetImageViewWidth() returns the image view width.</p></ol>
-
-<p>The format of the GetImageViewWidth method is:</p>
-
-<pre class="code">
-  size_t GetImageViewWidth(const ImageView *image_view)
-</pre>
-
-<p>A description of each parameter follows:</p></ol>
-
-<h5>image_view</h5>
-<ol><p>the image view.</p></ol>
-
- </div>
-<h2><a href="http://www.imagemagick.org/api/MagickCore/image-view
-_8c.html" target="source" name="GetImageViewX">GetImageViewX</a></h2>
-<div class="doc-section">
-
-<p>GetImageViewX() returns the image view x offset.</p></ol>
-
-<p>The format of the GetImageViewX method is:</p>
-
-<pre class="code">
-  ssize_t GetImageViewX(const ImageView *image_view)
-</pre>
-
-<p>A description of each parameter follows:</p></ol>
-
-<h5>image_view</h5>
-<ol><p>the image view.</p></ol>
-
- </div>
-<h2><a href="http://www.imagemagick.org/api/MagickCore/image-view
-_8c.html" target="source" name="GetImageViewY">GetImageViewY</a></h2>
-<div class="doc-section">
-
-<p>GetImageViewY() returns the image view y offset.</p></ol>
-
-<p>The format of the GetImageViewY method is:</p>
-
-<pre class="code">
-  ssize_t GetImageViewY(const ImageView *image_view)
-</pre>
-
-<p>A description of each parameter follows:</p></ol>
-
-<h5>image_view</h5>
-<ol><p>the image view.</p></ol>
-
- </div>
-<h2><a href="http://www.imagemagick.org/api/MagickCore/image-view
 _8c.html" target="source" name="IsImageView">IsImageView</a></h2>
 <div class="doc-section">
 
@@ -470,7 +413,7 @@
 _8c.html" target="source" name="NewImageView">NewImageView</a></h2>
 <div class="doc-section">
 
-<p>NewImageView() returns a image view required for all other methods in the Pixel View API.</p></ol>
+<p>NewImageView() returns a image view required for all other methods in the Image View API.</p></ol>
 
 <p>The format of the NewImageView method is:</p>
 
@@ -488,7 +431,7 @@
 _8c.html" target="source" name="NewImageViewRegion">NewImageViewRegion</a></h2>
 <div class="doc-section">
 
-<p>NewImageViewRegion() returns a image view required for all other methods in the Pixel View API.</p></ol>
+<p>NewImageViewRegion() returns a image view required for all other methods in the Image View API.</p></ol>
 
 <p>The format of the NewImageViewRegion method is:</p>
 
@@ -503,14 +446,14 @@
 <ol><p>the magick wand.</p></ol>
 
 <h5>x,y,columns,rows</h5>
-<ol><p>These values define the perimeter of a region of pixel_wands view.</p></ol>
+<ol><p>These values define the perimeter of a extent of pixel_wands view.</p></ol>
 
  </div>
 <h2><a href="http://www.imagemagick.org/api/MagickCore/image-view
 _8c.html" target="source" name="SetImageViewIterator">SetImageViewIterator</a></h2>
 <div class="doc-section">
 
-<p>SetImageViewIterator() iterates over the image view in parallel and calls your set method for each scanline of the view.  The pixel region is confined to the image canvas-- that is no negative offsets or widths or heights that exceed the image dimension.  The pixels are initiallly undefined and any settings you make in the callback method are automagically synced back to your image.</p></ol>
+<p>SetImageViewIterator() iterates over the image view in parallel and calls your set method for each scanline of the view.  The pixel extent is confined to the image canvas-- that is no negative offsets or widths or heights that exceed the image dimension.  The pixels are initiallly undefined and any settings you make in the callback method are automagically synced back to your image.</p></ol>
 
 <p>Use this pragma if the view is not single threaded:</p>
 
@@ -543,7 +486,7 @@
 _8c.html" target="source" name="TransferImageViewIterator">TransferImageViewIterator</a></h2>
 <div class="doc-section">
 
-<p>TransferImageViewIterator() iterates over two image views in parallel and calls your transfer method for each scanline of the view.  The source pixel region is not confined to the image canvas-- that is you can include negative offsets or widths or heights that exceed the image dimension. However, the destination image view is confined to the image canvas-- that is no negative offsets or widths or heights that exceed the image dimension are permitted.</p></ol>
+<p>TransferImageViewIterator() iterates over two image views in parallel and calls your transfer method for each scanline of the view.  The source pixel extent is not confined to the image canvas-- that is you can include negative offsets or widths or heights that exceed the image dimension. However, the destination image view is confined to the image canvas-- that is no negative offsets or widths or heights that exceed the image dimension are permitted.</p></ol>
 
 <p>Use this pragma if the view is not single threaded:</p>
 
@@ -579,7 +522,7 @@
 _8c.html" target="source" name="UpdateImageViewIterator">UpdateImageViewIterator</a></h2>
 <div class="doc-section">
 
-<p>UpdateImageViewIterator() iterates over the image view in parallel and calls your update method for each scanline of the view.  The pixel region is confined to the image canvas-- that is no negative offsets or widths or heights that exceed the image dimension are permitted.  Updates to pixels in your callback are automagically synced back to the image.</p></ol>
+<p>UpdateImageViewIterator() iterates over the image view in parallel and calls your update method for each scanline of the view.  The pixel extent is confined to the image canvas-- that is no negative offsets or widths or heights that exceed the image dimension are permitted.  Updates to pixels in your callback are automagically synced back to the image.</p></ol>
 
 <p>Use this pragma if the view is not single threaded:</p>
 
diff --git a/www/api/list.html b/www/api/list.html
index 50a9e08..d1895c5 100644
--- a/www/api/list.html
+++ b/www/api/list.html
@@ -142,7 +142,7 @@
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
 <div  class="sponsor">
-   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
+   <a title="Sponsor: Online-Magazin" href="http://www.unkostenbeitrag.de/" title="Online-Magazin">Online-Magazin</a><!-- 20101101000200 -->
 </div>
 </div>
 </div>
@@ -645,7 +645,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/api/magick-deprecate.html b/www/api/magick-deprecate.html
index e6a7438..bb46bd7 100644
--- a/www/api/magick-deprecate.html
+++ b/www/api/magick-deprecate.html
@@ -152,7 +152,7 @@
 
 <div class="main">
 
-<p class="navigation-index">[<a href="#MagickAverageImages">MagickAverageImages</a> &bull; <a href="#MagickClipPathImage">MagickClipPathImage</a> &bull; <a href="#DrawGetFillAlpha">DrawGetFillAlpha</a> &bull; <a href="#DrawGetStrokeAlpha">DrawGetStrokeAlpha</a> &bull; <a href="#DrawPeekGraphicWand">DrawPeekGraphicWand</a> &bull; <a href="#DrawPopGraphicContext">DrawPopGraphicContext</a> &bull; <a href="#DrawPushGraphicContext">DrawPushGraphicContext</a> &bull; <a href="#DrawSetFillAlpha">DrawSetFillAlpha</a> &bull; <a href="#DrawSetStrokeAlpha">DrawSetStrokeAlpha</a> &bull; <a href="#MagickColorFloodfillImage">MagickColorFloodfillImage</a> &bull; <a href="#MagickDescribeImage">MagickDescribeImage</a> &bull; <a href="#MagickFlattenImages">MagickFlattenImages</a> &bull; <a href="#MagickGetImageAttribute">MagickGetImageAttribute</a> &bull; <a href="#MagickGetImageMatte">MagickGetImageMatte</a> &bull; <a href="#MagickGetImagePixels">MagickGetImagePixels</a> &bull; <a href="#MagickGetImageSize">MagickGetImageSize</a> &bull; <a href="#MagickMapImage">MagickMapImage</a> &bull; <a href="#MagickMatteFloodfillImage">MagickMatteFloodfillImage</a> &bull; <a href="#MagickMaximumImages">MagickMaximumImages</a> &bull; <a href="#MagickMinimumImages">MagickMinimumImages</a> &bull; <a href="#MagickMosaicImages">MagickMosaicImages</a> &bull; <a href="#MagickOpaqueImage">MagickOpaqueImage</a> &bull; <a href="#MagickPaintFloodfillImage">MagickPaintFloodfillImage</a> &bull; <a href="#MagickPaintOpaqueImage">MagickPaintOpaqueImage</a> &bull; <a href="#MagickPaintTransparentImage">MagickPaintTransparentImage</a> &bull; <a href="#MagickRecolorImage">MagickRecolorImage</a> &bull; <a href="#MagickSetImageAttribute">MagickSetImageAttribute</a> &bull; <a href="#MagickSetImageIndex">MagickSetImageIndex</a> &bull; <a href="#MagickTransparentImage">MagickTransparentImage</a> &bull; <a href="#MagickRegionOfInterestImage">MagickRegionOfInterestImage</a> &bull; <a href="#MagickSetImagePixels">MagickSetImagePixels</a> &bull; <a href="#MagickWriteImageBlob">MagickWriteImageBlob</a> &bull; <a href="#PixelGetNextRow">PixelGetNextRow</a> &bull; <a href="#PixelIteratorGetException">PixelIteratorGetException</a>]</p>
+<p class="navigation-index">[<a href="#MagickAverageImages">MagickAverageImages</a> &bull; <a href="#ClonePixelView">ClonePixelView</a> &bull; <a href="#DestroyPixelView">DestroyPixelView</a> &bull; <a href="#DuplexTransferPixelViewIterator">DuplexTransferPixelViewIterator</a> &bull; <a href="#GetPixelViewException">GetPixelViewException</a> &bull; <a href="#GetPixelViewHeight">GetPixelViewHeight</a> &bull; <a href="#GetPixelViewIterator">GetPixelViewIterator</a> &bull; <a href="#GetPixelViewPixels">GetPixelViewPixels</a> &bull; <a href="#GetPixelViewWand">GetPixelViewWand</a> &bull; <a href="#GetPixelViewWidth">GetPixelViewWidth</a> &bull; <a href="#GetPixelViewX">GetPixelViewX</a> &bull; <a href="#GetPixelViewY">GetPixelViewY</a> &bull; <a href="#IsPixelView">IsPixelView</a> &bull; <a href="#MagickClipPathImage">MagickClipPathImage</a> &bull; <a href="#DrawGetFillAlpha">DrawGetFillAlpha</a> &bull; <a href="#DrawGetStrokeAlpha">DrawGetStrokeAlpha</a> &bull; <a href="#DrawPeekGraphicWand">DrawPeekGraphicWand</a> &bull; <a href="#DrawPopGraphicContext">DrawPopGraphicContext</a> &bull; <a href="#DrawPushGraphicContext">DrawPushGraphicContext</a> &bull; <a href="#DrawSetFillAlpha">DrawSetFillAlpha</a> &bull; <a href="#DrawSetStrokeAlpha">DrawSetStrokeAlpha</a> &bull; <a href="#MagickColorFloodfillImage">MagickColorFloodfillImage</a> &bull; <a href="#MagickDescribeImage">MagickDescribeImage</a> &bull; <a href="#MagickFlattenImages">MagickFlattenImages</a> &bull; <a href="#MagickGetImageAttribute">MagickGetImageAttribute</a> &bull; <a href="#MagickGetImageMatte">MagickGetImageMatte</a> &bull; <a href="#MagickGetImagePixels">MagickGetImagePixels</a> &bull; <a href="#MagickGetImageSize">MagickGetImageSize</a> &bull; <a href="#MagickMapImage">MagickMapImage</a> &bull; <a href="#MagickMatteFloodfillImage">MagickMatteFloodfillImage</a> &bull; <a href="#MagickMaximumImages">MagickMaximumImages</a> &bull; <a href="#MagickMinimumImages">MagickMinimumImages</a> &bull; <a href="#MagickMosaicImages">MagickMosaicImages</a> &bull; <a href="#MagickOpaqueImage">MagickOpaqueImage</a> &bull; <a href="#MagickPaintFloodfillImage">MagickPaintFloodfillImage</a> &bull; <a href="#MagickPaintOpaqueImage">MagickPaintOpaqueImage</a> &bull; <a href="#MagickPaintTransparentImage">MagickPaintTransparentImage</a> &bull; <a href="#MagickRecolorImage">MagickRecolorImage</a> &bull; <a href="#MagickSetImageAttribute">MagickSetImageAttribute</a> &bull; <a href="#MagickSetImageIndex">MagickSetImageIndex</a> &bull; <a href="#MagickTransparentImage">MagickTransparentImage</a> &bull; <a href="#MagickRegionOfInterestImage">MagickRegionOfInterestImage</a> &bull; <a href="#MagickSetImagePixels">MagickSetImagePixels</a> &bull; <a href="#MagickWriteImageBlob">MagickWriteImageBlob</a> &bull; <a href="#NewPixelView">NewPixelView</a> &bull; <a href="#NewPixelViewRegion">NewPixelViewRegion</a> &bull; <a href="#PixelGetNextRow">PixelGetNextRow</a> &bull; <a href="#PixelIteratorGetException">PixelIteratorGetException</a> &bull; <a href="#SetPixelViewIterator">SetPixelViewIterator</a> &bull; <a href="#TransferPixelViewIterator">TransferPixelViewIterator</a> &bull; <a href="#UpdatePixelViewIterator">UpdatePixelViewIterator</a>]</p>
 
 <h2><a href="http://www.imagemagick.org/api/MagickWand/deprecate
 _8c.html" target="source" name="MagickAverageImages">MagickAverageImages</a></h2>
@@ -173,6 +173,270 @@
 
  </div>
 <h2><a href="http://www.imagemagick.org/api/MagickWand/deprecate
+_8c.html" target="source" name="ClonePixelView">ClonePixelView</a></h2>
+<div class="doc-section">
+
+<p>ClonePixelView() makes a copy of the specified pixel view.</p></ol>
+
+<p>The format of the ClonePixelView method is:</p>
+
+<pre class="code">
+  PixelView *ClonePixelView(const PixelView *pixel_view)
+</pre>
+
+<p>A description of each parameter follows:</p></ol>
+
+<h5>pixel_view</h5>
+<ol><p>the pixel view.</p></ol>
+
+ </div>
+<h2><a href="http://www.imagemagick.org/api/MagickWand/deprecate
+_8c.html" target="source" name="DestroyPixelView">DestroyPixelView</a></h2>
+<div class="doc-section">
+
+<p>DestroyPixelView() deallocates memory associated with a pixel view.</p></ol>
+
+<p>The format of the DestroyPixelView method is:</p>
+
+<pre class="code">
+  PixelView *DestroyPixelView(PixelView *pixel_view,
+    const size_t number_wands,const size_t number_threads)
+</pre>
+
+<p>A description of each parameter follows:</p></ol>
+
+<h5>pixel_view</h5>
+<ol><p>the pixel view.</p></ol>
+
+<h5>number_wand</h5>
+<ol><p>the number of pixel wands.</p></ol>
+
+<h5>number_threads</h5>
+<ol><p>number of threads.</p></ol>
+
+ </div>
+<h2><a href="http://www.imagemagick.org/api/MagickWand/deprecate
+_8c.html" target="source" name="DuplexTransferPixelViewIterator">DuplexTransferPixelViewIterator</a></h2>
+<div class="doc-section">
+
+<p>DuplexTransferPixelViewIterator() iterates over three pixel views in parallel and calls your transfer method for each scanline of the view.  The source and duplex pixel region is not confined to the image canvas-- that is you can include negative offsets or widths or heights that exceed the image dimension.  However, the destination pixel view is confined to the image canvas-- that is no negative offsets or widths or heights that exceed the image dimension are permitted.</p></ol>
+
+<p>Use this pragma:</p>
+
+<pre class="text">
+      #pragma omp critical
+</pre>
+
+<p>to define a section of code in your callback transfer method that must be executed by a single thread at a time.</p></ol>
+
+<p>The format of the DuplexTransferPixelViewIterator method is:</p>
+
+<pre class="code">
+  MagickBooleanType DuplexTransferPixelViewIterator(PixelView *source,
+    PixelView *duplex,PixelView *destination,
+    DuplexTransferPixelViewMethod transfer,void *context)
+</pre>
+
+<p>A description of each parameter follows:</p></ol>
+
+<h5>source</h5>
+<ol><p>the source pixel view.</p></ol>
+
+<h5>duplex</h5>
+<ol><p>the duplex pixel view.</p></ol>
+
+<h5>destination</h5>
+<ol><p>the destination pixel view.</p></ol>
+
+<h5>transfer</h5>
+<ol><p>the transfer callback method.</p></ol>
+
+<h5>context</h5>
+<ol><p>the user defined context.</p></ol>
+
+ </div>
+<h2><a href="http://www.imagemagick.org/api/MagickWand/deprecate
+_8c.html" target="source" name="GetPixelViewException">GetPixelViewException</a></h2>
+<div class="doc-section">
+
+<p>GetPixelViewException() returns the severity, reason, and description of any error that occurs when utilizing a pixel view.</p></ol>
+
+<p>The format of the GetPixelViewException method is:</p>
+
+<pre class="code">
+  char *GetPixelViewException(const PixelWand *pixel_view,
+    ExceptionType *severity)
+</pre>
+
+<p>A description of each parameter follows:</p></ol>
+
+<h5>pixel_view</h5>
+<ol><p>the pixel pixel_view.</p></ol>
+
+<h5>severity</h5>
+<ol><p>the severity of the error is returned here.</p></ol>
+
+ </div>
+<h2><a href="http://www.imagemagick.org/api/MagickWand/deprecate
+_8c.html" target="source" name="GetPixelViewHeight">GetPixelViewHeight</a></h2>
+<div class="doc-section">
+
+<p>GetPixelViewHeight() returns the pixel view height.</p></ol>
+
+<p>The format of the GetPixelViewHeight method is:</p>
+
+<pre class="code">
+  size_t GetPixelViewHeight(const PixelView *pixel_view)
+</pre>
+
+<p>A description of each parameter follows:</p></ol>
+
+<h5>pixel_view</h5>
+<ol><p>the pixel view.</p></ol>
+
+ </div>
+<h2><a href="http://www.imagemagick.org/api/MagickWand/deprecate
+_8c.html" target="source" name="GetPixelViewIterator">GetPixelViewIterator</a></h2>
+<div class="doc-section">
+
+<p>GetPixelViewIterator() iterates over the pixel view in parallel and calls your get method for each scanline of the view.  The pixel region is not confined to the image canvas-- that is you can include negative offsets or widths or heights that exceed the image dimension.  Any updates to the pixels in your callback are ignored.</p></ol>
+
+<p>Use this pragma:</p>
+
+<pre class="text">
+      #pragma omp critical
+</pre>
+
+<p>to define a section of code in your callback get method that must be executed by a single thread at a time.</p></ol>
+
+<p>The format of the GetPixelViewIterator method is:</p>
+
+<pre class="code">
+  MagickBooleanType GetPixelViewIterator(PixelView *source,
+    GetPixelViewMethod get,void *context)
+</pre>
+
+<p>A description of each parameter follows:</p></ol>
+
+<h5>source</h5>
+<ol><p>the source pixel view.</p></ol>
+
+<h5>get</h5>
+<ol><p>the get callback method.</p></ol>
+
+<h5>context</h5>
+<ol><p>the user defined context.</p></ol>
+
+ </div>
+<h2><a href="http://www.imagemagick.org/api/MagickWand/deprecate
+_8c.html" target="source" name="GetPixelViewPixels">GetPixelViewPixels</a></h2>
+<div class="doc-section">
+
+<p>GetPixelViewPixels() returns the pixel view pixel_wands.</p></ol>
+
+<p>The format of the GetPixelViewPixels method is:</p>
+
+<pre class="code">
+  PixelWand *GetPixelViewPixels(const PixelView *pixel_view)
+</pre>
+
+<p>A description of each parameter follows:</p></ol>
+
+<h5>pixel_view</h5>
+<ol><p>the pixel view.</p></ol>
+
+ </div>
+<h2><a href="http://www.imagemagick.org/api/MagickWand/deprecate
+_8c.html" target="source" name="GetPixelViewWand">GetPixelViewWand</a></h2>
+<div class="doc-section">
+
+<p>GetPixelViewWand() returns the magick wand associated with the pixel view.</p></ol>
+
+<p>The format of the GetPixelViewWand method is:</p>
+
+<pre class="code">
+  MagickWand *GetPixelViewWand(const PixelView *pixel_view)
+</pre>
+
+<p>A description of each parameter follows:</p></ol>
+
+<h5>pixel_view</h5>
+<ol><p>the pixel view.</p></ol>
+
+ </div>
+<h2><a href="http://www.imagemagick.org/api/MagickWand/deprecate
+_8c.html" target="source" name="GetPixelViewWidth">GetPixelViewWidth</a></h2>
+<div class="doc-section">
+
+<p>GetPixelViewWidth() returns the pixel view width.</p></ol>
+
+<p>The format of the GetPixelViewWidth method is:</p>
+
+<pre class="code">
+  size_t GetPixelViewWidth(const PixelView *pixel_view)
+</pre>
+
+<p>A description of each parameter follows:</p></ol>
+
+<h5>pixel_view</h5>
+<ol><p>the pixel view.</p></ol>
+
+ </div>
+<h2><a href="http://www.imagemagick.org/api/MagickWand/deprecate
+_8c.html" target="source" name="GetPixelViewX">GetPixelViewX</a></h2>
+<div class="doc-section">
+
+<p>GetPixelViewX() returns the pixel view x offset.</p></ol>
+
+<p>The format of the GetPixelViewX method is:</p>
+
+<pre class="code">
+  ssize_t GetPixelViewX(const PixelView *pixel_view)
+</pre>
+
+<p>A description of each parameter follows:</p></ol>
+
+<h5>pixel_view</h5>
+<ol><p>the pixel view.</p></ol>
+
+ </div>
+<h2><a href="http://www.imagemagick.org/api/MagickWand/deprecate
+_8c.html" target="source" name="GetPixelViewY">GetPixelViewY</a></h2>
+<div class="doc-section">
+
+<p>GetPixelViewY() returns the pixel view y offset.</p></ol>
+
+<p>The format of the GetPixelViewY method is:</p>
+
+<pre class="code">
+  ssize_t GetPixelViewY(const PixelView *pixel_view)
+</pre>
+
+<p>A description of each parameter follows:</p></ol>
+
+<h5>pixel_view</h5>
+<ol><p>the pixel view.</p></ol>
+
+ </div>
+<h2><a href="http://www.imagemagick.org/api/MagickWand/deprecate
+_8c.html" target="source" name="IsPixelView">IsPixelView</a></h2>
+<div class="doc-section">
+
+<p>IsPixelView() returns MagickTrue if the the parameter is verified as a pixel view container.</p></ol>
+
+<p>The format of the IsPixelView method is:</p>
+
+<pre class="code">
+  MagickBooleanType IsPixelView(const PixelView *pixel_view)
+</pre>
+
+<p>A description of each parameter follows:</p></ol>
+
+<h5>pixel_view</h5>
+<ol><p>the pixel view.</p></ol>
+
+ </div>
+<h2><a href="http://www.imagemagick.org/api/MagickWand/deprecate
 _8c.html" target="source" name="MagickClipPathImage">MagickClipPathImage</a></h2>
 <div class="doc-section">
 
@@ -929,6 +1193,46 @@
 
  </div>
 <h2><a href="http://www.imagemagick.org/api/MagickWand/deprecate
+_8c.html" target="source" name="NewPixelView">NewPixelView</a></h2>
+<div class="doc-section">
+
+<p>NewPixelView() returns a pixel view required for all other methods in the Pixel View API.</p></ol>
+
+<p>The format of the NewPixelView method is:</p>
+
+<pre class="code">
+  PixelView *NewPixelView(MagickWand *wand)
+</pre>
+
+<p>A description of each parameter follows:</p></ol>
+
+<h5>wand</h5>
+<ol><p>the wand.</p></ol>
+
+ </div>
+<h2><a href="http://www.imagemagick.org/api/MagickWand/deprecate
+_8c.html" target="source" name="NewPixelViewRegion">NewPixelViewRegion</a></h2>
+<div class="doc-section">
+
+<p>NewPixelViewRegion() returns a pixel view required for all other methods in the Pixel View API.</p></ol>
+
+<p>The format of the NewPixelViewRegion method is:</p>
+
+<pre class="code">
+  PixelView *NewPixelViewRegion(MagickWand *wand,const ssize_t x,
+    const ssize_t y,const size_t width,const size_t height)
+</pre>
+
+<p>A description of each parameter follows:</p></ol>
+
+<h5>wand</h5>
+<ol><p>the magick wand.</p></ol>
+
+<h5>x,y,columns,rows</h5>
+<ol><p>These values define the perimeter of a region of pixel_wands view.</p></ol>
+
+ </div>
+<h2><a href="http://www.imagemagick.org/api/MagickWand/deprecate
 _8c.html" target="source" name="PixelGetNextRow">PixelGetNextRow</a></h2>
 <div class="doc-section">
 
@@ -972,6 +1276,108 @@
 <ol><p>the severity of the error is returned here.</p></ol>
 
  </div>
+<h2><a href="http://www.imagemagick.org/api/MagickWand/deprecate
+_8c.html" target="source" name="SetPixelViewIterator">SetPixelViewIterator</a></h2>
+<div class="doc-section">
+
+<p>SetPixelViewIterator() iterates over the pixel view in parallel and calls your set method for each scanline of the view.  The pixel region is confined to the image canvas-- that is no negative offsets or widths or heights that exceed the image dimension.  The pixels are initiallly undefined and any settings you make in the callback method are automagically synced back to your image.</p></ol>
+
+<p>Use this pragma:</p>
+
+<pre class="text">
+      #pragma omp critical
+</pre>
+
+<p>to define a section of code in your callback set method that must be executed by a single thread at a time.</p></ol>
+
+<p>The format of the SetPixelViewIterator method is:</p>
+
+<pre class="code">
+  MagickBooleanType SetPixelViewIterator(PixelView *destination,
+    SetPixelViewMethod set,void *context)
+</pre>
+
+<p>A description of each parameter follows:</p></ol>
+
+<h5>destination</h5>
+<ol><p>the pixel view.</p></ol>
+
+<h5>set</h5>
+<ol><p>the set callback method.</p></ol>
+
+<h5>context</h5>
+<ol><p>the user defined context.</p></ol>
+
+ </div>
+<h2><a href="http://www.imagemagick.org/api/MagickWand/deprecate
+_8c.html" target="source" name="TransferPixelViewIterator">TransferPixelViewIterator</a></h2>
+<div class="doc-section">
+
+<p>TransferPixelViewIterator() iterates over two pixel views in parallel and calls your transfer method for each scanline of the view.  The source pixel region is not confined to the image canvas-- that is you can include negative offsets or widths or heights that exceed the image dimension. However, the destination pixel view is confined to the image canvas-- that is no negative offsets or widths or heights that exceed the image dimension are permitted.</p></ol>
+
+<p>Use this pragma:</p>
+
+<pre class="text">
+      #pragma omp critical
+</pre>
+
+<p>to define a section of code in your callback transfer method that must be executed by a single thread at a time.</p></ol>
+
+<p>The format of the TransferPixelViewIterator method is:</p>
+
+<pre class="code">
+  MagickBooleanType TransferPixelViewIterator(PixelView *source,
+    PixelView *destination,TransferPixelViewMethod transfer,void *context)
+</pre>
+
+<p>A description of each parameter follows:</p></ol>
+
+<h5>source</h5>
+<ol><p>the source pixel view.</p></ol>
+
+<h5>destination</h5>
+<ol><p>the destination pixel view.</p></ol>
+
+<h5>transfer</h5>
+<ol><p>the transfer callback method.</p></ol>
+
+<h5>context</h5>
+<ol><p>the user defined context.</p></ol>
+
+ </div>
+<h2><a href="http://www.imagemagick.org/api/MagickWand/deprecate
+_8c.html" target="source" name="UpdatePixelViewIterator">UpdatePixelViewIterator</a></h2>
+<div class="doc-section">
+
+<p>UpdatePixelViewIterator() iterates over the pixel view in parallel and calls your update method for each scanline of the view.  The pixel region is confined to the image canvas-- that is no negative offsets or widths or heights that exceed the image dimension are permitted.  Updates to pixels in your callback are automagically synced back to the image.</p></ol>
+
+<p>Use this pragma:</p>
+
+<pre class="text">
+      #pragma omp critical
+</pre>
+
+<p>to define a section of code in your callback update method that must be executed by a single thread at a time.</p></ol>
+
+<p>The format of the UpdatePixelViewIterator method is:</p>
+
+<pre class="code">
+  MagickBooleanType UpdatePixelViewIterator(PixelView *source,
+    UpdatePixelViewMethod update,void *context)
+</pre>
+
+<p>A description of each parameter follows:</p></ol>
+
+<h5>source</h5>
+<ol><p>the source pixel view.</p></ol>
+
+<h5>update</h5>
+<ol><p>the update callback method.</p></ol>
+
+<h5>context</h5>
+<ol><p>the user defined context.</p></ol>
+
+ </div>
 
 </div>
 
diff --git a/www/api/magick-image.html b/www/api/magick-image.html
index 26f9fa9..45ba6a6 100644
--- a/www/api/magick-image.html
+++ b/www/api/magick-image.html
@@ -6462,7 +6462,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/api/magick-property.html b/www/api/magick-property.html
index 6867b03..b5bede3 100644
--- a/www/api/magick-property.html
+++ b/www/api/magick-property.html
@@ -142,7 +142,7 @@
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
 <div  class="sponsor">
-   <a title="Sponsor: Online-Magazin" href="http://www.unkostenbeitrag.de/" title="Online-Magazin">Online-Magazin</a><!-- 20101101000200 -->
+   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
 </div>
 </div>
 </div>
@@ -1627,7 +1627,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/api/magick.html b/www/api/magick.html
index 8a0ecab..3bdc66a 100644
--- a/www/api/magick.html
+++ b/www/api/magick.html
@@ -142,7 +142,7 @@
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
 <div  class="sponsor">
-   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
+   <a title="Sponsor: Online-Magazin" href="http://www.unkostenbeitrag.de/" title="Online-Magazin">Online-Magazin</a><!-- 20101101000200 -->
 </div>
 </div>
 </div>
diff --git a/www/api/memory.html b/www/api/memory.html
index fff0066..f6e00a7 100644
--- a/www/api/memory.html
+++ b/www/api/memory.html
@@ -142,7 +142,7 @@
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
 <div  class="sponsor">
-   <a title="Sponsor: Online-Magazin" href="http://www.unkostenbeitrag.de/" title="Online-Magazin">Online-Magazin</a><!-- 20101101000200 -->
+   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
 </div>
 </div>
 </div>
@@ -404,7 +404,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/api/module.html b/www/api/module.html
index 8a0cc00..6d72349 100644
--- a/www/api/module.html
+++ b/www/api/module.html
@@ -516,7 +516,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/api/monitor.html b/www/api/monitor.html
index ccd302c..d7415bc 100644
--- a/www/api/monitor.html
+++ b/www/api/monitor.html
@@ -142,7 +142,7 @@
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
 <div  class="sponsor">
-   <a title="Sponsor: Online-Magazin" href="http://www.unkostenbeitrag.de/" title="Online-Magazin">Online-Magazin</a><!-- 20101101000200 -->
+   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
 </div>
 </div>
 </div>
@@ -227,7 +227,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/api/montage.html b/www/api/montage.html
index e25f3d5..ecd4bcd 100644
--- a/www/api/montage.html
+++ b/www/api/montage.html
@@ -141,9 +141,6 @@
 <div  class="sponsor">
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
-<div  class="sponsor">
-   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
-</div>
 </div>
 </div>
 
@@ -253,7 +250,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/api/morphology.html b/www/api/morphology.html
index f5ae4aa..9289bea 100644
--- a/www/api/morphology.html
+++ b/www/api/morphology.html
@@ -141,6 +141,9 @@
 <div  class="sponsor">
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
+<div  class="sponsor">
+   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
+</div>
 </div>
 </div>
 
@@ -639,7 +642,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/api/paint.html b/www/api/paint.html
index e8b3b68..77f92c0 100644
--- a/www/api/paint.html
+++ b/www/api/paint.html
@@ -142,7 +142,7 @@
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
 <div  class="sponsor">
-   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
+   <a title="Sponsor: Online-Magazin" href="http://www.unkostenbeitrag.de/" title="Online-Magazin">Online-Magazin</a><!-- 20101101000200 -->
 </div>
 </div>
 </div>
@@ -326,7 +326,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/api/pixel-iterator.html b/www/api/pixel-iterator.html
index 0b8ed2d..82869f2 100644
--- a/www/api/pixel-iterator.html
+++ b/www/api/pixel-iterator.html
@@ -506,7 +506,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/api/pixel-wand.html b/www/api/pixel-wand.html
index 11f213d..6b94b9b 100644
--- a/www/api/pixel-wand.html
+++ b/www/api/pixel-wand.html
@@ -142,7 +142,7 @@
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
 <div  class="sponsor">
-   <a title="Sponsor: Online-Magazin" href="http://www.unkostenbeitrag.de/" title="Online-Magazin">Online-Magazin</a><!-- 20101101000200 -->
+   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
 </div>
 </div>
 </div>
@@ -1397,7 +1397,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/api/profile.html b/www/api/profile.html
index 7ee7681..7f0bf79 100644
--- a/www/api/profile.html
+++ b/www/api/profile.html
@@ -142,7 +142,7 @@
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
 <div  class="sponsor">
-   <a title="Sponsor: Online-Magazin" href="http://www.unkostenbeitrag.de/" title="Online-Magazin">Online-Magazin</a><!-- 20101101000200 -->
+   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
 </div>
 </div>
 </div>
diff --git a/www/api/property.html b/www/api/property.html
index edccecc..d03e1de 100644
--- a/www/api/property.html
+++ b/www/api/property.html
@@ -397,7 +397,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/api/quantize.html b/www/api/quantize.html
index 8383b56..44c060f 100644
--- a/www/api/quantize.html
+++ b/www/api/quantize.html
@@ -141,6 +141,9 @@
 <div  class="sponsor">
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
+<div  class="sponsor">
+   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
+</div>
 </div>
 </div>
 
diff --git a/www/api/resize.html b/www/api/resize.html
index bc1bb45..b394e8c 100644
--- a/www/api/resize.html
+++ b/www/api/resize.html
@@ -452,7 +452,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/api/shear.html b/www/api/shear.html
index d0b19d1..6c9d6bd 100644
--- a/www/api/shear.html
+++ b/www/api/shear.html
@@ -142,7 +142,7 @@
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
 <div  class="sponsor">
-   <a title="Sponsor: Online-Magazin" href="http://www.unkostenbeitrag.de/" title="Online-Magazin">Online-Magazin</a><!-- 20101101000200 -->
+   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
 </div>
 </div>
 </div>
diff --git a/www/api/statistic.html b/www/api/statistic.html
index 2cc3bcc..4e478a4 100644
--- a/www/api/statistic.html
+++ b/www/api/statistic.html
@@ -141,9 +141,6 @@
 <div  class="sponsor">
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
-<div  class="sponsor">
-   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
-</div>
 </div>
 </div>
 
diff --git a/www/api/transform.html b/www/api/transform.html
index c208376..90dc5ae 100644
--- a/www/api/transform.html
+++ b/www/api/transform.html
@@ -497,7 +497,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/architecture.html b/www/architecture.html
index 0c0e7b2..dddf3f8 100644
--- a/www/architecture.html
+++ b/www/architecture.html
@@ -142,7 +142,7 @@
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
 <div  class="sponsor">
-   <a title="Sponsor: Online-Magazin" href="http://www.unkostenbeitrag.de/" title="Online-Magazin">Online-Magazin</a><!-- 20101101000200 -->
+   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
 </div>
 </div>
 </div>
@@ -1332,7 +1332,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/binary-releases.html b/www/binary-releases.html
index acb5c0f..7d1022f 100644
--- a/www/binary-releases.html
+++ b/www/binary-releases.html
@@ -373,7 +373,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/changelog.html b/www/changelog.html
index a9f9e46..0d8ecba 100644
--- a/www/changelog.html
+++ b/www/changelog.html
@@ -142,7 +142,7 @@
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
 <div  class="sponsor">
-   <a title="Sponsor: Online-Magazin" href="http://www.unkostenbeitrag.de/" title="Online-Magazin">Online-Magazin</a><!-- 20101101000200 -->
+   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
 </div>
 </div>
 </div>
diff --git a/www/cipher.html b/www/cipher.html
index ba791bb..bc7770c 100644
--- a/www/cipher.html
+++ b/www/cipher.html
@@ -206,7 +206,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/color.html b/www/color.html
index 1f430a2..9949c3c 100644
--- a/www/color.html
+++ b/www/color.html
@@ -5018,7 +5018,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/command-line-options.html b/www/command-line-options.html
index d16b645..67b9568 100644
--- a/www/command-line-options.html
+++ b/www/command-line-options.html
@@ -5986,7 +5986,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/command-line-processing.html b/www/command-line-processing.html
index d985f82..1e197b7 100644
--- a/www/command-line-processing.html
+++ b/www/command-line-processing.html
@@ -635,7 +635,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/command-line-tools.html b/www/command-line-tools.html
index af6c91f..d84e406 100644
--- a/www/command-line-tools.html
+++ b/www/command-line-tools.html
@@ -142,7 +142,7 @@
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
 <div  class="sponsor">
-   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
+   <a title="Sponsor: Online-Magazin" href="http://www.unkostenbeitrag.de/" title="Online-Magazin">Online-Magazin</a><!-- 20101101000200 -->
 </div>
 </div>
 </div>
@@ -154,11 +154,11 @@
 
 <p class="navigation-index">[<a href="#animate">animate</a> &bull; <a href="#compare">compare</a> &bull; <a href="#composite">composite</a> &bull; <a href="#conjure">conjure</a> &bull; <a href="#convert">convert</a> &bull; <a href="#display">display</a> &bull; <a href="#identify">identify</a> &bull; <a href="#import">import</a> &bull; <a href="#mogrify">mogrify</a> &bull; <a href="#montage">montage</a> &bull; <a href="#stream">stream</a>]</p>
 
-<p>ImageMagick includes a number of command-line utilities for manipulating images.  Most of you are probably accustomed to editing images one at a time with a graphical user interface (GUI) with such programs as <a href="http://www.gimp.org" target="1460115314">gimp</a> or <a href="http://www.adobe.com" target="148562135">Photoshop</a>.  However, a GUI is not always convenient.  Suppose you want to process an image dynamically from a web script or you want to apply the same operations to many images or repeat a specific operation at different times to the same or different image.  For these types of operations, the command-line image processing utility is appropriate.</p>
+<p>ImageMagick includes a number of command-line utilities for manipulating images.  Most of you are probably accustomed to editing images one at a time with a graphical user interface (GUI) with such programs as <a href="http://www.gimp.org" target="1053193634">gimp</a> or <a href="http://www.adobe.com" target="1020454810">Photoshop</a>.  However, a GUI is not always convenient.  Suppose you want to process an image dynamically from a web script or you want to apply the same operations to many images or repeat a specific operation at different times to the same or different image.  For these types of operations, the command-line image processing utility is appropriate.</p>
 
 <p>The ImageMagick command-line tools exit with a status of 0 if the command line arguments have a proper syntax and no problems are encountered.  Expect a descriptive message and an exit status of 1 if any exception occurs such as improper syntax, a problem reading or writing an image, or any other problem that prevents the command from completing successfully.</p>
 
-<p>In the paragraphs below, find a short description for each command-line tool. Click on the program name to get details about the program usage and a list of command-line options that alters how the program behaves.  If you are just getting acquainted with ImageMagick, start with the <a href="#convert">convert</a> program.  Be sure to peruse Anthony Thyssen's tutorial on how to use ImageMagick utilities to <a href="http://www.imagemagick.org/Usage/" target="33045796">convert, compose, or edit</a> images from the command-line.</p>
+<p>In the paragraphs below, find a short description for each command-line tool. Click on the program name to get details about the program usage and a list of command-line options that alters how the program behaves.  If you are just getting acquainted with ImageMagick, start with the <a href="#convert">convert</a> program.  Be sure to peruse Anthony Thyssen's tutorial on how to use ImageMagick utilities to <a href="http://www.imagemagick.org/Usage/" target="282388718">convert, compose, or edit</a> images from the command-line.</p>
 
 <div style="margin: auto;">
   <h2><a name="animate"></a><a href="../www/animate.html">animate</a></h2>
diff --git a/www/conjure.html b/www/conjure.html
index ceec76e..2501d0f 100644
--- a/www/conjure.html
+++ b/www/conjure.html
@@ -143,7 +143,7 @@
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
 <div  class="sponsor">
-   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
+   <a title="Sponsor: Online-Magazin" href="http://www.unkostenbeitrag.de/" title="Online-Magazin">Online-Magazin</a><!-- 20101101000200 -->
 </div>
 </div>
 </div>
@@ -306,7 +306,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/contact.html b/www/contact.html
index 5a0e872..e833f78 100644
--- a/www/contact.html
+++ b/www/contact.html
@@ -160,7 +160,7 @@
     <h2>Contact the Development Team</h2>
   </div>
 
-  <p>Use this form to contact the ImageMagick Wizards for any of the issues listed below.  You can expect a reply within 24-48 hours if your message is on topic and is a sponsorshp, license, or security issue.  The bug and documentation issues are for reporting only.  For any other issue, post your message to the <a href="http://www.imagemagick.org/discourse-server" target="156201139">discourse server</a>.</p>
+  <p>Use this form to contact the ImageMagick Wizards for any of the issues listed below.  You can expect a reply within 24-48 hours if your message is on topic and is a sponsorshp, license, or security issue.  The bug and documentation issues are for reporting only.  For any other issue, post your message to the <a href="http://www.imagemagick.org/discourse-server" target="1073550710">discourse server</a>.</p>
   <fieldset>
   <legend>Contact the Wizards</legend>
 	<p>Enter this code, <em class="warn">
@@ -216,7 +216,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/convert.html b/www/convert.html
index 86d093f..fccc77f 100644
--- a/www/convert.html
+++ b/www/convert.html
@@ -143,7 +143,7 @@
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
 <div  class="sponsor">
-   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
+   <a title="Sponsor: Online-Magazin" href="http://www.unkostenbeitrag.de/" title="Online-Magazin">Online-Magazin</a><!-- 20101101000200 -->
 </div>
 </div>
 </div>
@@ -1280,7 +1280,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/download.html b/www/download.html
index c8382b5..6c46f7e 100644
--- a/www/download.html
+++ b/www/download.html
@@ -142,7 +142,7 @@
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
 <div  class="sponsor">
-   <a title="Sponsor: Online-Magazin" href="http://www.unkostenbeitrag.de/" title="Online-Magazin">Online-Magazin</a><!-- 20101101000200 -->
+   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
 </div>
 </div>
 </div>
@@ -204,7 +204,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/examples.html b/www/examples.html
index 25fb86e..e7f16f2 100644
--- a/www/examples.html
+++ b/www/examples.html
@@ -152,7 +152,7 @@
 
 <div class="main">
 
-<p>Here are a few examples of what you can do with an image using ImageMagick from the command line, a program interface, or script.  You can generate this image yourself with this <a href="../www/perl-magick.html">PerlMagick</a> script, <a href="../www/source/examples.pl" target="1636389627">examples.pl</a>.</p><br />
+<p>Here are a few examples of what you can do with an image using ImageMagick from the command line, a program interface, or script.  You can generate this image yourself with this <a href="../www/perl-magick.html">PerlMagick</a> script, <a href="../www/source/examples.pl" target="1234182728">examples.pl</a>.</p><br />
 
 <div class="viewport">
   <img src="../images/examples.jpg" alt="[ImageMagick]" width="734" height="2972" border="0" name="titlebar-west" />
diff --git a/www/exception.html b/www/exception.html
index e33c63d..1ab9cdb 100644
--- a/www/exception.html
+++ b/www/exception.html
@@ -142,7 +142,7 @@
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
 <div  class="sponsor">
-   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
+   <a title="Sponsor: Online-Magazin" href="http://www.unkostenbeitrag.de/" title="Online-Magazin">Online-Magazin</a><!-- 20101101000200 -->
 </div>
 </div>
 </div>
diff --git a/www/formats.html b/www/formats.html
index e50a865..6f9f943 100644
--- a/www/formats.html
+++ b/www/formats.html
@@ -143,7 +143,7 @@
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
 <div  class="sponsor">
-   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
+   <a title="Sponsor: Online-Magazin" href="http://www.unkostenbeitrag.de/" title="Online-Magazin">Online-Magazin</a><!-- 20101101000200 -->
 </div>
 </div>
 </div>
@@ -1768,7 +1768,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/fx.html b/www/fx.html
index c367d7b..c6ce826 100644
--- a/www/fx.html
+++ b/www/fx.html
@@ -143,7 +143,7 @@
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
 <div  class="sponsor">
-   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
+   <a title="Sponsor: Online-Magazin" href="http://www.unkostenbeitrag.de/" title="Online-Magazin">Online-Magazin</a><!-- 20101101000200 -->
 </div>
 </div>
 </div>
diff --git a/www/high-dynamic-range.html b/www/high-dynamic-range.html
index d712577..1f0e100 100644
--- a/www/high-dynamic-range.html
+++ b/www/high-dynamic-range.html
@@ -191,7 +191,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/history.html b/www/history.html
index a9b5a1c..0b08dcd 100644
--- a/www/history.html
+++ b/www/history.html
@@ -164,7 +164,7 @@
 
 <p>The next generation of ImageMagick, version 5, started when Bob Friesenhahn contacted me and suggested I improve the application programming interface so users could leverage the image-processing algorithms from other languages or scripts.  Bob also wrote a C++ wrapper for ImageMagick called Magick++, and began contributing enhancements such as the module loader facility, automatic file identification, and test suites.  In the mean-time, the project picked up a few other notable contributors: Glenn Randers-Pehrson, William Radcliffe, and Leonard Rosenthol.  By now, ImageMagick was being utilized by tens of thousands of users, who reacted gruffly when a new release broke an existing API call or script.  The other members of the group wanted to freeze the API and command line but I was not quite ready, since ImageMagick was not quite what I had envisioned it could be. Bob and the others created a fork of ImageMagick while I continued to develop ImageMagick.</p>
 
-<p>I did not work alone for long.  Anthony Thyssen contacted me about deficiencies in the ImageMagick command line programs.  He pointed out that the command line was confusing when dealing with more than one image. He suggested an orderly, well-defined method for dealing with the command line, and this became ImageMagick version 6 (the current release). His efforts are detailed on his web pages, <a href="http://www.imagemagick.org/Usage/" target="838024326">Examples of ImageMagick Usage</a>.  I highly recommend that you peruse his site. He has illustrated the power of ImageMagick in ways that even I did not know were possible.</p>
+<p>I did not work alone for long.  Anthony Thyssen contacted me about deficiencies in the ImageMagick command line programs.  He pointed out that the command line was confusing when dealing with more than one image. He suggested an orderly, well-defined method for dealing with the command line, and this became ImageMagick version 6 (the current release). His efforts are detailed on his web pages, <a href="http://www.imagemagick.org/Usage/" target="1380461342">Examples of ImageMagick Usage</a>.  I highly recommend that you peruse his site. He has illustrated the power of ImageMagick in ways that even I did not know were possible.</p>
 
 <p>Another notable contributer, Fred Weinhaus, makes available a plethora of command-line <a href="http://www.fmwconcepts.com/imagemagick/">scripts</a> that perform geometric transforms, blurs, sharpens, edging, noise removal, and color manipulations.</p>
 
diff --git a/www/import.html b/www/import.html
index b4f637f..a7da3d7 100644
--- a/www/import.html
+++ b/www/import.html
@@ -143,7 +143,7 @@
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
 <div  class="sponsor">
-   <a title="Sponsor: Online-Magazin" href="http://www.unkostenbeitrag.de/" title="Online-Magazin">Online-Magazin</a><!-- 20101101000200 -->
+   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
 </div>
 </div>
 </div>
diff --git a/www/index.html b/www/index.html
index 828da9c..d8cc377 100644
--- a/www/index.html
+++ b/www/index.html
@@ -141,9 +141,6 @@
 <div  class="sponsor">
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
-<div  class="sponsor">
-   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
-</div>
 </div>
 </div>
 
diff --git a/www/install-source.html b/www/install-source.html
index 2642f5f..428f215 100644
--- a/www/install-source.html
+++ b/www/install-source.html
@@ -223,7 +223,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/license.html b/www/license.html
index 917ec68..91c2341 100644
--- a/www/license.html
+++ b/www/license.html
@@ -142,7 +142,7 @@
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
 <div  class="sponsor">
-   <a title="Sponsor: Online-Magazin" href="http://www.unkostenbeitrag.de/" title="Online-Magazin">Online-Magazin</a><!-- 20101101000200 -->
+   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
 </div>
 </div>
 </div>
diff --git a/www/links.html b/www/links.html
index c385ce4..eb03896 100644
--- a/www/links.html
+++ b/www/links.html
@@ -142,7 +142,7 @@
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
 <div  class="sponsor">
-   <a title="Sponsor: Online-Magazin" href="http://www.unkostenbeitrag.de/" title="Online-Magazin">Online-Magazin</a><!-- 20101101000200 -->
+   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
 </div>
 </div>
 </div>
@@ -160,23 +160,23 @@
   <h2><a name="command-line"></a>Command-line Tutorials</h2>
 </div>
 <ul>
-  <dt><a href="http://www.imagemagick.org/Usage/" target="783523541">Examples of ImageMagick Usage</a></dt>
-  <dt><a href="http://software.newsforge.com/article.pl?sid=05/04/29/1358220" target="2014884832">Advanced image editing from the command line with ImageMagick</a></dt>
-  <dt><a href="http://www.applematters.com/index.html/section/comments/1113/" target="46455033">Best Open Source Software for the Macintosh</a></dt>
-  <dt><a href="http://software.newsforge.com/article.pl?sid=05/07/01/1959251" target="1136275418">Command-line animations using ImageMagick</a></dt>
-  <dt><a href="http://www.builderau.com.au/program/linux/soa/Convert_images_with_open_source_ImageMagick/0,339028299,339271774,00.htm" target="2004844255">Convert Images with Open Source ImageMagick</a></dt>
-  <dt><a href="http://polishlinux.org/apps/graphics/enchanting-pictures-with-imagemagick/" target="787152510">Enchanting Pictures with ImageMagick</a></dt>
-  <dt><a href="http://www-106.ibm.com/developerworks/library/l-graf/?ca=dnt-428" target="1240877916">Graphics from the Command Line</a></dt>
-  <dt><a href="http://www.ars-informatica.ca/article.html?article=22" target="220731089">Image creation, conversion and manipulation with ImageMagick</a></dt>
-  <dt><a href="http://www.applematters.com/index.html/section/comments/2104/" target="1796727798">Image Editing for Power Users on the Mac</a></dt>
-  <dt><a href="http://applications.linux.com/article.pl?sid=05/03/29/1525217" target="710121788">ImageMagick: A graphics wizard for the command line</a></dt>
-  <dt><a href="http://www.ioncannon.net/linux/81/5-imagemagick-command-line-examples-part-1/" target="1922101547">ImageMagick command line examples - part 1</a></dt>
-  <dt><a href="http://www.ioncannon.net/linux/72/5-imagemagick-command-line-examples-part-2/" target="474982168">ImageMagick command line examples - part 2</a></dt>
-  <dt><a href="http://www.rabuser.info/jmagick.html" target="1551857429">ImageMagick &amp; Java</a></dt>
-  <dt><a href="http://www.jpeek.com/articles/linuxmag/0606.pdf" target="232740032">ImageMagick, Part One</a></dt>
-  <dt><a href="http://www.jpeek.com/articles/linuxmag/0607.pdf" target="1296512844">ImageMagick, Part Two</a></dt>
-  <dt><a href="http://www-106.ibm.com/developerworks/library/l-graf2/?ca=dgr-lnxw15GraphicsLine" target="1601715278">More Graphics from the Command Line</a></dt>
-  <dt><a href="http://www.ffnn.nl/pages/projects/ubuntu-firefox-themes.html" target="640049665">Ubuntu Firefox Themes</a></dt>
+  <dt><a href="http://www.imagemagick.org/Usage/" target="1602108281">Examples of ImageMagick Usage</a></dt>
+  <dt><a href="http://software.newsforge.com/article.pl?sid=05/04/29/1358220" target="1460273997">Advanced image editing from the command line with ImageMagick</a></dt>
+  <dt><a href="http://www.applematters.com/index.html/section/comments/1113/" target="103971866">Best Open Source Software for the Macintosh</a></dt>
+  <dt><a href="http://software.newsforge.com/article.pl?sid=05/07/01/1959251" target="2130131894">Command-line animations using ImageMagick</a></dt>
+  <dt><a href="http://www.builderau.com.au/program/linux/soa/Convert_images_with_open_source_ImageMagick/0,339028299,339271774,00.htm" target="2143712927">Convert Images with Open Source ImageMagick</a></dt>
+  <dt><a href="http://polishlinux.org/apps/graphics/enchanting-pictures-with-imagemagick/" target="324873720">Enchanting Pictures with ImageMagick</a></dt>
+  <dt><a href="http://www-106.ibm.com/developerworks/library/l-graf/?ca=dnt-428" target="249141323">Graphics from the Command Line</a></dt>
+  <dt><a href="http://www.ars-informatica.ca/article.html?article=22" target="1982672865">Image creation, conversion and manipulation with ImageMagick</a></dt>
+  <dt><a href="http://www.applematters.com/index.html/section/comments/2104/" target="1352433383">Image Editing for Power Users on the Mac</a></dt>
+  <dt><a href="http://applications.linux.com/article.pl?sid=05/03/29/1525217" target="1261555996">ImageMagick: A graphics wizard for the command line</a></dt>
+  <dt><a href="http://www.ioncannon.net/linux/81/5-imagemagick-command-line-examples-part-1/" target="1047500279">ImageMagick command line examples - part 1</a></dt>
+  <dt><a href="http://www.ioncannon.net/linux/72/5-imagemagick-command-line-examples-part-2/" target="1662381230">ImageMagick command line examples - part 2</a></dt>
+  <dt><a href="http://www.rabuser.info/jmagick.html" target="1348063072">ImageMagick &amp; Java</a></dt>
+  <dt><a href="http://www.jpeek.com/articles/linuxmag/0606.pdf" target="1720138057">ImageMagick, Part One</a></dt>
+  <dt><a href="http://www.jpeek.com/articles/linuxmag/0607.pdf" target="1220578268">ImageMagick, Part Two</a></dt>
+  <dt><a href="http://www-106.ibm.com/developerworks/library/l-graf2/?ca=dgr-lnxw15GraphicsLine" target="901898239">More Graphics from the Command Line</a></dt>
+  <dt><a href="http://www.ffnn.nl/pages/projects/ubuntu-firefox-themes.html" target="693848986">Ubuntu Firefox Themes</a></dt>
 </ul>
 
 <div style="margin: auto;">
@@ -184,18 +184,18 @@
 </div>
 
 <ul>
-  <dt><a href="http://www-128.ibm.com/developerworks/openwww/source/library/os-mosaic/?ca=dgr-lnxw09MosaicImages" target="1992956462">Create Mosaic Images with Perl and ImageMagick</a></dt>
-  <dt><a href="http://builder.com.com/5100-6371-5924990.html" target="71249583">Convert images for printing with MagickWand for PHP</a></dt>
-  <dt><a href="http://www.sitepoint.com/article/dynamic-images-imagemagick" target="1011274367">Create Dynamic Images with ImageMagick</a></dt>
-  <dt><a href="http://www.clearimageonline.com/builder/pdf/imageservices.pdf" target="1949461328">Image Services Add-on for Aestiva's HTML/OS and H2O</a></dt>
-  <dt><a href="http://www.ioncannon.net/php/75/how-to-compile-imagemagick-for-php-by-hand/" target="1024305520">How to compile ImageMagick for PHP by hand</a></dt>
-  <dt><a href="http://members.shaw.ca/el.supremo/MagickWand/" target="1158857880">MagickWand Examples in C</a></dt>
-  <dt><a href="http://www.html-editors.com/contest/1/82-read.html" target="1967564366">PHP Extensions: MagickWand for PHP</a></dt>
-  <dt><a href="http://www.evolt.org/article/PHP_frontend_to_ImageMagick/17/55650/" target="584112693">PHP frontend to ImageMagick</a></dt>
-  <dt><a href="http://www.ioncannon.net/php/61/php-imagemagick-magickwand-examples/" target="596148139">PHP ImageMagick MagickWand Examples</a></dt>
-  <dt><a href="http://www.imagemagick.org/RMagick/doc/rvgtut.html" target="1392385758">RVG - Ruby Vector Graphics</a></dt>
-  <dt><a href="http://www.devshed.com/c/a/PHP/Security-Images-with-PHP-and-ImageMagick/" target="746888172">Security Images with PHP and ImageMagick</a></dt>
-  <dt><a href="http://www.rubblewebs.co.uk/imagemagick/" target="1805896186">Simple Uses of PHP and ImageMagick</a></dt>
+  <dt><a href="http://www-128.ibm.com/developerworks/openwww/source/library/os-mosaic/?ca=dgr-lnxw09MosaicImages" target="341849965">Create Mosaic Images with Perl and ImageMagick</a></dt>
+  <dt><a href="http://builder.com.com/5100-6371-5924990.html" target="811239612">Convert images for printing with MagickWand for PHP</a></dt>
+  <dt><a href="http://www.sitepoint.com/article/dynamic-images-imagemagick" target="138801075">Create Dynamic Images with ImageMagick</a></dt>
+  <dt><a href="http://www.clearimageonline.com/builder/pdf/imageservices.pdf" target="384328646">Image Services Add-on for Aestiva's HTML/OS and H2O</a></dt>
+  <dt><a href="http://www.ioncannon.net/php/75/how-to-compile-imagemagick-for-php-by-hand/" target="607681389">How to compile ImageMagick for PHP by hand</a></dt>
+  <dt><a href="http://members.shaw.ca/el.supremo/MagickWand/" target="2095395646">MagickWand Examples in C</a></dt>
+  <dt><a href="http://www.html-editors.com/contest/1/82-read.html" target="703789514">PHP Extensions: MagickWand for PHP</a></dt>
+  <dt><a href="http://www.evolt.org/article/PHP_frontend_to_ImageMagick/17/55650/" target="188442608">PHP frontend to ImageMagick</a></dt>
+  <dt><a href="http://www.ioncannon.net/php/61/php-imagemagick-magickwand-examples/" target="1860488579">PHP ImageMagick MagickWand Examples</a></dt>
+  <dt><a href="http://www.imagemagick.org/RMagick/doc/rvgtut.html" target="2136205940">RVG - Ruby Vector Graphics</a></dt>
+  <dt><a href="http://www.devshed.com/c/a/PHP/Security-Images-with-PHP-and-ImageMagick/" target="1653400700">Security Images with PHP and ImageMagick</a></dt>
+  <dt><a href="http://www.rubblewebs.co.uk/imagemagick/" target="320193822">Simple Uses of PHP and ImageMagick</a></dt>
 </ul>
 
 <div style="margin: auto;">
@@ -203,10 +203,10 @@
 </div>
 
 <ul>
-  <dt><a href="http://beta.bigmedium.com/blog/imagemagick-install-osx.shtml" target="1356772558">Installing ImageMagick on Mac OS X</a></dt>
-  <dt><a href="http://www.cloudgoessocial.net/2010/02/10/imagemagick-for-iphone-via-snowleopard/" target="233498611">ImageMagick on iPhone</a></dt>
-  <dt><a href="http://www.cloudgoessocial.net/2009/07/09/imagemagick-on-iphone-xcode/" target="441936079">ImageMagick on iPhone - Xcode</a></dt>
-  <dt><a href="http://www.digitalsanctum.com/?s=ImageMagick" target="1224173742">Installing ImageMagick from Source on Ubuntu</a></dt>
+  <dt><a href="http://beta.bigmedium.com/blog/imagemagick-install-osx.shtml" target="1399591238">Installing ImageMagick on Mac OS X</a></dt>
+  <dt><a href="http://www.cloudgoessocial.net/2010/02/10/imagemagick-for-iphone-via-snowleopard/" target="1709627091">ImageMagick on iPhone</a></dt>
+  <dt><a href="http://www.cloudgoessocial.net/2009/07/09/imagemagick-on-iphone-xcode/" target="1922302103">ImageMagick on iPhone - Xcode</a></dt>
+  <dt><a href="http://www.digitalsanctum.com/?s=ImageMagick" target="712381587">Installing ImageMagick from Source on Ubuntu</a></dt>
 </ul>
 
 <div style="margin: auto;">
@@ -214,24 +214,24 @@
 </div>
 
 <ul>
-  <dt><a href="http://www.xs4all.nl/%7Ebvdwolf/main/foto/down_sample/down_sample.htm" target="279953645">Down-sampling Methods</a></dt>
+  <dt><a href="http://www.xs4all.nl/%7Ebvdwolf/main/foto/down_sample/down_sample.htm" target="1813598957">Down-sampling Methods</a></dt>
 </ul>
 
 <div style="margin: auto;">
   <h2><a name="book-review"></a>ImageMagick Book Review</h2>
 </div>
 <ul>
-  <dt><a href="http://www.linux.com/article.pl?sid=06/09/29/1917210" target="1578211497">Book review: ImageMagick Tricks</a></dt>
-  <dt><a href="http://books.slashdot.org/books/06/03/13/1442239.shtml" target="1081534349">The Definitive Guide To ImageMagick</a></dt>
+  <dt><a href="http://www.linux.com/article.pl?sid=06/09/29/1917210" target="1904950349">Book review: ImageMagick Tricks</a></dt>
+  <dt><a href="http://books.slashdot.org/books/06/03/13/1442239.shtml" target="708610866">The Definitive Guide To ImageMagick</a></dt>
 </ul>
 
 <div style="margin: auto;">
   <h2><a name="command-line"></a>Mailing List Archives</h2>
 </div>
 <ul>
-  <dt><a href="http://www.archivesat.com/ImageMagick_Users_List/" target="1067106155">ImageMagick Users List</a></dt>
-  <dt><a href="http://www.archivesat.com/ImageMagick_Developer_List/" target="671605766">ImageMagick Developers List</a></dt>
-  <dt><a href="http://www.archivesat.com/ImageMagick_Defect_Support/" target="1302265439">ImageMagick Bugs List</a></dt>
+  <dt><a href="http://www.archivesat.com/ImageMagick_Users_List/" target="2138472677">ImageMagick Users List</a></dt>
+  <dt><a href="http://www.archivesat.com/ImageMagick_Developer_List/" target="6608025">ImageMagick Developers List</a></dt>
+  <dt><a href="http://www.archivesat.com/ImageMagick_Defect_Support/" target="543800084">ImageMagick Bugs List</a></dt>
 </ul>
 
 <div style="margin: auto;">
@@ -239,13 +239,13 @@
 </div>
 <dl>
   <dt>Denmark</dt>
-    <dd><a href="http://imagemagick.europnews.de" target="716350305">http://imagemagick.europnews.de</a></dd><br />
+    <dd><a href="http://imagemagick.europnews.de" target="1343422412">http://imagemagick.europnews.de</a></dd><br />
   <dt>Germany</dt>
-    <dd><a href="http://imagemagick.linux-mirror.org" target="1381727554">http://imagemagick.linux-mirror.org</a></dd><br />
+    <dd><a href="http://imagemagick.linux-mirror.org" target="1268164021">http://imagemagick.linux-mirror.org</a></dd><br />
   <dt>Ireland</dt>
-    <dd><a href="http://imagemagick.oss-mirror.org" target="1076883338">http://imagemagick.oss-mirror.org</a></dd><br />
+    <dd><a href="http://imagemagick.oss-mirror.org" target="1591300363">http://imagemagick.oss-mirror.org</a></dd><br />
   <dt>United States</dt>
-    <dd><a href="http://www.imagemagick.org" target="1191332474">http://www.imagemagick.org</a></dd>
+    <dd><a href="http://www.imagemagick.org" target="858319995">http://www.imagemagick.org</a></dd>
 </dl>
 
 <div style="margin: auto;">
@@ -253,16 +253,16 @@
 </div>
 
 <ul>
-  <dt><a href="http://gmic.sourceforge.net/" target="786101335">G'MIC</a>: convert, manipulate and visualize generic 1D/2D/3D multi-spectral image files</dt>
-  <dt><a href="http://www.beesoft.org/index.html?id=imagicom" target="1309623370">Image Commander</a>: bulk picture processing with a GUI</dt>
+  <dt><a href="http://gmic.sourceforge.net/" target="468743446">G'MIC</a>: convert, manipulate and visualize generic 1D/2D/3D multi-spectral image files</dt>
+  <dt><a href="http://www.beesoft.org/index.html?id=imagicom" target="1163954772">Image Commander</a>: bulk picture processing with a GUI</dt>
 </ul>
 
 <div style="margin: auto;">
   <h2><a name="other-projects"></a>Other Projects Hosted by ImageMagick Studio</h2>
 </div>
 <ul>
-  <dt><a href="http://www.wizards-toolkit.org" target="340361670">Wizard's Toolkit</a></dt>
-  <dt><a href="http://www.multipole.org" target="240332965">Computational Simulation of Multi-Body Interactions with O(n) Scaling</a></dt>
+  <dt><a href="http://www.wizards-toolkit.org" target="2078898263">Wizard's Toolkit</a></dt>
+  <dt><a href="http://www.multipole.org" target="1370641685">Computational Simulation of Multi-Body Interactions with O(n) Scaling</a></dt>
 </ul>
 
 
@@ -272,7 +272,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/magick-core.html b/www/magick-core.html
index 75782c3..7b3122b 100644
--- a/www/magick-core.html
+++ b/www/magick-core.html
@@ -143,7 +143,7 @@
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
 <div  class="sponsor">
-   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
+   <a title="Sponsor: Online-Magazin" href="http://www.unkostenbeitrag.de/" title="Online-Magazin">Online-Magazin</a><!-- 20101101000200 -->
 </div>
 </div>
 </div>
@@ -291,12 +291,15 @@
 #include &lt;magick/MagickCore.h>
 
 static MagickBooleanType SigmoidalContrast(ImageView *contrast_view,
-  void *context)
+  const ssize_t y,const int id,void *context)
 {
 #define QuantumScale  ((MagickRealType) 1.0/(MagickRealType) QuantumRange)
 #define SigmoidalContrast(x) \
   (QuantumRange*(1.0/(1+exp(10.0*(0.5-QuantumScale*x)))-0.0066928509)*1.0092503)
 
+  RectangleInfo
+    extent;
+
   register IndexPacket
     *indexes;
 
@@ -306,8 +309,9 @@
   register ssize_t
     x;
 
+  extent=GetImageViewExtent(contrast_view);
   pixels=GetImageViewAuthenticPixels(contrast_view);
-  for (x=0; x &lt; (ssize_t) GetImageViewWidth(contrast_view); x++)
+  for (x=0; x &lt; (ssize_t) (extent.width-extent.x); x++)
   {
     pixels[x].red=RoundToQuantum(SigmoidalContrast(pixels[x].red));
     pixels[x].green=RoundToQuantum(SigmoidalContrast(pixels[x].green));
@@ -316,7 +320,7 @@
   }
   indexes=GetImageViewAuthenticIndexes(contrast_view);
   if (indexes != (IndexPacket *) NULL)
-    for (x=0; x &lt; (ssize_t) GetImageViewWidth(contrast_view); x++)
+    for (x=0; x &lt; (ssize_t) (extent.width-extent.x); x++)
       indexes[x]=(IndexPacket) RoundToQuantum(SigmoidalContrast(indexes[x]));
   return(MagickTrue);
 }
@@ -329,9 +333,19 @@
   CatchException(exception); \
   if (contrast_image != (Image *) NULL) \
     contrast_image=DestroyImage(contrast_image); \
-  exception=DestroyExceptionInfo(exception); \
-  image_info=DestroyImageInfo(image_info); \
-  MagickCoreTerminus(); \
+  exit(-1); \
+}
+#define ThrowViewException(view) \
+{ \
+  char \
+    *description; \
+ \
+  ExceptionType \
+    severity; \
+ \
+  description=GetImageViewException(view,&severity); \
+  (void) fprintf(stderr,"%s %s %lu %s\n",GetMagickModule(),description); \
+  description=DestroyString(description); \
   exit(-1); \
 }
 
diff --git a/www/magick-wand.html b/www/magick-wand.html
index 48e7e0f..f3ab6fe 100644
--- a/www/magick-wand.html
+++ b/www/magick-wand.html
@@ -357,12 +357,15 @@
 #include &lt;wand/MagickWand.h>
 
 static MagickBooleanType SigmoidalContrast(WandView *pixel_view,
-  void *context)
+  const ssize_t y,const int id,void *context)
 {
 #define QuantumScale  ((MagickRealType) 1.0/(MagickRealType) QuantumRange)
 #define SigmoidalContrast(x) \
   (QuantumRange*(1.0/(1+exp(10.0*(0.5-QuantumScale*x)))-0.0066928509)*1.0092503)
 
+  RectangleInfo
+    extent;
+
   MagickPixelPacket
     pixel;
 
@@ -372,8 +375,9 @@
   register long
     x;
 
+  extent=GetWandViewExtent(contrast_view);
   pixels=GetWandViewPixels(contrast_view);
-  for (x=0; x &lt; (long) GetWandViewWidth(contrast_view); x++)
+  for (x=0; x &lt; (long) (extent.width-extent.height); x++)
   {
     PixelGetMagickColor(pixels[x],&amp;pixel);
     pixel.red=SigmoidalContrast(pixel.red);
@@ -387,19 +391,26 @@
 
 int main(int argc,char **argv)
 {
-#define ThrowWandException(wand) \
+#define ThrowViewException(view) \
 { \
-  char \
-    *description; \
- \
-  ExceptionType \
-    severity; \
- \
-  description=MagickGetException(wand,&amp;severity); \
+  description=GetWandViewException(view,&severity); \
   (void) fprintf(stderr,"%s %s %lu %s\n",GetMagickModule(),description); \
   description=(char *) MagickRelinquishMemory(description); \
   exit(-1); \
 }
+#define ThrowWandException(wand) \
+{ \
+  description=MagickGetException(wand,&severity); \
+  (void) fprintf(stderr,"%s %s %lu %s\n",GetMagickModule(),description); \
+  description=(char *) MagickRelinquishMemory(description); \
+  exit(-1); \
+}
+
+  char
+    *description;
+
+  ExceptionType
+    severity;
 
   MagickBooleanType
     status;
diff --git a/www/miff.html b/www/miff.html
index f20f521..3a7a830 100644
--- a/www/miff.html
+++ b/www/miff.html
@@ -308,7 +308,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/mirrors.html b/www/mirrors.html
index 10bbc85..3d1a94d 100644
--- a/www/mirrors.html
+++ b/www/mirrors.html
@@ -141,9 +141,6 @@
 <div  class="sponsor">
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
-<div  class="sponsor">
-   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
-</div>
 </div>
 </div>
 
@@ -155,9 +152,9 @@
 <p>The ImageMagick web site is available from a variety of web mirrors around the world listed below.</p>
 <dl class="magick-mirror">
   <dt>France</dt>
-    <dd><a href="http://imagemagick.europnews.de/" target="1057291824">http://imagemagick.europnews.de/</a></dd><br />
+    <dd><a href="http://imagemagick.europnews.de/" target="464520430">http://imagemagick.europnews.de/</a></dd><br />
   <dt>Unites States</dt>
-    <dd><a href="http://www.imagemagick.org/" target="1171664659">http://www.imagemagick.org/</a></dd>
+    <dd><a href="http://www.imagemagick.org/" target="2040972325">http://www.imagemagick.org/</a></dd>
 </dl>
 <p>If you want to add a new web-site mirror, please <a href="http://www.imagemagick.org/script/contact.php">contact us</a>.</p>
 
diff --git a/www/montage.html b/www/montage.html
index f1ba869..67d826d 100644
--- a/www/montage.html
+++ b/www/montage.html
@@ -142,6 +142,9 @@
 <div  class="sponsor">
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
+<div  class="sponsor">
+   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
+</div>
 </div>
 </div>
 
diff --git a/www/perl-magick.html b/www/perl-magick.html
index 0482fb7..0fb09d8 100644
--- a/www/perl-magick.html
+++ b/www/perl-magick.html
@@ -142,7 +142,7 @@
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
 <div  class="sponsor">
-   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
+   <a title="Sponsor: Online-Magazin" href="http://www.unkostenbeitrag.de/" title="Online-Magazin">Online-Magazin</a><!-- 20101101000200 -->
 </div>
 </div>
 </div>
diff --git a/www/quantize.html b/www/quantize.html
index d67be5c..5af83b8 100644
--- a/www/quantize.html
+++ b/www/quantize.html
@@ -142,7 +142,7 @@
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
 <div  class="sponsor">
-   <a title="Sponsor: Online-Magazin" href="http://www.unkostenbeitrag.de/" title="Online-Magazin">Online-Magazin</a><!-- 20101101000200 -->
+   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
 </div>
 </div>
 </div>
diff --git a/www/resources.html b/www/resources.html
index 981b1fb..cd18481 100644
--- a/www/resources.html
+++ b/www/resources.html
@@ -407,7 +407,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/sitemap.html b/www/sitemap.html
index 84c2ac9..de81e71 100644
--- a/www/sitemap.html
+++ b/www/sitemap.html
@@ -141,9 +141,6 @@
 <div  class="sponsor">
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
-<div  class="sponsor">
-   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
-</div>
 </div>
 </div>
 
@@ -163,7 +160,7 @@
 <dl>
   <dd><a href="../www/index.html">Introduction</a>: convert, edit, and compose images from the command-line or program interface.</dd>
   <dd><a href="../www/examples.html">Examples of ImageMagick usage</a>: a few examples that show what you can do with an image using ImageMagick.</dd>
-  <dd><a href="http://www.imagemagick.org/Usage/" target="411211278">Anthony Thyssen's examples of ImageMagick usage</a>:  a comprehensive tutorial of using ImageMagick from the command line.</dd>
+  <dd><a href="http://www.imagemagick.org/Usage/" target="1672848181">Anthony Thyssen's examples of ImageMagick usage</a>:  a comprehensive tutorial of using ImageMagick from the command line.</dd>
   <dd><a href="../www/color.html">Color names</a>: how to specify a color name, a hex color, or a numerical RGB, RGBA, HSL, HSLA, CMYK, or CMYKA color.</dd>
   <dd><a href="../www/resources.html">Resources</a>: ImageMagick depends on external resources including configuration files, loadable modules, fonts, and environment variables.</dd>
   <dd><a href="../www/architecture.html">Architecture</a>: get to know more about the software and algorithms behind ImageMagick.</dd>
@@ -177,12 +174,12 @@
 <dl>
   <dd><a href="../www/download.html">Download ImageMagick</a>: ImageMagick source and binary distributions are available from a variety of FTP and Web mirrors.</dd>
   <ul>
-    <dd><a href="http://www.imagemagick.org/download" target="1593902802">Unix source</a>: Unix source distributions.</dd>
-    <dd><a href="http://www.imagemagick.org/download/windows" target="1562864936">Windows source</a>: Windows source distributions.</dd>
-    <dd><a href="http://www.imagemagick.org/download/binaries" target="1225229667">Unix and Windows binaries</a>: Unix and Windows binary distributions.</dd>
+    <dd><a href="http://www.imagemagick.org/download" target="665630667">Unix source</a>: Unix source distributions.</dd>
+    <dd><a href="http://www.imagemagick.org/download/windows" target="280429760">Windows source</a>: Windows source distributions.</dd>
+    <dd><a href="http://www.imagemagick.org/download/binaries" target="1389609844">Unix and Windows binaries</a>: Unix and Windows binary distributions.</dd>
     <dd><a href="../www/subversion.html">Subversion repository</a>: stable and development source releases.</dd>
-    <dd><a href="http://www.magickwand.org/" target="1291304198">MagickWand for PHP</a>: a native PHP-extension to the ImageMagick MagickWand API.</dd>
-    <dd><a href="http://www.imagemagick.org/download/delegates" target="2139517152">Delegate libraries</a>: ImageMagick depends on a number of optional delegate libraries to extend its functionality.</dd>
+    <dd><a href="http://www.magickwand.org/" target="118312721">MagickWand for PHP</a>: a native PHP-extension to the ImageMagick MagickWand API.</dd>
+    <dd><a href="http://www.imagemagick.org/download/delegates" target="1823717388">Delegate libraries</a>: ImageMagick depends on a number of optional delegate libraries to extend its functionality.</dd>
   </ul>
 </dl>
 
@@ -221,7 +218,7 @@
   <dd><a href="../www/command-line-processing.html">Command line processing</a>: the anatomy of the command line.</dd>
   <dd><a href="../www/command-line-options.html">Command line options</a>: annotated list of all options that can appear on the command-line.</dd>
   <dd><a href="../www/fx.html">Fx</a>: apply a mathematical expression to an image or image channels.</dd>
-  <dd><a href="http://www.fmwconcepts.com/imagemagick/" target="1730686478">Fred's ImageMagick Scripts</a>:  a plethora of command-line scripts that perform geometric transforms, blurs, sharpens, edging, noise removal, and color manipulations.</dd>
+  <dd><a href="http://www.fmwconcepts.com/imagemagick/" target="811428397">Fred's ImageMagick Scripts</a>:  a plethora of command-line scripts that perform geometric transforms, blurs, sharpens, edging, noise removal, and color manipulations.</dd>
 </dl>
 
 <div style="margin: auto;">
@@ -231,21 +228,21 @@
 <dl>
   <dd><a href="../www/api.html">Program interfaces</a>: application programming interfaces.</dd>
   <ul>
-    <dd><a href="http://www.imagemagick.org/ChMagick" target="1423201016">ChMagick</a>: is a <a href="http://www.softintegration.com/" target="1576767716">Ch</a> an embeddable MagickCore C/C++ interpreter for cross-platform scripting.</dd>
-    <dd><a href="http://common-lisp.net/project/cl-magick/" target="2005388074">CL-Magick</a>: provides a Common Lisp interface to the ImageMagick library.</dd>
-    <dd><a href="https://gna.org/projects/g2f/" target="1914501182">G2F</a>: implements an Ada 95 binding to a subset of the low-level MagickCore library.</dd>
-    <dd><a href="http://www.imagemagick.org/Magick++" target="982663212">Magick++</a>: provides an object-oriented C++ interface to ImageMagick.</dd>
-    <dd><a href="http://pecl.php.net/package/imagick" target="908460201">IMagick</a>: is a native PHP extension to create and modify images using the ImageMagick API.</dd>
-    <dd><a href="http://www.yeo.id.au/jmagick/" target="1499788545">JMagick</a>: provides an object-oriented Java interface to ImageMagick.</dd>
+    <dd><a href="http://www.imagemagick.org/ChMagick" target="1954638218">ChMagick</a>: is a <a href="http://www.softintegration.com/" target="911219294">Ch</a> an embeddable MagickCore C/C++ interpreter for cross-platform scripting.</dd>
+    <dd><a href="http://common-lisp.net/project/cl-magick/" target="546530585">CL-Magick</a>: provides a Common Lisp interface to the ImageMagick library.</dd>
+    <dd><a href="https://gna.org/projects/g2f/" target="1424992967">G2F</a>: implements an Ada 95 binding to a subset of the low-level MagickCore library.</dd>
+    <dd><a href="http://www.imagemagick.org/Magick++" target="1967914207">Magick++</a>: provides an object-oriented C++ interface to ImageMagick.</dd>
+    <dd><a href="http://pecl.php.net/package/imagick" target="1166619794">IMagick</a>: is a native PHP extension to create and modify images using the ImageMagick API.</dd>
+    <dd><a href="http://www.yeo.id.au/jmagick/" target="1299368483">JMagick</a>: provides an object-oriented Java interface to ImageMagick.</dd>
     <dd><a href="../www/magick-core.html">MagickCore</a>: C API, recommended for wizard-level developers.</dd>
     <dd><a href="../www/magick-wand.html">MagickWand</a>: convert, compose, and edit images from the C language.</dd>
-    <dd><a href="http://www.magickwand.org/" target="528117958">MagickWand for PHP</a>: a native PHP-extension to the ImageMagick MagickWand API.</dd>
-    <dd><a href="http://code.google.com/p/nmagick" target="619581566">nMagick</a>: is a port of the ImageMagick library to the haXe and Neko platforms.</dd>
-    <dd><a href="http://wiki.lazarus.freepascal.org/index.html/PascalMagick" target="1624626913">PascalMagick</a>: a Pascal binding for the MagickWand API and also the low-level MagickCore library.</dd>
+    <dd><a href="http://www.magickwand.org/" target="986195522">MagickWand for PHP</a>: a native PHP-extension to the ImageMagick MagickWand API.</dd>
+    <dd><a href="http://code.google.com/p/nmagick" target="267011198">nMagick</a>: is a port of the ImageMagick library to the haXe and Neko platforms.</dd>
+    <dd><a href="http://wiki.lazarus.freepascal.org/index.html/PascalMagick" target="277693440">PascalMagick</a>: a Pascal binding for the MagickWand API and also the low-level MagickCore library.</dd>
     <dd><a href="../www/perl-magick.html">PerlMagick</a>: convert, compose, and edit images from the Perl language.</dd>
-    <dd><a href="http://www.imagemagick.org/download/python/" target="584187129">PythonMagick</a>: an object-oriented Python interface to ImageMagick.</dd>
-    <dd><a href="http://rmagick.rubyforge.org/" target="1563516981">RMagick</a>: is an interface between the Ruby programming language and ImageMagick.</dd>
-    <dd><a href="http://tclmagick.sourceforge.net/" target="595385021">TclMagick</a>: a native Tcl-extension to the ImageMagick MagickWand API.</dd>
+    <dd><a href="http://www.imagemagick.org/download/python/" target="1556176218">PythonMagick</a>: an object-oriented Python interface to ImageMagick.</dd>
+    <dd><a href="http://rmagick.rubyforge.org/" target="1785054160">RMagick</a>: is an interface between the Ruby programming language and ImageMagick.</dd>
+    <dd><a href="http://tclmagick.sourceforge.net/" target="938788169">TclMagick</a>: a native Tcl-extension to the ImageMagick MagickWand API.</dd>
   </ul>
 </dl>
 
@@ -265,8 +262,8 @@
 </div>
 
 <dl>
-  <dd><a href="http://www.amazon.com/exec/obidos/redirect?link_code=ur2&amp;camp=1789&amp;tag=imagemagick-20&amp;creative=9325&amp;path=tg/detail/-/1590595904/qid=1123551819/sr=8-1/ref=pd_bbs_sbs_1?v=glance%26s=books%26n=507846" target="1821886792">Definitive Guide to ImageMagick</a>: this book explains ImageMagick in a practical, learn-by-example fashion.</dd>
-  <dd><a href="http://www.amazon.com/exec/obidos/redirect?link_code=ur2&amp;camp=1789&amp;tag=imagemagick-20&amp;creative=9325&amp;path=tg/detail/-/1904811868/qid=1123551819/sr=8-1/ref=pd_bbs_sbs_1?v=glance%26s=books%26n=507846" target="898674280">ImageMagick Tricks</a>: this book is packed with examples of photo manipulations, logo creation, animations, and complete web projects.</dd>
+  <dd><a href="http://www.amazon.com/exec/obidos/redirect?link_code=ur2&amp;camp=1789&amp;tag=imagemagick-20&amp;creative=9325&amp;path=tg/detail/-/1590595904/qid=1123551819/sr=8-1/ref=pd_bbs_sbs_1?v=glance%26s=books%26n=507846" target="1834914164">Definitive Guide to ImageMagick</a>: this book explains ImageMagick in a practical, learn-by-example fashion.</dd>
+  <dd><a href="http://www.amazon.com/exec/obidos/redirect?link_code=ur2&amp;camp=1789&amp;tag=imagemagick-20&amp;creative=9325&amp;path=tg/detail/-/1904811868/qid=1123551819/sr=8-1/ref=pd_bbs_sbs_1?v=glance%26s=books%26n=507846" target="1264902875">ImageMagick Tricks</a>: this book is packed with examples of photo manipulations, logo creation, animations, and complete web projects.</dd>
   <dd><a href="http://www.imagemagick.org/discourse-server">Discourse server</a>: get help from fellow ImageMagick users and developers, post to these forums.</dd>
   <dd><a href="http://www.imagemagick.org/script/contact.php">Contact the Wizards</a>: for bug reports (only if you do not want to sign up to the <a href="http://www.imagemagick.org/discourse-server">discourse server</a>), a source or documentation patch, a security or license issue, or if you want to be a sponsor of the ImageMagick project.</dd>
 </dl>
@@ -276,7 +273,7 @@
 </div>
 
 <dl>
-  <dd><a href="http://www.imagemagick.org/discourse-server/viewforum.html?f=3" target="669510275">Report bugs and vulnerabilities</a>: our highest priority is to fix security defects and bug reports, usually within 48 hours of your report.  The bug discourse server requires that you register.  If you do not want to register, you can <a href="contact.html">contact the ImageMagick developers</a> with a convenient web form.</dd>
+  <dd><a href="http://www.imagemagick.org/discourse-server/viewforum.html?f=3" target="1343380254">Report bugs and vulnerabilities</a>: our highest priority is to fix security defects and bug reports, usually within 48 hours of your report.  The bug discourse server requires that you register.  If you do not want to register, you can <a href="contact.html">contact the ImageMagick developers</a> with a convenient web form.</dd>
   <dd><a href="../www/sponsors.html">Sponsor ImageMagick</a>: contribute bug fixes, enhancements, hardware, funds, etc. to ensure the ImageMagick project thrives.</dd>
   <dd><a href="../www/t-shirt.html">ImageMagick t-shirt</a>: donate $25 USD and we acknowledge your gift with a logoed t-shirt.</dd>
 </dl>
@@ -302,8 +299,8 @@
   <h2><a name="sandbox"></a>Technology Sandbox</h2>
 </div>
 <dl>
-  <dd><a href="http://www.fmwconcepts.com/imagemagick/linkcounter.html?dir=fourier_transforms/&linkname=fourier.html" target="59540511">Fourier Transform Processing With ImageMagick</a></dd>
-  <dd><a href="http://www.imagemagick.org/Usage/fourier/" target="1911981620">ImageMagick v6 Examples -- Fourier Transforms</a></dd>
+  <dd><a href="http://www.fmwconcepts.com/imagemagick/linkcounter.html?dir=fourier_transforms/&linkname=fourier.html" target="601923838">Fourier Transform Processing With ImageMagick</a></dd>
+  <dd><a href="http://www.imagemagick.org/Usage/fourier/" target="223529879">ImageMagick v6 Examples -- Fourier Transforms</a></dd>
 </dl>
 
 
@@ -313,7 +310,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/sponsors.html b/www/sponsors.html
index 72d4cb0..be448be 100644
--- a/www/sponsors.html
+++ b/www/sponsors.html
@@ -141,6 +141,9 @@
 <div  class="sponsor">
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
+<div  class="sponsor">
+   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
+</div>
 </div>
 </div>
 
@@ -236,7 +239,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/stream.html b/www/stream.html
index ad55ca6..df5b505 100644
--- a/www/stream.html
+++ b/www/stream.html
@@ -143,7 +143,7 @@
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
 <div  class="sponsor">
-   <a title="Sponsor: Online-Magazin" href="http://www.unkostenbeitrag.de/" title="Online-Magazin">Online-Magazin</a><!-- 20101101000200 -->
+   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
 </div>
 </div>
 </div>
diff --git a/www/subversion.html b/www/subversion.html
index dd15bae..1377a83 100644
--- a/www/subversion.html
+++ b/www/subversion.html
@@ -142,7 +142,7 @@
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
 <div  class="sponsor">
-   <a title="Sponsor: Online-Magazin" href="http://www.unkostenbeitrag.de/" title="Online-Magazin">Online-Magazin</a><!-- 20101101000200 -->
+   <a title="Sponsor: Webdesign" href="http://www.renehornig.com/" title="Webdesign">Webdesign</a><!-- 20111001000240 -->
 </div>
 </div>
 </div>
@@ -176,7 +176,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
diff --git a/www/t-shirt.html b/www/t-shirt.html
index 6e791c7..a97dc7e 100644
--- a/www/t-shirt.html
+++ b/www/t-shirt.html
@@ -141,9 +141,6 @@
 <div  class="sponsor">
    <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
 </div>
-<div  class="sponsor">
-   <a title="Sponsor: Online-Magazin" href="http://www.unkostenbeitrag.de/" title="Online-Magazin">Online-Magazin</a><!-- 20101101000200 -->
-</div>
 </div>
 </div>
 
@@ -191,7 +188,7 @@
  <!--    <span id="linkbar-west">&nbsp;</span>  -->
     <span id="linkbar-center">
       <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
-    <a href="http://studio.webbyland.com/ImageMagick/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
+    <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
     </span>
     <span id="linkbar-east">&nbsp;</span>
   </div>
