[vtkusers] wxVTK linking problems in VS2005
Mathieu Malaterre
mathieu.malaterre at kitware.com
Sat Mar 17 14:39:37 EDT 2007
Jason,
did you see the answer of Nigel Nunn on wxVTK mailing list ?
Thanks,
-Mathieu
On 3/17/07, jason g <jgorsk2 at uic.edu> wrote:
>
>
> I have searched this forum for similar issues and found many things close.
> I've tried to follow the suggestions in the those message threads to no
> avail. I'm about to give up on VTK and just go with some straight GL or just
> use VTK for data manip and storage and render things myself with GL. But I
> don't want to do that. So I thought I'd post this and see if anyone bites.
>
> I've installed wxPack (which includes wxWidgets, wxVC - basically a
> wxWidget Application Template for VS, wxFormBuilder), wxVTK (which is
> suppose to create a wxWidget to use as a render target for VTK), and VTK.
>
> I followed the basic instructions on how to install VTK: Use CMake to
> create a build Run ALL_BUILD Run INSTALL
>
> I did this with no problems.
>
> I also created an application in VS using wxWidgets and it runs fine. I
> even was able to use wxGLCanvas to make a nice GL Application in wxWidgets.
>
> I simply added the basic class files for wxVTK to my project and I get many
> errors. I didn't even write code that USES the classes yet, I just included
> them. They reference two VTK headers "vtkRenderWindowInteractor.h" and
> "vtkRenderWindow.h". When I point the project to the appropriate include
> directories to find these headers, it can't find many of the symbols. So I
> fixed that problem by adding the "appropriate" libraries as dependancies.
> Things like vtkRendering.lib, vtkCommon.lib, etc. Then I get a new error.
> Tons of redundancy errors like:
>
> _malloc already defined in LIBCMTD.lib(dbheap.obj) MSVCRTD.lib
>
>
>
>
> I've tried making the project dependant on the libraries specified in the
> VTK examples (which work) and I've tried making the project dependant on all
> the vtk libraries. I get the same errors. Somehow the libraries required for
> wxWidgets and the libraries required for VTK are in conflict. How do I fix
> this? The library dependancies that are part of the wxVC Template (which
> makes a wxWidget Application that runs fine) are:
> comctl32.lib
> rpcrt4.lib
> winmm.lib
> wsock32.lib
> version.lib
>
>
> and inherited library depenencies:
> kernel32.lib
> user32.lib
> gdi32.lib
> winspool.lib
> comdlg32.lib
> advapi32.lib
> shell32.lib
> ole32.lib
> oleaut32.lib
> uuid.lib
> odbc32.lib
> odbccp32.lib
>
>
>
>
>
>
> I've tried running the wxVTK sample that comes with wxVTK and I get the
> same errors. I've also taken out the inherited librarie depenancies above
> and still get the error. This is some conflict with wxWidget libraries and
> VTK.
>
> Any help would be greatly appreciated. I really want to use VTK with
> wxWidgets!
>
> sincerely,
> jason g
>
> p.s.
> Below are the class files for wxVTK. I don't think there's anything to
> learn from looking at them because this is clearly a linking problem, but I
> included them for good measure.
>
> wxVTKRenderWindowInteractor.h: #ifndef _wxVTKRenderWindowInteractor_h_
> #define _wxVTKRenderWindowInteractor_h_
>
> // For compilers that support precompilation, includes "wx/wx.h".
> #include "wx/wxprec.h"
>
> #ifdef __BORLANDC__
> # pragma hdrstop
> #endif
>
> #ifndef WX_PRECOMP
> #include
> #endif
>
> #include
> #include
>
> // vtk includes
> #include "vtkRenderWindowInteractor.h"
> #include "vtkRenderWindow.h"
>
> // Apparently since wxGTK 2.8.0 one can finally use wxWindow (just as in any
> // other port):
> #if (!wxCHECK_VERSION(2, 8, 0))
> #define USE_WXGLCANVAS
> #endif
>
> #if defined(__WXGTK__) && defined(USE_WXGLCANVAS)
> # if wxUSE_GLCANVAS
> # include
> # else
> # error "problem of wxGLCanvas, you need to build wxWidgets with opengl"
> # endif //wxUSE_GLCANVAS
> #endif //__WXGTK__
>
> // Motif version (renamed into wxX11 for wxWindow 2.4 and newer)
> #if defined(__WXMOTIF__)
> # error This GUI is not supported by wxVTKRenderWindowInteractor for now
> #endif
>
> // wx forward declarations
> class wxPaintEvent;
> class wxMouseEvent;
> class wxTimerEvent;
> class wxKeyEvent;
> class wxSizeEvent;
>
> #if defined(__WXGTK__) && defined(USE_WXGLCANVAS)
> class VTK_RENDERING_EXPORT wxVTKRenderWindowInteractor : public wxGLCanvas,
> virtual public vtkRenderWindowInteractor
> #else
> class VTK_RENDERING_EXPORT wxVTKRenderWindowInteractor : public wxWindow,
> virtual public vtkRenderWindowInteractor
> #endif //__WXGTK__
> {
> DECLARE_DYNAMIC_CLASS(wxVTKRenderWindowInteractor)
>
> public:
> //constructors
> wxVTKRenderWindowInteractor();
>
> wxVTKRenderWindowInteractor(wxWindow *parent,
> wxWindowID id,
> const wxPoint &pos = wxDefaultPosition,
> const wxSize &size = wxDefaultSize,
> long style = wxWANTS_CHARS | wxNO_FULL_REPAINT_ON_RESIZE,
> const wxString &name = wxPanelNameStr);
> //vtk ::New()
> static wxVTKRenderWindowInteractor * New();
> void PrintSelf(ostream& os, vtkIndent indent);
>
> //destructor
> ~wxVTKRenderWindowInteractor();
>
> // vtkRenderWindowInteractor overrides
> void Initialize();
> void Enable();
> bool Enable(bool enable);
> void Disable();
> void Start();
> void UpdateSize(int x, int y);
> int CreateTimer(int timertype);
> int DestroyTimer();
> void TerminateApp() {};
>
> // event handlers
> void OnPaint(wxPaintEvent &event);
> void OnEraseBackground (wxEraseEvent& event);
> void OnMotion(wxMouseEvent &event);
>
> void OnButtonDown(wxMouseEvent &event);
> void OnButtonUp(wxMouseEvent &event);
> #if !(VTK_MAJOR_VERSION == 3 && VTK_MINOR_VERSION == 1)
> void OnEnter(wxMouseEvent &event);
> void OnLeave(wxMouseEvent &event);
> void OnKeyDown(wxKeyEvent &event);
> void OnKeyUp(wxKeyEvent &event);
> #endif
> void OnTimer(wxTimerEvent &event);
> void OnSize(wxSizeEvent &event);
> void OnMouseWheel(wxMouseEvent& event);
>
> void Render();
> void SetRenderWhenDisabled(int newValue);
>
> // Description:
> // Prescribe that the window be created in a stereo-capable mode. This
> // method must be called before the window is realized. Default if off.
> vtkGetMacro(Stereo,int);
> vtkBooleanMacro(Stereo,int);
> virtual void SetStereo(int capable);
>
> // Description:
> // As CaptureMouse could be a problem sometimes on a window box
> // This method allow to set or not the CaptureMouse.
> // This method actually will works only if WX_USE_X_CAPTURE was set to 1
> vtkSetMacro(UseCaptureMouse,int);
> vtkBooleanMacro(UseCaptureMouse,int);
>
> protected:
> wxTimer timer;
> int ActiveButton;
> int RenderAllowed;
> long GetHandleHack();
> int Stereo;
>
> private:
> long Handle;
> bool Created;
> int RenderWhenDisabled;
> int UseCaptureMouse;
>
> DECLARE_EVENT_TABLE()
> };
>
> #endif //_wxVTKRenderWindowInteractor_h_
>
>
>
>
>
> wxVTKRenderWindowInteractor.cpp #include "wxVTKRenderWindowInteractor.h"
>
> //This is needed for vtk 3.1 :
> #ifndef VTK_MAJOR_VERSION
> # include "vtkVersion.h"
> #endif
>
> #if VTK_MAJOR_VERSION == 5 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION >
> 0)
> # include "vtkCommand.h"
> #else
> # include "vtkInteractorStyle.h"
> #endif
>
> //Keep this for compatibilty reason, this was introduced in wxGTK 2.4.0
> #if (!wxCHECK_VERSION(2, 4, 0))
> wxWindow* wxGetTopLevelParent(wxWindow *win)
> {
> while ( win && !win->IsTopLevel() )
> win = win->GetParent();
> return win;
> }
> #endif
>
> // To access objc calls on cocoa
> #ifdef __WXCOCOA__
> #ifdef VTK_USE_COCOA
> #import
> // This trick is no longer need in VTK CVS, should get rid of that:
> #define id Id
> #else
> #error Build mismatch you need both wxWidgets and VTK to be configure
> against Cocoa to work
> #endif //VTK_USE_COCOA
> #endif //__WXCOCOA__
>
> #ifdef __WXGTK__
> # include // GDK_WINDOW_XWINDOW is found here in wxWidgets 2.8.0
> # include "gdk/gdkprivate.h"
> #ifdef __WXGTK20__
> #include
> #else
> #include
> #endif
> #define GetXWindow(wxwin) (wxwin)->m_wxwindow ? \
> GDK_WINDOW_XWINDOW(GTK_PIZZA((wxwin)->m_wxwindow)->bin_window)
> : \
> GDK_WINDOW_XWINDOW((wxwin)->m_widget->window)
> #endif
>
> #ifdef __WXX11__
> #include "wx/x11/privx.h"
> #define GetXWindow(wxwin) ((Window)(wxwin)->GetHandle())
> #endif
>
>
> //For more info on this class please go to:
> //http://wxvtk.sf.net
> //This hack is for some buggy wxGTK version:
> #if wxCHECK_VERSION(2, 3, 2) && !wxCHECK_VERSION(2, 4, 1) &&
> defined(__WXGTK__)
> # define WX_USE_X_CAPTURE 0
> #else
> # define WX_USE_X_CAPTURE 1
> #endif
>
> #define ID_wxVTKRenderWindowInteractor_TIMER 1001
>
> #if defined(__WXGTK__) && defined(USE_WXGLCANVAS)
> IMPLEMENT_DYNAMIC_CLASS(wxVTKRenderWindowInteractor,
> wxGLCanvas)
> #else
> IMPLEMENT_DYNAMIC_CLASS(wxVTKRenderWindowInteractor,
> wxWindow)
> #endif //__WXGTK__
>
> //---------------------------------------------------------------------------
> #if defined(__WXGTK__) && defined(USE_WXGLCANVAS)
> BEGIN_EVENT_TABLE(wxVTKRenderWindowInteractor, wxGLCanvas)
> #else
> BEGIN_EVENT_TABLE(wxVTKRenderWindowInteractor, wxWindow)
> #endif //__WXGTK__
> //refresh window by doing a Render
> EVT_PAINT (wxVTKRenderWindowInteractor::OnPaint)
> EVT_ERASE_BACKGROUND(wxVTKRenderWindowInteractor::OnEraseBackground)
> EVT_MOTION (wxVTKRenderWindowInteractor::OnMotion)
>
> //Bind the events to the event converters
> EVT_LEFT_DOWN (wxVTKRenderWindowInteractor::OnButtonDown)
> EVT_MIDDLE_DOWN
> (wxVTKRenderWindowInteractor::OnButtonDown)
> EVT_RIGHT_DOWN (wxVTKRenderWindowInteractor::OnButtonDown)
> EVT_LEFT_UP (wxVTKRenderWindowInteractor::OnButtonUp)
> EVT_MIDDLE_UP (wxVTKRenderWindowInteractor::OnButtonUp)
> EVT_RIGHT_UP (wxVTKRenderWindowInteractor::OnButtonUp)
> #if !(VTK_MAJOR_VERSION == 3 && VTK_MINOR_VERSION == 1)
> EVT_ENTER_WINDOW(wxVTKRenderWindowInteractor::OnEnter)
> EVT_LEAVE_WINDOW(wxVTKRenderWindowInteractor::OnLeave)
> EVT_MOUSEWHEEL (wxVTKRenderWindowInteractor::OnMouseWheel)
> // If we use EVT_KEY_DOWN instead of EVT_CHAR, capital versions
> // of all characters are always returned. EVT_CHAR also performs
> // other necessary keyboard-dependent translations.
> //EVT_KEY_DOWN (wxVTKRenderWindowInteractor::OnKeyDown)
> EVT_CHAR (wxVTKRenderWindowInteractor::OnKeyDown)
> EVT_KEY_UP (wxVTKRenderWindowInteractor::OnKeyUp)
> #endif
> EVT_TIMER (ID_wxVTKRenderWindowInteractor_TIMER,
> wxVTKRenderWindowInteractor::OnTimer)
> EVT_SIZE (wxVTKRenderWindowInteractor::OnSize)
> END_EVENT_TABLE()
>
> //---------------------------------------------------------------------------
> #if defined(__WXGTK__) && defined(USE_WXGLCANVAS)
> wxVTKRenderWindowInteractor::wxVTKRenderWindowInteractor()
> : vtkRenderWindowInteractor(), wxGLCanvas()
> #else
> wxVTKRenderWindowInteractor::wxVTKRenderWindowInteractor()
> : vtkRenderWindowInteractor(), wxWindow()
> #endif //__WXGTK__
> , timer(this, ID_wxVTKRenderWindowInteractor_TIMER)
> , ActiveButton(wxEVT_NULL)
> , RenderAllowed(0)
> , Stereo(0)
> , Handle(0)
> , Created(true)
> , RenderWhenDisabled(1)
> , UseCaptureMouse(0)
> {
> this->RenderWindow = NULL;
> this->SetRenderWindow(vtkRenderWindow::New());
> this->RenderWindow->Delete();
> }
> //---------------------------------------------------------------------------
> wxVTKRenderWindowInteractor::wxVTKRenderWindowInteractor(wxWindow
> *parent,
> wxWindowID id,
> const wxPoint &pos,
> const wxSize &size,
> long style,
> const wxString &name)
> #if defined(__WXGTK__) && defined(USE_WXGLCANVAS)
> : vtkRenderWindowInteractor(), wxGLCanvas(parent, id, pos, size, style,
> name)
> #else
> : vtkRenderWindowInteractor(), wxWindow(parent, id, pos, size, style, name)
> #endif //__WXGTK__
> , timer(this, ID_wxVTKRenderWindowInteractor_TIMER)
> , ActiveButton(wxEVT_NULL)
> , RenderAllowed(0)
> , Stereo(0)
> , Handle(0)
> , Created(true)
> , RenderWhenDisabled(1)
> , UseCaptureMouse(0)
> {
> this->RenderWindow = NULL;
> this->SetRenderWindow(vtkRenderWindow::New());
> this->RenderWindow->Delete();
> }
> //---------------------------------------------------------------------------
> wxVTKRenderWindowInteractor::~wxVTKRenderWindowInteractor()
> {
> }
> //---------------------------------------------------------------------------
> wxVTKRenderWindowInteractor *
> wxVTKRenderWindowInteractor::New()
> {
> // we don't make use of the objectfactory, because we're not registered
> return new wxVTKRenderWindowInteractor;
> }
> //---------------------------------------------------------------------------
> void wxVTKRenderWindowInteractor::Initialize()
> {
> int *size = RenderWindow->GetSize();
> // enable everything and start rendering
> Enable();
> //RenderWindow->Start();
>
> // set the size in the render window interactor
> Size[0] = size[0];
> Size[1] = size[1];
>
> // this is initialized
> Initialized = 1;
> }
> //---------------------------------------------------------------------------
> void wxVTKRenderWindowInteractor::Enable()
> {
> // if already enabled then done
> if (Enabled)
> return;
>
> // that's it
> Enabled = 1;
> #if defined(__WXGTK__) && defined(USE_WXGLCANVAS)
> SetCurrent();
> #endif
> Modified();
> }
> //---------------------------------------------------------------------------
> bool wxVTKRenderWindowInteractor::Enable(bool enable)
> {
> #if defined(__WXGTK__) && defined(USE_WXGLCANVAS)
> return wxGLCanvas::Enable(enable);
> #else
> return wxWindow::Enable(enable);
> #endif
> }
> //---------------------------------------------------------------------------
> void wxVTKRenderWindowInteractor::Disable()
> {
> // if already disabled then done
> if (!Enabled)
> return;
>
> // that's it (we can't remove the event handler like it should be...)
> Enabled = 0;
> Modified();
> }
> //---------------------------------------------------------------------------
> void wxVTKRenderWindowInteractor::Start()
> {
> // the interactor cannot control the event loop
> vtkErrorMacro( << "wxVTKRenderWindowInteractor::Start() "
> "interactor cannot control event loop.");
> }
> //---------------------------------------------------------------------------
> void wxVTKRenderWindowInteractor::UpdateSize(int x, int y)
> {
> if( RenderWindow )
> {
> // if the size changed tell render window
> if ( x != Size[0] || y != Size[1] )
> {
> // adjust our (vtkRenderWindowInteractor size)
> Size[0] = x;
> Size[1] = y;
> // and our RenderWindow's size
> RenderWindow->SetSize(x, y);
> }
> }
> }
> //---------------------------------------------------------------------------
> int wxVTKRenderWindowInteractor::CreateTimer(int
> WXUNUSED(timertype))
> {
> // it's a one shot timer
> if (!timer.Start(10, TRUE))
> assert(false);
>
> return 1;
>
> }
> //---------------------------------------------------------------------------
> int wxVTKRenderWindowInteractor::DestroyTimer()
> {
> // do nothing
> return 1;
> }
> //---------------------------------------------------------------------------
> void wxVTKRenderWindowInteractor::OnTimer(wxTimerEvent&
> WXUNUSED(event))
> {
> if (!Enabled)
> return;
>
> #if VTK_MAJOR_VERSION == 5 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION >
> 0)
> // new style
> InvokeEvent(vtkCommand::TimerEvent, NULL);
> #else
> // old style
> InteractorStyle->OnTimer();
> #endif
> }
>
> //---------------------------------------------------------------------------
> // NOTE on implementation:
> // Bad luck you ended up in the only tricky place of this code.
> // A few note, wxWidgets still refuse to provide such convenient method
> // so I have to maintain it myself, eventhough this is completely integrated
> // in wxPython...
> // Anyway if this happen to break for you then compare to a recent version
> of wxPython
> // and look for the function long wxPyGetWinHandle(wxWindow* win)
> // in wxPython/src/helpers.cpp
> long wxVTKRenderWindowInteractor::GetHandleHack()
> {
> //helper function to hide the MSW vs GTK stuff
> long handle_tmp = 0;
>
> // __WXMSW__ is for Win32
> //__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)
> // __WXGTK__ is for both gtk 1.2.x and gtk 2.x
> #if defined(__WXMSW__) || defined(__WXMAC__)
> handle_tmp = (long)this->GetHandle();
> #endif //__WXMSW__
>
> //__WXCOCOA__ stands for using the objective-c Cocoa API
> #ifdef __WXCOCOA__
> // Here is how to find the NSWindow
> wxTopLevelWindow* toplevel = dynamic_cast(
> wxGetTopLevelParent( this ) );
> if (toplevel != NULL )
> {
> handle_tmp = (long)toplevel->GetNSWindow();
> }
> // The NSView will be deducted from
> // [(NSWindow*)Handle contentView]
> // if only I knew how to write that in c++
> #endif //__WXCOCOA__
>
> // Find and return the actual X-Window.
> #if defined(__WXGTK__) || defined(__WXX11__)
> return (long)GetXWindow(this);
> #endif
>
> //#ifdef __WXMOTIF__
> // handle_tmp = (long)this->GetXWindow();
> //#endif
>
> return handle_tmp;
> }
> //---------------------------------------------------------------------------
> void wxVTKRenderWindowInteractor::OnPaint(wxPaintEvent&
> WXUNUSED(event))
> {
> //must always be here
> wxPaintDC pDC(this);
>
> //do it here rather than in the cstor: this is safer.
> if(!Handle)
> {
> Handle = GetHandleHack();
> RenderWindow->SetWindowId(reinterpret_cast(Handle));
> #ifdef __WXMSW__
> RenderWindow->SetParentId(reinterpret_cast(this->GetParent()->GetHWND()));
> #endif //__WXMSW__
> }
> // get vtk to render to the wxWindows
> Render();
> }
> //---------------------------------------------------------------------------
> void
> wxVTKRenderWindowInteractor::OnEraseBackground(wxEraseEvent
> &event)
> {
> //turn off background erase to reduce flickering on MSW
> event.Skip(false);
> }
> //---------------------------------------------------------------------------
> void wxVTKRenderWindowInteractor::OnSize(wxSizeEvent&
> WXUNUSED(event))
> {
> int w, h;
> GetClientSize(&w, &h);
> UpdateSize(w, h);
>
> if (!Enabled)
> {
> return;
> }
>
> #if VTK_MAJOR_VERSION == 5 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION >
> 0)
> InvokeEvent(vtkCommand::ConfigureEvent, NULL);
> #endif
> //this will check for Handle
> //Render();
> }
> //---------------------------------------------------------------------------
> void wxVTKRenderWindowInteractor::OnMotion(wxMouseEvent
> &event)
> {
> if (!Enabled)
> {
> return;
> }
> #if VTK_MAJOR_VERSION == 5 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION >
> 0)
> SetEventInformationFlipY(event.GetX(), event.GetY(),
> event.ControlDown(), event.ShiftDown(), '\0', 0, NULL);
>
> InvokeEvent(vtkCommand::MouseMoveEvent, NULL);
> #else
> InteractorStyle->OnMouseMove(event.ControlDown(), event.ShiftDown(),
> event.GetX(), Size[1] - event.GetY() - 1);
> #endif
> }
> //---------------------------------------------------------------------------
> #if !(VTK_MAJOR_VERSION == 3 && VTK_MINOR_VERSION == 1)
> void wxVTKRenderWindowInteractor::OnEnter(wxMouseEvent
> &event)
> {
> if (!Enabled)
> {
> return;
> }
>
> #if VTK_MAJOR_VERSION == 5 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION >
> 0)
> // new style
> SetEventInformationFlipY(event.GetX(), event.GetY(),
> event.ControlDown(), event.ShiftDown(), '\0', 0, NULL);
>
> InvokeEvent(vtkCommand::EnterEvent, NULL);
> #else
> // old style
> InteractorStyle->OnEnter(event.ControlDown(), event.ShiftDown(),
> event.GetX(), Size[1] - event.GetY() - 1);
> #endif
> }
> //---------------------------------------------------------------------------
> void wxVTKRenderWindowInteractor::OnLeave(wxMouseEvent
> &event)
> {
> if (!Enabled)
> {
> return;
> }
>
> #if VTK_MAJOR_VERSION == 5 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION >
> 0)
> // new style
> SetEventInformationFlipY(event.GetX(), event.GetY(),
> event.ControlDown(), event.ShiftDown(), '\0', 0, NULL);
>
> InvokeEvent(vtkCommand::LeaveEvent, NULL);
> #else
> // old style
> InteractorStyle->OnLeave(event.ControlDown(), event.ShiftDown(),
> event.GetX(), Size[1] - event.GetY() - 1);
> #endif
> }
> //---------------------------------------------------------------------------
> void wxVTKRenderWindowInteractor::OnKeyDown(wxKeyEvent
> &event)
> {
> if (!Enabled)
> {
> return;
> }
>
> #if VTK_MAJOR_VERSION == 5 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION >
> 0)
> // new style
> int keycode = event.GetKeyCode();
> char key = '\0';
> if (keycode < 256)
> {
> // TODO: Unicode in non-Unicode mode ??
> key = (char)keycode;
> }
>
> SetEventInformationFlipY(event.GetX(), event.GetY(),
> event.ControlDown(), event.ShiftDown(), key, 0, NULL);
>
> InvokeEvent(vtkCommand::KeyPressEvent, NULL);
> InvokeEvent(vtkCommand::CharEvent, NULL);
> #else
> InteractorStyle->OnKeyDown(event.ControlDown(), event.ShiftDown(),
> event.GetKeyCode(), 1);
> #endif
> event.Skip();
> }
> //---------------------------------------------------------------------------
> void wxVTKRenderWindowInteractor::OnKeyUp(wxKeyEvent
> &event)
> {
> if (!Enabled)
> {
> return;
> }
>
> #if VTK_MAJOR_VERSION == 5 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION >
> 0)
> // new style
> int keycode = event.GetKeyCode();
> char key = '\0';
> if (keycode < 256)
> {
> // TODO: Unicode in non-Unicode mode ??
> key = (char)keycode;
> }
>
> SetEventInformationFlipY(event.GetX(), event.GetY(),
> event.ControlDown(), event.ShiftDown(), key, 0, NULL);
> InvokeEvent(vtkCommand::KeyReleaseEvent, NULL);
> #else
> InteractorStyle->OnKeyUp(event.ControlDown(), event.ShiftDown(),
> event.GetKeyCode(), 1);
> #endif
> event.Skip();
> }
> #endif //!(VTK_MAJOR_VERSION == 3 && VTK_MINOR_VERSION == 1)
> //---------------------------------------------------------------------------
> void wxVTKRenderWindowInteractor::OnButtonDown(wxMouseEvent
> &event)
> {
> if (!Enabled || (ActiveButton != wxEVT_NULL))
> {
> return;
> }
> ActiveButton = event.GetEventType();
>
> #if VTK_MAJOR_VERSION == 5 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION >
> 0)
> SetEventInformationFlipY(event.GetX(), event.GetY(),
> event.ControlDown(), event.ShiftDown(), '\0', 0, NULL);
> #endif
>
> if(event.RightDown())
> {
> #if VTK_MAJOR_VERSION == 5 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION >
> 0)
> // new style
> InvokeEvent(vtkCommand::RightButtonPressEvent, NULL);
> #else
> // old style
> InteractorStyle->OnRightButtonDown(event.ControlDown(),
> event.ShiftDown(),
> event.GetX(), Size[1] - event.GetY() - 1);
> #endif
> }
> else if(event.LeftDown())
> {
> #if VTK_MAJOR_VERSION == 5 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION >
> 0)
> // new style
> InvokeEvent(vtkCommand::LeftButtonPressEvent, NULL);
> #else
> // old style
> InteractorStyle->OnLeftButtonDown(event.ControlDown(),
> event.ShiftDown(),
> event.GetX(), Size[1] - event.GetY() - 1);
> #endif
> }
> else if(event.MiddleDown())
> {
> #if VTK_MAJOR_VERSION == 5 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION >
> 0)
> // new style
> InvokeEvent(vtkCommand::MiddleButtonPressEvent, NULL);
> #else
> // old style
> InteractorStyle->OnMiddleButtonDown(event.ControlDown(),
> event.ShiftDown(),
> event.GetX(), Size[1] - event.GetY() - 1);
> #endif
> }
> //save the button and capture mouse until the button is released
> //Only if :
> //1. it is possible (WX_USE_X_CAPTURE)
> //2. user decided to.
> if ((ActiveButton != wxEVT_NULL) && WX_USE_X_CAPTURE && UseCaptureMouse)
> {
> CaptureMouse();
> }
> }
> //---------------------------------------------------------------------------
> void wxVTKRenderWindowInteractor::OnButtonUp(wxMouseEvent
> &event)
> {
> //EVT_xxx_DOWN == EVT_xxx_UP - 1
> //This is only needed if two mouse buttons are pressed at the same time.
> //In wxWindows 2.4 and later: better use of wxMOUSE_BTN_RIGHT or
> //wxEVT_COMMAND_RIGHT_CLICK
> if (!Enabled || (ActiveButton != (event.GetEventType()-1)))
> {
> return;
> }
>
> #if VTK_MAJOR_VERSION == 5 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION >
> 0)
> SetEventInformationFlipY(event.GetX(), event.GetY(),
> event.ControlDown(), event.ShiftDown(), '\0', 0, NULL);
> #endif
>
> if(ActiveButton == wxEVT_RIGHT_DOWN)
> {
> #if VTK_MAJOR_VERSION == 5 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION >
> 0)
> // new style
> InvokeEvent(vtkCommand::RightButtonReleaseEvent, NULL);
> #else
> // old style
> InteractorStyle->OnRightButtonUp(event.ControlDown(),
> event.ShiftDown(),
> event.GetX(), Size[1] - event.GetY() - 1);
> #endif
> }
> else if(ActiveButton == wxEVT_LEFT_DOWN)
> {
> #if VTK_MAJOR_VERSION == 5 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION >
> 0)
> // new style
> InvokeEvent(vtkCommand::LeftButtonReleaseEvent, NULL);
> #else
> // old style
> InteractorStyle->OnLeftButtonUp(event.ControlDown(),
> event.ShiftDown(),
> event.GetX(), Size[1] - event.GetY() - 1);
> #endif
> }
> else if(ActiveButton == wxEVT_MIDDLE_DOWN)
> {
> #if VTK_MAJOR_VERSION == 5 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION >
> 0)
> // new style
> InvokeEvent(vtkCommand::MiddleButtonReleaseEvent, NULL);
> #else
> // old style
> InteractorStyle->OnMiddleButtonUp(event.ControlDown(),
> event.ShiftDown(),
> event.GetX(), Size[1] - event.GetY() - 1);
> #endif
> }
> //if the ActiveButton is realeased, then release mouse capture
> if ((ActiveButton != wxEVT_NULL) && WX_USE_X_CAPTURE && UseCaptureMouse)
> {
> ReleaseMouse();
> }
> ActiveButton = wxEVT_NULL;
> }
> //---------------------------------------------------------------------------
> void
> wxVTKRenderWindowInteractor::OnMouseWheel(wxMouseEvent&
> event)
> {
> // Mouse wheel was only added after VTK 4.4 (I think...)
> #if VTK_MAJOR_VERSION == 5 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION >
> 2)
> // new style
> //Set vtk event information ... The numebr of wheel rotations is stored in
> //the x varible. y varible is zero
> SetEventInformationFlipY(event.GetWheelRotation() / event.GetWheelDelta(),
> 0,
> event.ControlDown(), event.ShiftDown(), '\0', 0, NULL);
> if(event.GetWheelRotation() > 0)
> {
> //Send event to VTK
> InvokeEvent(vtkCommand::MouseWheelForwardEvent, NULL);
> }
> else
> {
> //Send event to VTK
> InvokeEvent(vtkCommand::MouseWheelBackwardEvent, NULL);
> }
> #endif
>
> }
>
> //---------------------------------------------------------------------------
> void wxVTKRenderWindowInteractor::Render()
> {
> RenderAllowed = 1;
> if (!RenderWhenDisabled)
> {
> //the user doesn't want us to render when the toplevel frame
> //is disabled - first find the top level parent
> wxWindow *topParent = wxGetTopLevelParent(this);
> if (topParent)
> {
> //if it exists, check whether it's enabled
> //if it's not enabeld, RenderAllowed will be false
> RenderAllowed = topParent->IsEnabled();
> }
> }
>
> if (RenderAllowed)
> {
> if(Handle && (Handle == GetHandleHack()) )
> {
> RenderWindow->Render();
> }
> #if VTK_MAJOR_VERSION == 5 || (VTK_MAJOR_VERSION == 4 && VTK_MINOR_VERSION >
> 2)
> else if(GetHandleHack())
> {
> //this means the user has reparented us; let's adapt to the
> //new situation by doing the WindowRemap dance
> //store the new situation
> Handle = GetHandleHack();
> RenderWindow->SetNextWindowId(reinterpret_cast(Handle));
> RenderWindow->WindowRemap();
> RenderWindow->Render();
> }
> #endif
> }
> }
> //---------------------------------------------------------------------------
> void wxVTKRenderWindowInteractor::SetRenderWhenDisabled(int
> newValue)
> {
> //Change value of __RenderWhenDisabled ivar.
> //If __RenderWhenDisabled is false (the default), this widget will not
> //call Render() on the RenderWindow if the top level frame (i.e. the
> //containing frame) has been disabled.
>
> //This prevents recursive rendering during wxSafeYield() calls.
> //wxSafeYield() can be called during the ProgressMethod() callback of
> //a VTK object to have progress bars and other GUI elements updated -
> //it does this by disabling all windows (disallowing user-input to
> //prevent re-entrancy of code) and then handling all outstanding
> //GUI events.
>
> //However, this often triggers an OnPaint() method for wxVTKRWIs,
> //resulting in a Render(), resulting in Update() being called whilst
> //still in progress.
>
> RenderWhenDisabled = (bool)newValue;
> }
> //---------------------------------------------------------------------------
> //
> // Set the variable that indicates that we want a stereo capable window
> // be created. This method can only be called before a window is realized.
> //
> void wxVTKRenderWindowInteractor::SetStereo(int capable)
> {
> if (Stereo != capable)
> {
> Stereo = capable;
> RenderWindow->StereoCapableWindowOn();
> RenderWindow->SetStereoTypeToCrystalEyes();
> Modified();
> }
> }
>
> //---------------------------------------------------------------------------
> //
> //
> void wxVTKRenderWindowInteractor::PrintSelf(ostream& os,
> vtkIndent indent)
> {
> this->Superclass::PrintSelf(os, indent);
> }
>
>
>
>
> ________________________________
> View this message in context: wxVTK linking problems in VS2005
> Sent from the VTK - Users mailing list archive at Nabble.com.
>
> _______________________________________________
> This is the private VTK discussion list.
> Please keep messages on-topic. Check the FAQ at:
> http://www.vtk.org/Wiki/VTK_FAQ
> Follow this link to subscribe/unsubscribe:
> http://www.vtk.org/mailman/listinfo/vtkusers
>
>
--
Mathieu Malaterre
R&D Engineer
28 Corporate Drive
Clifton Park, NY 12065-8662
Phone: 518-371-3971 x115
More information about the vtkusers
mailing list