bool GetToolState(int toolId) const
{
int t = FindTool(toolId);
if (t<0)
return false;
return mTools[t]->GetToggled();
}
bool FEdModeGeometry::ExecDelete()
{
check( GEditorModeTools().IsModeActive( FBuiltinEditorModes::EM_Geometry ) );
FEdModeGeometry* mode = (FEdModeGeometry*)GEditorModeTools().GetActiveMode( FBuiltinEditorModes::EM_Geometry );
// Find the delete modifier and execute it.
FModeTool_GeometryModify* mtgm = (FModeTool_GeometryModify*)FindTool( MT_GeometryModify );
for( FModeTool_GeometryModify::TModifierIterator Itor( mtgm->ModifierIterator() ) ; Itor ; ++Itor )
{
UGeomModifier* gm = *Itor;
if( gm->IsA( UGeomModifier_Delete::StaticClass()) )
{
if( gm->Apply() )
{
return 1;
}
}
}
return 0;
}
/**
* Deselects all edges, polygons, and vertices for all selected objects.
*/
void FEdModeGeometry::GeometrySelectNone(bool bStoreSelection, bool bResetPivot)
{
for( int32 ObjectIdx = 0 ; ObjectIdx < GeomObjects.Num() ; ++ObjectIdx )
{
FGeomObject* GeomObject = GeomObjects[ObjectIdx];
GeomObject->Select( 0 );
for( int VertexIdx = 0 ; VertexIdx < GeomObject->EdgePool.Num() ; ++VertexIdx )
{
GeomObject->EdgePool[VertexIdx].Select( 0 );
}
for( int VertexIdx = 0 ; VertexIdx < GeomObject->PolyPool.Num() ; ++VertexIdx )
{
GeomObject->PolyPool[VertexIdx].Select( 0 );
}
for( int VertexIdx = 0 ; VertexIdx < GeomObject->VertexPool.Num() ; ++VertexIdx )
{
GeomObject->VertexPool[VertexIdx].Select( 0 );
}
GeomObject->SelectionOrder.Empty();
}
if (bStoreSelection)
{
FModeTool_GeometryModify* GeometryModifier = (FModeTool_GeometryModify*)FindTool(MT_GeometryModify);
GeometryModifier->StoreAllCurrentGeomSelections();
}
if (bResetPivot && (GeomObjects.Num() > 0))
{
FEditorModeTools& ModeTools = GEditorModeTools();
ModeTools.SetPivotLocation(GeomObjects[0]->GetActualBrush()->GetActorLocation(), false);
}
}
void FEdMode::SetCurrentTool( EModeTools InID )
{
CurrentTool = FindTool( InID );
check( CurrentTool ); // Tool not found! This can't happen.
CurrentToolChanged();
}
bool TOOL_MANAGER::runTool( const std::string& aToolName )
{
TOOL_BASE* tool = FindTool( aToolName );
if( tool && tool->GetType() == INTERACTIVE )
return runTool( tool );
return false; // there is no tool with the given name
}
bool TOOL_MANAGER::runTool( TOOL_ID aToolId )
{
TOOL_BASE* tool = FindTool( aToolId );
if( tool && tool->GetType() == INTERACTIVE )
return runTool( tool );
return false; // there is no tool with the given id
}
//*****************************************************************************************
BOOL CBCGPUserToolsManager::InvokeTool (UINT uiCmdId)
{
CBCGPUserTool* pTool = FindTool (uiCmdId);
if (pTool == NULL)
{
return FALSE;
}
return pTool->Invoke ();
}
void FEdModeGeometry::AddReferencedObjects( FReferenceCollector& Collector )
{
// Call parent implementation
FEdMode::AddReferencedObjects( Collector );
FModeTool_GeometryModify* mtgm = (FModeTool_GeometryModify*)FindTool( MT_GeometryModify );
for( FModeTool_GeometryModify::TModifierIterator Itor( mtgm->ModifierIterator() ) ; Itor ; ++Itor )
{
Collector.AddReferencedObject( *Itor );
}
}
void Restore()
{
if (mRestoreGroup>=0 && FindTool(mRestoreTool))
{
SetButtonGroup(mRestoreGroup,mRestoreTool);
wxCommandEvent event(wxEVT_COMMAND_TOOL_CLICKED,mRestoreTool);
mRestoreGroup = mRestoreTool = -1;
GetParent()->GetEventHandler()->ProcessEvent(event);
}
}
bool FEdModeInterpEdit::AllowWidgetMove()
{
FModeTool_InterpEdit* InterpTool = (FModeTool_InterpEdit*)FindTool(MT_InterpEdit);
if(InterpTool->bMovingHandle)
{
return false;
}
else
{
return true;
}
}
void OnTool(wxCommandEvent &inEvent)
{
inEvent.Skip();
int tid = FindTool(inEvent.GetId());
if (tid>=0)
{
ToolBoxTool &tool = *mTools[tid];
if (tool.mGroupID>=0)
{
if (tool.mGroupID==mRestoreGroup)
mRestoreGroup = -1;
SetButtonGroup(tool.mGroupID,inEvent.GetId());
}
}
Restore();
}
void OnToolEnter(wxCommandEvent &inEvent)
{
// Hold the button down, but switch back if they move their mouse away
if (mRadioPreview)
{
int id = inEvent.GetId();
if (id>0)
{
int pos = FindTool(id);
if (pos>=0)
{
ToolBoxTool &tool = *mTools[pos];
if (tool.mGroupID>=0)
{
if (mRestoreGroup!=tool.mGroupID)
Restore();
int current = GetGroupTool(tool.mGroupID);
if (current!=tool.mID)
{
if (mRestoreGroup<0)
{
mRestoreTool = current;
mRestoreGroup = tool.mGroupID;
}
SetButtonGroup(mRestoreGroup,tool.mID);
wxCommandEvent event(wxEVT_COMMAND_TOOL_CLICKED,tool.mID);
GetParent()->GetEventHandler()->ProcessEvent(event);
}
}
}
}
else
Restore();
}
}
UWORD Toolbar_Edge(struct IClass *cl, Object *obj, struct MUIP_Toolbar_Edge *msg)
{
struct Toolbar_Data *data = (struct Toolbar_Data *)INST_DATA(cl, obj);
struct TB_Element *tool = FindTool(data, msg->Button);
UWORD result = 0;
switch(msg->MethodID)
{
case MUIM_Toolbar_LeftEdge:
result = tool->DstX;
break;
case MUIM_Toolbar_RightEdge:
result = tool->DstX + data->ButtonWidth - 1;
break;
case MUIM_Toolbar_TopEdge:
result = tool->DstY;
break;
case MUIM_Toolbar_BottomEdge:
result = tool->DstY + data->ButtonHeight - 1;
break;
}
return(result);
}
mtsMedtronicStealthlink::Tool * mtsMedtronicStealthlink::AddTool(const std::string & stealthName, const std::string & interfaceName)
{
// First, check if tool has already been added
Tool * tool = FindTool(stealthName);
if (tool) {
if (tool->GetInterfaceName() == interfaceName) {
CMN_LOG_CLASS_RUN_WARNING << "AddTool: tool " << stealthName << " already exists with interface "
<< interfaceName << std::endl;
return tool;
}
// We could support having the same tool in multiple interfaces, but we would need to maintain
// an array of CurrentTools, or loop through the entire Tools list in the Run method (to assign the
// MarkerPosition and TooltipPosition).
CMN_LOG_CLASS_RUN_ERROR << "AddTool: tool " << stealthName << " already exists in interface "
<< tool->GetInterfaceName() << ", could not create new interface "
<< interfaceName << std::endl;
return 0;
}
// Next, check if interface has already been added
mtsInterfaceProvided * provided = GetInterfaceProvided(interfaceName);
if (provided) {
CMN_LOG_CLASS_RUN_ERROR << "AddTool: interface " << interfaceName << " already exists." << std::endl;
return 0;
}
// Create the tool and add it to the list
tool = new Tool (stealthName, interfaceName);
Tools.push_back(tool);
DataMapContainerInsertReturnValue dataMapInsertReturn;
MNavStealthLink::DataItem * newItem = 0;
myGenericObject * newObject = tool;
if (strcmp(interfaceName.c_str(),"Frame") == 0){
MNavStealthLink::Frame * newFrame = new MNavStealthLink::Frame();
newFrame->name = stealthName;
newItem = newFrame;
} else if (strcmp(interfaceName.c_str(),"Tool") == 0 ){
MNavStealthLink::Instrument * newTool = new MNavStealthLink::Instrument();
newTool->name = stealthName;
newItem = newTool;
}else{
//warning not a Frame or Tool assuming Tool
MNavStealthLink::Instrument * newTool = new MNavStealthLink::Instrument();
newTool->name = stealthName;
newItem = newTool;
}
dataMapInsertReturn = myDataMap.insert(DataMapContainerItem(newItem,newObject));
if (dataMapInsertReturn.second){
CMN_LOG_CLASS_RUN_VERBOSE << "AddTool: adding " << stealthName << " to interface " << interfaceName << std::endl;
provided = AddInterfaceProvided(interfaceName);
dataMapInsertReturn.first->second->ConfigureInterfaceProvided(provided);
} else {
CMN_LOG_CLASS_INIT_ERROR << "AddTool: Failed to add tool to the DataMap" << std::endl;
}
return tool;
}
ULONG Toolbar_Set(struct IClass *cl,Object *obj,struct MUIP_Toolbar_Set *msg)
{
struct Toolbar_Data *data = (struct Toolbar_Data *)INST_DATA(cl, obj);
struct MUIP_Toolbar_Description *desc = &data->Desc[msg->Button];
if(msg->Value)
{
if(!(desc->Flags & msg->Flag))
{
desc->Flags |= msg->Flag; // Add flag
if(data->Active)
{
struct TB_Element *tool = FindTool(data, msg->Button);
if(msg->Flag == MUIV_Toolbar_Set_Gone)
{
data->SingleGone = tool;
}
else if(msg->Flag == MUIV_Toolbar_Set_Selected)
{
if(desc->MutualExclude)
{
Exclude(data, desc->MutualExclude);
}
}
data->RedrawFlag = TRUE;
tool->Redraw = TRUE;
data->UpdateFlag = 0; // Solving the problem with pressing a button simultaneously with it being ghosted by set
MUI_Redraw(obj, MADF_DRAWUPDATE);
}
}
}
else
{
if(desc->Flags & msg->Flag)
{
desc->Flags &= (-1)-(msg->Flag); //Remove flag
if(data->Active)
{
if(msg->Flag == MUIV_Toolbar_Set_Selected)
{
if(desc->MutualExclude)
{
Exclude(data, desc->MutualExclude);
}
}
data->RedrawFlag = TRUE;
FindTool(data, msg->Button)->Redraw = TRUE;
MUI_Redraw(obj, MADF_DRAWUPDATE);
}
}
}
// Måske burde der resettes i updateflag-sammenhæng...
return(TRUE);
}
