bool ParmLinkMgr::AddCurrLink()
{
//==== Check if Modifying Already Add Link ====//
if ( m_CurrParmLinkIndex >= 0 && m_CurrParmLinkIndex < (int)m_ParmLinkVec.size() )
return false;
if ( m_WorkingParmLink.GetParmA() == m_WorkingParmLink.GetParmB() )
return false;
if ( CheckForDuplicateLink( m_WorkingParmLink.GetParmA(), m_WorkingParmLink.GetParmB() ) )
return false;
ParmLink* pl = new ParmLink();
*pl = m_WorkingParmLink;
pl->GetParmA()->set_linked_flag( true );
pl->GetParmB()->set_linked_flag( true );
m_ParmLinkVec.push_back( pl );
m_CurrParmLinkIndex = (int)m_ParmLinkVec.size() - 1;
m_ParmLinkMap[pl->GetParmA()].push_back( pl );
ParmChanged( pl->GetParmA(), true ); // Trigger Update
return true;
}
void ParmLinkMgr::AddLink( Parm* pA, Parm* pB )
{
//==== Make Sure Parm Are Not Already Linked ====//
for ( int i = 0 ; i < (int)m_ParmLinkVec.size() ; i++ )
{
if ( m_ParmLinkVec[i]->GetParmA() == pA &&
m_ParmLinkVec[i]->GetParmB() == pB )
{
return;
}
}
ParmLink* pl = new ParmLink();
pl->SetParmA( pA );
pl->SetParmB( pB );
pl->SetOffsetFlag( true );
pl->SetOffset( pB->get() - pA->get() );
pl->SetScaleFlag( false );
pl->SetScale( 1.0 );
pA->set_linked_flag( true );
pB->set_linked_flag( true );
m_ParmLinkVec.push_back( pl );
m_CurrParmLinkIndex = (int)m_ParmLinkVec.size() - 1;
m_ParmLinkMap[pl->GetParmA()].push_back( pl );
ParmChanged( pl->GetParmA(), true ); // Trigger Update
}
void ParmLinkMgr::RebuildParmLinkMap()
{
map< Parm*, vector< ParmLink* > >::iterator itr;
for ( itr = m_ParmLinkMap.begin() ; itr != m_ParmLinkMap.end() ; itr++ )
itr->second.clear();
m_ParmLinkMap.clear();
for ( int i = 0 ; i < (int)m_ParmLinkVec.size() ; i++ )
{
ParmLink* pl = m_ParmLinkVec[i];
m_ParmLinkMap[pl->GetParmA()].push_back( pl );
pl->GetParmA()->set_linked_flag( true );
pl->GetParmB()->set_linked_flag( true );
}
}
void ParmLinkMgr::ParmChanged( Parm* parmPtr, bool start_flag )
{
int i;
map< Parm*, vector< ParmLink* > >::iterator itr;
//==== Look for Links and Modify Linked Parms ====//
itr = m_ParmLinkMap.find( parmPtr );
if ( itr == m_ParmLinkMap.end() )
return;
if ( parmPtr->get_link_update_flag() == true )
return;
vector< ParmLink* > plVec = itr->second;
if ( plVec.size() == 0 )
return;
parmPtr->set_link_update_flag( true );
m_UpdatedParmVec.push_back( parmPtr );
for ( i = 0 ; i < (int)plVec.size() ; i++ )
{
ParmLink* pl = plVec[i];
if ( pl->GetParmB()->get_link_update_flag() == false ) // Prevent Circular
{
double offset = 0.0;
if ( pl->GetOffsetFlag() ) offset = pl->GetOffset();
double scale = 1.0;
if ( pl->GetScaleFlag() ) scale = pl->GetScale();
double val = parmPtr->get()*scale + offset;
if ( pl->GetLowerLimitFlag() && val < pl->GetLowerLimit() ) // Constraints
val = pl->GetLowerLimit();
if ( pl->GetUpperLimitFlag() && val > pl->GetUpperLimit() ) // Constraints
val = pl->GetUpperLimit();
pl->GetParmB()->set_from_link( val );
pl->GetParmB()->get_geom()->parm_changed( pl->GetParmB() );
}
}
if ( start_flag ) // Clean Up
{
for ( i = 0 ; i < (int)m_UpdatedParmVec.size() ; i++ )
m_UpdatedParmVec[i]->set_link_update_flag( false );
m_UpdatedParmVec.clear();
}
}
void ParmLinkMgr::ReadLinks(xmlNodePtr root, vector< Geom* > & geomVec)
{
vector< Geom* > gVec = geomVec;
gVec.push_back( aircraftPtr->getUserGeom() );
xmlNodePtr node_list = xmlGetNode( root, "ParmLink_List", 0 );
if ( node_list )
{
int num_links = xmlGetNumNames( node_list, "Link" );
for ( int i = 0 ; i < num_links ; i++ )
{
xmlNodePtr link_node = xmlGetNode( node_list, "Link", i );
if ( link_node )
{
int geomA_id = xmlFindInt( link_node, "GeomA", 0 );
Stringc groupA_name = Stringc( xmlFindString( link_node, "GroupA", " " ) );
Stringc parmA_name = Stringc( xmlFindString( link_node, "ParmA", " " ) );
Parm* parmA = FindParm( gVec, geomA_id, groupA_name, parmA_name );
int geomB_id = xmlFindInt( link_node, "GeomB", 0 );
Stringc groupB_name = Stringc( xmlFindString( link_node, "GroupB", " " ) );
Stringc parmB_name = Stringc( xmlFindString( link_node, "ParmB", " " ) );
Parm* parmB = FindParm( gVec, geomB_id, groupB_name, parmB_name );
if ( parmA && parmB )
{
ParmLink* pl = new ParmLink();
pl->SetParmA( parmA );
pl->SetParmB( parmB );
pl->SetOffsetFlag( !!xmlFindInt( link_node, "OffsetFlag", 0 ) );
pl->SetOffset( xmlFindDouble( link_node, "Offset", 0.0 ) );
pl->SetScaleFlag( !!xmlFindInt( link_node, "ScaleFlag", 0 ) );
pl->SetScale( xmlFindDouble( link_node, "Scale", 1.0 ) );
pl->SetLowerLimitFlag( !!xmlFindInt( link_node, "LowerLimitFlag", 0 ) );
pl->SetLowerLimit( xmlFindDouble( link_node, "LowerLimit", 0.0 ) );
pl->SetUpperLimitFlag( !!xmlFindInt( link_node, "UpperLimitFlag", 0 ) );
pl->SetUpperLimit( xmlFindDouble( link_node, "UpperLimit", 0.0 ) );
pl->GetParmA()->set_linked_flag( true );
pl->GetParmB()->set_linked_flag( true );
m_ParmLinkVec.push_back( pl );
m_CurrParmLinkIndex = (int)m_ParmLinkVec.size() - 1;
}
}
}
}
}
void ParmLinkMgr::WriteLinks( xmlNodePtr root )
{
xmlNodePtr link_list_node = xmlNewChild( root, NULL, (const xmlChar *)"ParmLink_List", NULL );
for ( int i = 0 ; i < (int)m_ParmLinkVec.size() ; i++ )
{
ParmLink* pl = m_ParmLinkVec[i];
xmlNodePtr link_node = xmlNewChild( link_list_node, NULL, (const xmlChar *)"Link", NULL );
xmlAddIntNode( link_node, "GeomA", ((Geom*)pl->GetParmA()->get_geom_base())->getPtrID() );
xmlAddStringNode( link_node, "GroupA", pl->GetParmA()->get_group_name().get_char_star() );
xmlAddStringNode( link_node, "ParmA", pl->GetParmA()->get_name().get_char_star() );
xmlAddIntNode( link_node, "GeomB", ((Geom*)pl->GetParmB()->get_geom_base())->getPtrID() );
xmlAddStringNode( link_node, "GroupB", pl->GetParmB()->get_group_name().get_char_star() );
xmlAddStringNode( link_node, "ParmB", pl->GetParmB()->get_name().get_char_star() );
xmlAddIntNode( link_node, "OffsetFlag", pl->GetOffsetFlag() );
xmlAddDoubleNode( link_node, "Offset", pl->GetOffset() );
xmlAddIntNode( link_node, "ScaleFlag", pl->GetScaleFlag() );
xmlAddDoubleNode( link_node, "Scale", pl->GetScale() );
xmlAddIntNode( link_node, "LowerLimitFlag", pl->GetLowerLimitFlag() );
xmlAddDoubleNode( link_node, "LowerLimit", pl->GetLowerLimit() );
xmlAddIntNode( link_node, "UpperLimitFlag", pl->GetUpperLimitFlag() );
xmlAddDoubleNode( link_node, "UpperLimit", pl->GetUpperLimit() );
}
}
void ParmLinkScreen::screenCB( Fl_Widget* w )
{
ParmLink* currLink = parmLinkMgrPtr->GetCurrParmLink();
if ( w == parmLinkUI->compAChoice || w == parmLinkUI->compBChoice ||
w == parmLinkUI->groupAChoice || w == parmLinkUI->groupBChoice ||
w == parmLinkUI->parmAChoice || w == parmLinkUI->parmBChoice)
{
compGroupLinkChange();
}
else if ( w == parmLinkUI->offsetButton )
{
if ( parmLinkUI->offsetButton->value() )
currLink->SetOffsetFlag( true );
else
currLink->SetOffsetFlag( false );
m_OffsetSlider->Activate();
if ( !currLink->GetOffsetFlag() )
m_OffsetSlider->Deactivate();
parmLinkMgrPtr->ParmChanged( currLink->GetParmA(), true );
}
else if ( w == parmLinkUI->scaleButton )
{
if ( parmLinkUI->scaleButton->value() )
currLink->SetScaleFlag( true );
else
currLink->SetScaleFlag( false );
m_ScaleSlider->Activate();
if ( !currLink->GetScaleFlag() )
m_ScaleSlider->Deactivate();
parmLinkMgrPtr->ParmChanged( currLink->GetParmA(), true );
}
else if ( w == parmLinkUI->lowerLimitButton )
{
if ( parmLinkUI->lowerLimitButton->value() )
currLink->SetLowerLimitFlag( true );
else
currLink->SetLowerLimitFlag( false );
m_LowerLimitSlider->Activate();
if ( !currLink->GetLowerLimitFlag() )
m_LowerLimitSlider->Deactivate();
parmLinkMgrPtr->ParmChanged( currLink->GetParmA(), true );
}
else if ( w == parmLinkUI->upperLimitButton )
{
if ( parmLinkUI->upperLimitButton->value() )
currLink->SetUpperLimitFlag( true );
else
currLink->SetUpperLimitFlag( false );
m_UpperLimitSlider->Activate();
if ( !currLink->GetUpperLimitFlag() )
m_UpperLimitSlider->Deactivate();
parmLinkMgrPtr->ParmChanged( currLink->GetParmA(), true );
}
else if ( w == parmLinkUI->addLinkButton )
{
bool success = parmLinkMgrPtr->AddCurrLink();
if ( !success )
fl_alert( "Error: Identical Parms or Already Linked" );
update();
}
else if ( w == parmLinkUI->deleteLinkButton )
{
parmLinkMgrPtr->DelCurrLink();
update();
}
else if ( w == parmLinkUI->deleteAllLinksButton )
{
parmLinkMgrPtr->DelAllLinks();
update();
}
else if ( w == parmLinkUI->linkAllCompButton )
{
bool success = parmLinkMgrPtr->LinkAllComp();
if ( !success )
fl_alert( "Error: Identical Comps" );
update();
}
else if ( w == parmLinkUI->linkAllGroupButton )
{
bool success = parmLinkMgrPtr->LinkAllGroup();
if ( !success )
fl_alert( "Error: Identical Group" );
update();
}
else if ( w == parmLinkUI->linkBrowser )
{
int sel = parmLinkUI->linkBrowser->value();
parmLinkMgrPtr->SetCurrParmLinkIndex( sel-2 );
update();
}
else if ( m_OffsetSlider->GuiChanged( w ) )
{
currLink->SetOffset( m_OffsetSlider->GetVal() );
parmLinkMgrPtr->ParmChanged( currLink->GetParmA(), true );
}
else if ( m_ScaleSlider->GuiChanged( w ) )
{
currLink->SetScale( m_ScaleSlider->GetVal() );
parmLinkMgrPtr->ParmChanged( currLink->GetParmA(), true );
}
else if ( m_LowerLimitSlider->GuiChanged( w ) )
{
currLink->SetLowerLimit( m_LowerLimitSlider->GetVal() );
parmLinkMgrPtr->ParmChanged( currLink->GetParmA(), true );
}
else if ( m_UpperLimitSlider->GuiChanged( w ) )
{
currLink->SetUpperLimit( m_UpperLimitSlider->GetVal() );
parmLinkMgrPtr->ParmChanged( currLink->GetParmA(), true );
}
aircraftPtr->triggerDraw();
}
void ParmLinkScreen::update()
{
int i;
char str[256];
ParmLink* currLink = parmLinkMgrPtr->GetCurrParmLink();
if ( currLink->GetParmA() == NULL || currLink->GetParmB() == NULL )
currLink = parmLinkMgrPtr->ResetWorkingParmLink();
//==== Geom Names A ====//
parmLinkUI->compAChoice->clear();
vector< string > geomNameVecA;
int indA = parmLinkMgrPtr->GetCurrGeomNameVec( currLink->GetParmA(), geomNameVecA );
for ( i = 0 ; i < (int)geomNameVecA.size() ; i++ )
{
sprintf( str, "%d-%s", i, geomNameVecA[i].c_str() );
parmLinkUI->compAChoice->add( str );
}
//parmLinkUI->compAChoice->add( geomNameVecA[i].c_str() );
parmLinkUI->compAChoice->value( indA );
//==== Group Names A ====//
parmLinkUI->groupAChoice->clear();
vector< string > groupNameVecA;
indA = parmLinkMgrPtr->GetCurrGroupNameVec( currLink->GetParmA(), groupNameVecA );
for ( i = 0 ; i < (int)groupNameVecA.size() ; i++ )
parmLinkUI->groupAChoice->add( groupNameVecA[i].c_str() );
parmLinkUI->groupAChoice->value( indA );
//==== Parm Names A =====//
parmLinkUI->parmAChoice->clear();
vector< string > parmNameVecA;
indA = parmLinkMgrPtr->GetCurrParmNameVec( currLink->GetParmA(), parmNameVecA );
for ( i = 0 ; i < (int)parmNameVecA.size() ; i++ )
parmLinkUI->parmAChoice->add( parmNameVecA[i].c_str() );
parmLinkUI->parmAChoice->value( indA );
//==== Geom Names B ====//
parmLinkUI->compBChoice->clear();
vector< string > geomNameVecB;
int indB = parmLinkMgrPtr->GetCurrGeomNameVec( currLink->GetParmB(), geomNameVecB );
for ( i = 0 ; i < (int)geomNameVecB.size() ; i++ )
{
sprintf( str, "%d-%s", i, geomNameVecB[i].c_str() );
parmLinkUI->compBChoice->add( str );
}
// parmLinkUI->compBChoice->add( geomNameVecB[i].c_str() );
parmLinkUI->compBChoice->value( indB );
//==== Group Names B ====//
parmLinkUI->groupBChoice->clear();
vector< string > groupNameVecB;
indB = parmLinkMgrPtr->GetCurrGroupNameVec( currLink->GetParmB(), groupNameVecB );
for ( i = 0 ; i < (int)groupNameVecB.size() ; i++ )
parmLinkUI->groupBChoice->add( groupNameVecB[i].c_str() );
parmLinkUI->groupBChoice->value( indB );
//==== Parm Names B =====//
parmLinkUI->parmBChoice->clear();
vector< string > parmNameVecB;
indB = parmLinkMgrPtr->GetCurrParmNameVec( currLink->GetParmB(), parmNameVecB );
for ( i = 0 ; i < (int)parmNameVecB.size() ; i++ )
parmLinkUI->parmBChoice->add( parmNameVecB[i].c_str() );
parmLinkUI->parmBChoice->value( indB );
//===== Update Offset ====//
parmLinkUI->offsetButton->value(1);
m_OffsetSlider->Activate();
if ( !currLink->GetOffsetFlag() )
{
parmLinkUI->offsetButton->value(0);
m_OffsetSlider->Deactivate();
}
m_OffsetSlider->SetVal( currLink->GetOffset() );
m_OffsetSlider->UpdateGui();
//===== Update Scale ====//
parmLinkUI->scaleButton->value(1);
m_ScaleSlider->Activate();
if ( !currLink->GetScaleFlag() )
{
parmLinkUI->scaleButton->value(0);
m_ScaleSlider->Deactivate();
}
m_ScaleSlider->SetVal( currLink->GetScale() );
m_ScaleSlider->UpdateGui();
//===== Update Lower Limit ====//
parmLinkUI->lowerLimitButton->value(1);
m_LowerLimitSlider->Activate();
if ( !currLink->GetLowerLimitFlag() )
{
parmLinkUI->lowerLimitButton->value(0);
m_LowerLimitSlider->Deactivate();
}
m_LowerLimitSlider->SetVal( currLink->GetLowerLimit() );
m_LowerLimitSlider->UpdateGui();
//===== Update Upper Limit ====//
parmLinkUI->upperLimitButton->value(1);
m_UpperLimitSlider->Activate();
if ( !currLink->GetUpperLimitFlag() )
{
parmLinkUI->upperLimitButton->value(0);
m_UpperLimitSlider->Deactivate();
}
m_UpperLimitSlider->SetVal( currLink->GetUpperLimit() );
m_UpperLimitSlider->UpdateGui();
//==== Update Link Browser ====//
parmLinkUI->linkBrowser->clear();
static int widths[] = { 75,75,90,20,75,75,80,0 }; // widths for each column
parmLinkUI->linkBrowser->column_widths(widths); // assign array to widget
parmLinkUI->linkBrowser->column_char(':'); // use : as the column character
sprintf( str, "@[email protected]_A:@[email protected]:@[email protected]:->:@[email protected]_B:@[email protected]:@[email protected]" );
parmLinkUI->linkBrowser->add( str );
vector< ParmLink* > parmLinkVec = parmLinkMgrPtr->GetParmLinkVec();
for ( i = 0 ; i < (int)parmLinkVec.size() ; i++ )
{
Parm* pa = parmLinkVec[i]->GetParmA();
Parm* pb = parmLinkVec[i]->GetParmB();
sprintf( str, "%s:%s:%s:->:%s:%s:%s",
pa->get_geom_base()->getName().get_char_star(), pa->get_group_name().get_char_star(), pa->get_name().get_char_star(),
pb->get_geom_base()->getName().get_char_star(), pb->get_group_name().get_char_star(), pb->get_name().get_char_star() );
parmLinkUI->linkBrowser->add( str );
}
int index = parmLinkMgrPtr->GetCurrParmLinkIndex();
if ( index >= 0 && index < (int)parmLinkVec.size() )
parmLinkUI->linkBrowser->select( index+2 );
parmLinkUI->UIWindow->redraw();
for ( int i = 0 ; i < (int)m_ParmButtonVec.size() ; i++ )
{
m_ParmButtonVec[i]->update();
}
}
