[vtkusers] wxVTK linking problems in VS2005
jason g
jgorsk2 at uic.edu
Sat Mar 17 13:47:26 EDT 2007
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: http://www.nabble.com/wxVTK-linking-problems-in-VS2005-tf3419922.html#a9531627
Sent from the VTK - Users mailing list archive at Nabble.com.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.vtk.org/pipermail/vtkusers/attachments/20070317/bdf7bfa0/attachment.htm>
More information about the vtkusers
mailing list