1616 lines
39 KiB
C++
1616 lines
39 KiB
C++
/*
|
|
* This program source code file is part of KiCad, a free EDA CAD application.
|
|
*
|
|
* Copyright (C) 2017 Oliver Walters
|
|
* Copyright (C) 2017 KiCad Developers, see AUTHORS.txt for contributors.
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, you may find one here:
|
|
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
|
|
* or you may search the http://www.gnu.org website for the version 2 license,
|
|
* or you may write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#include "fields_editor_table_model.h"
|
|
|
|
// Indicator that multiple values exist in child rows
|
|
#define ROW_MULT_ITEMS wxString( "<...>" )
|
|
|
|
static const wxColor ROW_COLOUR_ITEM_CHANGED( 200, 0, 0 );
|
|
static const wxColor ROW_COLOUR_MULTIPLE_ITEMS( 60, 90, 200 );
|
|
|
|
|
|
/**
|
|
* Convert FIELDS_EDITOR_TABLE_ROW -> wxDataViewItem
|
|
*/
|
|
static wxDataViewItem RowToItem( FIELDS_EDITOR_TABLE_ROW const* aRow )
|
|
{
|
|
return wxDataViewItem( const_cast<void*>( static_cast<void const*>( aRow ) ) );
|
|
}
|
|
|
|
|
|
/**
|
|
* Convert wxDataViewItem -> FIELDS_EDITOR_TABEL_ROW
|
|
*/
|
|
static FIELDS_EDITOR_TABLE_ROW const* ItemToRow( wxDataViewItem aItem )
|
|
{
|
|
if( !aItem.IsOk() )
|
|
{
|
|
return nullptr;
|
|
}
|
|
else
|
|
{
|
|
return static_cast<FIELDS_EDITOR_TABLE_ROW const*>( aItem.GetID() );
|
|
}
|
|
}
|
|
|
|
|
|
FIELDS_EDITOR_FIELD_VALUES::FIELDS_EDITOR_FIELD_VALUES( const wxString& aRefDes, FIELD_VALUE_MAP* aTemplate ) :
|
|
m_refDes( aRefDes ),
|
|
m_templateValues( aTemplate )
|
|
{
|
|
}
|
|
|
|
|
|
bool FIELDS_EDITOR_FIELD_VALUES::GetFieldValue( unsigned int aFieldId, wxString& aValue ) const
|
|
{
|
|
auto search = m_currentValues.find( aFieldId );
|
|
|
|
if( search == m_currentValues.end() )
|
|
return false;
|
|
|
|
aValue = search->second;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool FIELDS_EDITOR_FIELD_VALUES::GetBackupValue( unsigned int aFieldId, wxString& aValue ) const
|
|
{
|
|
auto search = m_backupValues.find( aFieldId );
|
|
|
|
if( search == m_backupValues.end() )
|
|
return false;
|
|
|
|
aValue = search->second;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool FIELDS_EDITOR_FIELD_VALUES::GetTemplateValue( unsigned int aFieldId, wxString& aValue ) const
|
|
{
|
|
if( !m_templateValues )
|
|
return false;
|
|
|
|
auto search = m_templateValues->find( aFieldId );
|
|
|
|
if( search == m_templateValues->end() )
|
|
return false;
|
|
|
|
aValue = search->second;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
void FIELDS_EDITOR_FIELD_VALUES::SetFieldValue( unsigned int aFieldId, const wxString& aValue,
|
|
bool aOverwrite )
|
|
{
|
|
if( aOverwrite || m_currentValues.count( aFieldId ) == 0 ||
|
|
m_currentValues[aFieldId].IsEmpty() )
|
|
{
|
|
m_currentValues[aFieldId] = aValue;
|
|
}
|
|
}
|
|
|
|
|
|
bool FIELDS_EDITOR_FIELD_VALUES::HasValueChanged( unsigned int aFieldId) const
|
|
{
|
|
wxString currentValue, backupValue;
|
|
|
|
GetFieldValue( aFieldId, currentValue );
|
|
GetBackupValue( aFieldId, backupValue );
|
|
|
|
return currentValue.Cmp( backupValue ) != 0;
|
|
}
|
|
|
|
|
|
void FIELDS_EDITOR_FIELD_VALUES::RevertChanges( unsigned int aFieldId )
|
|
{
|
|
wxString backupValue;
|
|
|
|
GetBackupValue( aFieldId, backupValue );
|
|
|
|
SetFieldValue( aFieldId, backupValue, true );
|
|
}
|
|
|
|
void FIELDS_EDITOR_FIELD_VALUES::SetBackupPoint()
|
|
{
|
|
for( auto it = m_currentValues.begin(); it != m_currentValues.end(); ++it )
|
|
{
|
|
m_backupValues[it->first] = it->second;
|
|
}
|
|
}
|
|
|
|
|
|
FIELDS_EDITOR_TABLE_ROW::FIELDS_EDITOR_TABLE_ROW() : m_columnList( nullptr )
|
|
{
|
|
}
|
|
|
|
|
|
/**
|
|
* Update cell attributes based on parameters of the cell
|
|
* Default implementation highlights cells that have been altered
|
|
*/
|
|
bool FIELDS_EDITOR_TABLE_ROW::GetAttr( unsigned int aFieldId, wxDataViewItemAttr& aAttr ) const
|
|
{
|
|
auto field = m_columnList->GetColumnById( aFieldId );
|
|
|
|
if( HasValueChanged( field ) )
|
|
{
|
|
aAttr.SetBold( true );
|
|
aAttr.SetItalic( true );
|
|
aAttr.SetColour( ROW_COLOUR_ITEM_CHANGED );
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
bool FIELDS_EDITOR_TABLE_ROW::HasChanged() const
|
|
{
|
|
if( !m_columnList )
|
|
return false;
|
|
|
|
for( auto& column : m_columnList->Columns )
|
|
{
|
|
if( column && HasValueChanged( column ) )
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
/**
|
|
* Create a new group (which contains one or more components)
|
|
*/
|
|
FIELDS_EDITOR_TABLE_GROUP::FIELDS_EDITOR_TABLE_GROUP( FIELDS_EDITOR_COLUMN_LIST* aColumnList )
|
|
{
|
|
m_columnList = aColumnList;
|
|
}
|
|
|
|
|
|
bool FIELDS_EDITOR_TABLE_GROUP::GetAttr( unsigned int aFieldId, wxDataViewItemAttr& aAttr ) const
|
|
{
|
|
if( GetFieldValue( aFieldId ).Cmp( ROW_MULT_ITEMS ) == 0 )
|
|
{
|
|
aAttr.SetItalic( true );
|
|
aAttr.SetColour( ROW_COLOUR_MULTIPLE_ITEMS );
|
|
return true;
|
|
}
|
|
|
|
return FIELDS_EDITOR_TABLE_ROW::GetAttr( aFieldId, aAttr );
|
|
}
|
|
|
|
|
|
/**
|
|
* Return the value associated with a given field in the group.
|
|
* Some fields require special attention.
|
|
*/
|
|
wxString FIELDS_EDITOR_TABLE_GROUP::GetFieldValue( unsigned int aFieldId ) const
|
|
{
|
|
wxString value;
|
|
|
|
// Account for special cases
|
|
switch( aFieldId )
|
|
{
|
|
// QUANTITY returns the size of the group
|
|
case FIELDS_EDITOR_COL_ID_QUANTITY:
|
|
value = wxString::Format( "%u", (unsigned int) GroupSize() );
|
|
break;
|
|
|
|
// REFERENCE field returns consolidated list of references
|
|
case FIELDS_EDITOR_COL_ID_REFERENCE:
|
|
value = wxJoin( GetReferences(), ' ' );
|
|
break;
|
|
|
|
// Otherwise, return component data
|
|
default:
|
|
if( Components.size() == 0 )
|
|
{
|
|
value = wxEmptyString;
|
|
}
|
|
else
|
|
{
|
|
// If the components in this group contain multiple items,
|
|
// display a special string indicating this
|
|
for( unsigned int i=0; i<Components.size(); i++ )
|
|
{
|
|
auto const& cmp = Components[i];
|
|
|
|
if( i == 0 )
|
|
{
|
|
value = cmp->GetFieldValue( aFieldId );
|
|
}
|
|
// Mismatch found
|
|
else if( value.Cmp( cmp->GetFieldValue( aFieldId ) ) != 0 )
|
|
{
|
|
value = ROW_MULT_ITEMS;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
|
|
/**
|
|
* Set the value of a field in a group
|
|
* The new value is pushed to all components that are children of this group
|
|
*/
|
|
bool FIELDS_EDITOR_TABLE_GROUP::SetFieldValue( unsigned int aFieldId, const wxString aValue, bool aOverwrite )
|
|
{
|
|
bool result = false;
|
|
|
|
for( auto& cmp : Components )
|
|
{
|
|
result |= cmp->SetFieldValue( aFieldId, aValue, aOverwrite );
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
/**
|
|
* Determines if a given component matches against a particular field.
|
|
*
|
|
* - Tests each field in turn; all fields must match
|
|
* - Some fields require special checking
|
|
*
|
|
* @param aField - The field to test
|
|
* @param aComponent - The component being tested
|
|
*/
|
|
bool FIELDS_EDITOR_TABLE_GROUP::TestField( FIELDS_EDITOR_COLUMN* aField, FIELDS_EDITOR_TABLE_COMPONENT* aComponent ) const
|
|
{
|
|
if( !aField || !aComponent )
|
|
return false;
|
|
|
|
if( Components.size() == 0 )
|
|
return true;
|
|
|
|
wxString componentValue;
|
|
wxString comparisonValue;
|
|
|
|
// Some fields are handled in a special manner
|
|
// (handle these first)
|
|
switch( aField->Id() )
|
|
{
|
|
// These fields should NOT be compared (return True)
|
|
case FIELDS_EDITOR_COL_ID_QUANTITY:
|
|
return true;
|
|
|
|
// Reference matching is done only on prefix
|
|
case FIELDS_EDITOR_COL_ID_REFERENCE:
|
|
componentValue = aComponent->GetPrefix();
|
|
comparisonValue = Components[0]->GetPrefix();
|
|
break;
|
|
|
|
default:
|
|
componentValue = aComponent->GetFieldValue( aField->Id() );
|
|
comparisonValue = Components[0]->GetFieldValue( aField->Id() );
|
|
break;
|
|
}
|
|
|
|
bool result = componentValue.Cmp( comparisonValue ) == 0;
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
/**
|
|
* Add a new component to the group.
|
|
* It is assumed at this stage that the component is a good match for the group.
|
|
* @param aComponent is the new component to add
|
|
*/
|
|
bool FIELDS_EDITOR_TABLE_GROUP::AddComponent( FIELDS_EDITOR_TABLE_COMPONENT* aComponent )
|
|
{
|
|
if( !aComponent )
|
|
return false;
|
|
|
|
// To be a match, all fields must match!
|
|
bool match = true;
|
|
|
|
for( auto* column : m_columnList->Columns )
|
|
{
|
|
// Ignore any columns marked as "not used for sorting"
|
|
if( !column->IsUsedToSort() )
|
|
continue;
|
|
|
|
match = TestField( column, aComponent );
|
|
|
|
// Escape on first mismatch
|
|
if( !match )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( match )
|
|
{
|
|
aComponent->SetParent( this );
|
|
Components.push_back( aComponent );
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
/**
|
|
* Adds each child row to the supplied list, and returns the total child count
|
|
*/
|
|
unsigned int FIELDS_EDITOR_TABLE_GROUP::GetChildren( wxDataViewItemArray& aChildren ) const
|
|
{
|
|
// Show drop-down for child components
|
|
for( auto& row : Components )
|
|
{
|
|
if( row )
|
|
{
|
|
aChildren.push_back( RowToItem( &*row ) );
|
|
}
|
|
}
|
|
|
|
return aChildren.size();
|
|
}
|
|
|
|
|
|
/**
|
|
* Test if any components in this group have a new value in the provided field
|
|
* @param aField is the field to test
|
|
* @return true if any children have changed else false
|
|
*/
|
|
bool FIELDS_EDITOR_TABLE_GROUP::HasValueChanged( FIELDS_EDITOR_COLUMN* aField ) const
|
|
{
|
|
|
|
bool changed = false;
|
|
|
|
if( !aField )
|
|
return false;
|
|
|
|
for( auto const& row : Components )
|
|
{
|
|
if( row->HasValueChanged( aField ) )
|
|
{
|
|
changed = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// If the value has changed, the group field data must be updated
|
|
if( changed )
|
|
{
|
|
//TODO
|
|
}
|
|
|
|
return changed;
|
|
}
|
|
|
|
|
|
/**
|
|
* Return a list of (ordered) references
|
|
* for all the components in this group
|
|
*
|
|
* @param aSort - Sort the references
|
|
*/
|
|
wxArrayString FIELDS_EDITOR_TABLE_GROUP::GetReferences( bool aSort ) const
|
|
{
|
|
wxArrayString refs;
|
|
|
|
for( auto const& cmp : Components )
|
|
{
|
|
if( cmp )
|
|
{
|
|
refs.Add( cmp->GetFieldValue( FIELDS_EDITOR_COL_ID_REFERENCE ) );
|
|
}
|
|
}
|
|
|
|
if( aSort )
|
|
{
|
|
refs.Sort( SortReferences );
|
|
}
|
|
|
|
return refs;
|
|
}
|
|
|
|
|
|
/**
|
|
* Compare two references (e.g. "R100", "R19") and perform a 'natural' sort
|
|
* This sorting must preserve numerical order rather than alphabetical
|
|
* e.g. "R100" is lower (alphabetically) than "R19"
|
|
* BUT should be placed after R19
|
|
*/
|
|
int FIELDS_EDITOR_TABLE_GROUP::SortReferences( const wxString& aFirst, const wxString& aSecond )
|
|
{
|
|
// Default sorting
|
|
int defaultSort = aFirst.Cmp( aSecond );
|
|
|
|
static const wxString REGEX_STRING = "^([a-zA-Z]+)(\\d+)$";
|
|
|
|
// Compile regex statically
|
|
static wxRegEx regexFirst( REGEX_STRING, wxRE_ICASE | wxRE_ADVANCED );
|
|
static wxRegEx regexSecond( REGEX_STRING, wxRE_ICASE | wxRE_ADVANCED );
|
|
|
|
if( !regexFirst.Matches( aFirst ) || !regexSecond.Matches( aSecond ) )
|
|
{
|
|
return defaultSort;
|
|
}
|
|
|
|
// First priority is to order by prefix
|
|
wxString prefixFirst = regexFirst.GetMatch( aFirst, 1 );
|
|
wxString prefixSecond = regexSecond.GetMatch( aSecond, 1 );
|
|
|
|
if( prefixFirst.CmpNoCase( prefixSecond ) != 0 ) // Different prefixes!
|
|
{
|
|
return defaultSort;
|
|
}
|
|
|
|
wxString numStrFirst = regexFirst.GetMatch( aFirst, 2 );
|
|
wxString numStrSecond = regexSecond.GetMatch( aSecond, 2 );
|
|
|
|
// If either match failed, just return normal string comparison
|
|
if( numStrFirst.IsEmpty() || numStrSecond.IsEmpty() )
|
|
{
|
|
return defaultSort;
|
|
}
|
|
|
|
// Convert each number string to an integer
|
|
long numFirst = 0;
|
|
long numSecond = 0;
|
|
|
|
// If either conversion fails, return normal string comparison
|
|
if( !numStrFirst.ToLong( &numFirst ) || !numStrSecond.ToLong( &numSecond ) )
|
|
{
|
|
return defaultSort;
|
|
}
|
|
|
|
return (int) (numFirst - numSecond);
|
|
}
|
|
|
|
|
|
/**
|
|
* Compare two VALUE fields.
|
|
* A value field can reasonably be expected to be one of:
|
|
* a) Purely numerical e.g. '22'
|
|
* b) Numerical with included units e.g. '15uF'
|
|
* c) Numerical with included prefix but no units e.g. '20n'
|
|
* d) Numerical with prefix inside number e.g. '4K7'
|
|
* e) Other, e.g. 'MAX232'
|
|
*
|
|
* Cases a) to d) should be detected and converted to a common representation
|
|
* Values that do not match this pattern should revert to standard string comparison
|
|
*/
|
|
int FIELDS_EDITOR_TABLE_GROUP::SortValues( const wxString& aFirst, const wxString& aSecond )
|
|
{
|
|
//TODO - Intelligent comparison of component values
|
|
// e.g. 4K > 499
|
|
// e.g. 1nF < 0.1u
|
|
|
|
// For now, just return default comparison
|
|
|
|
return aFirst.CmpNoCase( aSecond );
|
|
}
|
|
|
|
|
|
/**
|
|
* Create a new COMPONENT row
|
|
* Each COMPONENT row is associated with a single component item.
|
|
*/
|
|
FIELDS_EDITOR_TABLE_COMPONENT::FIELDS_EDITOR_TABLE_COMPONENT( FIELDS_EDITOR_TABLE_GROUP* aParent,
|
|
FIELDS_EDITOR_COLUMN_LIST* aColumnList,
|
|
FIELDS_EDITOR_FIELD_VALUES* aFieldValues )
|
|
{
|
|
m_parent = aParent;
|
|
m_columnList = aColumnList;
|
|
m_fieldValues = aFieldValues;
|
|
}
|
|
|
|
|
|
/**
|
|
* Try to add a unit to this component
|
|
* If the references match, it will be added
|
|
*/
|
|
bool FIELDS_EDITOR_TABLE_COMPONENT::AddUnit( const SCH_REFERENCE& aUnit )
|
|
{
|
|
// Addition is successful if the references match or there are currently no units in the group
|
|
if( Units.size() == 0 || Units[0].GetRef().Cmp( aUnit.GetRef() ) == 0 )
|
|
{
|
|
Units.push_back( aUnit );
|
|
|
|
wxString value;
|
|
|
|
// Extract the component data
|
|
for( auto column : m_columnList->Columns )
|
|
{
|
|
auto cmp = aUnit.GetComp();
|
|
|
|
switch( column->Id() )
|
|
{
|
|
case FIELDS_EDITOR_COL_ID_QUANTITY:
|
|
value = wxEmptyString;
|
|
break;
|
|
|
|
case FIELDS_EDITOR_COL_ID_DESCRIPTION:
|
|
value = cmp->GetAliasDescription();
|
|
break;
|
|
|
|
case FIELDS_EDITOR_COL_ID_DATASHEET:
|
|
value = cmp->GetField( DATASHEET )->GetText();
|
|
if( value.IsEmpty() )
|
|
{
|
|
value = cmp->GetAliasDocumentation();
|
|
}
|
|
break;
|
|
|
|
case FIELDS_EDITOR_COL_ID_REFERENCE:
|
|
value = aUnit.GetRef();
|
|
break;
|
|
|
|
case FIELDS_EDITOR_COL_ID_VALUE:
|
|
value = cmp->GetField( VALUE )->GetText();
|
|
break;
|
|
|
|
case FIELDS_EDITOR_COL_ID_FOOTPRINT:
|
|
value = cmp->GetField( FOOTPRINT )->GetText();
|
|
break;
|
|
|
|
// User fields
|
|
default:
|
|
value = cmp->GetFieldText( column->Title(), false );
|
|
break;
|
|
}
|
|
|
|
m_fieldValues->SetFieldValue( column->Id(), value );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
/**
|
|
* Return the value associated with a particular field
|
|
* If no field is found, return an empty string
|
|
*/
|
|
wxString FIELDS_EDITOR_TABLE_COMPONENT::GetFieldValue( unsigned int aFieldId ) const
|
|
{
|
|
wxString value;
|
|
|
|
switch ( aFieldId )
|
|
{
|
|
case FIELDS_EDITOR_COL_ID_QUANTITY:
|
|
return wxEmptyString;
|
|
|
|
case FIELDS_EDITOR_COL_ID_REFERENCE:
|
|
return GetReference();
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if( m_fieldValues )
|
|
{
|
|
m_fieldValues->GetFieldValue( aFieldId, value );
|
|
|
|
if( value.IsEmpty() )
|
|
{
|
|
m_fieldValues->GetTemplateValue( aFieldId, value );
|
|
}
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
|
|
/**
|
|
* Set the value of a field in the component
|
|
* @param aFieldId is the unique ID of the field to update
|
|
* @param aValue is the new value
|
|
* @param aOverwrite enforces writing even if a value exists
|
|
*/
|
|
bool FIELDS_EDITOR_TABLE_COMPONENT::SetFieldValue( unsigned int aFieldId, const wxString aValue, bool aOverwrite )
|
|
{
|
|
if( m_fieldValues )
|
|
{
|
|
m_fieldValues->SetFieldValue( aFieldId, aValue, aOverwrite );
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
wxString FIELDS_EDITOR_TABLE_COMPONENT::GetPrefix() const
|
|
{
|
|
// Return the prefix of a component e.g. "R23" -> "R"
|
|
if( Units.size() == 0 )
|
|
return wxEmptyString;
|
|
|
|
return Units[0].GetComp()->GetPrefix();
|
|
}
|
|
|
|
|
|
/**
|
|
* Return the reference of a component e.g. "R23"
|
|
*/
|
|
wxString FIELDS_EDITOR_TABLE_COMPONENT::GetReference() const
|
|
{
|
|
if( Units.size() == 0 )
|
|
return wxEmptyString;
|
|
|
|
return Units[0].GetRef();
|
|
}
|
|
|
|
|
|
/**
|
|
* Determines if the given field has been changed for this component
|
|
*/
|
|
bool FIELDS_EDITOR_TABLE_COMPONENT::HasValueChanged( FIELDS_EDITOR_COLUMN* aField ) const
|
|
{
|
|
if( !aField )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return m_fieldValues->HasValueChanged( aField->Id() );
|
|
}
|
|
|
|
|
|
/**
|
|
* If any changes have been made to this component,
|
|
* they are now applied to the schematic component
|
|
*/
|
|
void FIELDS_EDITOR_TABLE_COMPONENT::ApplyFieldChanges()
|
|
{
|
|
for( auto& unit : Units )
|
|
{
|
|
auto cmp = unit.GetComp();
|
|
|
|
if( !cmp )
|
|
continue;
|
|
|
|
// Iterate over each column
|
|
SCH_FIELD* field;
|
|
|
|
for( auto& column : m_columnList->Columns )
|
|
{
|
|
if( column && HasValueChanged( column ) )
|
|
{
|
|
wxString value = GetFieldValue( column->Id() );
|
|
|
|
switch( column->Id() )
|
|
{
|
|
// Ignore read-only fields
|
|
case FIELDS_EDITOR_COL_ID_REFERENCE:
|
|
case FIELDS_EDITOR_COL_ID_QUANTITY:
|
|
continue;
|
|
|
|
// Special field considerations
|
|
case FIELDS_EDITOR_COL_ID_FOOTPRINT:
|
|
field = cmp->GetField( FOOTPRINT );
|
|
break;
|
|
|
|
case FIELDS_EDITOR_COL_ID_VALUE:
|
|
field = cmp->GetField( VALUE );
|
|
break;
|
|
case FIELDS_EDITOR_COL_ID_DATASHEET:
|
|
field = cmp->GetField( DATASHEET );
|
|
break;
|
|
|
|
default:
|
|
// Find the field by name (but ignore default fields)
|
|
field = cmp->FindField( column->Title(), false );
|
|
break;
|
|
}
|
|
|
|
// New field needs to be added?
|
|
if( !field && !value.IsEmpty() )
|
|
{
|
|
SCH_FIELD newField( wxPoint( 0, 0 ), -1, cmp, column->Title() );
|
|
field = cmp->AddField( newField );
|
|
}
|
|
|
|
if( field )
|
|
{
|
|
field->SetText( value );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Revert the displayed fields for this component
|
|
* to their original values (matching the schematic data)
|
|
*/
|
|
void FIELDS_EDITOR_TABLE_COMPONENT::RevertFieldChanges()
|
|
{
|
|
for( auto& column : m_columnList->Columns )
|
|
{
|
|
switch( column->Id() )
|
|
{
|
|
case FIELDS_EDITOR_COL_ID_REFERENCE:
|
|
case FIELDS_EDITOR_COL_ID_QUANTITY:
|
|
continue;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
m_fieldValues->RevertChanges( column->Id() );
|
|
}
|
|
}
|
|
|
|
|
|
FIELDS_EDITOR_TABLE_MODEL::FIELDS_EDITOR_TABLE_MODEL() :
|
|
m_widget( nullptr ),
|
|
m_sortingColumn( FIELDS_EDITOR_COL_ID_REFERENCE ),
|
|
m_sortingOrder( true )
|
|
{
|
|
//TODO
|
|
}
|
|
|
|
|
|
/**
|
|
* Create a container for the FIELDS_EDITOR_TABLE_MODEL
|
|
* This is required for reference counting by wxDataViewCtrl
|
|
*/
|
|
FIELDS_EDITOR_TABLE_MODEL::MODEL_PTR FIELDS_EDITOR_TABLE_MODEL::Create()
|
|
{
|
|
auto model = new FIELDS_EDITOR_TABLE_MODEL();
|
|
|
|
auto container = FIELDS_EDITOR_TABLE_MODEL::MODEL_PTR( model );
|
|
|
|
return container;
|
|
}
|
|
|
|
|
|
FIELDS_EDITOR_TABLE_MODEL::~FIELDS_EDITOR_TABLE_MODEL()
|
|
{
|
|
//TODO
|
|
}
|
|
|
|
|
|
wxDataViewColumn* FIELDS_EDITOR_TABLE_MODEL::AddColumn( FIELDS_EDITOR_COLUMN* aColumn, int aPosition )
|
|
{
|
|
static const unsigned int flags = wxDATAVIEW_COL_RESIZABLE | wxDATAVIEW_COL_SORTABLE;
|
|
|
|
if( !m_widget || !aColumn || !aColumn->IsVisible() )
|
|
return nullptr;
|
|
|
|
wxDataViewCellMode editFlag = aColumn->IsReadOnly() ? wxDATAVIEW_CELL_INERT : wxDATAVIEW_CELL_EDITABLE;
|
|
|
|
auto renderer = new wxDataViewTextRenderer( "string" , editFlag );
|
|
|
|
auto column = new wxDataViewColumn( aColumn->Title(),
|
|
renderer,
|
|
aColumn->Id(),
|
|
150, //TODO - variable default width?
|
|
wxAlignment( wxALIGN_LEFT ),
|
|
flags );
|
|
|
|
// Work out where to insert the column
|
|
std::set<unsigned int> columnsBefore;
|
|
|
|
for( auto testCol : ColumnList.Columns )
|
|
{
|
|
if( testCol->Id() == aColumn->Id() )
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
columnsBefore.insert( testCol->Id() );
|
|
}
|
|
}
|
|
|
|
bool found = false;
|
|
|
|
for( unsigned int ii=0; ii<m_widget->GetColumnCount(); ii++ )
|
|
{
|
|
auto col = m_widget->GetColumn( ii );
|
|
|
|
if( !col )
|
|
continue;
|
|
|
|
// If the new column is already in the view, escape
|
|
if( col->GetModelColumn() == aColumn->Id() )
|
|
{
|
|
return col;
|
|
}
|
|
|
|
// If we should insert the new column BEFORE this one
|
|
if( columnsBefore.count( col->GetModelColumn() ) == 0 )
|
|
{
|
|
found = true;
|
|
m_widget->InsertColumn( ii, column );
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( !found )
|
|
m_widget->AppendColumn( column );
|
|
|
|
column->SetResizeable( true );
|
|
|
|
return column;
|
|
}
|
|
|
|
|
|
/**
|
|
* Gracefully remove the given column from the wxDataViewCtrl
|
|
* Removing columns individually prevents bad redraw of entire table
|
|
*/
|
|
bool FIELDS_EDITOR_TABLE_MODEL::RemoveColumn( FIELDS_EDITOR_COLUMN* aColumn )
|
|
{
|
|
if( !m_widget || !aColumn )
|
|
return false;
|
|
|
|
for( unsigned int ii=0; ii<m_widget->GetColumnCount(); ii++ )
|
|
{
|
|
auto col = m_widget->GetColumn( ii );
|
|
|
|
if( col && col->GetModelColumn() == aColumn->Id() )
|
|
{
|
|
m_widget->DeleteColumn( col );
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
/**
|
|
* Attach the MODEL to a particular VIEW
|
|
* This function causes the view to be updated appropriately
|
|
*/
|
|
void FIELDS_EDITOR_TABLE_MODEL::AttachTo( wxDataViewCtrl* aView )
|
|
{
|
|
if( !aView )
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_widget = aView;
|
|
aView->Freeze();
|
|
Cleared();
|
|
|
|
aView->AssociateModel( this );
|
|
aView->ClearColumns();
|
|
|
|
// Add all columns
|
|
for( auto col : ColumnList.Columns )
|
|
{
|
|
AddColumn( col );
|
|
}
|
|
|
|
aView->Thaw();
|
|
|
|
// Notify the view that the data needs to be redrawn
|
|
aView->Update();
|
|
}
|
|
|
|
|
|
/**
|
|
* Return the total number of components displayed by the model
|
|
*/
|
|
unsigned int FIELDS_EDITOR_TABLE_MODEL::ComponentCount() const
|
|
{
|
|
unsigned int count = 0;
|
|
|
|
for( auto& group : Groups )
|
|
{
|
|
if( group )
|
|
count += group->GroupSize();
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
|
|
void FIELDS_EDITOR_TABLE_MODEL::ClearColumns()
|
|
{
|
|
ColumnList.Clear();
|
|
}
|
|
|
|
|
|
/**
|
|
* Add default columns to the table
|
|
* These columns are ALWAYS available in the table
|
|
* They are immutable - can be hidden by user but not removed
|
|
*/
|
|
void FIELDS_EDITOR_TABLE_MODEL::AddDefaultColumns()
|
|
{
|
|
// Reference column is read-only
|
|
ColumnList.AddColumn( new FIELDS_EDITOR_COLUMN(
|
|
FIELDS_EDITOR_COL_ID_REFERENCE,
|
|
FIELDS_EDITOR_COL_TYPE_GENERATED,
|
|
FIELDS_EDITOR_COL_TITLE_REFERENCE,
|
|
true, true ) );
|
|
|
|
ColumnList.AddColumn( new FIELDS_EDITOR_COLUMN(
|
|
FIELDS_EDITOR_COL_ID_VALUE,
|
|
FIELDS_EDITOR_COL_TYPE_KICAD,
|
|
FIELDS_EDITOR_COL_TITLE_VALUE,
|
|
true, false ) );
|
|
|
|
ColumnList.AddColumn( new FIELDS_EDITOR_COLUMN(
|
|
FIELDS_EDITOR_COL_ID_FOOTPRINT,
|
|
FIELDS_EDITOR_COL_TYPE_KICAD,
|
|
FIELDS_EDITOR_COL_TITLE_FOOTPRINT,
|
|
true, false ) );
|
|
|
|
ColumnList.AddColumn( new FIELDS_EDITOR_COLUMN(
|
|
FIELDS_EDITOR_COL_ID_DATASHEET,
|
|
FIELDS_EDITOR_COL_TYPE_KICAD,
|
|
FIELDS_EDITOR_COL_TITLE_DATASHEET,
|
|
true, false ) );
|
|
|
|
// Description comes from .dcm file and is read-only
|
|
ColumnList.AddColumn( new FIELDS_EDITOR_COLUMN(
|
|
FIELDS_EDITOR_COL_ID_DESCRIPTION,
|
|
FIELDS_EDITOR_COL_TYPE_LIBRARY,
|
|
FIELDS_EDITOR_COL_TITLE_DESCRIPTION,
|
|
true, true ) );
|
|
|
|
// Quantity column is read-only
|
|
ColumnList.AddColumn( new FIELDS_EDITOR_COLUMN(
|
|
FIELDS_EDITOR_COL_ID_QUANTITY,
|
|
FIELDS_EDITOR_COL_TYPE_GENERATED,
|
|
FIELDS_EDITOR_COL_TITLE_QUANTITY,
|
|
true, true ) );
|
|
}
|
|
|
|
|
|
/**
|
|
* Extract field data from all components
|
|
* Compiles an inclusive list of all field names from all components
|
|
*/
|
|
void FIELDS_EDITOR_TABLE_MODEL::AddComponentFields( SCH_COMPONENT* aCmp )
|
|
{
|
|
std::vector< SCH_FIELD* > fields;
|
|
|
|
SCH_FIELD* field;
|
|
wxString fieldName;
|
|
|
|
if( nullptr == aCmp )
|
|
return;
|
|
|
|
// Extract custom columns from component
|
|
fields.clear();
|
|
aCmp->GetFields( fields, false );
|
|
|
|
// Iterate over custom field datas
|
|
for( unsigned int i=MANDATORY_FIELDS; i<fields.size(); i++ )
|
|
{
|
|
field = fields[i];
|
|
|
|
if( nullptr == field ) continue;
|
|
|
|
fieldName = field->GetName();
|
|
|
|
bool userMatchFound = false;
|
|
|
|
// Search for the column within the existing columns
|
|
for( auto col : ColumnList.Columns )
|
|
{
|
|
if( !col )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if( col->Title().Cmp( fieldName ) == 0 )
|
|
{
|
|
if( col->Id() >= FIELDS_EDITOR_COL_ID_USER )
|
|
{
|
|
userMatchFound = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// If a user-made column already exists with the same name, abort
|
|
if( userMatchFound )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
ColumnList.AddColumn( new FIELDS_EDITOR_COLUMN( ColumnList.NextFieldId(),
|
|
FIELDS_EDITOR_COL_TYPE_USER,
|
|
field->GetName(),
|
|
true, false ) );
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Add a list of component items to the BOM manager
|
|
* Creates consolidated groups of components as required
|
|
*/
|
|
void FIELDS_EDITOR_TABLE_MODEL::SetComponents( SCH_REFERENCE_LIST aRefs, const TEMPLATE_FIELDNAMES& aTemplateFields )
|
|
{
|
|
|
|
// Add default columns
|
|
AddDefaultColumns();
|
|
|
|
// Extract all component fields
|
|
for( unsigned int ii=0; ii<aRefs.GetCount(); ii++ )
|
|
{
|
|
auto ref = aRefs.GetItem( ii );
|
|
auto cmp = ref.GetComp();
|
|
|
|
if( cmp )
|
|
{
|
|
AddComponentFields( cmp );
|
|
}
|
|
}
|
|
|
|
// Add template fields if they are not already added
|
|
for( auto field : aTemplateFields )
|
|
{
|
|
FIELDS_EDITOR_COLUMN* col;
|
|
|
|
col = ColumnList.GetColumnByTitle( field.m_Name );
|
|
|
|
if( !col )
|
|
{
|
|
col = new FIELDS_EDITOR_COLUMN( ColumnList.NextFieldId(),
|
|
FIELDS_EDITOR_COL_TYPE_USER,
|
|
field.m_Name,
|
|
true, false );
|
|
|
|
ColumnList.AddColumn( col );
|
|
}
|
|
|
|
// Add template value for that field
|
|
m_fieldTemplates[col->Id()] = field.m_Value;
|
|
}
|
|
|
|
// Group multi-unit components together
|
|
m_components.clear();
|
|
m_fieldValues.clear();
|
|
|
|
|
|
// Iterate through each unique component
|
|
for( unsigned int ii=0; ii<aRefs.GetCount(); ii++ )
|
|
{
|
|
auto ref = aRefs.GetItem( ii );
|
|
|
|
bool found = false;
|
|
|
|
for( auto& cmp : m_components )
|
|
{
|
|
if( cmp->AddUnit( ref ) )
|
|
{
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( !found )
|
|
{
|
|
// Find the field:value map associated with this component
|
|
wxString refDes = ref.GetComp()->GetField( REFERENCE )->GetText();
|
|
|
|
bool dataFound = false;
|
|
|
|
FIELDS_EDITOR_FIELD_VALUES* values;
|
|
|
|
for( auto& data : m_fieldValues )
|
|
{
|
|
// Look for a match based on RefDes
|
|
if( data->GetReference().Cmp( refDes ) == 0 )
|
|
{
|
|
dataFound = true;
|
|
values = &*data;
|
|
}
|
|
}
|
|
|
|
if( !dataFound )
|
|
{
|
|
values = new FIELDS_EDITOR_FIELD_VALUES( refDes, &m_fieldTemplates );
|
|
m_fieldValues.push_back( std::unique_ptr<FIELDS_EDITOR_FIELD_VALUES>( values ) );
|
|
}
|
|
|
|
auto* newComponent = new FIELDS_EDITOR_TABLE_COMPONENT( nullptr, &ColumnList, values );
|
|
newComponent->AddUnit( ref );
|
|
|
|
m_components.push_back( std::unique_ptr<FIELDS_EDITOR_TABLE_COMPONENT>( newComponent ) );
|
|
}
|
|
}
|
|
|
|
SetBackupPoint();
|
|
}
|
|
|
|
|
|
void FIELDS_EDITOR_TABLE_MODEL::SetBackupPoint()
|
|
{
|
|
// Mark backup locations for all values
|
|
for( auto& vals : m_fieldValues )
|
|
{
|
|
vals->SetBackupPoint();
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Recalculate grouping of components and reload table
|
|
**/
|
|
void FIELDS_EDITOR_TABLE_MODEL::ReloadTable()
|
|
{
|
|
if( m_widget )
|
|
{
|
|
m_widget->Freeze();
|
|
}
|
|
|
|
// Alert the view that the model data has changed
|
|
Cleared();
|
|
|
|
Groups.clear();
|
|
|
|
for( auto& cmp : m_components )
|
|
{
|
|
bool grouped = false;
|
|
|
|
if( m_groupColumns )
|
|
{
|
|
for( auto& group : Groups )
|
|
{
|
|
if( group->AddComponent( &*cmp ) )
|
|
{
|
|
grouped = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// No suitable group was found for this component
|
|
if( !grouped )
|
|
{
|
|
auto* newGroup = new FIELDS_EDITOR_TABLE_GROUP( &ColumnList );
|
|
|
|
newGroup->AddComponent( &*cmp );
|
|
|
|
Groups.push_back( std::unique_ptr<FIELDS_EDITOR_TABLE_GROUP>( newGroup ) );
|
|
}
|
|
}
|
|
|
|
// Update the display
|
|
if( m_widget )
|
|
{
|
|
//Cleared();
|
|
m_widget->AssociateModel( this );
|
|
m_widget->Thaw();
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Return a string array of data from a given row
|
|
*/
|
|
wxArrayString FIELDS_EDITOR_TABLE_MODEL::GetRowData( unsigned int aRow, std::vector<FIELDS_EDITOR_COLUMN*> aColumns ) const
|
|
{
|
|
wxArrayString row;
|
|
|
|
wxString data;
|
|
|
|
if( Groups.size() <= aRow )
|
|
return row;
|
|
|
|
auto const& group = Groups[aRow];
|
|
|
|
if ( !group )
|
|
return row;
|
|
|
|
for( auto const col : aColumns )
|
|
{
|
|
if( !col )
|
|
{
|
|
row.Add( wxEmptyString );
|
|
continue;
|
|
}
|
|
|
|
row.Add( group->GetFieldValue( col->Id() ) );
|
|
}
|
|
|
|
return row;
|
|
}
|
|
|
|
|
|
/**
|
|
* Get the value of a particular item in the model
|
|
*/
|
|
void FIELDS_EDITOR_TABLE_MODEL::GetValue( wxVariant& aVariant, const wxDataViewItem& aItem,
|
|
unsigned int aFieldId ) const
|
|
{
|
|
auto row = ItemToRow( aItem );
|
|
|
|
if( row )
|
|
{
|
|
aVariant = row->GetFieldValue( aFieldId );
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Set the value of a particular item in the model
|
|
*/
|
|
bool FIELDS_EDITOR_TABLE_MODEL::SetValue( const wxVariant& aVariant, const wxDataViewItem& aItem,
|
|
unsigned int aFieldId )
|
|
{
|
|
if( !aItem.IsOk() || !m_widget )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Extract the value to be set
|
|
if( aVariant.GetType().Cmp( "string" ) == 0 )
|
|
{
|
|
wxString value = aVariant.GetString();
|
|
|
|
bool result = false;
|
|
|
|
wxDataViewItemArray selectedItems;
|
|
m_widget->GetSelections( selectedItems );
|
|
|
|
// Set the row value for all selected rows
|
|
|
|
for( auto item : selectedItems )
|
|
{
|
|
auto selectedRow = static_cast<FIELDS_EDITOR_TABLE_ROW*>( item.GetID() );
|
|
|
|
if( selectedRow )
|
|
{
|
|
result |= selectedRow->SetFieldValue( aFieldId, value, true );
|
|
}
|
|
}
|
|
|
|
if( m_widget )
|
|
{
|
|
m_widget->Update();
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// Default
|
|
return false;
|
|
}
|
|
|
|
|
|
/**
|
|
* Return the parent item for a given item in the model.
|
|
* If no parent is found (or the item is invalid) return an invalid item.
|
|
*/
|
|
wxDataViewItem FIELDS_EDITOR_TABLE_MODEL::GetParent( const wxDataViewItem& aItem ) const
|
|
{
|
|
auto row = ItemToRow( aItem );
|
|
auto parent = row ? row->GetParent() : nullptr;
|
|
|
|
if( parent )
|
|
{
|
|
return RowToItem( parent );
|
|
}
|
|
|
|
// Return an invalid item
|
|
return wxDataViewItem();
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns true if the supplied item has children
|
|
*/
|
|
bool FIELDS_EDITOR_TABLE_MODEL::IsContainer( const wxDataViewItem& aItem ) const
|
|
{
|
|
auto row = ItemToRow( aItem );
|
|
|
|
if( row )
|
|
{
|
|
return row->HasChildren();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
/**
|
|
* Push all children of the supplied item into the list
|
|
* If the supplied item is invalid, push all the top-level items
|
|
*/
|
|
unsigned int FIELDS_EDITOR_TABLE_MODEL::GetChildren( const wxDataViewItem& aItem,
|
|
wxDataViewItemArray& aChildren ) const
|
|
{
|
|
auto row = aItem.IsOk() ? ItemToRow( aItem ) : nullptr;
|
|
|
|
// Valid row, return its children
|
|
if( row )
|
|
{
|
|
return row->GetChildren( aChildren );
|
|
}
|
|
else
|
|
{
|
|
for( auto& group : Groups )
|
|
{
|
|
aChildren.Add( RowToItem( &*group ) );
|
|
}
|
|
|
|
return aChildren.size();
|
|
}
|
|
}
|
|
|
|
|
|
bool FIELDS_EDITOR_TABLE_MODEL::GetAttr( const wxDataViewItem& aItem,
|
|
unsigned int aFieldId,
|
|
wxDataViewItemAttr& aAttr ) const
|
|
{
|
|
auto row = aItem.IsOk() ? ItemToRow( aItem ) : nullptr;
|
|
|
|
if( row )
|
|
{
|
|
return row->GetAttr( aFieldId, aAttr );
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
/**
|
|
* Custom comparison function for improved column sorting
|
|
* Alphanumeric sorting is not sufficient for correct ordering of some fields
|
|
* Some columns are sorted numerically, others with more complex rules.
|
|
*/
|
|
int FIELDS_EDITOR_TABLE_MODEL::Compare( const wxDataViewItem& aItem1,
|
|
const wxDataViewItem& aItem2,
|
|
unsigned int aColumnId,
|
|
bool aAscending ) const
|
|
{
|
|
if( !aItem1.IsOk() || !aItem2.IsOk() )
|
|
return 0;
|
|
|
|
int result = 0;
|
|
|
|
auto row1 = ItemToRow( aItem1 );
|
|
auto row2 = ItemToRow( aItem2 );
|
|
|
|
if( !row1 || !row2 )
|
|
return 0;
|
|
|
|
if( row1->GetParent() != row2->GetParent() )
|
|
return 0;
|
|
|
|
wxString strVal1 = row1->GetFieldValue( aColumnId );
|
|
wxString strVal2 = row2->GetFieldValue( aColumnId );
|
|
|
|
long numVal1;
|
|
long numVal2;
|
|
|
|
switch( aColumnId )
|
|
{
|
|
// Reference column sorted by reference val
|
|
case FIELDS_EDITOR_COL_ID_REFERENCE:
|
|
result = FIELDS_EDITOR_TABLE_GROUP::SortReferences( strVal1, strVal2 );
|
|
break;
|
|
|
|
case FIELDS_EDITOR_COL_ID_VALUE:
|
|
result = FIELDS_EDITOR_TABLE_GROUP::SortValues( strVal1, strVal2 );
|
|
break;
|
|
|
|
// These columns are sorted numerically
|
|
case FIELDS_EDITOR_COL_ID_QUANTITY:
|
|
if( strVal1.ToLong( &numVal1 ) && strVal2.ToLong( &numVal2 ) )
|
|
{
|
|
result = numVal1 - numVal2;
|
|
}
|
|
else
|
|
{
|
|
result = strVal1.Cmp( strVal2 );
|
|
}
|
|
break;
|
|
|
|
default:
|
|
// Default comparison (no special case)
|
|
result = strVal1.Cmp( strVal2 );
|
|
break;
|
|
}
|
|
|
|
// If initial sorting failed, sort secondly by reference
|
|
if( result == 0 && aColumnId != FIELDS_EDITOR_COL_ID_REFERENCE )
|
|
{
|
|
result = FIELDS_EDITOR_TABLE_GROUP::SortReferences(
|
|
row1->GetFieldValue( FIELDS_EDITOR_COL_ID_REFERENCE ),
|
|
row2->GetFieldValue( FIELDS_EDITOR_COL_ID_REFERENCE ) );
|
|
}
|
|
|
|
// If sorting still failed, sort thirdly by value
|
|
if( result == 0 && aColumnId != FIELDS_EDITOR_COL_ID_VALUE )
|
|
{
|
|
result = FIELDS_EDITOR_TABLE_GROUP::SortValues(
|
|
row1->GetFieldValue( FIELDS_EDITOR_COL_ID_VALUE ),
|
|
row2->GetFieldValue( FIELDS_EDITOR_COL_ID_VALUE ) );
|
|
}
|
|
|
|
if( !aAscending )
|
|
{
|
|
result *= -1;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
/**
|
|
* Revert all component data back to the original values.
|
|
* The table view is updated accordingly
|
|
*/
|
|
void FIELDS_EDITOR_TABLE_MODEL::RevertFieldChanges()
|
|
{
|
|
for( auto& group : Groups )
|
|
{
|
|
if( !group )
|
|
continue;
|
|
|
|
bool changed = false;
|
|
|
|
for( auto& component : group->Components )
|
|
{
|
|
if( !component )
|
|
continue;
|
|
|
|
if( component->HasChanged() )
|
|
{
|
|
component->RevertFieldChanges();
|
|
ItemChanged( RowToItem( &*component ) );
|
|
changed = true;
|
|
}
|
|
}
|
|
|
|
// Update the group if any components changed
|
|
if( changed )
|
|
{
|
|
ItemChanged( RowToItem( &*group ) );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Apply all outstanding field changes.
|
|
* This is performed only when the window is closed
|
|
*/
|
|
void FIELDS_EDITOR_TABLE_MODEL::ApplyFieldChanges()
|
|
{
|
|
for( auto& group : Groups )
|
|
{
|
|
if( !group )
|
|
continue;
|
|
|
|
for( auto& component : group->Components )
|
|
{
|
|
if( !component )
|
|
continue;
|
|
|
|
if( component->HasChanged() )
|
|
{
|
|
component->ApplyFieldChanges();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Tests if any component values in the table have been altered
|
|
*/
|
|
bool FIELDS_EDITOR_TABLE_MODEL::HaveFieldsChanged() const
|
|
{
|
|
for( auto const& group : Groups )
|
|
{
|
|
if( !group )
|
|
continue;
|
|
|
|
for( auto const& cmp : group->Components )
|
|
{
|
|
if( !cmp )
|
|
continue;
|
|
|
|
if( cmp->HasChanged() )
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns a list of only those components that have been changed
|
|
*/
|
|
std::vector<SCH_REFERENCE> FIELDS_EDITOR_TABLE_MODEL::GetChangedComponents()
|
|
{
|
|
std::vector<SCH_REFERENCE> components;
|
|
|
|
for( auto& group : Groups )
|
|
{
|
|
if( !group )
|
|
continue;
|
|
|
|
for( auto& component : group->Components )
|
|
{
|
|
if( !component )
|
|
continue;
|
|
|
|
if( component->HasChanged() )
|
|
{
|
|
for( auto& unit : component->Units )
|
|
{
|
|
components.push_back( unit );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return components;
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns a count of the components that have been changed
|
|
*/
|
|
unsigned int FIELDS_EDITOR_TABLE_MODEL::CountChangedComponents()
|
|
{
|
|
unsigned int count = 0;
|
|
|
|
for( auto& group : Groups )
|
|
{
|
|
if( !group )
|
|
continue;
|
|
|
|
for( auto& component : group->Components )
|
|
{
|
|
if( component && component->HasChanged() )
|
|
{
|
|
count++;
|
|
}
|
|
}
|
|
}
|
|
|
|
return count;
|
|
}
|