packages/wxvtk/src/wxVTKRenderWindowInteractor.cxx

   1 /*
   2  # ---------------------------------------------------------------------
   3  #
   4  # Copyright (c) CREATIS (Centre de Recherche en Acquisition et Traitement de l'Image
   5  #                        pour la SantÈ)
   6  # Authors : Eduardo Davila, Frederic Cervenansky, Claire Mouton
   7  # Previous Authors : Laurent Guigues, Jean-Pierre Roux
   8  # CreaTools website : www.creatis.insa-lyon.fr/site/fr/creatools_accueil
   9  #
  10  #  This software is governed by the CeCILL-B license under French law and
  11  #  abiding by the rules of distribution of free software. You can  use,
  12  #  modify and/ or redistribute the software under the terms of the CeCILL-B
  13  #  license as circulated by CEA, CNRS and INRIA at the following URL
  14  #  http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
  15  #  or in the file LICENSE.txt.
  16  #
  17  #  As a counterpart to the access to the source code and  rights to copy,
  18  #  modify and redistribute granted by the license, users are provided only
  19  #  with a limited warranty  and the software's author,  the holder of the
  20  #  economic rights,  and the successive licensors  have only  limited
  21  #  liability.
  22  #
  23  #  The fact that you are presently reading this means that you have had
  24  #  knowledge of the CeCILL-B license and that you accept its terms.
  25  # ------------------------------------------------------------------------ */
  26
  27
  28 /*=========================================================================
  29
  30   Program:   Visualization Toolkit
  31   Module:    $RCSfile: wxVTKRenderWindowInteractor.cxx,v $
  32   Language:  C++
  33   Date:      $Date: 2012/11/16 08:52:36 $
  34   Version:   $Revision: 1.5 $
  35
  36 =========================================================================*/
  37
  38 #include <assert.h>
  39
  40 #include "wxVTKRenderWindowInteractor.h"
  41
  42 //This is needed for vtk 3.1 :
  43 #ifndef VTK_MAJOR_VERSION
  44 #  include "vtkVersion.h"
  45 #endif
  46
  47 #if VTK_MAJOR_VERSION > 4 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION > 0)
  48 #  include "vtkCommand.h"
  49 #else
  50 #  include "vtkInteractorStyle.h"
  51 #endif
  52 #include "vtkDebugLeaks.h"
  53
  54 #ifdef __WXMAC__
  55 #include "vtkCarbonRenderWindow.h"
  56 #endif
  57
  58 //=======================================================================
  59 // LG : NAMESPACE IS NECESSARY TO AVOID CONFLICTING SYMBOLS IN DYN LIBS
  60 namespace bbwxvtk
  61 {
  62
  63
  64 //Keep this for compatibilty reason, this was introduced in wxGTK 2.4.0
  65 #if (!wxCHECK_VERSION(2, 4, 0))
  66 wxWindow* wxGetTopLevelParent(wxWindow *win)
  67 {
  68     while ( win && !win->IsTopLevel() )
  69          win = win->GetParent();
  70     return win;
  71 }
  72 #endif
  73 }
  74 // LG : EO namespace bbwxvtk
  75 //=======================================================================
  76
  77 // To access objc calls on cocoa
  78 #ifdef __WXCOCOA__
  79 #ifdef VTK_USE_COCOA
  80 #import <Cocoa/Cocoa.h>
  81 // This trick is no longer need in VTK CVS, should get rid of that:
  82 #define id Id
  83 #else
  84 #error Build mismatch you need both wxWidgets and VTK to be configure against Cocoa to work
  85 #endif //VTK_USE_COCOA
  86 #endif //__WXCOCOA__
  87
  88 #ifdef __WXGTK__
  89 #    include <gdk/gdkx.h> // GDK_WINDOW_XWINDOW is found here in wxWidgets 2.8.0
  90 #    include "gdk/gdkprivate.h"
  91 #if wxCHECK_VERSION(2, 8, 0)
  92 #ifdef __WXGTK20__
  93 #include <wx/gtk/win_gtk.h>
  94 #else
  95 #include <wx/gtk1/win_gtk.h>
  96 #endif
  97 #else
  98 #include <wx/gtk/win_gtk.h>
  99 #endif
 100 #define GetXWindow(wxwin) (wxwin)->m_wxwindow ? \
 101                           GDK_WINDOW_XWINDOW(GTK_PIZZA((wxwin)->m_wxwindow)->bin_window) : \
 102                           GDK_WINDOW_XWINDOW((wxwin)->m_widget->window)
 103 #endif
 104
 105 #ifdef __WXX11__
 106 #include "wx/x11/privx.h"
 107 #define GetXWindow(wxwin)   ((Window)(wxwin)->GetHandle())
 108 #endif
 109
 110
 111 //For more info on this class please go to:
 112 //http://wxvtk.sf.net
 113 //This hack is for some buggy wxGTK version:
 114 #if wxCHECK_VERSION(2, 3, 2) && !wxCHECK_VERSION(2, 4, 1) && defined(__WXGTK__)
 115 #  define WX_USE_X_CAPTURE 0
 116 #else
 117 #  define WX_USE_X_CAPTURE 1
 118 #endif
 119
 120 #define ID_wxVTKRenderWindowInteractor_TIMER 1001
 121
 122 //=======================================================================
 123 // LG : NAMESPACE IS NECESSARY TO AVOID CONFLICTING SYMBOLS IN DYN LIBS
 124 namespace bbwxvtk
 125 {
 126
 127 #if defined(__WXGTK__) && defined(USE_WXGLCANVAS)
 128 IMPLEMENT_DYNAMIC_CLASS(wxVTKRenderWindowInteractor, wxGLCanvas)
 129 #else
 130 IMPLEMENT_DYNAMIC_CLASS(wxVTKRenderWindowInteractor, wxWindow)
 131 #endif  //__WXGTK__
 132
 133 //---------------------------------------------------------------------------
 134 #if defined(__WXGTK__) && defined(USE_WXGLCANVAS)
 135 BEGIN_EVENT_TABLE(wxVTKRenderWindowInteractor, wxGLCanvas)
 136 #else
 137 BEGIN_EVENT_TABLE(wxVTKRenderWindowInteractor, wxWindow)
 138 #endif //__WXGTK__
 139   //refresh window by doing a Render
 140   EVT_PAINT       (wxVTKRenderWindowInteractor::OnPaint)
 141   EVT_ERASE_BACKGROUND(wxVTKRenderWindowInteractor::OnEraseBackground)
 142   EVT_MOTION      (wxVTKRenderWindowInteractor::OnMotion)
 143
 144   //Bind the events to the event converters
 145   EVT_LEFT_DOWN   (wxVTKRenderWindowInteractor::OnButtonDown)
 146   EVT_MIDDLE_DOWN (wxVTKRenderWindowInteractor::OnButtonDown)
 147   EVT_RIGHT_DOWN  (wxVTKRenderWindowInteractor::OnButtonDown)
 148   EVT_LEFT_UP     (wxVTKRenderWindowInteractor::OnButtonUp)
 149   EVT_MIDDLE_UP   (wxVTKRenderWindowInteractor::OnButtonUp)
 150   EVT_RIGHT_UP    (wxVTKRenderWindowInteractor::OnButtonUp)
 151 #if !(VTK_MAJOR_VERSION == 3 && VTK_MINOR_VERSION == 1)
 152   EVT_ENTER_WINDOW(wxVTKRenderWindowInteractor::OnEnter)
 153   EVT_LEAVE_WINDOW(wxVTKRenderWindowInteractor::OnLeave)
 154   EVT_MOUSEWHEEL  (wxVTKRenderWindowInteractor::OnMouseWheel)
 155   EVT_KEY_DOWN    (wxVTKRenderWindowInteractor::OnKeyDown)
 156   EVT_KEY_UP      (wxVTKRenderWindowInteractor::OnKeyUp)
 157   EVT_CHAR        (wxVTKRenderWindowInteractor::OnChar)
 158 #endif
 159   EVT_TIMER       (ID_wxVTKRenderWindowInteractor_TIMER, wxVTKRenderWindowInteractor::OnTimer)
 160   EVT_SIZE        (wxVTKRenderWindowInteractor::OnSize)
 161 END_EVENT_TABLE()
 162
 163
 164
 165 //EED 2017-01-01 Migration VTK7
 166 #if VTK_MAJOR_VERSION <= 5
 167   vtkCxxRevisionMacro(wxVTKRenderWindowInteractor, "$Revision: 1.5 $")
 168 #else
 169   //...
 170 #endif
 171
 172 vtkInstantiatorNewMacro(wxVTKRenderWindowInteractor)
 173
 174 //---------------------------------------------------------------------------
 175 #if defined(__WXGTK__) && defined(USE_WXGLCANVAS)
 176 #if (wxCHECK_VERSION(2, 8, 0))
 177 wxVTKRenderWindowInteractor::wxVTKRenderWindowInteractor() : wxGLCanvas(0, -1, wxDefaultPosition), vtkRenderWindowInteractor()
 178 #else
 179 wxVTKRenderWindowInteractor::wxVTKRenderWindowInteractor() : wxGLCanvas(), vtkRenderWindowInteractor()
 180 #endif
 181 #else
 182 wxVTKRenderWindowInteractor::wxVTKRenderWindowInteractor() : wxWindow(), vtkRenderWindowInteractor()
 183 #endif //__WXGTK__
 184       , timer(this, ID_wxVTKRenderWindowInteractor_TIMER)
 185       , ActiveButton(wxEVT_NULL)
 186       , RenderAllowed(0)
 187       , Stereo(0)
 188       , Handle(0)
 189       , Created(true)
 190       , RenderWhenDisabled(1)
 191       , UseCaptureMouse(0)
 192 {
 193 #ifdef VTK_DEBUG_LEAKS
 194   vtkDebugLeaks::ConstructClass("wxVTKRenderWindowInteractor");
 195 #endif
 196
 197   this->RenderWindow = NULL;
 198   this->SetRenderWindow(vtkRenderWindow::New());
 199   this->RenderWindow->Delete();
 200   this->SetBackgroundStyle( wxBG_STYLE_COLOUR );
 201   this->SetBackgroundColour( wxColor(0,0,0,0) );
 202 }
 203 //---------------------------------------------------------------------------
 204 wxVTKRenderWindowInteractor::wxVTKRenderWindowInteractor(wxWindow *parent,
 205                                                          wxWindowID id,
 206                                                          const wxPoint &pos,
 207                                                          const wxSize &size,
 208                                                          long style,
 209                                                          const wxString &name)
 210 #if defined(__WXGTK__) && defined(USE_WXGLCANVAS)
 211       : wxGLCanvas(parent, id, pos, size, style, name), vtkRenderWindowInteractor()
 212 #else
 213       : wxWindow(parent, id, pos, size, style, name), vtkRenderWindowInteractor()
 214 #endif //__WXGTK__
 215       , timer(this, ID_wxVTKRenderWindowInteractor_TIMER)
 216       , ActiveButton(wxEVT_NULL)
 217       , RenderAllowed(0)
 218       , Stereo(0)
 219       , Handle(0)
 220       , Created(true)
 221       , RenderWhenDisabled(1)
 222       , UseCaptureMouse(0)
 223 {
 224 #ifdef VTK_DEBUG_LEAKS
 225   vtkDebugLeaks::ConstructClass("wxVTKRenderWindowInteractor");
 226 #endif
 227   this->RenderWindow = NULL;
 228   this->SetRenderWindow(vtkRenderWindow::New());
 229   this->RenderWindow->Delete();
 230 #ifdef __WXMAC__
 231   // On Mac (Carbon) we don't get notified of the initial window size with an EVT_SIZE event,
 232   // so we update the size information of the interactor/renderwindow here
 233   this->UpdateSize(size.x, size.y);
 234 #endif
 235   this->SetBackgroundStyle( wxBG_STYLE_COLOUR );
 236   this->SetBackgroundColour( wxColor(0,0,0,0) );
 237 }
 238 //---------------------------------------------------------------------------
 239 wxVTKRenderWindowInteractor::~wxVTKRenderWindowInteractor()
 240 {
 241   SetRenderWindow(NULL);
 242   SetInteractorStyle(NULL);
 243 }
 244 //---------------------------------------------------------------------------
 245 wxVTKRenderWindowInteractor * wxVTKRenderWindowInteractor::New()
 246 {
 247   // we don't make use of the objectfactory, because we're not registered
 248   return new wxVTKRenderWindowInteractor;
 249 }
 250 //---------------------------------------------------------------------------
 251 void wxVTKRenderWindowInteractor::Initialize()
 252 {
 253   int *size = RenderWindow->GetSize();
 254   // enable everything and start rendering
 255   Enable();
 256   //RenderWindow->Start();
 257
 258   // set the size in the render window interactor
 259   Size[0] = size[0];
 260   Size[1] = size[1];
 261
 262   // this is initialized
 263   Initialized = 1;
 264 }
 265 //---------------------------------------------------------------------------
 266 void wxVTKRenderWindowInteractor::Enable()
 267 {
 268   // if already enabled then done
 269   if (Enabled)
 270     return;
 271
 272   // that's it
 273   Enabled = 1;
 274 #if defined(__WXGTK__) && defined(USE_WXGLCANVAS)
 275   SetCurrent();
 276 #endif
 277   Modified();
 278 }
 279 //---------------------------------------------------------------------------
 280 bool wxVTKRenderWindowInteractor::Enable(bool enable)
 281 {
 282 #if defined(__WXGTK__) && defined(USE_WXGLCANVAS)
 283   return wxGLCanvas::Enable(enable);
 284 #else
 285   return wxWindow::Enable(enable);
 286 #endif
 287 }
 288 //---------------------------------------------------------------------------
 289 void wxVTKRenderWindowInteractor::Disable()
 290 {
 291   // if already disabled then done
 292   if (!Enabled)
 293     return;
 294
 295   // that's it (we can't remove the event handler like it should be...)
 296   Enabled = 0;
 297   Modified();
 298 }
 299 //---------------------------------------------------------------------------
 300 void wxVTKRenderWindowInteractor::Start()
 301 {
 302   // the interactor cannot control the event loop
 303   vtkErrorMacro( << "wxVTKRenderWindowInteractor::Start() "
 304     "interactor cannot control event loop.");
 305 }
 306 //---------------------------------------------------------------------------
 307 void wxVTKRenderWindowInteractor::UpdateSize(int x, int y)
 308 {
 309   if( RenderWindow )
 310   {
 311     // if the size changed tell render window
 312     if ( x != Size[0] || y != Size[1] )
 313     {
 314       // adjust our (vtkRenderWindowInteractor size)
 315       Size[0] = x;
 316       Size[1] = y;
 317       // and our RenderWindow's size
 318       RenderWindow->SetSize(x, y);
 319     } // if x y
 320   } // if RenderWindow
 321 }
 322 //---------------------------------------------------------------------------
 323 int wxVTKRenderWindowInteractor::CreateTimer(int WXUNUSED(timertype))
 324 {
 325   // it's a one shot timer
 326   if (!timer.Start(10, TRUE))
 327         {
 328         assert(false);
 329         }
 330
 331   return 1;
 332
 333 }
 334 //---------------------------------------------------------------------------
 335 int wxVTKRenderWindowInteractor::DestroyTimer()
 336 {
 337   // do nothing
 338   return 1;
 339 }
 340 //---------------------------------------------------------------------------
 341 void wxVTKRenderWindowInteractor::OnTimer(wxTimerEvent& WXUNUSED(event))
 342 {
 343         if (!Enabled)
 344         {
 345             return;
 346     }
 347
 348 #if VTK_MAJOR_VERSION > 4 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION > 0)
 349     // new style
 350     InvokeEvent(vtkCommand::TimerEvent, NULL);
 351 #else
 352     // old style
 353     InteractorStyle->OnTimer();
 354 #endif
 355 }
 356
 357 //---------------------------------------------------------------------------
 358 // NOTE on implementation:
 359 // Bad luck you ended up in the only tricky place of this code.
 360 // A few note, wxWidgets still refuse to provide such convenient method
 361 // so I have to maintain it myself, eventhough this is completely integrated
 362 // in wxPython...
 363 // Anyway if this happen to break for you then compare to a recent version of wxPython
 364 // and look for the function long wxPyGetWinHandle(wxWindow* win)
 365 // in wxPython/src/helpers.cpp
 366 long wxVTKRenderWindowInteractor::GetHandleHack()
 367 {
 368   //helper function to hide the MSW vs GTK stuff
 369   long handle_tmp = 0;
 370
 371 // __WXMSW__ is for Win32
 372 //__WXMAC__ stands for using Carbon C-headers, using either the CarbonLib/CFM or the native Mach-O builds (which then also use the latest features available)
 373 // __WXGTK__ is for both gtk 1.2.x and gtk 2.x
 374 #if defined(__WXMSW__) || defined(__WXMAC__)
 375     handle_tmp = (long)this->GetHandle();
 376 #endif //__WXMSW__
 377
 378 //__WXCOCOA__ stands for using the objective-c Cocoa API
 379 #ifdef __WXCOCOA__
 380    // Here is how to find the NSWindow
 381    wxTopLevelWindow* toplevel = dynamic_cast<wxTopLevelWindow*>(
 382      wxGetTopLevelParent( this ) );
 383    if (toplevel != NULL )
 384    {
 385      handle_tmp = (long)toplevel->GetNSWindow();
 386    }
 387    // The NSView will be deducted from
 388    // [(NSWindow*)Handle contentView]
 389    // if only I knew how to write that in c++
 390 #endif //__WXCOCOA__
 391
 392     // Find and return the actual X-Window.
 393 #if defined(__WXGTK__) || defined(__WXX11__)
 394     return (long)GetXWindow(this);
 395 #endif
 396
 397 //#ifdef __WXMOTIF__
 398 //    handle_tmp = (long)this->GetXWindow();
 399 //#endif
 400
 401   return handle_tmp;
 402 }
 403 //---------------------------------------------------------------------------
 404 void wxVTKRenderWindowInteractor::OnPaint(wxPaintEvent& WXUNUSED(event))
 405 {
 406   //must always be here
 407   wxPaintDC pDC(this);
 408
 409   //do it here rather than in the cstor: this is safer.
 410   if(!Handle)
 411   {
 412     Handle = GetHandleHack();
 413     RenderWindow->SetWindowId(reinterpret_cast<void *>(Handle));
 414 #ifdef __WXMSW__
 415     RenderWindow->SetParentId(reinterpret_cast<void *>(this->GetParent()->GetHWND()));
 416 #endif //__WXMSW__
 417   }
 418   // get vtk to render to the wxWindows
 419   Render();
 420 #ifdef __WXMAC__
 421   // This solves a problem with repainting after a window resize
 422   // See also: http://sourceforge.net/mailarchive/forum.php?thread_id=31690967&forum_id=41789
 423   vtkCarbonRenderWindow* rwin = vtkCarbonRenderWindow::SafeDownCast(RenderWindow);
 424   if( rwin )
 425   {
 426     rwin->UpdateGLRegion();
 427   }
 428 #endif
 429
 430 }
 431 //---------------------------------------------------------------------------
 432 void wxVTKRenderWindowInteractor::OnEraseBackground(wxEraseEvent &event)
 433 {
 434   //turn off background erase to reduce flickering on MSW
 435   event.Skip(false);
 436 }
 437 //---------------------------------------------------------------------------
 438 void wxVTKRenderWindowInteractor::OnSize(wxSizeEvent& WXUNUSED(event))
 439 {
 440   int w, h;
 441   GetClientSize(&w, &h);
 442   UpdateSize(w, h);
 443
 444   if (!Enabled)
 445     {
 446     return;
 447     }
 448
 449 #if VTK_MAJOR_VERSION > 4 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION > 0)
 450   InvokeEvent(vtkCommand::ConfigureEvent, NULL);
 451 #endif
 452   //this will check for Handle
 453   //Render();
 454 }
 455 //---------------------------------------------------------------------------
 456 void wxVTKRenderWindowInteractor::OnMotion(wxMouseEvent &event)
 457 {
 458         this->Render();
 459
 460         if (!Enabled)
 461     {
 462         return;
 463     }
 464 #if VTK_MAJOR_VERSION > 4 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION > 0)
 465   SetEventInformationFlipY(event.GetX(), event.GetY(), event.ControlDown(), event.ShiftDown(), '\0', 0, NULL);
 466   InvokeEvent(vtkCommand::MouseMoveEvent, NULL);
 467 #else
 468   InteractorStyle->OnMouseMove(event.ControlDown(), event.ShiftDown(), event.GetX(), Size[1] - event.GetY() - 1);
 469 #endif
 470 }
 471 //---------------------------------------------------------------------------
 472 #if !(VTK_MAJOR_VERSION == 3 && VTK_MINOR_VERSION == 1)
 473 void wxVTKRenderWindowInteractor::OnEnter(wxMouseEvent &event)
 474 {
 475   if (!Enabled)
 476     {
 477     return;
 478     }
 479
 480 #if VTK_MAJOR_VERSION > 4 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION > 0)
 481     // new style
 482   SetEventInformationFlipY(event.GetX(), event.GetY(), event.ControlDown(), event.ShiftDown(), '\0', 0, NULL);
 483   InvokeEvent(vtkCommand::EnterEvent, NULL);
 484 #else
 485     // old style
 486   InteractorStyle->OnEnter(event.ControlDown(), event.ShiftDown(), event.GetX(), Size[1] - event.GetY() - 1);
 487 #endif
 488 }
 489 //---------------------------------------------------------------------------
 490 void wxVTKRenderWindowInteractor::OnLeave(wxMouseEvent &event)
 491 {
 492   if (!Enabled)
 493     {
 494     return;
 495     }
 496
 497 #if VTK_MAJOR_VERSION > 4 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION > 0)
 498     // new style
 499   SetEventInformationFlipY(event.GetX(), event.GetY(),
 500       event.ControlDown(), event.ShiftDown(), '\0', 0, NULL);
 501
 502   InvokeEvent(vtkCommand::LeaveEvent, NULL);
 503 #else
 504     // old style
 505   InteractorStyle->OnLeave(event.ControlDown(), event.ShiftDown(),
 506       event.GetX(), Size[1] - event.GetY() - 1);
 507 #endif
 508 }
 509 //---------------------------------------------------------------------------
 510 void wxVTKRenderWindowInteractor::OnKeyDown(wxKeyEvent &event)
 511 {
 512   if (!Enabled)
 513     {
 514     return;
 515     }
 516
 517 #if VTK_MAJOR_VERSION > 4 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION > 0)
 518     // new style
 519   int keycode = event.GetKeyCode();
 520   char key = '\0';
 521   if (((unsigned int)keycode) < 256)
 522   {
 523     // TODO: Unicode in non-Unicode mode ??
 524     key = (char)keycode;
 525   }
 526
 527   // we don't get a valid mouse position inside the key event on every platform
 528   // so we retrieve the mouse position explicitly and pass it along
 529   wxPoint mousePos = ScreenToClient(wxGetMousePosition());
 530   SetEventInformationFlipY(mousePos.x, mousePos.y,
 531                            event.ControlDown(), event.ShiftDown(), key, 0, NULL);
 532   InvokeEvent(vtkCommand::KeyPressEvent, NULL);
 533 #else
 534   InteractorStyle->OnKeyDown(event.ControlDown(), event.ShiftDown(),
 535     event.GetKeyCode(), 1);
 536 #endif
 537   event.Skip();
 538 }
 539 //---------------------------------------------------------------------------
 540 void wxVTKRenderWindowInteractor::OnKeyUp(wxKeyEvent &event)
 541 {
 542   if (!Enabled)
 543     {
 544     return;
 545     }
 546
 547 #if VTK_MAJOR_VERSION > 4 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION > 0)
 548     // new style
 549   int keycode = event.GetKeyCode();
 550   char key = '\0';
 551   if (((unsigned int)keycode) < 256)
 552   {
 553     // TODO: Unicode in non-Unicode mode ??
 554     key = (char)keycode;
 555   }
 556
 557   // we don't get a valid mouse position inside the key event on every platform
 558   // so we retrieve the mouse position explicitly and pass it along
 559   wxPoint mousePos = ScreenToClient(wxGetMousePosition());
 560   SetEventInformationFlipY(mousePos.x, mousePos.y,
 561                            event.ControlDown(), event.ShiftDown(), key, 0, NULL);
 562   InvokeEvent(vtkCommand::KeyReleaseEvent, NULL);
 563 #else
 564   InteractorStyle->OnKeyUp(event.ControlDown(), event.ShiftDown(),
 565     event.GetKeyCode(), 1);
 566 #endif
 567   event.Skip();
 568 }
 569 #endif //!(VTK_MAJOR_VERSION == 3 && VTK_MINOR_VERSION == 1)
 570  //---------------------------------------------------------------------------
 571 void wxVTKRenderWindowInteractor::OnChar(wxKeyEvent &event)
 572 {
 573   if (!Enabled)
 574     {
 575     return;
 576     }
 577
 578 #if VTK_MAJOR_VERSION > 4 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION > 0)
 579   // new style
 580   int keycode = event.GetKeyCode();
 581   char key = '\0';
 582   if (((unsigned int)keycode) < 256)
 583     {
 584     // TODO: Unicode in non-Unicode mode ??
 585     key = (char)keycode;
 586     }
 587
 588   // we don't get a valid mouse position inside the key event on every platform
 589   // so we retrieve the mouse position explicitly and pass it along
 590   wxPoint mousePos = ScreenToClient(wxGetMousePosition());
 591   SetEventInformationFlipY(mousePos.x, mousePos.y,
 592                            event.ControlDown(), event.ShiftDown(), key, 0, NULL);
 593   InvokeEvent(vtkCommand::CharEvent, NULL);
 594 #endif
 595   event.Skip();
 596 }
 597 //---------------------------------------------------------------------------
 598 void wxVTKRenderWindowInteractor::OnButtonDown(wxMouseEvent &event)
 599 {
 600   if (!Enabled || (ActiveButton != wxEVT_NULL))
 601     {
 602     return;
 603     }
 604   ActiveButton = event.GetEventType();
 605
 606     // On Mac (Carbon) and Windows we don't automatically get the focus when
 607     // you click inside the window
 608     // we therefore set the focus explicitly
 609     // Apparently we need that on linux (GTK) too:
 610     this->SetFocus();
 611
 612 #if VTK_MAJOR_VERSION > 4 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION > 0)
 613   SetEventInformationFlipY(event.GetX(), event.GetY(),
 614     event.ControlDown(), event.ShiftDown(), '\0', 0, NULL);
 615 #endif
 616
 617   if(event.RightDown())
 618   {
 619 #if VTK_MAJOR_VERSION > 4 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION > 0)
 620     // new style
 621     InvokeEvent(vtkCommand::RightButtonPressEvent, NULL);
 622 #else
 623     // old style
 624     InteractorStyle->OnRightButtonDown(event.ControlDown(), event.ShiftDown(),
 625       event.GetX(), Size[1] - event.GetY() - 1);
 626 #endif
 627   }
 628   else if(event.LeftDown())
 629   {
 630 #if VTK_MAJOR_VERSION > 4 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION > 0)
 631     // new style
 632     InvokeEvent(vtkCommand::LeftButtonPressEvent, NULL);
 633 #else
 634     // old style
 635     InteractorStyle->OnLeftButtonDown(event.ControlDown(),  event.ShiftDown(),
 636       event.GetX(), Size[1] - event.GetY() - 1);
 637 #endif
 638   }
 639   else if(event.MiddleDown())
 640   {
 641 #if VTK_MAJOR_VERSION > 4 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION > 0)
 642     // new style
 643     InvokeEvent(vtkCommand::MiddleButtonPressEvent, NULL);
 644 #else
 645     // old style
 646     InteractorStyle->OnMiddleButtonDown(event.ControlDown(), event.ShiftDown(),
 647       event.GetX(), Size[1] - event.GetY() - 1);
 648 #endif
 649   }
 650   //save the button and capture mouse until the button is released
 651   //Only if :
 652   //1. it is possible (WX_USE_X_CAPTURE)
 653   //2. user decided to.
 654   if ((ActiveButton != wxEVT_NULL) && WX_USE_X_CAPTURE && UseCaptureMouse)
 655   {
 656     CaptureMouse();
 657   }
 658 }
 659 //---------------------------------------------------------------------------
 660 void wxVTKRenderWindowInteractor::OnButtonUp(wxMouseEvent &event)
 661 {
 662   //EVT_xxx_DOWN == EVT_xxx_UP - 1
 663   //This is only needed if two mouse buttons are pressed at the same time.
 664   //In wxWindows 2.4 and later: better use of wxMOUSE_BTN_RIGHT or
 665   //wxEVT_COMMAND_RIGHT_CLICK
 666   if (!Enabled || (ActiveButton != (event.GetEventType()-1)))
 667     {
 668     return;
 669     }
 670
 671 #if VTK_MAJOR_VERSION > 4 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION > 0)
 672   SetEventInformationFlipY(event.GetX(), event.GetY(),
 673     event.ControlDown(), event.ShiftDown(), '\0', 0, NULL);
 674 #endif
 675
 676   if(ActiveButton == wxEVT_RIGHT_DOWN)
 677   {
 678 #if VTK_MAJOR_VERSION > 4 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION > 0)
 679     // new style
 680     InvokeEvent(vtkCommand::RightButtonReleaseEvent, NULL);
 681 #else
 682     // old style
 683     InteractorStyle->OnRightButtonUp(event.ControlDown(), event.ShiftDown(),
 684       event.GetX(), Size[1] - event.GetY() - 1);
 685 #endif
 686   }
 687   else if(ActiveButton == wxEVT_LEFT_DOWN)
 688   {
 689 #if VTK_MAJOR_VERSION > 4 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION > 0)
 690     // new style
 691     InvokeEvent(vtkCommand::LeftButtonReleaseEvent, NULL);
 692 #else
 693     // old style
 694     InteractorStyle->OnLeftButtonUp(event.ControlDown(), event.ShiftDown(),
 695       event.GetX(), Size[1] - event.GetY() - 1);
 696 #endif
 697   }
 698   else if(ActiveButton == wxEVT_MIDDLE_DOWN)
 699   {
 700 #if VTK_MAJOR_VERSION > 4 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION > 0)
 701     // new style
 702     InvokeEvent(vtkCommand::MiddleButtonReleaseEvent, NULL);
 703 #else
 704     // old style
 705     InteractorStyle->OnMiddleButtonUp(event.ControlDown(), event.ShiftDown(),
 706       event.GetX(), Size[1] - event.GetY() - 1);
 707 #endif
 708   }
 709   //if the ActiveButton is realeased, then release mouse capture
 710   if ((ActiveButton != wxEVT_NULL) && WX_USE_X_CAPTURE && UseCaptureMouse)
 711   {
 712     ReleaseMouse();
 713   }
 714   ActiveButton = wxEVT_NULL;
 715 }
 716 //---------------------------------------------------------------------------
 717 void wxVTKRenderWindowInteractor::OnMouseWheel(wxMouseEvent& event)
 718 {
 719 // Mouse wheel was only added after VTK 4.4 (I think...)
 720 #if VTK_MAJOR_VERSION > 4 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION > 2)
 721   // new style
 722   //Set vtk event information ... The numebr of wheel rotations is stored in
 723   //the x varible.  y varible is zero
 724   SetEventInformationFlipY(event.GetWheelRotation() / event.GetWheelDelta(), 0,
 725                            event.ControlDown(), event.ShiftDown(), '\0', 0, NULL);
 726   if(event.GetWheelRotation() > 0)
 727     {
 728       //Send event to VTK
 729       InvokeEvent(vtkCommand::MouseWheelForwardEvent, NULL);
 730     }
 731   else
 732     {
 733       //Send event to VTK
 734       InvokeEvent(vtkCommand::MouseWheelBackwardEvent, NULL);
 735     }
 736 #endif
 737
 738 }
 739
 740 //---------------------------------------------------------------------------
 741 void wxVTKRenderWindowInteractor::Render()
 742 {
 743   RenderAllowed = 1;
 744   if (!RenderWhenDisabled)
 745     {
 746     //the user doesn't want us to render when the toplevel frame
 747     //is disabled - first find the top level parent
 748     wxWindow *topParent = wxGetTopLevelParent(this);
 749     if (topParent)
 750       {
 751       //if it exists, check whether it's enabled
 752       //if it's not enabeld, RenderAllowed will be false
 753       RenderAllowed = topParent->IsEnabled();
 754       }
 755     }
 756
 757   if (RenderAllowed)
 758     {
 759     if(Handle && (Handle == GetHandleHack()) )
 760       {
 761       RenderWindow->Render();
 762       }
 763 #if VTK_MAJOR_VERSION > 4 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION > 2)
 764     else if(GetHandleHack())
 765       {
 766       //this means the user has reparented us; let's adapt to the
 767       //new situation by doing the WindowRemap dance
 768       //store the new situation
 769       Handle = GetHandleHack();
 770       RenderWindow->SetNextWindowId(reinterpret_cast<void *>(Handle));
 771       RenderWindow->WindowRemap();
 772       RenderWindow->Render();
 773       }
 774 #endif
 775     }
 776 }
 777 //---------------------------------------------------------------------------
 778 void wxVTKRenderWindowInteractor::SetRenderWhenDisabled(int newValue)
 779 {
 780   //Change value of __RenderWhenDisabled ivar.
 781   //If __RenderWhenDisabled is false (the default), this widget will not
 782   //call Render() on the RenderWindow if the top level frame (i.e. the
 783   //containing frame) has been disabled.
 784
 785   //This prevents recursive rendering during wxSafeYield() calls.
 786   //wxSafeYield() can be called during the ProgressMethod() callback of
 787   //a VTK object to have progress bars and other GUI elements updated -
 788   //it does this by disabling all windows (disallowing user-input to
 789   //prevent re-entrancy of code) and then handling all outstanding
 790   //GUI events.
 791
 792   //However, this often triggers an OnPaint() method for wxVTKRWIs,
 793   //resulting in a Render(), resulting in Update() being called whilst
 794   //still in progress.
 795
 796   RenderWhenDisabled = (bool)newValue;
 797 }
 798 //---------------------------------------------------------------------------
 799 //
 800 // Set the variable that indicates that we want a stereo capable window
 801 // be created. This method can only be called before a window is realized.
 802 //
 803 void wxVTKRenderWindowInteractor::SetStereo(int capable)
 804 {
 805   if (Stereo != capable)
 806     {
 807     Stereo = capable;
 808     RenderWindow->StereoCapableWindowOn();
 809     RenderWindow->SetStereoTypeToCrystalEyes();
 810     Modified();
 811     }
 812 }
 813
 814 //---------------------------------------------------------------------------
 815 //
 816 //
 817 void wxVTKRenderWindowInteractor::PrintSelf(ostream& os, vtkIndent indent)
 818 {
 819   this->Superclass::PrintSelf(os, indent);
 820 }
 821
 822
 823 }
 824 // LG : EO namespace bbwxvtk
 825 //=======================================================================
 826
 827