packages/wxvtk/src/wxVTKRenderWindowInteractor.cxx

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