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