void wxXmlSerializer::SetRootItem(xsSerializable* root)
{
wxASSERT(root);
wxASSERT(root->IsKindOf(CLASSINFO(xsSerializable)));
if( m_pRoot )delete m_pRoot;
if(root && root->IsKindOf(CLASSINFO(xsSerializable)))
{
m_pRoot = root;
}
else
m_pRoot = new xsSerializable();
// update pointers to parent manager
m_mapUsedIDs.clear();
m_pRoot->m_pParentManager = this;
m_mapUsedIDs[m_pRoot->GetId()] = m_pRoot;
xsSerializable *pItem;
SerializableList lstItems;
GetItems(NULL, lstItems);
SerializableList::compatibility_iterator node = lstItems.GetFirst();
while( node )
{
pItem = node->GetData();
pItem->m_pParentManager = this;
m_mapUsedIDs[pItem->GetId()] = pItem;
node = node->GetNext();
}
}
void wxSFDiagramManager::GetAssignedConnections(wxSFShapeBase* parent, wxClassInfo* shapeInfo, wxSFShapeBase::CONNECTMODE mode, ShapeList& lines)
{
wxSFLineShape* pLine;
if( parent->GetId() == -1 ) return;
SerializableList lstLines;
// lines are children of root item only so we have not to search recursively...
GetRootItem()->GetChildren( shapeInfo, lstLines );
if( !lstLines.IsEmpty() )
{
SerializableList::compatibility_iterator node = lstLines.GetFirst();
while(node)
{
pLine = (wxSFLineShape*)node->GetData();
switch(mode)
{
case wxSFShapeBase::lineSTARTING:
if( pLine->GetSrcShapeId() == parent->GetId() ) lines.Append(pLine);
break;
case wxSFShapeBase::lineENDING:
if( pLine->GetTrgShapeId() == parent->GetId() ) lines.Append(pLine);
break;
case wxSFShapeBase::lineBOTH:
if( ( pLine->GetSrcShapeId() == parent->GetId() ) ||
( pLine->GetTrgShapeId() == parent->GetId() ) ) lines.Append(pLine);
break;
}
node = node->GetNext();
}
}
}
bool wxXmlSerializer::Contains(wxClassInfo *type)
{
SerializableList lstItems;
GetItems( type, lstItems );
return !lstItems.IsEmpty();
}
void testClear( )
{
FileBasedStore store( DIRECTORY_BASE );
std::string sectionName = "alpha";
SerializableList allValues;
allValues.push_back( makeSerializableWrapperPtr( 10 ) );
store.saveSection( sectionName, allValues );
store.clear();
CPPUNIT_ASSERT( ! store.hasSection( sectionName ) );
}
udSettingsCategory* udSettings::GetCategory(const wxString& name)
{
SerializableList lstCategories;
GetItems( CLASSINFO(udSettingsCategory), lstCategories );
SerializableList::compatibility_iterator node = lstCategories.GetFirst();
while( node )
{
if( ((udSettingsCategory*)node->GetData())->GetName() == name ) return (udSettingsCategory*)node->GetData();
node = node->GetNext();
}
return NULL;
}
int wxXmlSerializer::GetIDCount(long id)
{
int nCount = 0;
SerializableList items;
GetItems(CLASSINFO(xsSerializable), items);
SerializableList::compatibility_iterator node = items.GetFirst();
while(node)
{
if( node->GetData()->GetId() == id ) nCount++;
node = node->GetNext();
}
if( m_pRoot->GetId() == id ) nCount++;
return nCount;
}
void TableSettings::OnRemoveColumnClick(wxCommandEvent& event)
{
Column *col = GetColumn( GetSelectedColumnName() );
if( col ) {
// delete associated keys
SerializableList keys;
GetConstraints( keys, col->GetName() );
for(SerializableList::iterator it = keys.begin(); it != keys.end(); ++it ) {
Constraint *key = (Constraint*) *it;
m_lstKeys.DeleteObject( key );
delete key;
}
// delete the column
m_lstColumns.DeleteObject( col );
delete col;
UpdateView();
}
}
void TableSettings::GetConstraints(SerializableList& keys, const wxString& localcol)
{
for( SerializableList::iterator it = m_lstKeys.begin();
it != m_lstKeys.end(); ++it ) {
Constraint *c = wxDynamicCast( *it, Constraint );
if( c && ( c->GetLocalColumn() == localcol ) ) keys.Append( *it );
}
}
void testSaveSection( )
{
FileBasedStore store( DIRECTORY_BASE );
RecordedGrip grip = makeSerializableWrapperPtr( 10 );
SerializableList allValues;
allValues.push_back( grip );
store.saveSection( "anExample", allValues );
CPPUNIT_ASSERT( store.hasSection( "anExample" ) );
SerializableList retrievedValues;
store.retrieveSection( "anExample", retrievedValues );
CPPUNIT_ASSERT( grip == *( retrievedValues.begin( ) ) );
}
xsSerializable* xsSerializable::GetChild(long id, bool recursive)
{
SerializableList lstChildren;
SerializableList::compatibility_iterator node;
if( recursive )
{
GetChildrenRecursively( CLASSINFO(xsSerializable), lstChildren );
node = lstChildren.GetFirst();
}
else
node = m_lstChildItems.GetFirst();
while(node)
{
if( node->GetData()->GetId() == id) return node->GetData();
node = node->GetNext();
}
return NULL;
}
void udCPPClassElementProcessor::ProcessClassMembers(wxSFShapeBase* element)
{
SerializableList lstMembers;
umlClassDiagram::GetClassMembers( (umlClassItem*)element, CLASSINFO(udMemberDataLinkItem), (udLanguage::ACCESSTYPE)-1, lstMembers );
if( !lstMembers.IsEmpty() )
{
udMemberDataItem *pVar;
udLanguage *pLang = m_pParentGenerator->GetActiveLanguage();
pLang->SingleLineCommentCmd( wxT("member data initialization") );
for( SerializableList::iterator it = lstMembers.begin(); it != lstMembers.end(); ++it )
{
pVar = (udMemberDataItem*)((udMemberDataLinkItem*)*it)->GetOriginal();
if( !pVar->GetValue().IsEmpty() ) pLang->WriteCodeBlocks( pVar->ToString( udCodeItem::cfDEFINITION, pLang ) );
}
pLang->NewLine();
}
}
xsProperty* udSettings::GetProperty(const wxString& name)
{
udSettingsCategory *pCategory;
xsProperty *pProperty;
SerializableList lstCategories;
GetItems( CLASSINFO(udSettingsCategory), lstCategories );
SerializableList::compatibility_iterator node = lstCategories.GetFirst();
while( node )
{
pCategory = (udSettingsCategory*)node->GetData();
pProperty = pCategory->GetProperty( name );
if( pProperty ) return pProperty;
node = node->GetNext();
}
return NULL;
}
void xsSerializable::InitChild(xsSerializable* child)
{
if( child )
{
child->m_pParentItem = this;
if( m_pParentManager )
{
if( child->m_pParentManager != m_pParentManager )
{
child->m_pParentManager = m_pParentManager;
// assign unique ids to the child object
if( child->GetId() == -1 ) child->SetId(m_pParentManager->GetNewId());
else
m_pParentManager->GetUsedIDs()[child->GetId()] = child;
// if the child has another children, set their parent manager and ID as well
xsSerializable *pItem;
SerializableList lstChildren;
child->GetChildrenRecursively( NULL, lstChildren );
SerializableList::compatibility_iterator node = lstChildren.GetFirst();
while( node )
{
pItem = node->GetData();
pItem->SetParentManager( m_pParentManager );
if( pItem->GetId() == -1 ) pItem->SetId(m_pParentManager->GetNewId());
else
m_pParentManager->GetUsedIDs()[pItem->GetId()] = pItem;
node = node->GetNext();
}
}
}
}
}
void xsSerializable::GetChildren(wxClassInfo *type, SerializableList& list)
{
xsSerializable *pChild;
SerializableList::compatibility_iterator node = m_lstChildItems.GetFirst();
while(node)
{
pChild = node->GetData();
if( !type || pChild->IsKindOf(type) ) list.Append(pChild);
node = node->GetNext();
}
}
void xsSerializable::GetChildrenRecursively(wxClassInfo *type, SerializableList& list, SEARCHMODE mode)
{
xsSerializable *pChild;
SerializableList::compatibility_iterator node = m_lstChildItems.GetFirst();
while(node)
{
pChild = node->GetData();
if( !type || pChild->IsKindOf(type) ) list.Append(pChild);
if( mode == searchDFS ) pChild->GetChildrenRecursively(type, list);
node = node->GetNext();
}
if( mode == searchBFS )
{
node = m_lstChildItems.GetFirst();
while(node)
{
node->GetData()->GetChildrenRecursively(type, list);
node = node->GetNext();
}
}
}
void udCPPClassElementProcessor::ProcessClassDeclaration(wxSFShapeBase* element)
{
udLanguage *pLang = m_pParentGenerator->GetActiveLanguage();
udClassAlgorithm *pAlg = (udClassAlgorithm*) m_pParentGenerator->GetActiveAlgorithm();
// get base classes if exists
ShapeList lstBases;
umlClassDiagram::GetBaseClasses( (umlClassItem*)element, lstBases );
int nTemplateIndex = 0;
wxString sBases;
for( ShapeList::iterator it = lstBases.begin(); it != lstBases.end(); ++it )
{
if( it != lstBases.begin() ) sBases << wxT(", ");
sBases << pLang->MakeValidIdentifier( udPROJECT::GetDiagramElement(*it)->GetName() );
// add template parameter if exists
umlClassTemplateItem *pTemplate = wxDynamicCast( *it, umlClassTemplateItem );
if( pTemplate )
{
// find corespondent template binding connection
ShapeList lstConnections;
element->GetShapeManager()->GetAssignedConnections( element, CLASSINFO(umlTemplateBindItem), wxSFShapeBase::lineSTARTING, lstConnections );
if( !lstConnections.IsEmpty() )
{
// append bind type to the base name
udTemplateBindElementItem *pBindElement = wxDynamicCast( udPROJECT::GetDiagramElement( lstConnections.Item(nTemplateIndex)->GetData() ), udTemplateBindElementItem );
if( pBindElement )
{
sBases << wxT("<") << pBindElement->GetBindType() << wxT(">");
}
}
nTemplateIndex++;
}
}
udClassElementItem *pClass = (udClassElementItem*) udPROJECT::GetDiagramElement(element);
//generate comment if requested
pLang->WriteCodeBlocks( udGenerator::GetComment( pClass, pLang) );
// write template definition if needed
udClassTemplateElementItem *pClassTempl = wxDynamicCast( pClass, udClassTemplateElementItem );
if( pClassTempl )
{
pLang->WriteCodeBlocks( wxT("template <typename ") + pClassTempl->GetTemplateName() + wxT(">") );
}
// generate class declaration
pLang->ClassDeclCmd( pLang->MakeValidIdentifier( pClass->GetName() ), sBases );
pLang->BeginCmd();
// declare class members
int nAccessType = 0;
wxClassInfo *pPrevType;
SerializableList lstMembers;
ShapeList lstAssocs;
while( pLang->GetAccessTypeString( (udLanguage::ACCESSTYPE) nAccessType ) != wxEmptyString )
{
pLang->WriteCodeBlocks( pLang->GetAccessTypeString( (udLanguage::ACCESSTYPE) nAccessType ) + wxT(":") );
pLang->IncIndentation();
lstMembers.Clear();
lstAssocs.Clear();
pPrevType = NULL;
// process associations
umlClassDiagram::GetClassAssociations( (umlClassItem*) element, CLASSINFO(wxSFLineShape), wxSFLineShape::lineSTARTING, (udLanguage::ACCESSTYPE) nAccessType, lstAssocs );
for( ShapeList::iterator it = lstAssocs.begin(); it != lstAssocs.end(); ++it )
{
udElementProcessor *pProcessor = pAlg->GetElementProcessor( (*it)->GetClassInfo()->GetClassName() );
if( pProcessor ) pProcessor->ProcessElement( *it );
}
// process class members
umlClassDiagram::GetClassMembers( (umlClassItem*) element, CLASSINFO(udMemberDataLinkItem), (udLanguage::ACCESSTYPE) nAccessType, lstMembers);
umlClassDiagram::GetClassMembers( (umlClassItem*) element, CLASSINFO(udMemberFunctionLinkItem), (udLanguage::ACCESSTYPE) nAccessType, lstMembers);
for( SerializableList::iterator it = lstMembers.begin(); it != lstMembers.end(); ++it )
{
if( pPrevType && ((*it)->GetClassInfo() != pPrevType) ) pLang->NewLine();
// generate comment
pLang->WriteCodeBlocks( udGenerator::GetComment( ((udCodeLinkItem*)*it)->GetOriginal(), pLang ) );
// generate function decl
pLang->WriteCodeBlocks( ((udCodeLinkItem*)*it)->ToString( udCodeItem::cfDECLARATION, pLang ) );
pPrevType = (*it)->GetClassInfo();
}
nAccessType++;
pLang->DecIndentation();
pLang->NewLine();
}
// insert class ending with delimiter
pLang->PushCode();
pLang->EndCmd();
wxString sEnding = pLang->GetCodeBuffer().Trim() + pLang->Delimiter();
pLang->PopCode();
pLang->WriteCodeBlocks( sEnding );
pLang->NewLine();
}
void DatabaseCanvas::OnRightDown(wxMouseEvent &event)
{
FieldShape *erdField = NULL;
MyErdTable *erdTable = NULL;
ConstraintSign *erdSign = NULL;
wxPoint pt = event.GetPosition();
ShapeList selection;
this->GetSelectedShapes( selection );
for( ShapeList::iterator it = selection.begin(); it != selection.end(); ++it )
{
MyErdTable *table = wxDynamicCast( (*it), MyErdTable );
if( table )
m_realSelectedShape = table;
}
wxMenu mnu;
int allSelected = 0;
mnu.Bind( wxEVT_COMMAND_MENU_SELECTED, &DatabaseCanvas::OnDropTable, this, wxID_DROPOBJECT );
mnu.Bind( wxEVT_COMMAND_MENU_SELECTED, &DatabaseCanvas::OnDropTable, this, wxID_TABLECLOSE );
m_selectedShape = GetShapeUnderCursor();
ViewType type = dynamic_cast<DrawingView *>( m_view )->GetViewType();
if( m_selectedShape )
{
ShapeList list;
GetShapesAtPosition( pt, list );
if( type == DatabaseView )
if( m_selectedShape->IsKindOf( CLASSINFO( MyErdTable ) ) )
DeselectAll();
wxRect tableRect;
bool fieldSelected = false;
bool signSelected = false;
for( ShapeList::iterator it = list.begin(); it != list.end(); ++it )
{
MyErdTable *table = wxDynamicCast( (*it), MyErdTable );
if( table )
{
if( type == DatabaseView )
table->Select( true );
tableRect = table->GetBoundingBox();
erdTable = table;
}
else
{
FieldShape *field = wxDynamicCast( (*it), FieldShape );
if( field )
{
if( type == DatabaseView )
field->Select( true );
field->SetParentRect( tableRect );
fieldSelected = true;
erdField = field;
}
else
{
ConstraintSign *sign = wxDynamicCast( (*it), ConstraintSign );
if( sign )
{
if( type == DatabaseView )
sign->Select( true );
signSelected = true;
erdSign = sign;
}
}
}
}
if( type == DatabaseView && list.empty() )
{
MyErdTable *table = wxDynamicCast( m_selectedShape, MyErdTable );
if( table )
{
table->Select( true );
}
else
{
table = wxDynamicCast( m_selectedShape->GetParentShape()->GetParentShape(), MyErdTable );
table->Select( true );
}
}
if( type == QueryView )
{
size_t selectedCount = 0;
SerializableList tableFields;
if( erdTable )
{
erdTable->GetChildrenRecursively( CLASSINFO( FieldShape ), tableFields );
SerializableList::compatibility_iterator node = tableFields.GetFirst();
while( node )
{
FieldShape *shape = dynamic_cast<FieldShape *>( node->GetData() );
if( shape->IsSelected() )
selectedCount++;
node = node->GetNext();
}
if( selectedCount == const_cast<DatabaseTable &>( erdTable->GetTable() ).GetFields().size() )
allSelected = 1;
else
allSelected = -1;
}
}
Refresh();
if( type == DatabaseView )
{
if( !fieldSelected && !signSelected )
{
mnu.Append( wxID_TABLECLOSE, _( "Close" ), _( "Close Table" ), false );
mnu.AppendSeparator();
mnu.Append( wxID_TABLEALTERTABLE, _( "Alter Table" ), _( "Alter Table" ), false );
mnu.Append( wxID_PROPERTIES, _( "Properties..." ), _( "Table Properties" ), false );
mnu.AppendSeparator();
wxMenu *newObjectMenu = new wxMenu();
newObjectMenu->Append( wxID_OBJECTNEWINDEX, _( "Index..." ), _( "New Index" ) );
newObjectMenu->Append( wxID_OBJECTNEWFF, _( "Foreign Key..." ), _( "New Foreign Key" ) );
mnu.AppendSubMenu( newObjectMenu, _( "New" ), _( "New" ) );
mnu.AppendSeparator();
mnu.Append( wxID_DROPOBJECT, _( "Drop Table" ), _( "Drop Table" ), false );
mnu.AppendSeparator();
mnu.Append( wxID_TABLEEDITDATA, _( "Edit Data" ), _( "Edit Data" ), false );
mnu.AppendSeparator();
mnu.Append( wxID_TABLEDATATRANSFER, _( "Data Transfer" ), _( "Data Transfer" ), false );
mnu.AppendSeparator();
mnu.Append( wxID_TABLEPRINTDEFINITION, _( "Print Definition" ), _( "Print Definition" ), false );
}
else if( fieldSelected )
{
mnu.Append( wxID_FIELDDEFINITION, _( "Definition" ), _( "Edit definition of selected object" ), false );
mnu.Append( wxID_FIELDPROPERTIES, _( "Properties..." ), _( "Show properties of selected object" ), false );
}
else
{
mnu.Append( wxID_FKDEFINITION, _( "Definition..." ), _( "Edit definition of selected object" ) );
mnu.Append( wxID_FKOPENREFTABLE, _( "Open Referenced Table" ), _( "Open Referenced Table" ) );
mnu.Append( wxID_DROPOBJECT, _( "Drop Foreign Key..." ), _( "Drop Foreign Key for the table" ) );
}
}
else
{
if( erdTable )
{
mnu.Append( wxID_SELECTALLFIELDS, _( "Select All" ), _( "Select all columns for display" ) );
mnu.Append( wxID_DESELECTALLFIELDS, _("Deselect All" ), _( "Deselect all columns for display" ) );
mnu.Append( wxID_TABLECLOSE, _( "Close" ), _( "Close Table" ), false );
if( !allSelected )
mnu.FindItem( wxID_DESELECTALLFIELDS )->Enable( false );
else if( allSelected == 1 )
mnu.FindItem( wxID_SELECTALLFIELDS )->Enable( false );
}
}
}
else
{
if( type == DatabaseView )
{
mnu.Append( wxID_SELECTTABLE, _( "Select Table..." ), _( "Select Table" ), false );
mnu.Append( wxID_VIEWARRANGETABLES, _( "Arramge Tables..." ), _( "Arrange Tables" ), false );
mnu.AppendCheckItem( wxID_VIEWSHOWCOMMENTS, _( "Show Comments" ), _( "Show Comments" ) );
mnu.AppendCheckItem( wxID_VIEWSHOWINDEXKEYS, _( "Show Index Keys" ), _( "Show Index Keys" ) );
mnu.AppendCheckItem( wxID_VIEWSHOWINTEGRITY, _( "Show Referential Integrity" ), _( "Show Referential Integrity" ) );
if( m_showComments )
mnu.Check( wxID_VIEWSHOWCOMMENTS, true );
if( m_showIndexKeys )
mnu.Check( wxID_VIEWSHOWINDEXKEYS, true );
if( m_showIntegrity )
mnu.Check( wxID_VIEWSHOWINTEGRITY, true );
}
else
{
mnu.Append( wxID_SELECTTABLE, _( "Select Table..." ), _( "Select addtional tables for the query" ) );
mnu.Append( wxID_ARRANGETABLES, _( "Arrange Tables" ), _( "Arrange Tables" ) );
wxMenu *showMenu = new wxMenu();
showMenu->AppendCheckItem( wxID_SHOWDATATYPES, _( "Datatypes" ), _( "Datatypes" ) );
showMenu->AppendCheckItem( wxID_SHOWLABELS, _( "Labels" ), _( "Labels" ) );
showMenu->AppendCheckItem( wxID_VIEWSHOWCOMMENTS, _( "Comments" ), _( "Comments" ) );
showMenu->AppendCheckItem( wxID_SHOWSQLTOOLBOX, _( "SQL Toolbox" ), _( "SQL Toolbox" ) );
mnu.AppendSubMenu( showMenu, _( "Show" ) );
if( m_showDataTypes )
showMenu->Check( wxID_SHOWDATATYPES, true );
if( m_showLabels )
showMenu->Check( wxID_SHOWLABELS, true );
if( m_showComments )
showMenu->Check( wxID_VIEWSHOWCOMMENTS, true );
if( m_showToolBox )
showMenu->Check( wxID_SHOWSQLTOOLBOX, true );
}
}
int rc = GetPopupMenuSelectionFromUser( mnu, pt );
if( rc == wxID_NONE && erdField )
{
// if( field )
{
erdField->Select( false );
erdTable->GetFieldGrid()->Refresh();
erdTable->Refresh();
}
}
else
{
if( erdField )
{
erdField->Select( false );
erdTable->GetFieldGrid()->Refresh();
erdTable->Refresh();
}
wxCommandEvent evt( wxEVT_MENU, rc );
if( erdField )
evt.SetEventObject( erdField );
else
evt.SetEventObject( erdTable );
if( rc == wxID_SHOWSQLTOOLBOX || rc == wxID_VIEWSHOWCOMMENTS )
GetEventHandler()->ProcessEvent( evt );
else
m_view->ProcessEvent( evt );
}
}
void udCPPClassElementProcessor::ProcessClassDefinition(wxSFShapeBase* element)
{
udLanguage *pLang = m_pParentGenerator->GetActiveLanguage();
int nAccessType = 0;
udFunctionItem *pFcn;
SerializableList lstMembers;
while( pLang->GetAccessTypeString( (udLanguage::ACCESSTYPE) nAccessType ) != wxEmptyString )
{
lstMembers.Clear();
umlClassDiagram::GetClassMembers( (umlClassItem*) element, CLASSINFO(udMemberFunctionLinkItem), (udLanguage::ACCESSTYPE) nAccessType, lstMembers);
if( !lstMembers.IsEmpty() )
{
pLang->SingleLineCommentCmd( pLang->GetAccessTypeString( (udLanguage::ACCESSTYPE) nAccessType ) + wxT(" function members of '") + udPROJECT::GetDiagramElement(element)->GetName() + wxT("' class") );
}
for( SerializableList::iterator it = lstMembers.begin(); it != lstMembers.end(); ++it )
{
pFcn = (udFunctionItem*)((udCodeLinkItem*)*it)->GetOriginal();
// generate non-abstract functions only
if( pFcn->GetFunctionModifer() == udLanguage::FM_ABSTRACT ) continue;
// write template definition if needed
udClassTemplateElementItem *pClassTempl = wxDynamicCast( udPROJECT::GetDiagramElement(element), udClassTemplateElementItem );
if( pClassTempl )
{
pLang->WriteCodeBlocks( wxT("template <typename ") + pClassTempl->GetTemplateName() + wxT(">") );
}
if( pFcn->GetImplementation() == uddvFUNCTION_USERIMPLEMENTATION )
{
pLang->WriteCodeBlocks( pFcn->ToString( udCodeItem::cfDEFINITION, pLang ) );
pLang->BeginCmd();
if( pFcn->IsKindOf( CLASSINFO(udConstructorFunctionItem) ) ) ProcessClassMembers( element );
/*if( pFcn->GetCode().IsEmpty() ) pLang->WriteCodeBlocks( pLang->Dummy() );
else
{*/
// insert code marks here needed for code synchronization
pLang->SingleLineCommentCmd( udGenerator::GetBeginCodeMark( pFcn ) );
pLang->WriteCodeBlocks( pFcn->GetCode() );
pLang->SingleLineCommentCmd( udGenerator::GetEndCodeMark( pFcn ) );
/*}*/
pLang->EndCmd();
pLang->NewLine();
}
}
nAccessType++;
}
}
void wxSFDiagramManager::_DeserializeObjects(xsSerializable* parent, wxXmlNode* node)
{
wxSFShapeBase *pShape;
wxXS::IntArray arrNewIDs;
SerializableList lstForUpdate;
wxXmlNode* shapeNode = node->GetChildren();
while(shapeNode)
{
if(shapeNode->GetName() == wxT("object"))
{
#if wxVERSION_NUMBER < 2900
pShape = AddShape((wxSFShapeBase*)wxCreateDynamicObject(shapeNode->GetPropVal(wxT("type"), wxT(""))), parent, wxPoint(0, 0), true, sfDONT_SAVE_STATE);
#else
pShape = AddShape((wxSFShapeBase*)wxCreateDynamicObject(shapeNode->GetAttribute(wxT("type"), wxT(""))), parent, wxPoint(0, 0), true, sfDONT_SAVE_STATE);
#endif
if(pShape)
{
// store new assigned ID
lstForUpdate.Append( pShape );
pShape->GetChildrenRecursively( NULL, lstForUpdate );
for( SerializableList::iterator it = lstForUpdate.begin(); it != lstForUpdate.end(); ++it )
{
arrNewIDs.Add( (*it)->GetId() );
}
// deserialize stored content
pShape->DeserializeObject(shapeNode);
// update handle in line shapes
if( pShape->IsKindOf( CLASSINFO(wxSFLineShape) ) )
{
pShape->CreateHandles();
m_lstLinesForUpdate.Append(pShape);
}
else if( pShape->IsKindOf( CLASSINFO(wxSFGridShape) ) )
{
m_lstGridsForUpdate.Append(pShape);
}
// store information about IDs' changes and re-assign shapes' IDs
int newId, i = 0;
for( SerializableList::iterator it = lstForUpdate.begin(); it != lstForUpdate.end(); ++it )
{
newId = arrNewIDs[i++];
if( newId != (*it)->GetId() )
{
m_lstIDPairs.Append( new IDPair((*it)->GetId(), newId) );
(*it)->SetId( newId );
}
}
// deserialize child objects
_DeserializeObjects(pShape, shapeNode);
arrNewIDs.Clear();
lstForUpdate.Clear();
}
else
{
// there are some unsupported shapes so the diagrams must be cleared because of possible damage
RemoveAll();
m_lstLinesForUpdate.Clear();
m_lstGridsForUpdate.Clear();
wxMessageBox( wxT("Deserialization couldn't be completed because not of all shapes are accepted."), wxT("wxShapeFramework"), wxOK | wxICON_WARNING );
return;
}
}
else if(shapeNode->GetName() == m_sRootName + wxT("_properties"))
{
m_pRoot->DeserializeObject(shapeNode->GetChildren());
}
shapeNode = shapeNode->GetNext();
}
}
void TableSettings::OnColumnChanged(wxDataViewEvent& event)
{
Column *col = reinterpret_cast<Column*>(m_dvColumns->GetItemData( event.GetItem() ) );
if( col ) {
wxVariant val;
event.GetModel()->GetValue( val, event.GetItem(), event.GetColumn() );
if( ! val.IsNull() ) {
switch( event.GetColumn() ) {
case 0: {
// rename local columns in keys
SerializableList keys;
GetConstraints( keys, col->GetName() );
for(SerializableList::iterator it = keys.begin(); it != keys.end(); ++it ) {
Constraint *key = (Constraint*) *it;
if( key->GetType() == Constraint::primaryKey ) key->SetName( wxT("PK_") + val.GetString() );
key->SetLocalColumn( val.GetString() );
}
// rename table column
col->SetName( val.GetString() );
break;
}
case 1: {
col->SetType( m_pDbAdapter->GetDbTypeByName( val.GetString() ) );
break;
}
case 2: {
long s1, s2;
s1 = s2 = 0;
wxSscanf( val.GetString(), wxT("%ld,%ld"), &s1, &s2 );
IDbType *type = col->GetType();
if( type->HaveSize() ) type->SetSize( s1 );
else {
m_infobar->ShowMessage( wxT("This data type doesn't support size definition."), wxICON_WARNING );
Refresh();
}
if( type->HaveSize2() ) type->SetSize2( s1 );
else {
m_infobar->ShowMessage( wxT("This data type doesn't support size definition."), wxICON_WARNING );
Refresh();
}
break;
}
case 3: {
IDbType *type = col->GetType();
if( type->HaveNotNull() ) type->SetNotNull( val.GetBool() );
else {
m_infobar->ShowMessage( wxT("This data type doesn't support NOT NULL feature."), wxICON_WARNING );
Refresh();
}
break;
}
case 4: {
IDbType *type = col->GetType();
if( type->HaveAutoIncrement() ) type->SetAutoIncrement( val.GetBool() );
else {
m_infobar->ShowMessage( wxT("This data type doesn't support AUTOINCREMENT feature."), wxICON_WARNING );
Refresh();
}
break;
}
case 5: {
Constraint *key = GetConstraint( Constraint::primaryKey, col->GetName() );
if( key ) {
// remove primary key if exists
m_lstKeys.DeleteObject( key );
delete key;
} else {
// create new primary key
key = new Constraint( wxT("PK_") + col->GetName(),
col->GetName(),
Constraint::primaryKey,
Constraint::noAction,
Constraint::noAction );
m_lstKeys.Append( key );
}
break;
}
}
}
}
event.Skip();
UpdateView();
}
