path: root/src/vtk-7-mingw-w64-git.patch

This file is part of MXE.
See index.html for further information.

This patch has been taken from the git url below:

From: David Partyka <david.partyka@kitware.com>
Date: Wed, 21 Sep 2011 13:19:30 +0000 (-0400)
Subject: Merge branch '11742_mingw64_compile_fixes' into release
X-Git-Tag: v5.10.0-rc1~108^2~1
X-Git-Url: http://vtk.org/gitweb?p=VTK.git;a=commitdiff_plain;h=be64234e8399145f1e2c099500779a9bcff75702;hp=7b4ad680f6b2b4b4211baf47de6588308db7e14f

Merge branch '11742_mingw64_compile_fixes' into release
---

diff --git a/Common/vtkWin32Header.h b/Common/vtkWin32Header.h
index 81b094a..a3edb90 100644
--- a/Common/vtkWin32Header.h
+++ b/Common/vtkWin32Header.h
@@ -102,9 +102,15 @@ Do_not_include_vtkWin32Header_directly__vtkSystemIncludes_includes_it;
 #  define vtkGetWindowLong GetWindowLong
 #  define vtkSetWindowLong SetWindowLong
 #  define vtkLONG LONG
+#  ifdef _WIN64
+#    define vtkGWL_WNDPROC GWLP_WNDPROC
+#    define vtkGWL_HINSTANCE GWLP_HINSTANCE
+#    define vtkGWL_USERDATA GWLP_USERDATA
+#  else
 #  define vtkGWL_WNDPROC GWL_WNDPROC
 #  define vtkGWL_HINSTANCE GWL_HINSTANCE
 #  define vtkGWL_USERDATA GWL_USERDATA
+#  endif
 #endif //
 
 #endif
diff --git a/Hybrid/vtkVideoSource.cxx b/Hybrid/vtkVideoSource.cxx
index 1fcdbe1..c40b845 100644
--- a/Hybrid/vtkVideoSource.cxx
+++ b/Hybrid/vtkVideoSource.cxx
@@ -32,9 +32,9 @@
 
 //---------------------------------------------------------------
 // Important FrameBufferMutex rules:
-// 
+//
 // The frame grabs are generally done asynchronously, and it is necessary
-// to ensure that when the frame buffer is valid when it is being written 
+// to ensure that when the frame buffer is valid when it is being written
 // to or read from
 //
 // The following information can only be changed within a mutex lock,
@@ -59,8 +59,8 @@
 //
 // AdvanceFrameBuffer()
 //
-// Any methods which might be called asynchronously must lock the 
-// mutex before reading the above information, and you must be very 
+// Any methods which might be called asynchronously must lock the
+// mutex before reading the above information, and you must be very
 // careful when accessing any information except for the above.
 // These methods include the following:
 //
@@ -74,13 +74,13 @@ vtkStandardNewMacro(vtkVideoSource);
 #if ( _MSC_VER >= 1300 ) // Visual studio .NET
 #pragma warning ( disable : 4311 )
 #pragma warning ( disable : 4312 )
-#endif 
+#endif
 
 //----------------------------------------------------------------------------
 vtkVideoSource::vtkVideoSource()
 {
   int i;
-  
+
   this->Initialized = 0;
 
   this->AutoAdvance = 1;
@@ -93,7 +93,7 @@ vtkVideoSource::vtkVideoSource()
     {
     this->FrameBufferExtent[i] = 0;
     }
-  
+
   this->Playing = 0;
   this->Recording = 0;
 
@@ -151,8 +151,8 @@ vtkVideoSource::vtkVideoSource()
 
 //----------------------------------------------------------------------------
 vtkVideoSource::~vtkVideoSource()
-{ 
-  // we certainly don't want to access a virtual 
+{
+  // we certainly don't want to access a virtual
   // function after the subclass has destructed!!
   this->vtkVideoSource::ReleaseSystemResources();
 
@@ -165,10 +165,10 @@ vtkVideoSource::~vtkVideoSource()
 void vtkVideoSource::PrintSelf(ostream& os, vtkIndent indent)
 {
   int idx;
-  
+
   this->Superclass::PrintSelf(os,indent);
-  
-  os << indent << "FrameSize: (" << this->FrameSize[0] << ", " 
+
+  os << indent << "FrameSize: (" << this->FrameSize[0] << ", "
      << this->FrameSize[1] << ", " << this->FrameSize[2] << ")\n";
 
   os << indent << "ClipRegion: (" << this->ClipRegion[0];
@@ -177,14 +177,14 @@ void vtkVideoSource::PrintSelf(ostream& os, vtkIndent indent)
     os << ", " << this->ClipRegion[idx];
     }
   os << ")\n";
-  
+
   os << indent << "DataSpacing: (" << this->DataSpacing[0];
   for (idx = 1; idx < 3; ++idx)
     {
     os << ", " << this->DataSpacing[idx];
     }
   os << ")\n";
-  
+
   os << indent << "DataOrigin: (" << this->DataOrigin[0];
   for (idx = 1; idx < 3; ++idx)
     {
@@ -205,7 +205,7 @@ void vtkVideoSource::PrintSelf(ostream& os, vtkIndent indent)
     os << ", " << this->OutputWholeExtent[idx];
     }
   os << ")\n";
-  
+
   os << indent << "FrameRate: " << this->FrameRate << "\n";
 
   os << indent << "FrameCount: " << this->FrameCount << "\n";
@@ -232,7 +232,7 @@ void vtkVideoSource::PrintSelf(ostream& os, vtkIndent indent)
 
 //----------------------------------------------------------------------------
 // Update the FrameBuffers according to any changes in the FrameBuffer*
-// information. 
+// information.
 // This function should always be called from within a FrameBufferMutex lock
 // and should never be called asynchronously.
 // It sets up the FrameBufferExtent
@@ -246,10 +246,10 @@ void vtkVideoSource::UpdateFrameBuffer()
   for (i = 0; i < 3; i++)
     {
     oldExt = this->FrameBufferExtent[2*i+1] - this->FrameBufferExtent[2*i] + 1;
-    this->FrameBufferExtent[2*i] = ((this->ClipRegion[2*i] > 0) 
-                             ? this->ClipRegion[2*i] : 0);  
-    this->FrameBufferExtent[2*i+1] = ((this->ClipRegion[2*i+1] < 
-                                       this->FrameSize[i]-1) 
+    this->FrameBufferExtent[2*i] = ((this->ClipRegion[2*i] > 0)
+                             ? this->ClipRegion[2*i] : 0);
+    this->FrameBufferExtent[2*i+1] = ((this->ClipRegion[2*i+1] <
+                                       this->FrameSize[i]-1)
                              ? this->ClipRegion[2*i+1] : this->FrameSize[i]-1);
 
     ext[i] = this->FrameBufferExtent[2*i+1] - this->FrameBufferExtent[2*i] + 1;
@@ -318,20 +318,20 @@ void vtkVideoSource::ReleaseSystemResources()
 //----------------------------------------------------------------------------
 void vtkVideoSource::SetFrameSize(int x, int y, int z)
 {
-  if (x == this->FrameSize[0] && 
-      y == this->FrameSize[1] && 
+  if (x == this->FrameSize[0] &&
+      y == this->FrameSize[1] &&
       z == this->FrameSize[2])
     {
     return;
     }
 
-  if (x < 1 || y < 1 || z < 1) 
+  if (x < 1 || y < 1 || z < 1)
     {
     vtkErrorMacro(<< "SetFrameSize: Illegal frame size");
     return;
     }
 
-  if (this->Initialized) 
+  if (this->Initialized)
     {
     this->FrameBufferMutex->Lock();
     this->FrameSize[0] = x;
@@ -349,7 +349,7 @@ void vtkVideoSource::SetFrameSize(int x, int y, int z)
 
   this->Modified();
 }
-    
+
 //----------------------------------------------------------------------------
 void vtkVideoSource::SetFrameRate(float rate)
 {
@@ -363,7 +363,7 @@ void vtkVideoSource::SetFrameRate(float rate)
 }
 
 //----------------------------------------------------------------------------
-void vtkVideoSource::SetClipRegion(int x0, int x1, int y0, int y1, 
+void vtkVideoSource::SetClipRegion(int x0, int x1, int y0, int y1,
                                    int z0, int z1)
 {
   if (this->ClipRegion[0] != x0 || this->ClipRegion[1] != x1 ||
@@ -371,7 +371,7 @@ void vtkVideoSource::SetClipRegion(int x0, int x1, int y0, int y1,
       this->ClipRegion[4] != z0 || this->ClipRegion[5] != z1)
     {
     this->Modified();
-    if (this->Initialized) 
+    if (this->Initialized)
       { // modify the FrameBufferExtent
       this->FrameBufferMutex->Lock();
       this->ClipRegion[0] = x0; this->ClipRegion[1] = x1;
@@ -422,7 +422,7 @@ void vtkVideoSource::InternalGrab()
                      this->FrameBufferBitsPerPixel + 7)/8;
   bytesPerRow = ((bytesPerRow + this->FrameBufferRowAlignment - 1) /
                  this->FrameBufferRowAlignment)*this->FrameBufferRowAlignment;
-  int totalSize = bytesPerRow * 
+  int totalSize = bytesPerRow *
                    (this->FrameBufferExtent[3]-this->FrameBufferExtent[2]+1) *
                    (this->FrameBufferExtent[5]-this->FrameBufferExtent[4]+1);
 
@@ -432,7 +432,7 @@ void vtkVideoSource::InternalGrab()
   ptr = reinterpret_cast<vtkUnsignedCharArray *>(this->FrameBuffer[index])->GetPointer(0);
 
   // Somebody should check this:
-  lptr = (int *)(((((long)ptr) + 3)/4)*4);
+  lptr = (int *)(((((intptr_t)ptr) + 3)/4)*4);
   i = totalSize/4;
 
   while (--i >= 0)
@@ -482,7 +482,7 @@ static inline void vtkSleep(double duration)
 
 //----------------------------------------------------------------------------
 // Sleep until the specified absolute time has arrived.
-// You must pass a handle to the current thread.  
+// You must pass a handle to the current thread.
 // If '0' is returned, then the thread was aborted before or during the wait.
 static int vtkThreadSleep(vtkMultiThreader::ThreadInfo *data, double time)
 {
@@ -506,7 +506,7 @@ static int vtkThreadSleep(vtkMultiThreader::ThreadInfo *data, double time)
       remaining = 0.1;
       }
 
-    // check to see if we are being told to quit 
+    // check to see if we are being told to quit
     data->ActiveFlagLock->Lock();
     int activeFlag = *(data->ActiveFlag);
     data->ActiveFlagLock->Unlock();
@@ -527,7 +527,7 @@ static int vtkThreadSleep(vtkMultiThreader::ThreadInfo *data, double time)
 static void *vtkVideoSourceRecordThread(vtkMultiThreader::ThreadInfo *data)
 {
   vtkVideoSource *self = (vtkVideoSource *)(data->UserData);
-  
+
   double startTime = vtkTimerLog::GetUniversalTime();
   double rate = self->GetFrameRate();
   int frame = 0;
@@ -544,7 +544,7 @@ static void *vtkVideoSourceRecordThread(vtkMultiThreader::ThreadInfo *data)
 
 //----------------------------------------------------------------------------
 // Set the source to grab frames continuously.
-// You should override this as appropriate for your device.  
+// You should override this as appropriate for your device.
 void vtkVideoSource::Record()
 {
   if (this->Playing)
@@ -559,19 +559,19 @@ void vtkVideoSource::Record()
     this->Recording = 1;
     this->FrameCount = 0;
     this->Modified();
-    this->PlayerThreadId = 
+    this->PlayerThreadId =
       this->PlayerThreader->SpawnThread((vtkThreadFunctionType)\
                                 &vtkVideoSourceRecordThread,this);
     }
 }
-    
+
 //----------------------------------------------------------------------------
 // this function runs in an alternate thread to 'play the tape' at the
 // specified frame rate.
 static void *vtkVideoSourcePlayThread(vtkMultiThreader::ThreadInfo *data)
 {
   vtkVideoSource *self = (vtkVideoSource *)(data->UserData);
- 
+
   double startTime = vtkTimerLog::GetUniversalTime();
   double rate = self->GetFrameRate();
   int frame = 0;
@@ -588,7 +588,7 @@ static void *vtkVideoSourcePlayThread(vtkMultiThreader::ThreadInfo *data)
 
 //----------------------------------------------------------------------------
 // Set the source to play back recorded frames.
-// You should override this as appropriate for your device.  
+// You should override this as appropriate for your device.
 void vtkVideoSource::Play()
 {
   if (this->Recording)
@@ -602,12 +602,12 @@ void vtkVideoSource::Play()
 
     this->Playing = 1;
     this->Modified();
-    this->PlayerThreadId = 
+    this->PlayerThreadId =
       this->PlayerThreader->SpawnThread((vtkThreadFunctionType)\
                                         &vtkVideoSourcePlayThread,this);
     }
 }
-    
+
 //----------------------------------------------------------------------------
 // Stop continuous grabbing or playback.  You will have to override this
 // if your class overrides Play() and Record()
@@ -621,7 +621,7 @@ void vtkVideoSource::Stop()
     this->Recording = 0;
     this->Modified();
     }
-} 
+}
 
 //----------------------------------------------------------------------------
 // Rewind back to the frame with the earliest timestamp.
@@ -665,7 +665,7 @@ void vtkVideoSource::Rewind()
     }
 
   this->FrameBufferMutex->Unlock();
-}  
+}
 
 //----------------------------------------------------------------------------
 // Fast-forward to the frame with the latest timestamp.
@@ -717,12 +717,12 @@ void vtkVideoSource::FastForward()
     }
 
   this->FrameBufferMutex->Unlock();
-}  
+}
 
 //----------------------------------------------------------------------------
 // Rotate the buffers
 void vtkVideoSource::Seek(int n)
-{ 
+{
   this->FrameBufferMutex->Lock();
   this->AdvanceFrameBuffer(n);
   this->FrameIndex = (this->FrameIndex + n) % this->FrameBufferSize;
@@ -731,7 +731,7 @@ void vtkVideoSource::Seek(int n)
     this->FrameIndex += this->FrameBufferSize;
     }
   this->FrameBufferMutex->Unlock();
-  this->Modified(); 
+  this->Modified();
 }
 
 //----------------------------------------------------------------------------
@@ -798,7 +798,7 @@ void vtkVideoSource::SetOutputFormat(int format)
 
 //----------------------------------------------------------------------------
 // set or change the circular buffer size
-// you will have to override this if you want the buffers 
+// you will have to override this if you want the buffers
 // to be device-specific (i.e. something other than vtkDataArray)
 void vtkVideoSource::SetFrameBufferSize(int bufsize)
 {
@@ -830,12 +830,12 @@ void vtkVideoSource::SetFrameBufferSize(int bufsize)
         {
         this->FrameBuffer[i] = vtkUnsignedCharArray::New();
         this->FrameBufferTimeStamps[i] = 0.0;
-        } 
+        }
       this->FrameBufferSize = bufsize;
       this->Modified();
       }
     }
