//---------------------------------------------------------------------------
void WorldViewWindowManager::notifyMessageBoxChoice(MessageBoxButton _button)
{
switch(_button)
{
case MessageBoxButton::CANCEL:
{
cancelWindowClosing();
break;
}
case MessageBoxButton::BUTTON1: // Save
{
if(!mSaveWorldTool)
{
ToolManager* toolMgr = ToolManagerList::getSingleton().getToolManager("EditorToolManager");
mSaveWorldTool = toolMgr->getTool("SaveWorld");
}
if(mSaveWorldTool)
{
mSaveWorldTool->activateTool();
registerFrameListener();
}
break;
}
case MessageBoxButton::BUTTON2: // Don't save
{
WorldManager::getSingleton().destroyWorld(getActiveWindow()->getWorld());
_processWindowClosing();
break;
}
}
}
ValuatorTurnNavigationToolFactory::ValuatorTurnNavigationToolFactory(ToolManager& toolManager)
:ToolFactory("ValuatorTurnNavigationTool",toolManager),
valuatorThreshold(0.25),
flyDirection(Vector(0,1,0)),
flyFactor(getDisplaySize()*Scalar(0.5)),
rotationAxis0(Vector(0,0,1)),
rotationAxis1(Vector(1,0,0)),
rotationCenter(Point::origin),
rotationFactor(Scalar(90))
{
/* Initialize tool layout: */
layout.setNumButtons(1);
layout.setNumValuators(2);
/* Insert class into class hierarchy: */
ToolFactory* navigationToolFactory=toolManager.loadClass("NavigationTool");
navigationToolFactory->addChildClass(this);
addParentClass(navigationToolFactory);
/* Load class settings: */
Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
valuatorThreshold=cfs.retrieveValue<Scalar>("./valuatorThreshold",valuatorThreshold);
flyDirection=cfs.retrieveValue<Vector>("./flyDirection",flyDirection);
flyDirection.normalize();
flyFactor=cfs.retrieveValue<Scalar>("./flyFactor",flyFactor);
rotationAxis0=cfs.retrieveValue<Vector>("./rotationAxis0",rotationAxis0);
rotationAxis0.normalize();
rotationAxis1=cfs.retrieveValue<Vector>("./rotationAxis1",rotationAxis1);
rotationAxis1.normalize();
rotationCenter=cfs.retrieveValue<Point>("./rotationCenter",rotationCenter);
rotationFactor=Math::rad(cfs.retrieveValue<Scalar>("./rotationFactor",rotationFactor));
/* Set tool class' factory pointer: */
ValuatorTurnNavigationTool::factory=this;
}
ButtonInputDeviceToolFactory::ButtonInputDeviceToolFactory(ToolManager& toolManager)
:ToolFactory("ButtonInputDeviceTool",toolManager)
{
/* Initialize tool layout: */
layout.setNumButtons(8,true);
layout.setNumValuators(0,true);
/* Load class settings: */
Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
/* Insert class into class hierarchy: */
ToolFactory* inputDeviceToolFactory=toolManager.loadClass("InputDeviceTool");
inputDeviceToolFactory->addChildClass(this);
addParentClass(inputDeviceToolFactory);
/* Initialize translation and rotation vectors: */
Scalar translateFactor=cfs.retrieveValue<Scalar>("./translateFactor",Scalar(4)*getInchFactor());
Scalar rotateFactor=Math::rad(cfs.retrieveValue<Scalar>("./rotateFactor",Scalar(60)));
for(int i=0;i<6;++i)
translations[i]=Vector::zero;
for(int i=0;i<3;++i)
{
translations[2*i+0][i]=-translateFactor;
translations[2*i+1][i]=translateFactor;
}
rotations[0]=Vector(0,0,-rotateFactor);
rotations[1]=Vector(0,0,rotateFactor);
rotations[2]=Vector(0,-rotateFactor,0);
rotations[3]=Vector(0,rotateFactor,0);
rotations[4]=Vector(rotateFactor,0,0);
rotations[5]=Vector(-rotateFactor,0,0);
/* Set tool class' factory pointer: */
ButtonInputDeviceTool::factory=this;
}
ValuatorFlyNavigationToolFactory::ValuatorFlyNavigationToolFactory(ToolManager& toolManager)
:ToolFactory("ValuatorFlyNavigationTool",toolManager),
valuatorThreshold(0),
flyDirection(Vector(0,1,0)),
flyFactor(getDisplaySize()*Scalar(0.5))
{
/* Initialize tool layout: */
layout.setNumDevices(1);
layout.setNumValuators(0,1);
/* Insert class into class hierarchy: */
ToolFactory* navigationToolFactory=toolManager.loadClass("NavigationTool");
navigationToolFactory->addChildClass(this);
addParentClass(navigationToolFactory);
/* Load class settings: */
Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
valuatorThreshold=cfs.retrieveValue<Scalar>("./valuatorThreshold",valuatorThreshold);
flyDirection=cfs.retrieveValue<Vector>("./flyDirection",flyDirection);
flyDirection.normalize();
flyFactor=cfs.retrieveValue<Scalar>("./flyFactor",flyFactor);
/* Set tool class' factory pointer: */
ValuatorFlyNavigationTool::factory=this;
}
JediToolFactory::JediToolFactory(ToolManager& toolManager)
:ToolFactory("JediTool",toolManager),
lightsaberLength(Scalar(48)*getInchFactor()),
lightsaberWidth(Scalar(6)*getInchFactor()),
baseOffset(Scalar(3)*getInchFactor()),
lightsaberImageFileName(std::string(VRUI_INTERNAL_CONFIG_SHAREDIR)+"/Textures/Lightsaber.png")
{
/* Initialize tool layout: */
layout.setNumButtons(1);
/* Insert class into class hierarchy: */
ToolFactory* toolFactory=toolManager.loadClass("PointingTool");
toolFactory->addChildClass(this);
addParentClass(toolFactory);
/* Load class settings: */
Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
lightsaberLength=cfs.retrieveValue<Scalar>("./lightsaberLength",lightsaberLength);
lightsaberWidth=cfs.retrieveValue<Scalar>("./lightsaberWidth",lightsaberWidth);
baseOffset=cfs.retrieveValue<Scalar>("./baseOffset",baseOffset);
lightsaberImageFileName=cfs.retrieveString("./lightsaberImageFileName",lightsaberImageFileName);
/* Set tool class' factory pointer: */
JediTool::factory=this;
}
ViewpointFileNavigationToolFactory::ViewpointFileNavigationToolFactory(ToolManager& toolManager)
:ToolFactory("ViewpointFileNavigationTool",toolManager),
viewpointFileName(""),
showGui(false),
showKeyframes(true),
pauseFileName("ViewpointFileNavigation.pauses"),
autostart(false)
{
/* Initialize tool layout: */
layout.setNumButtons(1);
/* Insert class into class hierarchy: */
ToolFactory* toolFactory=toolManager.loadClass("NavigationTool");
toolFactory->addChildClass(this);
addParentClass(toolFactory);
/* Load class settings: */
Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
viewpointFileName=cfs.retrieveString("./viewpointFileName",viewpointFileName);
showGui=cfs.retrieveValue<bool>("./showGui",showGui);
showKeyframes=cfs.retrieveValue<bool>("./showKeyframes",showKeyframes);
pauseFileName=cfs.retrieveString("./pauseFileName",pauseFileName);
autostart=cfs.retrieveValue<bool>("./autostart",autostart);
/* Set tool class' factory pointer: */
ViewpointFileNavigationTool::factory=this;
}
SixDofWithScaleNavigationToolFactory::SixDofWithScaleNavigationToolFactory(ToolManager& toolManager)
:ToolFactory("SixDofWithScaleNavigationTool",toolManager),
scaleDeviceDistance(getInchFactor()*Scalar(6)),
deviceScaleDirection(0,1,0),
scaleFactor(getInchFactor()*Scalar(12))
{
/* Initialize tool layout: */
layout.setNumDevices(2);
layout.setNumButtons(0,1);
layout.setNumButtons(1,0);
/* Insert class into class hierarchy: */
ToolFactory* navigationToolFactory=toolManager.loadClass("NavigationTool");
navigationToolFactory->addChildClass(this);
addParentClass(navigationToolFactory);
/* Load class settings: */
Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
scaleDeviceDistance=cfs.retrieveValue<Scalar>("./scaleDeviceDistance",scaleDeviceDistance);
scaleDeviceDistance2=scaleDeviceDistance*scaleDeviceDistance;
deviceScaleDirection=cfs.retrieveValue<Vector>("./deviceScaleDirection",deviceScaleDirection);
scaleFactor=cfs.retrieveValue<Scalar>("./scaleFactor",scaleFactor);
/* Set tool class' factory pointer: */
SixDofWithScaleNavigationTool::factory=this;
}
MouseDialogNavigationToolFactory::MouseDialogNavigationToolFactory(ToolManager& toolManager)
:ToolFactory("MouseDialogNavigationTool",toolManager),
rotatePlaneOffset(getInchFactor()*Scalar(3)),
rotateFactor(getInchFactor()*Scalar(3)),
screenDollyingDirection(0,-1,0),
screenScalingDirection(0,-1,0),
dollyFactor(Scalar(1)),
scaleFactor(getInchFactor()*Scalar(3)),
spinThreshold(getUiSize()*Scalar(2)),
interactWithWidgets(true)
{
/* Initialize tool layout: */
layout.setNumButtons(1);
/* Insert class into class hierarchy: */
ToolFactory* navigationToolFactory=toolManager.loadClass("NavigationTool");
navigationToolFactory->addChildClass(this);
addParentClass(navigationToolFactory);
/* Load class settings: */
Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
rotatePlaneOffset=cfs.retrieveValue<Scalar>("./rotatePlaneOffset",rotatePlaneOffset);
rotateFactor=cfs.retrieveValue<Scalar>("./rotateFactor",rotateFactor);
screenDollyingDirection=cfs.retrieveValue<Vector>("./screenDollyingDirection",screenDollyingDirection);
screenScalingDirection=cfs.retrieveValue<Vector>("./screenScalingDirection",screenScalingDirection);
dollyFactor=cfs.retrieveValue<Scalar>("./dollyFactor",dollyFactor);
scaleFactor=cfs.retrieveValue<Scalar>("./scaleFactor",scaleFactor);
spinThreshold=cfs.retrieveValue<Scalar>("./spinThreshold",spinThreshold);
interactWithWidgets=cfs.retrieveValue<bool>("./interactWithWidgets",interactWithWidgets);
/* Set tool class' factory pointer: */
MouseDialogNavigationTool::factory=this;
}
ComeHitherNavigationToolFactory::ComeHitherNavigationToolFactory(ToolManager& toolManager)
:ToolFactory("ComeHitherNavigationTool",toolManager),
linearSnapThreshold(getDisplaySize()*Scalar(0.5)),
angularSnapThreshold(Scalar(45)),
maxLinearVelocity(getDisplaySize()*Scalar(1.5)),
maxAngularVelocity(Scalar(90.0))
{
/* Initialize tool layout: */
layout.setNumDevices(1);
layout.setNumButtons(0,1);
/* Insert class into class hierarchy: */
ToolFactory* navigationToolFactory=toolManager.loadClass("NavigationTool");
navigationToolFactory->addChildClass(this);
addParentClass(navigationToolFactory);
/* Load class settings: */
Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
linearSnapThreshold=cfs.retrieveValue<Scalar>("./linearSnapThreshold",linearSnapThreshold);
angularSnapThreshold=Math::rad(cfs.retrieveValue<Scalar>("./angularSnapThreshold",angularSnapThreshold));
maxLinearVelocity=cfs.retrieveValue<Scalar>("./maxLinearVelocity",maxLinearVelocity);
maxAngularVelocity=Math::rad(cfs.retrieveValue<Scalar>("./maxAngularVelocity",maxAngularVelocity));
/* Set tool class' factory pointer: */
ComeHitherNavigationTool::factory=this;
}
MouseNavigationToolFactory::MouseNavigationToolFactory(ToolManager& toolManager)
:ToolFactory("MouseNavigationTool",toolManager),
rotatePlaneOffset(getInchFactor()*Scalar(12)),
rotateFactor(getInchFactor()*Scalar(12)),
invertDolly(false),
screenDollyingDirection(0,1,0),
screenScalingDirection(0,1,0),
dollyFactor(getInchFactor()*Scalar(12)),
scaleFactor(getInchFactor()*Scalar(12)),
wheelDollyFactor(getInchFactor()*Scalar(-12)),
wheelScaleFactor(Scalar(0.5)),
spinThreshold(Scalar(0)),
showScreenCenter(false),
interactWithWidgets(true),
showMouseCursor(false),
mouseCursorSize(Scalar(0.5),Scalar(0.5),Scalar(0.0)),
mouseCursorHotspot(Scalar(0.0),Scalar(1.0),Scalar(0.0)),
mouseCursorImageFileName(DEFAULTMOUSECURSORIMAGEFILENAME),
mouseCursorNominalSize(24)
{
/* Initialize tool layout: */
layout.setNumDevices(1);
layout.setNumButtons(0,3);
layout.setNumValuators(0,1);
/* Insert class into class hierarchy: */
ToolFactory* navigationToolFactory=toolManager.loadClass("NavigationTool");
navigationToolFactory->addChildClass(this);
addParentClass(navigationToolFactory);
/* Load class settings: */
Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
rotatePlaneOffset=cfs.retrieveValue<Scalar>("./rotatePlaneOffset",rotatePlaneOffset);
rotateFactor=cfs.retrieveValue<Scalar>("./rotateFactor",rotateFactor);
invertDolly=cfs.retrieveValue<bool>("./invertDolly",invertDolly);
screenDollyingDirection=cfs.retrieveValue<Vector>("./screenDollyingDirection",screenDollyingDirection);
screenScalingDirection=cfs.retrieveValue<Vector>("./screenScalingDirection",screenScalingDirection);
dollyFactor=cfs.retrieveValue<Scalar>("./dollyFactor",dollyFactor);
scaleFactor=cfs.retrieveValue<Scalar>("./scaleFactor",scaleFactor);
wheelDollyFactor=cfs.retrieveValue<Scalar>("./wheelDollyFactor",wheelDollyFactor);
wheelScaleFactor=cfs.retrieveValue<Scalar>("./wheelScaleFactor",wheelScaleFactor);
spinThreshold=cfs.retrieveValue<Scalar>("./spinThreshold",spinThreshold);
showScreenCenter=cfs.retrieveValue<bool>("./showScreenCenter",showScreenCenter);
interactWithWidgets=cfs.retrieveValue<bool>("./interactWithWidgets",interactWithWidgets);
showMouseCursor=cfs.retrieveValue<bool>("./showMouseCursor",showMouseCursor);
mouseCursorSize=cfs.retrieveValue<Size>("./mouseCursorSize",mouseCursorSize);
mouseCursorHotspot=cfs.retrieveValue<Vector>("./mouseCursorHotspot",mouseCursorHotspot);
mouseCursorImageFileName=cfs.retrieveString("./mouseCursorImageFileName",mouseCursorImageFileName);
mouseCursorNominalSize=cfs.retrieveValue<unsigned int>("./mouseCursorNominalSize",mouseCursorNominalSize);
/* Set tool class' factory pointer: */
MouseNavigationTool::factory=this;
}
MenuToolFactory::MenuToolFactory(ToolManager& toolManager)
:ToolFactory("MenuTool",toolManager)
{
/* Insert class into class hierarchy: */
ToolFactory* toolFactory=toolManager.loadClass("UserInterfaceTool");
toolFactory->addChildClass(this);
addParentClass(toolFactory);
}
SixAxisSurfaceNavigationToolFactory::SixAxisSurfaceNavigationToolFactory(ToolManager& toolManager)
:ToolFactory("SixAxisSurfaceNavigationTool",toolManager),
canRoll(true),
bankTurns(false),levelSpeed(5),
canFly(true),
probeSize(getDisplaySize()),
maxClimb(getDisplaySize()),
fixAzimuth(false),
drawHud(true),hudColor(0.0f,1.0f,0.0f),hudRadius(float(getFrontplaneDist()*1.25f)),hudFontSize(float(getUiSize())*1.5f)
{
/* Initialize tool layout: */
layout.setNumValuators(6);
/* Load class settings: */
Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
Vector trans;
for(int i=0;i<3;++i)
trans[i]=getDisplaySize();
trans=cfs.retrieveValue<Vector>("./translateFactors",trans);
for(int i=0;i<3;++i)
translateFactors[i]=trans[i];
Vector rot=cfs.retrieveValue<Vector>("./rotateFactors",Vector(180,180,180));
for(int i=0;i<3;++i)
rotateFactors[i]=Math::rad(rot[i]);
canRoll=cfs.retrieveValue<bool>("./canRoll",canRoll);
bankTurns=cfs.retrieveValue<bool>("./bankTurns",bankTurns);
levelSpeed=cfs.retrieveValue<Scalar>("./levelSpeed",levelSpeed);
if(levelSpeed<Scalar(0))
levelSpeed=Scalar(0);
canFly=cfs.retrieveValue<bool>("./canFly",canFly);
probeSize=cfs.retrieveValue<Scalar>("./probeSize",probeSize);
maxClimb=cfs.retrieveValue<Scalar>("./maxClimb",maxClimb);
fixAzimuth=cfs.retrieveValue<bool>("./fixAzimuth",fixAzimuth);
drawHud=cfs.retrieveValue<bool>("./drawHud",drawHud);
hudColor=cfs.retrieveValue<Color>("./hudColor",hudColor);
hudRadius=cfs.retrieveValue<float>("./hudRadius",hudRadius);
hudFontSize=cfs.retrieveValue<float>("./hudFontSize",hudFontSize);
/* Insert class into class hierarchy: */
ToolFactory* navigationToolFactory=toolManager.loadClass("SurfaceNavigationTool");
navigationToolFactory->addChildClass(this);
addParentClass(navigationToolFactory);
/* Set tool class' factory pointer: */
SixAxisSurfaceNavigationTool::factory=this;
}
MultiDeviceNavigationToolFactory::MultiDeviceNavigationToolFactory(ToolManager& toolManager)
:ToolFactory("MultiDeviceNavigationTool",toolManager)
{
/* Initialize tool layout: */
layout.setNumButtons(1,true);
/* Insert class into class hierarchy: */
ToolFactory* navigationToolFactory=toolManager.loadClass("NavigationTool");
navigationToolFactory->addChildClass(this);
addParentClass(navigationToolFactory);
/* Load class settings: */
Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
configuration.read(cfs);
/* Set tool class' factory pointer: */
MultiDeviceNavigationTool::factory=this;
}
SixAxisTransformToolFactory::SixAxisTransformToolFactory(ToolManager& toolManager)
:ToolFactory("SixAxisTransformTool",toolManager)
{
/* Initialize tool layout: */
layout.setNumButtons(1,true);
layout.setNumValuators(6,true);
/* Insert class into class hierarchy: */
ToolFactory* transformToolFactory=toolManager.loadClass("TransformTool");
transformToolFactory->addChildClass(this);
addParentClass(transformToolFactory);
/* Load class settings: */
config.load(toolManager.getToolClassSection(getClassName()));
/* Set tool class' factory pointer: */
SixAxisTransformTool::factory=this;
}
SixAxisNavigationToolFactory::SixAxisNavigationToolFactory(ToolManager& toolManager)
:ToolFactory("SixAxisNavigationTool",toolManager)
{
/* Initialize tool layout: */
layout.setNumValuators(7);
/* Insert class into class hierarchy: */
ToolFactory* navigationToolFactory=toolManager.loadClass("NavigationTool");
navigationToolFactory->addChildClass(this);
addParentClass(navigationToolFactory);
/* Load class settings: */
Misc::ConfigurationFileSection cfs(toolManager.getToolClassSection(getClassName()));
config.load(cfs);
/* Set tool class' factory pointer: */
SixAxisNavigationTool::factory=this;
}
WalkNavigationToolFactory::WalkNavigationToolFactory(ToolManager& toolManager)
:ToolFactory("WalkNavigationTool",toolManager),
floorPlane(getFloorPlane()),
centerOnActivation(false),
centerPoint(getDisplayCenter()),
moveSpeed(getDisplaySize()),
innerRadius(getDisplaySize()*Scalar(0.5)),outerRadius(getDisplaySize()*Scalar(0.75)),
centerViewDirection(getForwardDirection()),
rotateSpeed(Math::rad(Scalar(120))),
innerAngle(Math::rad(Scalar(30))),outerAngle(Math::rad(Scalar(120))),
drawMovementCircles(true),
movementCircleColor(0.0f,1.0f,0.0f)
{
/* Initialize tool layout: */
layout.setNumDevices(1);
layout.setNumButtons(0,1);
/* Insert class into class hierarchy: */
ToolFactory* navigationToolFactory=toolManager.loadClass("NavigationTool");
navigationToolFactory->addChildClass(this);
addParentClass(navigationToolFactory);
/* Load class settings: */
Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
floorPlane=cfs.retrieveValue<Plane>("./floorPlane",floorPlane);
floorPlane.normalize();
centerOnActivation=cfs.retrieveValue<bool>("./centerOnActivation",centerOnActivation);
centerPoint=cfs.retrieveValue<Point>("./centerPoint",centerPoint);
centerPoint=floorPlane.project(centerPoint);
moveSpeed=cfs.retrieveValue<Scalar>("./moveSpeed",moveSpeed);
innerRadius=cfs.retrieveValue<Scalar>("./innerRadius",innerRadius);
outerRadius=cfs.retrieveValue<Scalar>("./outerRadius",outerRadius);
centerViewDirection=cfs.retrieveValue<Vector>("./centerViewDirection",centerViewDirection);
centerViewDirection=floorPlane.project(centerViewDirection);
centerViewDirection.normalize();
rotateSpeed=Math::rad(cfs.retrieveValue<Scalar>("./rotateSpeed",Math::deg(rotateSpeed)));
innerAngle=Math::rad(cfs.retrieveValue<Scalar>("./innerAngle",Math::deg(innerAngle)));
outerAngle=Math::rad(cfs.retrieveValue<Scalar>("./outerAngle",Math::deg(outerAngle)));
drawMovementCircles=cfs.retrieveValue<bool>("./drawMovementCircles",drawMovementCircles);
movementCircleColor=cfs.retrieveValue<Color>("./movementCircleColor",movementCircleColor);
/* Set tool class' factory pointer: */
WalkNavigationTool::factory=this;
}
DraggingToolFactory::DraggingToolFactory(ToolManager& toolManager)
:ToolFactory("DraggingTool",toolManager)
{
#if 0
/* Insert class into class hierarchy: */
ToolFactory* toolFactory=toolManager.loadClass("Tool");
toolFactory->addChildClass(this);
addParentClass(toolFactory);
#endif
}
PlaneSnapInputDeviceToolFactory::PlaneSnapInputDeviceToolFactory(ToolManager& toolManager)
:ToolFactory("PlaneSnapInputDeviceTool",toolManager),
markerSize(getUiSize())
{
/* Initialize tool layout: */
layout.setNumButtons(1);
/* Insert class into class hierarchy: */
ToolFactory* inputDeviceToolFactory=toolManager.loadClass("InputDeviceTool");
inputDeviceToolFactory->addChildClass(this);
addParentClass(inputDeviceToolFactory);
/* Load class settings: */
Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
markerSize=cfs.retrieveValue<Scalar>("./markerSize",markerSize);
/* Set tool class' factory pointer: */
PlaneSnapInputDeviceTool::factory=this;
}
RayScreenMenuToolFactory::RayScreenMenuToolFactory(ToolManager& toolManager)
:ToolFactory("RayScreenMenuTool",toolManager),
interactWithWidgets(false)
{
/* Initialize tool layout: */
layout.setNumButtons(1);
/* Insert class into class hierarchy: */
ToolFactory* menuToolFactory=toolManager.loadClass("MenuTool");
menuToolFactory->addChildClass(this);
addParentClass(menuToolFactory);
/* Load class settings: */
Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
interactWithWidgets=cfs.retrieveValue<bool>("./interactWithWidgets",interactWithWidgets);
/* Set tool class' factory pointer: */
RayScreenMenuTool::factory=this;
}
TrackballNavigationToolFactory::TrackballNavigationToolFactory(ToolManager& toolManager)
:ToolFactory("TrackballNavigationTool",toolManager),
rotateFactor(1)
{
/* Initialize tool layout: */
layout.setNumButtons(1);
/* Insert class into class hierarchy: */
ToolFactory* navigationToolFactory=toolManager.loadClass("NavigationTool");
navigationToolFactory->addChildClass(this);
addParentClass(navigationToolFactory);
/* Load class settings: */
Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
rotateFactor=cfs.retrieveValue<Scalar>("./rotateFactor",rotateFactor);
/* Set tool class' factory pointer: */
TrackballNavigationTool::factory=this;
}
RayInputDeviceToolFactory::RayInputDeviceToolFactory(ToolManager& toolManager)
:ToolFactory("RayInputDeviceTool",toolManager),
rotateFactor(getInchFactor()*Scalar(3))
{
/* Initialize tool layout: */
layout.setNumDevices(1);
layout.setNumButtons(0,1);
/* Insert class into class hierarchy: */
ToolFactory* inputDeviceToolFactory=toolManager.loadClass("InputDeviceTool");
inputDeviceToolFactory->addChildClass(this);
addParentClass(inputDeviceToolFactory);
/* Load class settings: */
Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
rotateFactor=cfs.retrieveValue<Scalar>("./rotateFactor",rotateFactor);
/* Set tool class' factory pointer: */
RayInputDeviceTool::factory=this;
}
RevolverToolFactory::RevolverToolFactory(ToolManager& toolManager)
:ToolFactory("RevolverTool",toolManager),
numChambers(6)
{
/* Insert class into class hierarchy: */
TransformToolFactory* transformToolFactory=dynamic_cast<TransformToolFactory*>(toolManager.loadClass("TransformTool"));
transformToolFactory->addChildClass(this);
addParentClass(transformToolFactory);
/* Load class settings: */
Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
numChambers=cfs.retrieveValue<int>("./numChambers",numChambers);
/* Initialize tool layout: */
layout.setNumButtons(1,true);
layout.setNumValuators(0,true);
/* Set tool class' factory pointer: */
RevolverTool::factory=this;
}
DocumentManager::DocumentManager(QObject *parent)
: QObject(parent)
, mTabWidget(new QTabWidget)
, mUndoGroup(new QUndoGroup(this))
, mSelectedTool(0)
, mSceneWithTool(0)
{
mTabWidget->setDocumentMode(true);
mTabWidget->setTabsClosable(true);
connect(mTabWidget, SIGNAL(currentChanged(int)),
SLOT(currentIndexChanged()));
connect(mTabWidget, SIGNAL(tabCloseRequested(int)),
SIGNAL(documentCloseRequested(int)));
ToolManager *toolManager = ToolManager::instance();
setSelectedTool(toolManager->selectedTool());
connect(toolManager, SIGNAL(selectedToolChanged(AbstractTool*)),
SLOT(setSelectedTool(AbstractTool*)));
}
WaldoToolFactory::WaldoToolFactory(ToolManager& toolManager)
:ToolFactory("WaldoTool",toolManager),
linearScale(0.25),angularScale(0.25)
{
/* Insert class into class hierarchy: */
TransformToolFactory* transformToolFactory=dynamic_cast<TransformToolFactory*>(toolManager.loadClass("TransformTool"));
transformToolFactory->addChildClass(this);
addParentClass(transformToolFactory);
/* Load class settings: */
Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
linearScale=cfs.retrieveValue<Scalar>("./linearScale",linearScale);
angularScale=cfs.retrieveValue<Scalar>("./angularScale",angularScale);
/* Initialize tool layout: */
layout.setNumButtons(0,true);
layout.setNumValuators(0,true);
/* Set tool class' factory pointer: */
WaldoTool::factory=this;
}
DaisyWheelToolFactory::DaisyWheelToolFactory(ToolManager& toolManager)
:ToolFactory("DaisyWheelTool",toolManager),
innerRadius(getUiSize()*Scalar(8)),outerRadius(getUiSize()*Scalar(24))
{
/* Initialize tool layout: */
layout.setNumDevices(1);
layout.setNumButtons(0,1);
/* Insert class into class hierarchy: */
ToolFactory* toolFactory=toolManager.loadClass("UserInterfaceTool");
toolFactory->addChildClass(this);
addParentClass(toolFactory);
/* Load class settings: */
Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
innerRadius=cfs.retrieveValue<Scalar>("./innerRadius",innerRadius);
outerRadius=cfs.retrieveValue<Scalar>("./outerRadius",outerRadius);
/* Set tool class' factory pointer: */
DaisyWheelTool::factory=this;
}
ClutchToolFactory::ClutchToolFactory(ToolManager& toolManager)
:ToolFactory("ClutchTool",toolManager),
clutchButtonToggleFlag(false)
{
/* Insert class into class hierarchy: */
TransformToolFactory* transformToolFactory=dynamic_cast<TransformToolFactory*>(toolManager.loadClass("TransformTool"));
transformToolFactory->addChildClass(this);
addParentClass(transformToolFactory);
/* Load class settings: */
Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
clutchButtonToggleFlag=cfs.retrieveValue<bool>("./clutchButtonToggleFlag",clutchButtonToggleFlag);
/* Initialize tool layout: */
layout.setNumDevices(1);
layout.setNumButtons(0,transformToolFactory->getNumButtons()+1);
layout.setNumValuators(0,transformToolFactory->getNumValuators());
/* Set tool class' factory pointer: */
ClutchTool::factory=this;
}
OffsetToolFactory::OffsetToolFactory(ToolManager& toolManager)
:ToolFactory("OffsetTool",toolManager),
offset(ONTransform::identity)
{
/* Insert class into class hierarchy: */
TransformToolFactory* transformToolFactory=dynamic_cast<TransformToolFactory*>(toolManager.loadClass("TransformTool"));
transformToolFactory->addChildClass(this);
addParentClass(transformToolFactory);
/* Load class settings: */
Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
offset=cfs.retrieveValue<ONTransform>("./offset",offset);
/* Initialize tool layout: */
layout.setNumDevices(1);
layout.setNumButtons(0,transformToolFactory->getNumButtons());
layout.setNumValuators(0,transformToolFactory->getNumValuators());
/* Set tool class' factory pointer: */
OffsetTool::factory=this;
}
SketchingToolFactory::SketchingToolFactory(ToolManager& toolManager)
:ToolFactory("SketchingTool",toolManager),
detailSize(getUiSize()),
curveFileName("SketchingTool.curves")
{
/* Initialize tool layout: */
layout.setNumButtons(1);
/* Insert class into class hierarchy: */
ToolFactory* toolFactory=toolManager.loadClass("UtilityTool");
toolFactory->addChildClass(this);
addParentClass(toolFactory);
/* Load class settings: */
Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
detailSize=cfs.retrieveValue<Scalar>("./detailSize",detailSize);
curveFileName=cfs.retrieveString("./curveFileName",curveFileName);
/* Set tool class' factory pointer: */
SketchingTool::factory=this;
}
ClipPlaneToolFactory::ClipPlaneToolFactory(ToolManager& toolManager)
:ToolFactory("ClipPlaneTool",toolManager),
normal(0,1,0)
{
/* Initialize tool layout: */
layout.setNumDevices(1);
layout.setNumButtons(0,1);
/* Insert class into class hierarchy: */
ToolFactory* toolFactory=toolManager.loadClass("PointingTool");
toolFactory->addChildClass(this);
addParentClass(toolFactory);
/* Load class settings: */
Misc::ConfigurationFileSection cfs=toolManager.getToolClassSection(getClassName());
normal=cfs.retrieveValue<Vector>("./normal",normal);
normal.normalize();
/* Set tool class' factory pointer: */
ClipPlaneTool::factory=this;
}
TransformToolFactory::TransformToolFactory(ToolManager& toolManager)
:ToolFactory("TransformTool",toolManager)
{
#if 0
/* Insert class into class hierarchy: */
ToolFactory* toolFactory=toolManager.loadClass("Tool");
toolFactory->addChildClass(this);
addParentClass(toolFactory);
#endif
/* Set tool class' factory pointer: */
TransformTool::factory=this;
}