-  else 
+  else
     {
     if (bufsize > 0)
       {
@@ -909,7 +909,7 @@ void vtkVideoSource::SetFrameBufferSize(int bufsize)
 void vtkVideoSource::AdvanceFrameBuffer(int n)
 {
   int i = (this->FrameBufferIndex - n) % this->FrameBufferSize;
-  while (i < 0) 
+  while (i < 0)
     {
     i += this->FrameBufferSize;
     }
@@ -918,7 +918,7 @@ void vtkVideoSource::AdvanceFrameBuffer(int n)
 
 //----------------------------------------------------------------------------
 double vtkVideoSource::GetFrameTimeStamp(int frame)
-{ 
+{
   double timeStamp;
 
   this->FrameBufferMutex->Lock();
@@ -959,7 +959,7 @@ int vtkVideoSource::RequestInformation(
     // if 'flag' is set in output extent, use the FrameBufferExtent instead
     if (extent[2*i+1] < extent[2*i])
       {
-      extent[2*i] = 0; 
+      extent[2*i] = 0;
       extent[2*i+1] = \
         this->FrameBufferExtent[2*i+1] - this->FrameBufferExtent[2*i];
       }
@@ -981,7 +981,7 @@ int vtkVideoSource::RequestInformation(
   extent[5] = extent[4] + (extent[5]-extent[4]+1) * numFrames - 1;
 
   outInfo->Set(vtkStreamingDemandDrivenPipeline::WHOLE_EXTENT(),extent,6);
-    
+
   // set the spacing
   outInfo->Set(vtkDataObject::SPACING(),this->DataSpacing,3);
 
@@ -989,7 +989,7 @@ int vtkVideoSource::RequestInformation(
   outInfo->Set(vtkDataObject::ORIGIN(),this->DataOrigin,3);
 
   // set default data type (8 bit greyscale)
-  vtkDataObject::SetPointDataActiveScalarInfo(outInfo, VTK_UNSIGNED_CHAR, 
+  vtkDataObject::SetPointDataActiveScalarInfo(outInfo, VTK_UNSIGNED_CHAR,
     this->NumberOfScalarComponents);
 
   return 1;
@@ -1000,7 +1000,7 @@ int vtkVideoSource::RequestInformation(
 // unusual pixel packing formats, such as XRGB XBRG BGRX BGR etc.
 // The version below assumes that the packing of the framebuffer is
 // identical to that of the output.
-void vtkVideoSource::UnpackRasterLine(char *outPtr, char *rowPtr, 
+void vtkVideoSource::UnpackRasterLine(char *outPtr, char *rowPtr,
                                       int start, int count)
 {
   char *inPtr = rowPtr + start*this->NumberOfScalarComponents;
@@ -1020,7 +1020,7 @@ void vtkVideoSource::UnpackRasterLine(char *outPtr, char *rowPtr,
 //----------------------------------------------------------------------------
 // The Execute method is fairly complex, so I would not recommend overriding
 // it unless you have to.  Override the UnpackRasterLine() method instead.
-// You should only have to override it if you are using something other 
+// You should only have to override it if you are using something other
 // than 8-bit vtkUnsignedCharArray for the frame buffer.
 int vtkVideoSource::RequestData(
   vtkInformation *vtkNotUsed(request),
@@ -1037,9 +1037,9 @@ int vtkVideoSource::RequestData(
     {
     saveOutputExtent[i] = outputExtent[i];
     }
-  // clip to extent to the Z size of one frame  
-  outputExtent[4] = this->FrameOutputExtent[4]; 
-  outputExtent[5] = this->FrameOutputExtent[5]; 
+  // clip to extent to the Z size of one frame
+  outputExtent[4] = this->FrameOutputExtent[4];
+  outputExtent[5] = this->FrameOutputExtent[5];
 
   int frameExtentX = this->FrameBufferExtent[1]-this->FrameBufferExtent[0]+1;
   int frameExtentY = this->FrameBufferExtent[3]-this->FrameBufferExtent[2]+1;
@@ -1093,8 +1093,8 @@ int vtkVideoSource::RequestData(
     outPadY = 0;
     }
 
-  int outX = frameExtentX - inPadX; 
-  int outY = frameExtentY - inPadY; 
+  int outX = frameExtentX - inPadX;
+  int outY = frameExtentY - inPadY;
   int outZ; // do outZ later
 
   if (outX > extentX - outPadX)
@@ -1117,7 +1117,7 @@ int vtkVideoSource::RequestData(
     }
 
   // ditto for number of scalar components
-  if (data->GetNumberOfScalarComponents() != 
+  if (data->GetNumberOfScalarComponents() !=
       this->LastNumberOfScalarComponents)
     {
     this->LastNumberOfScalarComponents = data->GetNumberOfScalarComponents();
@@ -1132,7 +1132,7 @@ int vtkVideoSource::RequestData(
            (saveOutputExtent[3]-saveOutputExtent[2]+1)*
            (saveOutputExtent[5]-saveOutputExtent[4]+1)*outIncX);
     this->OutputNeedsInitialization = 0;
-    } 
+    }
 
   // we have to modify the outputExtent of the first frame,
   // because it might be complete (it will be restored after
@@ -1143,7 +1143,7 @@ int vtkVideoSource::RequestData(
   this->FrameBufferMutex->Lock();
 
   int index = this->FrameBufferIndex;
-  this->FrameTimeStamp = 
+  this->FrameTimeStamp =
     this->FrameBufferTimeStamps[index % this->FrameBufferSize];
 
   int frame;
@@ -1152,8 +1152,8 @@ int vtkVideoSource::RequestData(
     if (frame == finalFrame)
       {
       outputExtent[5] = finalOutputExtent5;
-      } 
-    
+      }
+
     vtkDataArray *frameBuffer = reinterpret_cast<vtkDataArray *>(this->FrameBuffer[(index + frame) % this->FrameBufferSize]);
 
     char *inPtr = reinterpret_cast<char*>(frameBuffer->GetVoidPointer(0));
@@ -1162,7 +1162,7 @@ int vtkVideoSource::RequestData(
     extentZ = outputExtent[5]-outputExtent[4]+1;
     inPadZ = 0;
     outPadZ = -outputExtent[4];
-    
+
     if (outPadZ < 0)
       {
       inPadZ -= outPadZ;
@@ -1209,7 +1209,7 @@ int vtkVideoSource::RequestData(
         outPtrTmp = outPtr;
         for (j = 0; j < outY; j++)
           {
-          if (outX > 0) 
+          if (outX > 0)
             {
             this->UnpackRasterLine(outPtrTmp,inPtrTmp,inPadX,outX);
             }
diff --git a/Rendering/vtkFreeTypeTools.cxx b/Rendering/vtkFreeTypeTools.cxx
index 7443693..681fae6 100644
--- a/Rendering/vtkFreeTypeTools.cxx
+++ b/Rendering/vtkFreeTypeTools.cxx
@@ -222,7 +222,7 @@ vtkFreeTypeToolsFaceRequester(FTC_FaceID face_id,
   // Map the ID to a text property
   vtkSmartPointer<vtkTextProperty> tprop =
       vtkSmartPointer<vtkTextProperty>::New();
-  self->MapIdToTextProperty(reinterpret_cast<unsigned long>(face_id), tprop);
+  self->MapIdToTextProperty(reinterpret_cast<intptr_t>(face_id), tprop);
 
   // Fonts, organized by [Family][Bold][Italic]
   static EmbeddedFontStruct EmbeddedFonts[3][2][2] =
diff --git a/Rendering/vtkFreeTypeUtilities.cxx b/Rendering/vtkFreeTypeUtilities.cxx
index 629e5da..2d140a8 100644
--- a/Rendering/vtkFreeTypeUtilities.cxx
+++ b/Rendering/vtkFreeTypeUtilities.cxx
@@ -337,7 +337,7 @@ vtkFreeTypeUtilitiesFaceRequester(FTC_FaceID face_id,
   // Map the ID to a text property
 
   vtkTextProperty *tprop = vtkTextProperty::New();
-  self->MapIdToTextProperty(reinterpret_cast<unsigned long>(face_id), tprop);
+  self->MapIdToTextProperty(reinterpret_cast<intptr_t>(face_id), tprop);
 
   // Fonts, organized by [Family][Bold][Italic]
 
diff --git a/Rendering/vtkWin32OpenGLRenderWindow.cxx b/Rendering/vtkWin32OpenGLRenderWindow.cxx
index a4485d2..6b6e6b4 100644
--- a/Rendering/vtkWin32OpenGLRenderWindow.cxx
+++ b/Rendering/vtkWin32OpenGLRenderWindow.cxx
@@ -75,9 +75,9 @@ vtkWin32OpenGLRenderWindow::~vtkWin32OpenGLRenderWindow()
 void vtkWin32OpenGLRenderWindow::Clean()
 {
   GLuint id;
-  
+
   /* finish OpenGL rendering */
-  if (this->ContextId) 
+  if (this->ContextId)
     {
     this->MakeCurrent();
 
@@ -86,7 +86,7 @@ void vtkWin32OpenGLRenderWindow::Clean()
       {
       glDisable((GLenum)cur_light);
       }
-    
+
     /* now delete all textures */
     glDisable(GL_TEXTURE_2D);
     for (int i = 1; i < this->TextureResourceIds->GetNumberOfIds(); i++)
@@ -106,16 +106,16 @@ void vtkWin32OpenGLRenderWindow::Clean()
       }
 
     this->CleanUpRenderers();
-    
+
     // Note: wglMakeCurrent(NULL,NULL) is valid according to the documentation
     // and works with nVidia and ATI but not with Intel. Passing an existing
     // device context works in any case.
     // see VTK Bug 7119.
-    if(wglMakeCurrent(this->DeviceContext,NULL)!=TRUE) 
+    if(wglMakeCurrent(this->DeviceContext,NULL)!=TRUE)
       {
       vtkErrorMacro("wglMakeCurrent failed in Clean(), error: " << GetLastError());
       }
-    if (wglDeleteContext(this->ContextId) != TRUE) 
+    if (wglDeleteContext(this->ContextId) != TRUE)
       {
       vtkErrorMacro("wglDeleteContext failed in Clean(), error: " << GetLastError());
       }
@@ -136,7 +136,7 @@ void vtkWin32OpenGLRenderWindow::CleanUpRenderers()
   // destructor)
   vtkRenderer *ren;
   vtkCollectionSimpleIterator rsit;
-  for (this->Renderers->InitTraversal(rsit); 
+  for (this->Renderers->InitTraversal(rsit);
        (ren = this->Renderers->GetNextRenderer(rsit));)
     {
     ren->SetRenderWindow(NULL);
@@ -144,13 +144,13 @@ void vtkWin32OpenGLRenderWindow::CleanUpRenderers()
     }
 }
 
-LRESULT APIENTRY vtkWin32OpenGLRenderWindow::WndProc(HWND hWnd, UINT message, 
-                                                     WPARAM wParam, 
+LRESULT APIENTRY vtkWin32OpenGLRenderWindow::WndProc(HWND hWnd, UINT message,
+                                                     WPARAM wParam,
                                                      LPARAM lParam)
 {
   LRESULT res;
 
-  vtkWin32OpenGLRenderWindow *me = 
+  vtkWin32OpenGLRenderWindow *me =
     (vtkWin32OpenGLRenderWindow *)vtkGetWindowLong(hWnd,sizeof(vtkLONG));
 
   if (me && me->GetReferenceCount()>0)
@@ -199,7 +199,7 @@ int vtkWin32OpenGLRenderWindow::GetEventPending()
       return 1;
       }
     }
-  
+
   return 0;
 }
 
@@ -216,21 +216,21 @@ void vtkWin32OpenGLRenderWindow::MakeCurrent()
                     " than the one doing the picking, this can causes crashes"
                     " and/or bad pick results");
       }
-    else 
+    else
       {
-      if (wglMakeCurrent(this->DeviceContext, this->ContextId) != TRUE) 
+      if (wglMakeCurrent(this->DeviceContext, this->ContextId) != TRUE)
         {
         LPVOID lpMsgBuf;
-        ::FormatMessage( 
-          FORMAT_MESSAGE_ALLOCATE_BUFFER | 
-          FORMAT_MESSAGE_FROM_SYSTEM | 
+        ::FormatMessage(
+          FORMAT_MESSAGE_ALLOCATE_BUFFER |
+          FORMAT_MESSAGE_FROM_SYSTEM |
           FORMAT_MESSAGE_IGNORE_INSERTS,
           NULL,
           GetLastError(),
           MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
           (LPTSTR) &lpMsgBuf,
           0,
-          NULL 
+          NULL
           );
         if(lpMsgBuf)
           {
@@ -243,7 +243,7 @@ void vtkWin32OpenGLRenderWindow::MakeCurrent()
           delete [] wmsg;
           delete [] wtemp;
 #else
-          vtkErrorMacro("wglMakeCurrent failed in MakeCurrent(), error: " 
+          vtkErrorMacro("wglMakeCurrent failed in MakeCurrent(), error: "
                         << (LPCTSTR)lpMsgBuf);
 #endif
           ::LocalFree( lpMsgBuf );
@@ -289,13 +289,13 @@ void vtkWin32OpenGLRenderWindow::SetSize(int x, int y)
           }
         }
       }
-    
+
     else if (this->Mapped)
       {
       if (!resizing)
         {
         resizing = 1;
-        
+
         if (this->ParentId)
           {
           SetWindowExtEx(this->DeviceContext,x,y,NULL);
@@ -330,7 +330,7 @@ void vtkWin32OpenGLRenderWindow::SetPosition(int x, int y)
       if (!resizing)
         {
         resizing = 1;
-        
+
         SetWindowPos(this->WindowId,HWND_TOP,x,y,
                      0, 0, SWP_NOSIZE | SWP_NOZORDER);
         resizing = 0;
@@ -426,7 +426,7 @@ const char* vtkWin32OpenGLRenderWindow::ReportCapabilities()
   if (pfd.cColorBits <= 8)
     {
     strm << "class:  PseudoColor" << endl;
-    } 
+    }
   else
     {
     strm << "class:  TrueColor" << endl;
@@ -447,14 +447,14 @@ const char* vtkWin32OpenGLRenderWindow::ReportCapabilities()
   strm << "double buffer:  False" << endl;
   }
   if (pfd.dwFlags & PFD_STEREO) {
-  strm << "stereo:  True" << endl;  
+  strm << "stereo:  True" << endl;
   } else {
   strm << "stereo:  False" << endl;
   }
   if (pfd.dwFlags & PFD_GENERIC_FORMAT) {
-  strm << "hardware acceleration:  False" << endl; 
+  strm << "hardware acceleration:  False" << endl;
   } else {
-  strm << "hardware acceleration:  True" << endl; 
+  strm << "hardware acceleration:  True" << endl;
   }
   strm << "rgba:  redSize=" << static_cast<int>(pfd.cRedBits) << " greenSize=" << static_cast<int>(pfd.cGreenBits) << "blueSize=" << static_cast<int>(pfd.cBlueBits) << "alphaSize=" << static_cast<int>(pfd.cAlphaBits) << endl;
   strm << "aux buffers:  " << static_cast<int>(pfd.cAuxBuffers)<< endl;
@@ -463,17 +463,17 @@ const char* vtkWin32OpenGLRenderWindow::ReportCapabilities()
   strm << "accum:  redSize=" << static_cast<int>(pfd.cAccumRedBits) << " greenSize=" << static_cast<int>(pfd.cAccumGreenBits) << "blueSize=" << static_cast<int>(pfd.cAccumBlueBits) << "alphaSize=" << static_cast<int>(pfd.cAccumAlphaBits) << endl;
 
   delete[] this->Capabilities;
-  
+
   size_t len = strm.str().length() + 1;
   this->Capabilities = new char[len];
   strncpy(this->Capabilities, strm.str().c_str(), len);
-  
+
   return this->Capabilities;
 }
 
- 
-void vtkWin32OpenGLRenderWindow::SetupPixelFormat(HDC hDC, DWORD dwFlags, 
-                                                  int debug, int bpp, 
+
+void vtkWin32OpenGLRenderWindow::SetupPixelFormat(HDC hDC, DWORD dwFlags,
+                                                  int debug, int bpp,
                                                   int zbpp)
 {
   PIXELFORMATDESCRIPTOR pfd = {
@@ -505,12 +505,12 @@ void vtkWin32OpenGLRenderWindow::SetupPixelFormat(HDC hDC, DWORD dwFlags,
     if (!(pfd.dwFlags & PFD_SUPPORT_OPENGL))
       {
 #ifdef UNICODE
-      MessageBox(WindowFromDC(hDC), 
+      MessageBox(WindowFromDC(hDC),
                  L"Invalid pixel format, no OpenGL support",
                  L"Error",
                  MB_ICONERROR | MB_OK);
 #else
-      MessageBox(WindowFromDC(hDC), 
+      MessageBox(WindowFromDC(hDC),
                  "Invalid pixel format, no OpenGL support",
                  "Error",
                  MB_ICONERROR | MB_OK);
@@ -524,11 +524,11 @@ void vtkWin32OpenGLRenderWindow::SetupPixelFormat(HDC hDC, DWORD dwFlags,
         {
         exit(1);
         }
-      }         
+      }
     }
   else
     {
-    // hDC has no current PixelFormat, so 
+    // hDC has no current PixelFormat, so
     pixelFormat = ChoosePixelFormat(hDC, &pfd);
     if (pixelFormat == 0)
       {
@@ -549,8 +549,8 @@ void vtkWin32OpenGLRenderWindow::SetupPixelFormat(HDC hDC, DWORD dwFlags,
         exit(1);
         }
       }
-    DescribePixelFormat(hDC, pixelFormat,sizeof(pfd), &pfd); 
-    if (SetPixelFormat(hDC, pixelFormat, &pfd) != TRUE) 
+    DescribePixelFormat(hDC, pixelFormat,sizeof(pfd), &pfd);
+    if (SetPixelFormat(hDC, pixelFormat, &pfd) != TRUE)
       {
       // int err = GetLastError();
 #ifdef UNICODE
@@ -626,10 +626,10 @@ void vtkWin32OpenGLRenderWindow::SetupPalette(HDC hDC)
 }
 
 
-LRESULT vtkWin32OpenGLRenderWindow::MessageProc(HWND hWnd, UINT message, 
+LRESULT vtkWin32OpenGLRenderWindow::MessageProc(HWND hWnd, UINT message,
                                                 WPARAM wParam, LPARAM lParam)
 {
-  switch (message) 
+  switch (message)
     {
     case WM_CREATE:
     {
@@ -648,18 +648,18 @@ LRESULT vtkWin32OpenGLRenderWindow::MessageProc(HWND hWnd, UINT message,
       return 0;
     case WM_SIZE:
       /* track window size changes */
-      if (this->ContextId) 
+      if (this->ContextId)
         {
         this->SetSize((int) LOWORD(lParam),(int) HIWORD(lParam));
         return 0;
         }
     case WM_PALETTECHANGED:
       /* realize palette if this is *not* the current window */
-      if (this->ContextId && this->Palette && (HWND) wParam != hWnd) 
+      if (this->ContextId && this->Palette && (HWND) wParam != hWnd)
         {
         SelectPalette(this->DeviceContext, this->OldPalette, FALSE);
         UnrealizeObject(this->Palette);
-        this->OldPalette = SelectPalette(this->DeviceContext, 
+        this->OldPalette = SelectPalette(this->DeviceContext,
                                          this->Palette, FALSE);
         RealizePalette(this->DeviceContext);
         this->Render();
@@ -667,11 +667,11 @@ LRESULT vtkWin32OpenGLRenderWindow::MessageProc(HWND hWnd, UINT message,
       break;
     case WM_QUERYNEWPALETTE:
       /* realize palette if this is the current window */
-      if (this->ContextId && this->Palette) 
+      if (this->ContextId && this->Palette)
         {
         SelectPalette(this->DeviceContext, this->OldPalette, FALSE);
         UnrealizeObject(this->Palette);
-        this->OldPalette = SelectPalette(this->DeviceContext, 
+        this->OldPalette = SelectPalette(this->DeviceContext,
                                          this->Palette, FALSE);
         RealizePalette(this->DeviceContext);
         this->Render();
@@ -682,7 +682,7 @@ LRESULT vtkWin32OpenGLRenderWindow::MessageProc(HWND hWnd, UINT message,
     {
     PAINTSTRUCT ps;
     BeginPaint(hWnd, &ps);
-    if (this->ContextId) 
+    if (this->ContextId)
       {
       this->Render();
       }
@@ -730,20 +730,20 @@ void vtkWin32OpenGLRenderWindow::CreateAWindow()
     {
     static int count = 1;
     char *windowName;
-    
+
     if (!this->WindowId)
       {
       WNDCLASS wndClass;
       this->DeviceContext = 0;
-      
-      int len = static_cast<int>(strlen("Visualization Toolkit - Win32OpenGL #")) 
+
+      int len = static_cast<int>(strlen("Visualization Toolkit - Win32OpenGL #"))
         + (int)ceil( (double) log10( (double)(count+1) ) )
-        + 1; 
+        + 1;
       windowName = new char [ len ];
       sprintf(windowName,"Visualization Toolkit - Win32OpenGL #%i",count++);
       this->SetWindowName(windowName);
       delete [] windowName;
-      
+
       // has the class been registered ?
 #ifdef UNICODE
       if (!GetClassInfo(this->ApplicationInstance,L"vtkOpenGL",&wndClass))
@@ -770,7 +770,7 @@ void vtkWin32OpenGLRenderWindow::CreateAWindow()
           wndClass.cbWndExtra = 2 * sizeof(vtkLONG);
           RegisterClass(&wndClass);
           }
-      
+
 #ifdef UNICODE
       wchar_t *wname = new wchar_t [mbstowcs(NULL, this->WindowName, 32000)+1];
       mbstowcs(wname, this->WindowName, 32000);
@@ -779,7 +779,7 @@ void vtkWin32OpenGLRenderWindow::CreateAWindow()
       int y = ((this->Position[1] >= 0) ? this->Position[1] : 5);
       int height = ((this->Size[1] > 0) ? this->Size[1] : 300);
       int width = ((this->Size[0] > 0) ? this->Size[0] : 300);
-      
+
       /* create window */
       if (this->ParentId)
         {
@@ -812,7 +812,7 @@ void vtkWin32OpenGLRenderWindow::CreateAWindow()
         this->WindowId = CreateWindow(
           L"vtkOpenGL", wname, style,
           x,y, width+2*GetSystemMetrics(SM_CXFRAME),
-          height+2*GetSystemMetrics(SM_CYFRAME) 
+          height+2*GetSystemMetrics(SM_CYFRAME)
           +GetSystemMetrics(SM_CYCAPTION),
           NULL, NULL, this->ApplicationInstance, NULL);
 #else
@@ -827,14 +827,14 @@ void vtkWin32OpenGLRenderWindow::CreateAWindow()
 #ifdef UNICODE
       delete [] wname;
 #endif
-      
+
       if (!this->WindowId)
         {
         vtkErrorMacro("Could not create window, error:  " << GetLastError());
         return;
         }
       // extract the create info
-      
+
       /* display window */
       if(!this->OffScreenRendering)
         {
@@ -842,7 +842,7 @@ void vtkWin32OpenGLRenderWindow::CreateAWindow()
         }
       //UpdateWindow(this->WindowId);
       this->OwnWindow = 1;
-      vtkSetWindowLong(this->WindowId,sizeof(vtkLONG),(vtkLONG)this);
+      vtkSetWindowLong(this->WindowId,sizeof(vtkLONG),(intptr_t)this);
       }
     if (!this->DeviceContext)
       {
@@ -862,16 +862,16 @@ void vtkWin32OpenGLRenderWindow::CreateAWindow()
       }
     this->SetupPalette(this->DeviceContext);
     this->ContextId = wglCreateContext(this->DeviceContext);
-    if (this->ContextId == NULL) 
+    if (this->ContextId == NULL)
       {
       vtkErrorMacro("wglCreateContext failed in CreateAWindow(), error: " << GetLastError());
       }
     this->MakeCurrent();
-    
+
     // wipe out any existing display lists
     vtkRenderer* ren;
     vtkCollectionSimpleIterator rsit;
-    for (this->Renderers->InitTraversal(rsit); 
+    for (this->Renderers->InitTraversal(rsit);
          (ren = this->Renderers->GetNextRenderer(rsit));)
       {
       ren->SetRenderWindow(0);
@@ -889,20 +889,20 @@ void vtkWin32OpenGLRenderWindow::CreateAWindow()
 
 // Initialize the window for rendering.
 void vtkWin32OpenGLRenderWindow::WindowInitialize()
-{ 
+{
   // create our own window if not already set
   this->OwnWindow = 0;
   if (!this->MFChandledWindow)
     {
     this->InitializeApplication();
     this->CreateAWindow();
-    }   
-  else 
+    }
+  else
     {
     this->MakeCurrent(); // hsr
     this->OpenGLInit();
     }
-  
+
   // set the DPI
   this->SetDPI(GetDeviceCaps(this->DeviceContext, LOGPIXELSY));
 }
@@ -910,7 +910,7 @@ void vtkWin32OpenGLRenderWindow::WindowInitialize()
 // Initialize the rendering window.
 void vtkWin32OpenGLRenderWindow::Initialize (void)
 {
-  // make sure we havent already been initialized 
+  // make sure we havent already been initialized
   if (!this->OffScreenRendering && !this->ContextId)
     {
     this->WindowInitialize();
@@ -955,7 +955,7 @@ void vtkWin32OpenGLRenderWindow::DestroyWindow()
         ReleaseDC(this->WindowId, this->DeviceContext);
         // can't set WindowId=NULL, needed for DestroyWindow
         this->DeviceContext = NULL;
-        
+
         // clear the extra data before calling destroy
         vtkSetWindowLong(this->WindowId,sizeof(vtkLONG),(vtkLONG)0);
         if(this->OwnWindow)
@@ -971,18 +971,18 @@ void vtkWin32OpenGLRenderWindow::DestroyWindow()
 // Get the current size of the window.
 int *vtkWin32OpenGLRenderWindow::GetSize(void)
 {
-  // if we aren't mapped then just return the ivar 
+  // if we aren't mapped then just return the ivar
   if (this->Mapped)
     {
     RECT rect;
 
-    //  Find the current window size 
+    //  Find the current window size
     if (GetClientRect(this->WindowId, &rect))
-      {    
+      {
       this->Size[0] = rect.right;
       this->Size[1] = rect.bottom;
       }
-    else 
+    else
       {
       this->Size[0] = 0;
       this->Size[1] = 0;
@@ -999,23 +999,23 @@ int *vtkWin32OpenGLRenderWindow::GetScreenSize(void)
   RECT rect;
 
   SystemParametersInfo(SPI_GETWORKAREA, 0, &rect, 0);
-                            
+
   this->Size[0] = rect.right - rect.left;
   this->Size[1] = rect.bottom - rect.top;
-  
+
   return this->Size;
 }
 
 // Get the position in screen coordinates of the window.
 int *vtkWin32OpenGLRenderWindow::GetPosition(void)
 {
-  // if we aren't mapped then just return the ivar 
+  // if we aren't mapped then just return the ivar
   if (!this->Mapped)
     {
     return this->Position;
     }
 
-  //  Find the current window position 
+  //  Find the current window position
   //  x,y,&this->Position[0],&this->Position[1],&child);
 
   return this->Position;
@@ -1025,34 +1025,34 @@ int *vtkWin32OpenGLRenderWindow::GetPosition(void)
 void vtkWin32OpenGLRenderWindow::SetFullScreen(int arg)
 {
   int *temp;
-  
+
   if (this->FullScreen == arg)
     {
     return;
     }
-  
+
   if (!this->Mapped)
     {
     this->PrefFullScreen();
     return;
     }
 
-  // set the mode 
+  // set the mode
   this->FullScreen = arg;
   if (this->FullScreen <= 0)
     {
     this->Position[0] = this->OldScreen[0];
     this->Position[1] = this->OldScreen[1];
-    this->Size[0] = this->OldScreen[2]; 
+    this->Size[0] = this->OldScreen[2];
     this->Size[1] = this->OldScreen[3];
     this->Borders = this->OldScreen[4];
     }
   else
     {
-    // if window already up get its values 
+    // if window already up get its values
     if (this->WindowId)
       {
-      temp = this->GetPosition();      
+      temp = this->GetPosition();
       this->OldScreen[0] = temp[0];
       this->OldScreen[1] = temp[1];
 
@@ -1060,8 +1060,8 @@ void vtkWin32OpenGLRenderWindow::SetFullScreen(int arg)
       this->PrefFullScreen();
       }
     }
-  
-  // remap the window 
+
+  // remap the window
   this->WindowRemap();
 
   this->Modified();
@@ -1092,14 +1092,14 @@ void vtkWin32OpenGLRenderWindow::PrefFullScreen()
 
   size = this->GetScreenSize();
 
-  // use full screen 
+  // use full screen
   this->Position[0] = 0;
   this->Position[1] = 0;
   this->Size[0] = size[0] - 2*GetSystemMetrics(SM_CXFRAME);
-  this->Size[1] = size[1] - 
+  this->Size[1] = size[1] -
     2*GetSystemMetrics(SM_CYFRAME) - GetSystemMetrics(SM_CYCAPTION);
 
-  // don't show borders 
+  // don't show borders
   this->Borders = 0;
 }
 
@@ -1108,8 +1108,8 @@ void vtkWin32OpenGLRenderWindow::WindowRemap()
 {
   // close everything down
   this->Finalize();
-  
-  // set the default windowid 
+
+  // set the default windowid
   this->WindowId = this->NextWindowId;
   this->NextWindowId = 0;
 
@@ -1129,7 +1129,7 @@ void vtkWin32OpenGLRenderWindow::PrintSelf(ostream& os, vtkIndent indent)
 // Get the window id.
 HWND vtkWin32OpenGLRenderWindow::GetWindowId()
 {
-  vtkDebugMacro(<< "Returning WindowId of " << this->WindowId << "\n"); 
+  vtkDebugMacro(<< "Returning WindowId of " << this->WindowId << "\n");
 
   return this->WindowId;
 }
@@ -1138,11 +1138,11 @@ HWND vtkWin32OpenGLRenderWindow::GetWindowId()
 void vtkWin32OpenGLRenderWindow::SetWindowId(HWND arg)
 {
   vtkDebugMacro(<< "Setting WindowId to " << arg << "\n");
-  
+
   if (arg != this->WindowId)
     {
     this->WindowId = arg;
-    if (this->ContextId) 
+    if (this->ContextId)
       {
       wglDeleteContext(this->ContextId);
       }
@@ -1155,24 +1155,24 @@ void vtkWin32OpenGLRenderWindow::SetWindowId(HWND arg)
 void vtkWin32OpenGLRenderWindow::SetWindowInfo(char *info)
 {
   int tmp;
-  
+
   sscanf(info,"%i",&tmp);
 
   this->WindowId = (HWND)tmp;
-  vtkDebugMacro(<< "Setting WindowId to " << this->WindowId << "\n"); 
+  vtkDebugMacro(<< "Setting WindowId to " << this->WindowId << "\n");
 }
 
 void vtkWin32OpenGLRenderWindow::SetNextWindowInfo(char *info)
 {
   int tmp;
-  
+
   sscanf(info,"%i",&tmp);
 
   this->SetNextWindowId((HWND)tmp);
 }
 
 void vtkWin32OpenGLRenderWindow::SetDisplayId(void * arg)
-{ 
+{
   this->DeviceContext = (HDC) arg;
 }
 
@@ -1181,7 +1181,7 @@ void vtkWin32OpenGLRenderWindow::SetContextId(HGLRC arg)
   this->ContextId = arg;
 }
 
-void vtkWin32OpenGLRenderWindow::SetDeviceContext(HDC arg) 
+void vtkWin32OpenGLRenderWindow::SetDeviceContext(HDC arg)
 {
   this->DeviceContext = arg;
   this->MFChandledWindow = TRUE;
@@ -1191,17 +1191,17 @@ void vtkWin32OpenGLRenderWindow::SetDeviceContext(HDC arg)
 void vtkWin32OpenGLRenderWindow::SetParentInfo(char *info)
 {
   int tmp;
-  
+
   sscanf(info,"%i",&tmp);
 
   this->ParentId = (HWND)tmp;
-  vtkDebugMacro(<< "Setting ParentId to " << this->ParentId << "\n"); 
+  vtkDebugMacro(<< "Setting ParentId to " << this->ParentId << "\n");
 }
 
 // Set the window id to a pre-existing window.
 void vtkWin32OpenGLRenderWindow::SetParentId(HWND arg)
 {
-  vtkDebugMacro(<< "Setting ParentId to " << arg << "\n"); 
+  vtkDebugMacro(<< "Setting ParentId to " << arg << "\n");
 
   this->ParentId = arg;
 }
@@ -1209,7 +1209,7 @@ void vtkWin32OpenGLRenderWindow::SetParentId(HWND arg)
 // Set the window id of the new window once a WindowRemap is done.
 void vtkWin32OpenGLRenderWindow::SetNextWindowId(HWND arg)
 {
-  vtkDebugMacro(<< "Setting NextWindowId to " << arg << "\n"); 
+  vtkDebugMacro(<< "Setting NextWindowId to " << arg << "\n");
 
   this->NextWindowId = arg;
 }
@@ -1228,7 +1228,7 @@ void vtkWin32OpenGLRenderWindow::Start(void)
     this->Initialize();
     }
 
-  // set the current window 
+  // set the current window
   this->MakeCurrent();
 }
 
@@ -1296,13 +1296,13 @@ void vtkWin32OpenGLRenderWindow::CreateOffScreenWindow(int width,
     DeleteDC(dc);
     }
   this->CreatingOffScreenWindow = status;
-} 
+}
 
 void vtkWin32OpenGLRenderWindow::CreateOffScreenDC(int xsize, int ysize,
                                                    HDC aHdc)
 {
   int dataWidth = ((xsize*3+3)/4)*4;
-  
+
   this->MemoryDataHeader.bmiHeader.biSize = 40;
   this->MemoryDataHeader.bmiHeader.biWidth = xsize;
   this->MemoryDataHeader.bmiHeader.biHeight = ysize;
@@ -1314,7 +1314,7 @@ void vtkWin32OpenGLRenderWindow::CreateOffScreenDC(int xsize, int ysize,
   this->MemoryDataHeader.bmiHeader.biSizeImage = dataWidth*ysize;
   this->MemoryDataHeader.bmiHeader.biXPelsPerMeter = 10000;
   this->MemoryDataHeader.bmiHeader.biYPelsPerMeter = 10000;
-  
+
   HBITMAP dib = CreateDIBSection(aHdc,
                                  &this->MemoryDataHeader, DIB_RGB_COLORS,
                                  (void **)(&(this->MemoryData)),  NULL, 0);
@@ -1330,13 +1330,13 @@ void vtkWin32OpenGLRenderWindow::CreateOffScreenDC(HBITMAP hbmp, HDC aHdc)
   GetObject(hbmp, sizeof(BITMAP), &bm);
 
   this->MemoryBuffer = hbmp;
-  
+
   // Create a compatible device context
   this->MemoryHdc = (HDC)CreateCompatibleDC(aHdc);
-  
+
   // Put the bitmap into the device context
   SelectObject(this->MemoryHdc, this->MemoryBuffer);
-  
+
   // Renderers will need to redraw anything cached in display lists
   this->CleanUpRenderers();
 
@@ -1344,15 +1344,15 @@ void vtkWin32OpenGLRenderWindow::CreateOffScreenDC(HBITMAP hbmp, HDC aHdc)
   this->Mapped =0;
   this->Size[0] = bm.bmWidth;
   this->Size[1] = bm.bmHeight;
-  
+
   this->DeviceContext = this->MemoryHdc;
   this->DoubleBuffer = 0;
-  this->SetupPixelFormat(this->DeviceContext, 
-                         PFD_SUPPORT_OPENGL | PFD_SUPPORT_GDI | 
+  this->SetupPixelFormat(this->DeviceContext,
+                         PFD_SUPPORT_OPENGL | PFD_SUPPORT_GDI |
                          PFD_DRAW_TO_BITMAP, this->GetDebug(), 24, 32);
   this->SetupPalette(this->DeviceContext);
   this->ContextId = wglCreateContext(this->DeviceContext);
-  if (this->ContextId == NULL) 
+  if (this->ContextId == NULL)
     {
     vtkErrorMacro("wglCreateContext failed in CreateOffScreenDC(), error: " << GetLastError());
     }
@@ -1391,7 +1391,7 @@ void vtkWin32OpenGLRenderWindow::SetupMemoryRendering(HBITMAP hbmp)
   this->ScreenContextId = this->ContextId;
 
   this->CreateOffScreenDC(hbmp, dc);
-  DeleteDC(dc); 
+  DeleteDC(dc);
 }
 
 HDC vtkWin32OpenGLRenderWindow::GetMemoryDC()
@@ -1411,15 +1411,15 @@ void vtkWin32OpenGLRenderWindow::CleanUpOffScreenRendering(void)
       {
       return;
       }
-      
+
     GdiFlush();
-      
+
     // we need to release resources
     this->CleanUpRenderers();
     DeleteDC(this->MemoryHdc);
     this->MemoryHdc = (HDC)0;
     DeleteObject(this->MemoryBuffer);
-    if (wglDeleteContext(this->ContextId) != TRUE) 
+    if (wglDeleteContext(this->ContextId) != TRUE)
       {
       vtkErrorMacro("wglDeleteContext failed in CleanUpOffScreenRendering(), error: " << GetLastError());
       }
@@ -1429,7 +1429,7 @@ void vtkWin32OpenGLRenderWindow::CleanUpOffScreenRendering(void)
 
 void vtkWin32OpenGLRenderWindow::ResumeScreenRendering(void)
 {
-  // release OpenGL graphics resources before switch back to on-screen. 
+  // release OpenGL graphics resources before switch back to on-screen.
   if(this->ContextId!=0)
     {
       this->MakeCurrent();
@@ -1467,10 +1467,10 @@ void vtkWin32OpenGLRenderWindow::ShowCursor()
   this->CursorHidden = 0;
 
   ::ShowCursor(!this->CursorHidden);
-}                                  
+}
 
 //----------------------------------------------------------------------------
-void vtkWin32OpenGLRenderWindow::SetCursorPosition(int x, int y) 
+void vtkWin32OpenGLRenderWindow::SetCursorPosition(int x, int y)
 {
   int *size = this->GetSize();
 
@@ -1517,7 +1517,7 @@ void vtkWin32OpenGLRenderWindow::SetCurrentCursor(int shape)
       cursorName = IDC_SIZEALL;
       break;
     case VTK_CURSOR_HAND:
-#if(WINVER >= 0x0500)      
+#if(WINVER >= 0x0500)
       cursorName = IDC_HAND;
 #else
       cursorName = IDC_ARROW;
@@ -1527,10 +1527,10 @@ void vtkWin32OpenGLRenderWindow::SetCurrentCursor(int shape)
       cursorName = IDC_CROSS;
       break;
     }
-  
+
   if (cursorName)
     {
-    HANDLE cursor = 
+    HANDLE cursor =
       LoadImage(0,cursorName,IMAGE_CURSOR,0,0,LR_SHARED | LR_DEFAULTSIZE);
     SetCursor((HCURSOR)cursor);
     }
diff --git a/Rendering/vtkWin32RenderWindowInteractor.cxx b/Rendering/vtkWin32RenderWindowInteractor.cxx
index a53bbc8..8a3dc63 100644
--- a/Rendering/vtkWin32RenderWindowInteractor.cxx
+++ b/Rendering/vtkWin32RenderWindowInteractor.cxx
@@ -17,10 +17,12 @@
 #include <string.h>
 #include <math.h>
 
-#define _WIN32_WINNT 0x0400  // for trackmouseevent support  requires Win95 with IE 3.0 or greater.
-
 #include "vtkWin32OpenGLRenderWindow.h"
 
+#ifndef _WIN32_WINNT
+#define _WIN32_WINNT 0x0400  // for trackmouseevent support  requires Win95 with IE 3.0 or greater.
+#endif
+
 // Mouse wheel support
 // In an ideal world we would just have to include <zmouse.h>, but it is not
 // always available with all compilers/headers
@@ -31,7 +33,7 @@
 #  define GET_WHEEL_DELTA_WPARAM(wparam) ((short)HIWORD (wparam))
 #endif  //GET_WHEEL_DELTA_WPARAM
 
-// MSVC does the right thing without the forward declaration when it 
+// MSVC does the right thing without the forward declaration when it
 // sees it in the friend decl in vtkWin32RenderWindowInteractor, but
 // GCC needs to see the declaration beforehand. It has to do with the
 // CALLBACK attribute.
@@ -60,42 +62,42 @@ void (*vtkWin32RenderWindowInteractor::ClassExitMethodArgDelete)(void *) = (void
 
 //----------------------------------------------------------------------------
 // Construct object so that light follows camera motion.
-vtkWin32RenderWindowInteractor::vtkWin32RenderWindowInteractor() 
+vtkWin32RenderWindowInteractor::vtkWin32RenderWindowInteractor()
 {
   this->WindowId           = 0;
   this->InstallMessageProc = 1;
   this->MouseInWindow = 0;
   this->StartedMessageLoop = 0;
-  
+
 #ifdef VTK_USE_TDX
   this->Device=vtkTDxWinDevice::New();
 #endif
 }
 
 //----------------------------------------------------------------------------
-vtkWin32RenderWindowInteractor::~vtkWin32RenderWindowInteractor() 
+vtkWin32RenderWindowInteractor::~vtkWin32RenderWindowInteractor()
 {
   vtkWin32OpenGLRenderWindow *tmp;
 
   // we need to release any hold we have on a windows event loop
-  if (this->WindowId && this->Enabled && this->InstallMessageProc) 
+  if (this->WindowId && this->Enabled && this->InstallMessageProc)
     {
     vtkWin32OpenGLRenderWindow *ren;
     ren = static_cast<vtkWin32OpenGLRenderWindow *>(this->RenderWindow);
     tmp = (vtkWin32OpenGLRenderWindow *)(vtkGetWindowLong(this->WindowId,sizeof(vtkLONG)));
     // watch for odd conditions
-    if ((tmp != ren) && (ren != NULL)) 
+    if ((tmp != ren) && (ren != NULL))
       {
       // OK someone else has a hold on our event handler
       // so lets have them handle this stuff
       // well send a USER message to the other
       // event handler so that it can properly
       // call this event handler if required
-      CallWindowProc(this->OldProc,this->WindowId,WM_USER+14,28,(LONG)this->OldProc);
+      CallWindowProc(this->OldProc,this->WindowId,WM_USER+14,28,(intptr_t)this->OldProc);
       }
-    else 
+    else
       {
-      vtkSetWindowLong(this->WindowId,vtkGWL_WNDPROC,(vtkLONG)this->OldProc);
+      vtkSetWindowLong(this->WindowId,vtkGWL_WNDPROC,(intptr_t)this->OldProc);
       }
     this->Enabled = 0;
     }
@@ -105,7 +107,7 @@ vtkWin32RenderWindowInteractor::~vtkWin32RenderWindowInteractor()
 }
 
 //----------------------------------------------------------------------------
-void  vtkWin32RenderWindowInteractor::Start() 
+void  vtkWin32RenderWindowInteractor::Start()
 {
   // Let the compositing handle the event loop if it wants to.
   if (this->HasObserver(vtkCommand::StartEvent) && !this->HandleEventLoop)
@@ -132,18 +134,18 @@ void  vtkWin32RenderWindowInteractor::Start()
 
 //----------------------------------------------------------------------------
 // Begin processing keyboard strokes.
-void vtkWin32RenderWindowInteractor::Initialize() 
+void vtkWin32RenderWindowInteractor::Initialize()
 {
   vtkWin32OpenGLRenderWindow *ren;
   int *size;
 
   // make sure we have a RenderWindow and camera
-  if ( ! this->RenderWindow) 
+  if ( ! this->RenderWindow)
     {
     vtkErrorMacro(<<"No renderer defined!");
     return;
     }
-  if (this->Initialized) 
+  if (this->Initialized)
     {
     return;
     }
@@ -160,35 +162,35 @@ void vtkWin32RenderWindowInteractor::Initialize()
 }
 
 //----------------------------------------------------------------------------
-void vtkWin32RenderWindowInteractor::Enable() 
+void vtkWin32RenderWindowInteractor::Enable()
 {
   vtkWin32OpenGLRenderWindow *ren;
   vtkWin32OpenGLRenderWindow *tmp;
-  if (this->Enabled) 
+  if (this->Enabled)
     {
     return;
     }
-  if (this->InstallMessageProc) 
+  if (this->InstallMessageProc)
     {
     // add our callback
     ren = (vtkWin32OpenGLRenderWindow *)(this->RenderWindow);
     this->OldProc = (WNDPROC)vtkGetWindowLong(this->WindowId,vtkGWL_WNDPROC);
     tmp=(vtkWin32OpenGLRenderWindow *)vtkGetWindowLong(this->WindowId,sizeof(vtkLONG));
     // watch for odd conditions
-    if (tmp != ren) 
+    if (tmp != ren)
       {
       // OK someone else has a hold on our event handler
       // so lets have them handle this stuff
       // well send a USER message to the other
       // event handler so that it can properly
       // call this event handler if required
-      CallWindowProc(this->OldProc,this->WindowId,WM_USER+12,24,(LONG)vtkHandleMessage);
+      CallWindowProc(this->OldProc,this->WindowId,WM_USER+12,24,(intptr_t)vtkHandleMessage);
       }
-    else 
+    else
       {
-      vtkSetWindowLong(this->WindowId,vtkGWL_WNDPROC,(vtkLONG)vtkHandleMessage);
+      vtkSetWindowLong(this->WindowId,vtkGWL_WNDPROC,(intptr_t)vtkHandleMessage);
       }
-    
+
 #ifdef VTK_USE_TDX
     if(this->UseTDx)
       {
@@ -197,7 +199,7 @@ void vtkWin32RenderWindowInteractor::Enable()
       this->Device->StartListening();
       }
 #endif
-    
+
     // in case the size of the window has changed while we were away
     int *size;
     size = ren->GetSize();
@@ -210,33 +212,33 @@ void vtkWin32RenderWindowInteractor::Enable()
 
 
 //----------------------------------------------------------------------------
-void vtkWin32RenderWindowInteractor::Disable() 
+void vtkWin32RenderWindowInteractor::Disable()
 {
   vtkWin32OpenGLRenderWindow *tmp;
-  if (!this->Enabled) 
+  if (!this->Enabled)
     {
     return;
     }
-  
-  if (this->InstallMessageProc && this->Enabled && this->WindowId) 
+
+  if (this->InstallMessageProc && this->Enabled && this->WindowId)
     {
     // we need to release any hold we have on a windows event loop
     vtkWin32OpenGLRenderWindow *ren;
     ren = (vtkWin32OpenGLRenderWindow *)(this->RenderWindow);
     tmp = (vtkWin32OpenGLRenderWindow *)vtkGetWindowLong(this->WindowId,sizeof(vtkLONG));
     // watch for odd conditions
-    if ((tmp != ren) && (ren != NULL)) 
+    if ((tmp != ren) && (ren != NULL))
       {
       // OK someone else has a hold on our event handler
       // so lets have them handle this stuff
       // well send a USER message to the other
       // event handler so that it can properly
       // call this event handler if required
-      CallWindowProc(this->OldProc,this->WindowId,WM_USER+14,28,(LONG)this->OldProc);
+      CallWindowProc(this->OldProc,this->WindowId,WM_USER+14,28,(intptr_t)this->OldProc);
       }
-    else 
+    else
       {
-      vtkSetWindowLong(this->WindowId,vtkGWL_WNDPROC,(vtkLONG)this->OldProc);
+      vtkSetWindowLong(this->WindowId,vtkGWL_WNDPROC,(intptr_t)this->OldProc);
       }
 #ifdef VTK_USE_TDX
     if(this->Device->GetInitialized())
@@ -270,7 +272,7 @@ int vtkWin32RenderWindowInteractor::InternalCreateTimer(int timerId, int vtkNotU
 }
 
 //----------------------------------------------------------------------------
-int vtkWin32RenderWindowInteractor::InternalDestroyTimer(int platformTimerId) 
+int vtkWin32RenderWindowInteractor::InternalDestroyTimer(int platformTimerId)
 {
   return KillTimer(this->WindowId,platformTimerId);
 }
@@ -282,42 +284,42 @@ int vtkWin32RenderWindowInteractor::InternalDestroyTimer(int platformTimerId)
 // this ascii code to keysym table is meant to mimic Tk
 
 static const char *AsciiToKeySymTable[] = {
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
-  "space", "exclam", "quotedbl", "numbersign", 
-  "dollar", "percent", "ampersand", "quoteright", 
-  "parenleft", "parenright", "asterisk", "plus", 
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  "space", "exclam", "quotedbl", "numbersign",
+  "dollar", "percent", "ampersand", "quoteright",
+  "parenleft", "parenright", "asterisk", "plus",
   "comma", "minus", "period", "slash",
-  "0", "1", "2", "3", "4", "5", "6", "7", 
+  "0", "1", "2", "3", "4", "5", "6", "7",
   "8", "9", "colon", "semicolon", "less", "equal", "greater", "question",
-  "at", "A", "B", "C", "D", "E", "F", "G", 
+  "at", "A", "B", "C", "D", "E", "F", "G",
   "H", "I", "J", "K", "L", "M", "N", "O",
   "P", "Q", "R", "S", "T", "U", "V", "W",
-  "X", "Y", "Z", "bracketleft", 
+  "X", "Y", "Z", "bracketleft",
   "backslash", "bracketright", "asciicircum", "underscore",
   "quoteleft", "a", "b", "c", "d", "e", "f", "g",
   "h", "i", "j", "k", "l", "m", "n", "o",
   "p", "q", "r", "s", "t", "u", "v", "w",
   "x", "y", "z", "braceleft", "bar", "braceright", "asciitilde", "Delete",
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-  
+
 // this virtual key code to keysym table is meant to mimic Tk
 
 static const char *VKeyCodeToKeySymTable[] = {
   0, 0, 0, "Cancel", 0, 0, 0, 0,
   "BackSpace", "Tab", 0, 0, "Clear", "Return", 0, 0,
-  "Shift_L", "Control_L", "Alt_L", "Pause", "Caps_Lock", 0,0,0, 
+  "Shift_L", "Control_L", "Alt_L", "Pause", "Caps_Lock", 0,0,0,
   0, 0, 0, "Escape", 0, 0, 0, 0,
   "space", "Prior", "Next", "End", "Home", "Left", "Up", "Right",
   "Down", "Select", 0, "Execute", "Snapshot", "Insert", "Delete", "Help",
-  "0", "1", "2", "3", "4", "5", "6", "7", 
+  "0", "1", "2", "3", "4", "5", "6", "7",
   "8", "9", 0, 0, 0, 0, 0, 0,
   0, "a", "b", "c", "d", "e", "f", "g",
   "h", "i", "j", "k", "l", "m", "n", "o",
@@ -326,7 +328,7 @@ static const char *VKeyCodeToKeySymTable[] = {
   "KP_0", "KP_1", "KP_2", "KP_3", "KP_4", "KP_5", "KP_6", "KP_7",
   "KP_8", "KP_9", "asterisk", "plus", "bar", "minus", "period", "slash",
   "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8",
-  "F9", "F10", "F11", "F12", "F13", "F14", "F15", "F16", 
+  "F9", "F10", "F11", "F12", "F13", "F14", "F15", "F16",
   "F17", "F18", "F19", "F20", "F21", "F22", "F23", "F24",
   0, 0, 0, 0, 0, 0, 0, 0,
   "Num_Lock", "Scroll_Lock", 0, 0, 0, 0, 0, 0,
@@ -341,20 +343,20 @@ static const char *VKeyCodeToKeySymTable[] = {
 //-------------------------------------------------------------
 // Event loop handlers
 //-------------------------------------------------------------
-void vtkWin32RenderWindowInteractor::OnMouseMove(HWND hWnd, UINT nFlags, 
-                                                 int X, int Y) 
+void vtkWin32RenderWindowInteractor::OnMouseMove(HWND hWnd, UINT nFlags,
+                                                 int X, int Y)
 {
-  if (!this->Enabled) 
+  if (!this->Enabled)
     {
     return;
     }
 
-  this->SetEventInformationFlipY(X, 
-                                 Y, 
-                                 nFlags & MK_CONTROL, 
+  this->SetEventInformationFlipY(X,
+                                 Y,
+                                 nFlags & MK_CONTROL,
                                  nFlags & MK_SHIFT);
   this->SetAltKey(GetKeyState(VK_MENU) & (~1));
-  if (!this->MouseInWindow && 
+  if (!this->MouseInWindow &&
       (X >= 0 && X < this->Size[0] && Y >= 0 && Y < this->Size[1]))
     {
     this->InvokeEvent(vtkCommand::EnterEvent, NULL);
@@ -366,15 +368,15 @@ void vtkWin32RenderWindowInteractor::OnMouseMove(HWND hWnd, UINT nFlags,
     tme.hwndTrack = hWnd;
     TrackMouseEvent(&tme);
     }
- 
+
   this->InvokeEvent(vtkCommand::MouseMoveEvent, NULL);
 }
 
 //----------------------------------------------------------------------------
-void vtkWin32RenderWindowInteractor::OnNCMouseMove(HWND, UINT nFlags, 
-                                                   int X, int Y) 
+void vtkWin32RenderWindowInteractor::OnNCMouseMove(HWND, UINT nFlags,
+                                                   int X, int Y)
 {
-  if (!this->Enabled) 
+  if (!this->Enabled)
     {
     return;
     }
@@ -382,9 +384,9 @@ void vtkWin32RenderWindowInteractor::OnNCMouseMove(HWND, UINT nFlags,
   int *pos = this->RenderWindow->GetPosition();
   if (this->MouseInWindow)
     {
-    this->SetEventInformationFlipY(X - pos[0], 
+    this->SetEventInformationFlipY(X - pos[0],
                                    Y - pos[1],
-                                   nFlags & MK_CONTROL, 
+                                   nFlags & MK_CONTROL,
                                    nFlags & MK_SHIFT);
     this->SetAltKey(GetKeyState(VK_MENU) & (~1));
     this->InvokeEvent(vtkCommand::LeaveEvent, NULL);
@@ -393,50 +395,50 @@ void vtkWin32RenderWindowInteractor::OnNCMouseMove(HWND, UINT nFlags,
 }
 
 //----------------------------------------------------------------------------
-void vtkWin32RenderWindowInteractor::OnMouseWheelForward(HWND,UINT nFlags, 
-                                                   int X, int Y) 
+void vtkWin32RenderWindowInteractor::OnMouseWheelForward(HWND,UINT nFlags,
+                                                   int X, int Y)
 {
-  if (!this->Enabled) 
+  if (!this->Enabled)
     {
     return;
     }
-  this->SetEventInformationFlipY(X, 
-                                 Y, 
-                                 nFlags & MK_CONTROL, 
+  this->SetEventInformationFlipY(X,
+                                 Y,
+                                 nFlags & MK_CONTROL,
                                  nFlags & MK_SHIFT);
   this->SetAltKey(GetKeyState(VK_MENU) & (~1));
   this->InvokeEvent(vtkCommand::MouseWheelForwardEvent,NULL);
 }
 
 //----------------------------------------------------------------------------
-void vtkWin32RenderWindowInteractor::OnMouseWheelBackward(HWND,UINT nFlags, 
-                                                   int X, int Y) 
+void vtkWin32RenderWindowInteractor::OnMouseWheelBackward(HWND,UINT nFlags,
+                                                   int X, int Y)
 {
-  if (!this->Enabled) 
+  if (!this->Enabled)
     {
     return;
     }
-  this->SetEventInformationFlipY(X, 
-                                 Y, 
-                                 nFlags & MK_CONTROL, 
+  this->SetEventInformationFlipY(X,
+                                 Y,
+                                 nFlags & MK_CONTROL,
                                  nFlags & MK_SHIFT);
   this->SetAltKey(GetKeyState(VK_MENU) & (~1));
   this->InvokeEvent(vtkCommand::MouseWheelBackwardEvent,NULL);
 }
 
 //----------------------------------------------------------------------------
-void vtkWin32RenderWindowInteractor::OnLButtonDown(HWND wnd,UINT nFlags, 
-                                                   int X, int Y, int repeat) 
+void vtkWin32RenderWindowInteractor::OnLButtonDown(HWND wnd,UINT nFlags,
+                                                   int X, int Y, int repeat)
 {
-  if (!this->Enabled) 
+  if (!this->Enabled)
     {
     return;
     }
   SetFocus(wnd);
   SetCapture(wnd);
-  this->SetEventInformationFlipY(X, 
-                                 Y, 
-                                 nFlags & MK_CONTROL, 
+  this->SetEventInformationFlipY(X,
+                                 Y,
+                                 nFlags & MK_CONTROL,
                                  nFlags & MK_SHIFT,
                                  0, repeat);
   this->SetAltKey(GetKeyState(VK_MENU) & (~1));
@@ -444,16 +446,16 @@ void vtkWin32RenderWindowInteractor::OnLButtonDown(HWND wnd,UINT nFlags,
 }
 
 //----------------------------------------------------------------------------
-void vtkWin32RenderWindowInteractor::OnLButtonUp(HWND,UINT nFlags, 
-                                                 int X, int Y) 
+void vtkWin32RenderWindowInteractor::OnLButtonUp(HWND,UINT nFlags,
+                                                 int X, int Y)
 {
-  if (!this->Enabled) 
+  if (!this->Enabled)
     {
     return;
     }
-  this->SetEventInformationFlipY(X, 
-                                 Y, 
-                                 nFlags & MK_CONTROL, 
+  this->SetEventInformationFlipY(X,
+                                 Y,
+                                 nFlags & MK_CONTROL,
                                  nFlags & MK_SHIFT);
   this->SetAltKey(GetKeyState(VK_MENU) & (~1));
   this->InvokeEvent(vtkCommand::LeftButtonReleaseEvent,NULL);
@@ -461,18 +463,18 @@ void vtkWin32RenderWindowInteractor::OnLButtonUp(HWND,UINT nFlags,
 }
 
 //----------------------------------------------------------------------------
-void vtkWin32RenderWindowInteractor::OnMButtonDown(HWND wnd,UINT nFlags, 
-                                                   int X, int Y, int repeat) 
+void vtkWin32RenderWindowInteractor::OnMButtonDown(HWND wnd,UINT nFlags,
+                                                   int X, int Y, int repeat)
 {
-  if (!this->Enabled) 
+  if (!this->Enabled)
     {
     return;
     }
   SetFocus(wnd);
   SetCapture(wnd);
-  this->SetEventInformationFlipY(X, 
-                                 Y, 
-                                 nFlags & MK_CONTROL, 
+  this->SetEventInformationFlipY(X,
+                                 Y,
+                                 nFlags & MK_CONTROL,
                                  nFlags & MK_SHIFT,
                                  0, repeat);
   this->SetAltKey(GetKeyState(VK_MENU) & (~1));
@@ -480,16 +482,16 @@ void vtkWin32RenderWindowInteractor::OnMButtonDown(HWND wnd,UINT nFlags,
 }
 
 //----------------------------------------------------------------------------
-void vtkWin32RenderWindowInteractor::OnMButtonUp(HWND,UINT nFlags, 
-                                                 int X, int Y) 
+void vtkWin32RenderWindowInteractor::OnMButtonUp(HWND,UINT nFlags,
+                                                 int X, int Y)
 {
-  if (!this->Enabled) 
+  if (!this->Enabled)
     {
     return;
     }
-  this->SetEventInformationFlipY(X, 
-                                 Y, 
-                                 nFlags & MK_CONTROL, 
+  this->SetEventInformationFlipY(X,
+                                 Y,
+                                 nFlags & MK_CONTROL,
                                  nFlags & MK_SHIFT);
   this->SetAltKey(GetKeyState(VK_MENU) & (~1));
   this->InvokeEvent(vtkCommand::MiddleButtonReleaseEvent,NULL);
@@ -497,18 +499,18 @@ void vtkWin32RenderWindowInteractor::OnMButtonUp(HWND,UINT nFlags,
 }
 
 //----------------------------------------------------------------------------
-void vtkWin32RenderWindowInteractor::OnRButtonDown(HWND wnd,UINT nFlags, 
-                                                   int X, int Y, int repeat) 
+void vtkWin32RenderWindowInteractor::OnRButtonDown(HWND wnd,UINT nFlags,
+                                                   int X, int Y, int repeat)
 {
-  if (!this->Enabled) 
+  if (!this->Enabled)
     {
     return;
     }
   SetFocus(wnd);
   SetCapture(wnd);
-  this->SetEventInformationFlipY(X, 
-                                 Y, 
-                                 nFlags & MK_CONTROL, 
+  this->SetEventInformationFlipY(X,
+                                 Y,
+                                 nFlags & MK_CONTROL,
                                  nFlags & MK_SHIFT,
                                  0, repeat);
   this->SetAltKey(GetKeyState(VK_MENU) & (~1));
@@ -516,16 +518,16 @@ void vtkWin32RenderWindowInteractor::OnRButtonDown(HWND wnd,UINT nFlags,
 }
 
 //----------------------------------------------------------------------------
-void vtkWin32RenderWindowInteractor::OnRButtonUp(HWND,UINT nFlags, 
-                                                 int X, int Y) 
+void vtkWin32RenderWindowInteractor::OnRButtonUp(HWND,UINT nFlags,
+                                                 int X, int Y)
 {
-  if (!this->Enabled) 
+  if (!this->Enabled)
     {
     return;
     }
-  this->SetEventInformationFlipY(X, 
-                                 Y, 
-                                 nFlags & MK_CONTROL, 
+  this->SetEventInformationFlipY(X,
+                                 Y,
+                                 nFlags & MK_CONTROL,
                                  nFlags & MK_SHIFT);
   this->SetAltKey(GetKeyState(VK_MENU) & (~1));
   this->InvokeEvent(vtkCommand::RightButtonReleaseEvent,NULL);
@@ -542,15 +544,15 @@ void vtkWin32RenderWindowInteractor::OnSize(HWND,UINT, int X, int Y) {
 }
 
 //----------------------------------------------------------------------------
-void vtkWin32RenderWindowInteractor::OnTimer(HWND,UINT timerId) 
+void vtkWin32RenderWindowInteractor::OnTimer(HWND,UINT timerId)
 {
-  if (!this->Enabled) 
+  if (!this->Enabled)
     {
     return;
     }
   int tid = static_cast<int>(timerId);
   this->InvokeEvent(vtkCommand::TimerEvent,(void*)&tid);
-  
+
   // Here we deal with one-shot versus repeating timers
   if ( this->IsOneShotTimer(tid) )
     {
@@ -578,7 +580,7 @@ void vtkWin32RenderWindowInteractor::OnKeyDown(HWND, UINT vCode, UINT nRepCnt, U
       nChar = 0;
       }
 #endif
-  } 
+  }
   const char *keysym = AsciiToKeySymTable[(unsigned char)nChar];
   if (keysym == 0)
     {
@@ -588,10 +590,10 @@ void vtkWin32RenderWindowInteractor::OnKeyDown(HWND, UINT vCode, UINT nRepCnt, U
     {
     keysym = "None";
     }
-  this->SetKeyEventInformation(ctrl, 
-                               shift, 
-                               nChar, 
-                               nRepCnt, 
+  this->SetKeyEventInformation(ctrl,
+                               shift,
+                               nChar,
+                               nRepCnt,
                                keysym);
   this->SetAltKey(alt);
   this->InvokeEvent(vtkCommand::KeyPressEvent, NULL);
@@ -627,10 +629,10 @@ void vtkWin32RenderWindowInteractor::OnKeyUp(HWND, UINT vCode, UINT nRepCnt, UIN
     {
     keysym = "None";
     }
-  this->SetKeyEventInformation(ctrl, 
-                               shift, 
-                               nChar, 
-                               nRepCnt, 
+  this->SetKeyEventInformation(ctrl,
+                               shift,
+                               nChar,
+                               nRepCnt,
                                keysym);
   this->SetAltKey(alt);
   this->InvokeEvent(vtkCommand::KeyReleaseEvent, NULL);
@@ -645,11 +647,11 @@ void vtkWin32RenderWindowInteractor::OnChar(HWND,UINT nChar,
     return;
     }
   int ctrl  = GetKeyState(VK_CONTROL) & (~1);
-  int shift = GetKeyState(VK_SHIFT) & (~1); 
+  int shift = GetKeyState(VK_SHIFT) & (~1);
   int alt = GetKeyState(VK_MENU) & (~1);
-  this->SetKeyEventInformation(ctrl, 
-                               shift, 
-                               nChar, 
+  this->SetKeyEventInformation(ctrl,
+                               shift,
+                               nChar,
                                nRepCnt);
   this->SetAltKey(alt);
   this->InvokeEvent(vtkCommand::CharEvent, NULL);
@@ -658,11 +660,11 @@ void vtkWin32RenderWindowInteractor::OnChar(HWND,UINT nChar,
 //----------------------------------------------------------------------------
 void vtkWin32RenderWindowInteractor::OnFocus(HWND,UINT)
 {
-  if (!this->Enabled) 
+  if (!this->Enabled)
     {
     return;
     }
-  
+
 #ifdef VTK_USE_TDX
   if(this->Device->GetInitialized() && !this->Device->GetIsListening())
     {
@@ -674,7 +676,7 @@ void vtkWin32RenderWindowInteractor::OnFocus(HWND,UINT)
 //----------------------------------------------------------------------------
 void vtkWin32RenderWindowInteractor::OnKillFocus(HWND,UINT)
 {
-  if (!this->Enabled) 
+  if (!this->Enabled)
     {
     return;
     }
@@ -688,8 +690,8 @@ void vtkWin32RenderWindowInteractor::OnKillFocus(HWND,UINT)
 
 //----------------------------------------------------------------------------
 // This is only called when InstallMessageProc is true
-LRESULT CALLBACK vtkHandleMessage(HWND hWnd,UINT uMsg, WPARAM wParam, 
-                                  LPARAM lParam) 
+LRESULT CALLBACK vtkHandleMessage(HWND hWnd,UINT uMsg, WPARAM wParam,
+                                  LPARAM lParam)
 {
   LRESULT res = 0;
   vtkWin32OpenGLRenderWindow *ren;
@@ -713,33 +715,33 @@ LRESULT CALLBACK vtkHandleMessage(HWND hWnd,UINT uMsg, WPARAM wParam,
 }
 
 #ifndef MAKEPOINTS
-#define MAKEPOINTS(l)   (*((POINTS FAR *) & (l))) 
+#define MAKEPOINTS(l)   (*((POINTS FAR *) & (l)))
 #endif
 
 //----------------------------------------------------------------------------
-LRESULT CALLBACK vtkHandleMessage2(HWND hWnd,UINT uMsg, WPARAM wParam, 
-                                   LPARAM lParam, 
-                                   vtkWin32RenderWindowInteractor *me) 
+LRESULT CALLBACK vtkHandleMessage2(HWND hWnd,UINT uMsg, WPARAM wParam,
+                                   LPARAM lParam,
+                                   vtkWin32RenderWindowInteractor *me)
 {
-  if ((uMsg == WM_USER+13)&&(wParam == 26)) 
+  if ((uMsg == WM_USER+13)&&(wParam == 26))
     {
     // someone is telling us to set our OldProc
     me->OldProc = (WNDPROC)lParam;
     return 1;
     }
-  
-  switch (uMsg) 
+
+  switch (uMsg)
     {
     case WM_PAINT:
       me->Render();
       return CallWindowProc(me->OldProc,hWnd,uMsg,wParam,lParam);
       break;
-      
+
     case WM_SIZE:
       me->OnSize(hWnd,wParam,LOWORD(lParam),HIWORD(lParam));
       return CallWindowProc(me->OldProc,hWnd,uMsg,wParam,lParam);
       break;
-      
+
     case WM_LBUTTONDBLCLK:
       me->OnLButtonDown(hWnd,wParam,MAKEPOINTS(lParam).x,MAKEPOINTS(lParam).y, 1);
       break;
@@ -747,7 +749,7 @@ LRESULT CALLBACK vtkHandleMessage2(HWND hWnd,UINT uMsg, WPARAM wParam,
     case WM_LBUTTONDOWN:
       me->OnLButtonDown(hWnd,wParam,MAKEPOINTS(lParam).x,MAKEPOINTS(lParam).y, 0);
       break;
-      
+
     case WM_LBUTTONUP:
       me->OnLButtonUp(hWnd,wParam,MAKEPOINTS(lParam).x,MAKEPOINTS(lParam).y);
       break;
@@ -759,11 +761,11 @@ LRESULT CALLBACK vtkHandleMessage2(HWND hWnd,UINT uMsg, WPARAM wParam,
     case WM_MBUTTONDOWN:
       me->OnMButtonDown(hWnd,wParam,MAKEPOINTS(lParam).x,MAKEPOINTS(lParam).y, 0);
       break;
-      
+
     case WM_MBUTTONUP:
       me->OnMButtonUp(hWnd,wParam,MAKEPOINTS(lParam).x,MAKEPOINTS(lParam).y);
       break;
-      
+
     case WM_RBUTTONDBLCLK:
       me->OnRButtonDown(hWnd,wParam,MAKEPOINTS(lParam).x,MAKEPOINTS(lParam).y, 1);
       break;
@@ -771,7 +773,7 @@ LRESULT CALLBACK vtkHandleMessage2(HWND hWnd,UINT uMsg, WPARAM wParam,
     case WM_RBUTTONDOWN:
       me->OnRButtonDown(hWnd,wParam,MAKEPOINTS(lParam).x,MAKEPOINTS(lParam).y, 0);
       break;
-      
+
     case WM_RBUTTONUP:
       me->OnRButtonUp(hWnd,wParam,MAKEPOINTS(lParam).x,MAKEPOINTS(lParam).y);
       break;
@@ -811,7 +813,7 @@ LRESULT CALLBACK vtkHandleMessage2(HWND hWnd,UINT uMsg, WPARAM wParam,
     case WM_CHAR:
       me->OnChar(hWnd,wParam,LOWORD(lParam),HIWORD(lParam));
       break;
-      
+
     case WM_KEYDOWN:
     case WM_SYSKEYDOWN:
       me->OnKeyDown(hWnd,wParam,LOWORD(lParam),HIWORD(lParam));
@@ -823,7 +825,7 @@ LRESULT CALLBACK vtkHandleMessage2(HWND hWnd,UINT uMsg, WPARAM wParam,
       break;
 
     case WM_TIMER:
-      me->OnTimer(hWnd,wParam);    
+      me->OnTimer(hWnd,wParam);
       break;
 
     case WM_ACTIVATE:
@@ -836,25 +838,25 @@ LRESULT CALLBACK vtkHandleMessage2(HWND hWnd,UINT uMsg, WPARAM wParam,
         me->OnFocus(hWnd,wParam);
         }
       break;
-      
+
     case WM_SETFOCUS:
       // occurs when SetFocus() is called on the current window
       me->OnFocus(hWnd,wParam);
       break;
-      
+
     case WM_KILLFOCUS:
       // occurs when the focus was on the current window and SetFocus() is
-      // called on another window. 
+      // called on another window.
       me->OnKillFocus(hWnd,wParam);
       break;
-      
+
     default:
-      if (me) 
+      if (me)
         {
         return CallWindowProc(me->OldProc,hWnd,uMsg,wParam,lParam);
         }
     };
-  
+
   return 0;
 }