TDE
/
tdesdk
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/tdesdk
0
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '508a49f9ef'
${ noResults }
tdesdk/umbrello/umbrello/umllistviewitem.cpp

697 lines
24 KiB
Raw Blame History

/***************************************************************************
* *
* 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. *
* *
* copyright (C) 2002-2007 *
* Umbrello UML Modeller Authors <uml-devel@uml.sf.net> *
***************************************************************************/
// own header
#include "umllistviewitem.h"
// system includes
#include <cstdlib>
// qt/kde includes
#include <tqfile.h>
#include <tqregexp.h>
#include <tdeapplication.h>
#include <tdelocale.h>
#include <tdemessagebox.h>
#include <kdebug.h>
// app includes
#include "folder.h"
#include "classifier.h"
#include "template.h"
#include "attribute.h"
#include "operation.h"
#include "umldoc.h"
#include "umllistview.h"
#include "umlobjectlist.h"
#include "umlview.h"
#include "model_utils.h"
#include "uniqueid.h"
#include "uml.h"
UMLListView* UMLListViewItem::s_pListView = 0;
UMLListViewItem::UMLListViewItem( UMLListView * parent, const TQString &name,
Uml::ListView_Type t, UMLObject* o)
: TQListViewItem(parent, name) {
init(parent);
m_Type = t;
m_pObject = o;
if (o)
m_nId = o->getID();
setIcon(Uml::it_Home);
setText( name );
setRenameEnabled( 0, false );
}
UMLListViewItem::UMLListViewItem(UMLListView * parent)
: TQListViewItem(parent) {
init(parent);
if (parent == NULL)
kDebug() << "UMLListViewItem constructor called with a NULL listview parent" << endl;
}
UMLListViewItem::UMLListViewItem(UMLListViewItem * parent)
: TQListViewItem(parent) {
init();
}
UMLListViewItem::UMLListViewItem(UMLListViewItem * parent, const TQString &name, Uml::ListView_Type t,UMLObject*o)
: TQListViewItem(parent, name) {
init();
m_Type = t;
m_pObject = o;
if( !o ) {
m_nId = Uml::id_None;
updateFolder();
} else {
UMLClassifierListItem *umlchild = dynamic_cast<UMLClassifierListItem*>(o);
if (umlchild)
parent->addClassifierListItem(umlchild, this);
updateObject();
m_nId = o->getID();
}
setRenameEnabled( 0, !Model_Utils::typeIsRootView(t) );
setText( name );
}
UMLListViewItem::UMLListViewItem(UMLListViewItem * parent, const TQString &name, Uml::ListView_Type t,Uml::IDType id)
: TQListViewItem(parent, name) {
init();
m_Type = t;
m_nId = id;
switch (m_Type) {
case Uml::lvt_Collaboration_Diagram:
setIcon(Uml::it_Diagram_Collaboration);
break;
case Uml::lvt_Class_Diagram:
setIcon(Uml::it_Diagram_Class);
break;
case Uml::lvt_State_Diagram:
setIcon(Uml::it_Diagram_State);
break;
case Uml::lvt_Activity_Diagram:
setIcon(Uml::it_Diagram_Activity);
break;
case Uml::lvt_Sequence_Diagram:
setIcon(Uml::it_Diagram_Sequence);
break;
case Uml::lvt_Component_Diagram:
setIcon(Uml::it_Diagram_Component);
break;
case Uml::lvt_Deployment_Diagram:
setIcon(Uml::it_Diagram_Deployment);
break;
case Uml::lvt_UseCase_Diagram:
setIcon(Uml::it_Diagram_Usecase);
break;
default:
setIcon(Uml::it_Diagram);
}
/*
Constructor also used by folder so just make sure we don't need to
to set pixmap to folder. doesn't hurt diagrams.
*/
updateFolder();
setText( name );
setRenameEnabled( 0, true );
}
UMLListViewItem::~UMLListViewItem() {}
void UMLListViewItem::init(UMLListView * parent) {
m_Type = Uml::lvt_Unknown;
m_bCreating = false;
m_pObject = NULL;
m_nId = Uml::id_None;
m_nChildren = 0;
if (s_pListView == NULL && parent != NULL) {
kDebug() << "UMLListViewItem::init: s_pListView still NULL, setting it now "
<< endl;
s_pListView = parent;
}
}
Uml::ListView_Type UMLListViewItem::getType() const {
return m_Type;
}
void UMLListViewItem::addClassifierListItem(UMLClassifierListItem *child, UMLListViewItem *childItem) {
m_comap[child] = childItem;
}
void UMLListViewItem::deleteChildItem(UMLClassifierListItem *child) {
UMLListViewItem *childItem = findChildObject(child);
if (childItem == NULL) {
kError() << "UMLListViewItem::deleteChildItem(" << child->getName()
<< "): child listview item not found" << endl;
return;
}
m_comap.remove(child);
delete childItem;
}
Uml::IDType UMLListViewItem::getID() const {
if (m_pObject)
return m_pObject->getID();
return m_nId;
}
void UMLListViewItem::setID(Uml::IDType id) {
if (m_pObject) {
Uml::IDType oid = m_pObject->getID();
if (id != Uml::id_None && oid != id)
kDebug() << "UMLListViewItem::setID: new id " << ID2STR(id)
<< " does not agree with object id " << ID2STR(oid) << endl;
}
m_nId = id;
}
bool UMLListViewItem::isOwnParent(Uml::IDType listViewItemID) {
TQListViewItem *lvi = (TQListViewItem*)s_pListView->findItem(listViewItemID);
if (lvi == NULL) {
kError() << "UMLListViewItem::isOwnParent: ListView->findItem("
<< ID2STR(listViewItemID) << ") returns NULL" << endl;
return true;
}
for (TQListViewItem *self = (TQListViewItem*)this; self; self = self->parent()) {
if (lvi == self)
return true;
}
return false;
}
void UMLListViewItem::updateObject() {
if( m_pObject == NULL )
return;
Uml::Visibility scope = m_pObject->getVisibility();
Uml::Object_Type ot = m_pObject->getBaseType();
TQString modelObjText = m_pObject->getName();
if (Model_Utils::isClassifierListitem(ot)) {
UMLClassifierListItem *pNarrowed = static_cast<UMLClassifierListItem*>(m_pObject);
modelObjText = pNarrowed->toString(Uml::st_SigNoVis);
}
setText(modelObjText);
Uml::Icon_Type icon = Uml::it_Home;
switch (ot) {
case Uml::ot_Package:
if (m_pObject->getStereotype() == "subsystem")
icon = Uml::it_Subsystem;
else
icon = Uml::it_Package;
break;
/*
case Uml::ot_Folder:
{
Uml::ListView_Type lvt = Model_Utils::convert_OT_LVT(m_pObject);
icon = Model_Utils::convert_LVT_IT(lvt);
}
break;
*/
case Uml::ot_Operation:
if (scope == Uml::Visibility::Public)
icon = Uml::it_Public_Method;
else if (scope == Uml::Visibility::Private)
icon = Uml::it_Private_Method;
else if (scope == Uml::Visibility::Implementation)
icon = Uml::it_Private_Method;
else
icon = Uml::it_Protected_Method;
break;
case Uml::ot_Attribute:
case Uml::ot_EntityAttribute:
if (scope == Uml::Visibility::Public)
icon = Uml::it_Public_Attribute;
else if (scope == Uml::Visibility::Private)
icon = Uml::it_Private_Attribute;
else if (scope == Uml::Visibility::Implementation)
icon = Uml::it_Private_Attribute;
else
icon = Uml::it_Protected_Attribute;
break;
default:
icon = Model_Utils::convert_LVT_IT(m_Type);
break;
}//end switch
if (icon)
setIcon(icon);
}
void UMLListViewItem::updateFolder() {
Uml::Icon_Type icon = Model_Utils::convert_LVT_IT(m_Type);
if (icon) {
if (Model_Utils::typeIsFolder(m_Type))
icon = (Uml::Icon_Type)((int)icon + (int)isOpen());
setIcon(icon);
}
}
void UMLListViewItem::setOpen( bool open ) {
TQListViewItem::setOpen( open );
updateFolder();
}
void UMLListViewItem::setText(const TQString &newText) {
m_Label = newText;
TQListViewItem::setText(0, newText);
}
TQString UMLListViewItem::getText() const {
return m_Label;
}
void UMLListViewItem::setIcon(Uml::Icon_Type iconType) {
setPixmap(0, s_pListView->getPixmap(iconType));
}
void UMLListViewItem::okRename( int col ) {
TQListViewItem::okRename( col );
UMLDoc* doc = s_pListView->getDocument();
if (m_bCreating) {
m_bCreating = false;
TQString savedLabel = m_Label;
m_Label = text(col);
if ( s_pListView->itemRenamed( this, col ) ) {
s_pListView->ensureItemVisible(this);
doc->setModified(true);
} else {
delete this;
}
return;
}
TQString newText = text( col );
if ( newText == m_Label ) {
return;
}
if( newText.isEmpty() ) {
cancelRenameWithMsg();
return;
}
switch( m_Type ) {
case Uml::lvt_UseCase:
case Uml::lvt_Actor:
case Uml::lvt_Class:
case Uml::lvt_Package:
case Uml::lvt_UseCase_Folder:
case Uml::lvt_Logical_Folder:
case Uml::lvt_Component_Folder:
case Uml::lvt_Deployment_Folder:
case Uml::lvt_EntityRelationship_Folder:
case Uml::lvt_Interface:
case Uml::lvt_Datatype:
case Uml::lvt_Enum:
case Uml::lvt_EnumLiteral:
case Uml::lvt_Subsystem:
case Uml::lvt_Component:
case Uml::lvt_Node:
if (m_pObject == NULL || !doc->isUnique(newText)) {
cancelRenameWithMsg();
return;
}
m_pObject -> setName( newText );
doc->setModified(true);
m_Label = newText;
break;
case Uml::lvt_Operation:
{
if (m_pObject == NULL) {
cancelRenameWithMsg();
return;
}
UMLOperation *op = static_cast<UMLOperation*>(m_pObject);
UMLClassifier *parent = static_cast<UMLClassifier *>( op -> parent() );
Model_Utils::OpDescriptor od;
Model_Utils::Parse_Status st = Model_Utils::parseOperation(newText, od, parent);
if (st == Model_Utils::PS_OK) {
// TODO: Check that no operation with the exact same profile exists.
op->setName( od.m_name );
op->setType( od.m_pReturnType );
UMLAttributeList parmList = op->getParmList();
const unsigned newParmListCount = parmList.count();
if (newParmListCount > od.m_args.count()) {
// Remove parameters at end of of list that no longer exist.
for (unsigned i = od.m_args.count(); i < newParmListCount; i++) {
UMLAttribute *a = parmList.at(i);
op->removeParm(a, false);
}
}
Model_Utils::NameAndType_ListIt lit = od.m_args.begin();
for (unsigned i = 0; lit != od.m_args.end(); ++lit, ++i) {
const Model_Utils::NameAndType& nm_tp = *lit;
UMLAttribute *a;
if (i < newParmListCount) {
a = parmList.at(i);
} else {
a = new UMLAttribute(op);
a->setID( UniqueID::gen() );
}
a->setName(nm_tp.m_name);
a->setType(nm_tp.m_type);
a->setParmKind(nm_tp.m_direction);
a->setInitialValue(nm_tp.m_initialValue);
if (i >= newParmListCount) {
op->addParm(a);
}
}
m_Label = op->toString(Uml::st_SigNoVis);
} else {
KMessageBox::error( kapp->mainWidget(),
Model_Utils::psText(st),
i18n("Rename canceled") );
}
TQListViewItem::setText(0, m_Label);
break;
}
case Uml::lvt_Attribute:
case Uml::lvt_EntityAttribute:
{
if (m_pObject == NULL) {
cancelRenameWithMsg();
return;
}
UMLClassifier *parent = static_cast<UMLClassifier*>(m_pObject->parent());
Model_Utils::NameAndType nt;
Uml::Visibility vis;
Model_Utils::Parse_Status st;
st = Model_Utils::parseAttribute(newText, nt, parent, &vis);
if (st == Model_Utils::PS_OK) {
UMLObject *exists = parent->findChildObject(newText);
if (exists) {
cancelRenameWithMsg();
return;
}
m_pObject->setName(nt.m_name);
UMLAttribute *pAtt = static_cast<UMLAttribute*>(m_pObject);
pAtt->setType(nt.m_type);
pAtt->setVisibility(vis);
pAtt->setParmKind(nt.m_direction);
pAtt->setInitialValue(nt.m_initialValue);
m_Label = pAtt->toString(Uml::st_SigNoVis);
} else {
KMessageBox::error( kapp->mainWidget(),
Model_Utils::psText(st),
i18n("Rename canceled") );
}
TQListViewItem::setText(0, m_Label);
break;
}
case Uml::lvt_Template:
{
if (m_pObject == NULL) {
cancelRenameWithMsg();
return;
}
UMLClassifier *parent = static_cast<UMLClassifier*>(m_pObject->parent());
Model_Utils::NameAndType nt;
Model_Utils::Parse_Status st = Model_Utils::parseTemplate(newText, nt, parent);
if (st == Model_Utils::PS_OK) {
UMLObject *exists = parent->findChildObject(newText);
if (exists) {
cancelRenameWithMsg();
return;
}
m_pObject->setName(nt.m_name);
UMLTemplate *tmpl = static_cast<UMLTemplate*>(m_pObject);
tmpl->setType(nt.m_type);
m_Label = tmpl->toString(Uml::st_SigNoVis);
} else {
KMessageBox::error( kapp->mainWidget(),
Model_Utils::psText(st),
i18n("Rename canceled") );
}
TQListViewItem::setText(0, m_Label);
break;
}
case Uml::lvt_UseCase_Diagram:
case Uml::lvt_Class_Diagram:
case Uml::lvt_Sequence_Diagram:
case Uml::lvt_Collaboration_Diagram:
case Uml::lvt_State_Diagram:
case Uml::lvt_Activity_Diagram:
case Uml::lvt_Component_Diagram:
case Uml::lvt_Deployment_Diagram:
{
UMLView *view = doc -> findView( getID() );
if (view == NULL) {
cancelRenameWithMsg();
return;
}
UMLView *anotherView = doc -> findView( view->getType(), newText );
if( anotherView && anotherView -> getID() == getID() )
anotherView = 0;
if (anotherView) {
cancelRenameWithMsg();
return;
}
view->setName( newText );
setText(newText);
doc->signalDiagramRenamed(view);
break;
}
default:
KMessageBox::error( kapp->mainWidget() ,
i18n("Renaming an item of listview type %1 is not yet implemented.").arg(m_Type),
i18n("Function Not Implemented") );
TQListViewItem::setText(0, m_Label);
break;
}
doc->setModified(true);
}
void UMLListViewItem::cancelRenameWithMsg() {
KMessageBox::error( kapp->mainWidget() ,
i18n("The name you entered was invalid.\nRenaming process has been canceled."),
i18n("Name Not Valid") );
TQListViewItem::setText(0, m_Label);
}
void UMLListViewItem::cancelRename(int col) {
TQListViewItem::cancelRename(col);
if (m_bCreating) {
s_pListView->cancelRename(this);
}
}
// Sort the listview items by type and position within the corresponding list
// of UMLObjects. If the item does not have an UMLObject then place it last.
int UMLListViewItem::compare(TQListViewItem *other, int col, bool ascending) const
{
UMLListViewItem *ulvi = static_cast<UMLListViewItem*>(other);
Uml::ListView_Type ourType = getType();
Uml::ListView_Type otherType = ulvi->getType();
if ( ourType < otherType )
return -1;
if ( ourType > otherType )
return 1;
// ourType == otherType
const bool subItem = Model_Utils::typeIsClassifierList(ourType);
const int alphaOrder = key(col, ascending).compare(other->key(col, ascending));
int retval = 0;
TQString dbgPfx = "compare(type=" + TQString::number((int)ourType)
+ ", self=" + getText() + ", other=" + ulvi->getText()
+ "): return ";
UMLObject *otherObj = ulvi->getUMLObject();
if (m_pObject == NULL) {
retval = (subItem ? 1 : alphaOrder);
#ifdef DEBUG_LVITEM_INSERTION_ORDER
kDebug() << dbgPfx << retval << " because (m_pObject==NULL)" << endl;
#endif
return retval;
}
if (otherObj == NULL) {
retval = (subItem ? -1 : alphaOrder);
#ifdef DEBUG_LVITEM_INSERTION_ORDER
kDebug() << dbgPfx << retval << " because (otherObj==NULL)" << endl;
#endif
return retval;
}
UMLClassifier *ourParent = dynamic_cast<UMLClassifier*>(m_pObject->parent());
UMLClassifier *otherParent = dynamic_cast<UMLClassifier*>(otherObj->parent());
if (ourParent == NULL) {
retval = (subItem ? 1 : alphaOrder);
#ifdef DEBUG_LVITEM_INSERTION_ORDER
kDebug() << dbgPfx << retval << " because (ourParent==NULL)" << endl;
#endif
return retval;
}
if (otherParent == NULL) {
retval = (subItem ? -1 : alphaOrder);
#ifdef DEBUG_LVITEM_INSERTION_ORDER
kDebug() << dbgPfx << retval << " because (otherParent==NULL)" << endl;
#endif
return retval;
}
if (ourParent != otherParent) {
retval = (subItem ? 0 : alphaOrder);
#ifdef DEBUG_LVITEM_INSERTION_ORDER
kDebug() << dbgPfx << retval << " because (ourParent != otherParent)" << endl;
#endif
return retval;
}
UMLClassifierListItem *thisUmlItem = dynamic_cast<UMLClassifierListItem*>(m_pObject);
UMLClassifierListItem *otherUmlItem = dynamic_cast<UMLClassifierListItem*>(otherObj);
if (thisUmlItem == NULL) {
retval = (subItem ? 1 : alphaOrder);
#ifdef DEBUG_LVITEM_INSERTION_ORDER
kDebug() << dbgPfx << retval << " because (thisUmlItem==NULL)" << endl;
#endif
return retval;
}
if (otherUmlItem == NULL) {
retval = (subItem ? -1 : alphaOrder);
#ifdef DEBUG_LVITEM_INSERTION_ORDER
kDebug() << dbgPfx << retval << " because (otherUmlItem==NULL)" << endl;
#endif
return retval;
}
UMLClassifierListItemList items = ourParent->getFilteredList(thisUmlItem->getBaseType());
int myIndex = items.findRef(thisUmlItem);
int otherIndex = items.findRef(otherUmlItem);
if (myIndex < 0) {
retval = (subItem ? -1 : alphaOrder);
kError() << dbgPfx << retval << " because (myIndex < 0)" << endl;
return retval;
}
if (otherIndex < 0) {
retval = (subItem ? 1 : alphaOrder);
kError() << dbgPfx << retval << " because (otherIndex < 0)" << endl;
return retval;
}
return (myIndex < otherIndex ? -1 : myIndex > otherIndex ? 1 : 0);
}
UMLListViewItem* UMLListViewItem::deepCopy(UMLListViewItem *newParent) {
TQString nm = getText();
Uml::ListView_Type t = getType();
UMLObject *o = getUMLObject();
UMLListViewItem* newItem;
if (o)
newItem = new UMLListViewItem(newParent, nm, t, o);
else
newItem = new UMLListViewItem(newParent, nm, t, m_nId);
UMLListViewItem *childItem = static_cast<UMLListViewItem*>(firstChild());
while (childItem) {
childItem->deepCopy(newItem);
childItem = static_cast<UMLListViewItem*>(childItem->nextSibling());
}
return newItem;
}
UMLListViewItem* UMLListViewItem::findUMLObject(const UMLObject *o) {
if (m_pObject == o)
return this;
UMLListViewItem *childItem = static_cast<UMLListViewItem*>(firstChild());
while (childItem) {
UMLListViewItem *inner = childItem->findUMLObject(o);
if (inner)
return inner;
childItem = static_cast<UMLListViewItem*>(childItem->nextSibling());
}
return NULL;
}
UMLListViewItem* UMLListViewItem::findChildObject(UMLClassifierListItem *cli) {
ChildObjectMap::iterator it = m_comap.find(cli);
if (it != m_comap.end()) {
return *it;
}
return NULL;
}
UMLListViewItem * UMLListViewItem::findItem(Uml::IDType id) {
if (getID() == id)
return this;
UMLListViewItem *childItem = static_cast<UMLListViewItem*>(firstChild());
while (childItem) {
UMLListViewItem *inner = childItem->findItem(id);
if (inner)
return inner;
childItem = static_cast<UMLListViewItem*>(childItem->nextSibling());
}
return NULL;
}
void UMLListViewItem::saveToXMI( TQDomDocument & qDoc, TQDomElement & qElement) {
TQDomElement itemElement = qDoc.createElement( "listitem" );
Uml::IDType id = getID();
TQString idStr = ID2STR(id);
//kDebug() << "UMLListViewItem::saveToXMI: id = " << idStr
// << ", type = " << m_Type << endl;
if (id != Uml::id_None)
itemElement.setAttribute( "id", idStr );
itemElement.setAttribute( "type", m_Type );
UMLFolder *extFolder = NULL;
if (m_pObject == NULL) {
if (! Model_Utils::typeIsDiagram(m_Type) && m_Type != Uml::lvt_View)
kError() << "UMLListViewItem::saveToXMI(" << m_Label
<< "): m_pObject is NULL" << endl;
itemElement.setAttribute( "label", m_Label );
} else if (m_pObject->getID() == Uml::id_None) {
if (m_Label.isEmpty()) {
kDebug() << "UMLListViewItem::saveToXMI(): Skipping empty item"
<< endl;
return;
}
kDebug() << "UMLListViewItem::saveToXMI(): saving local label "
<< m_Label << " because umlobject ID is not set" << endl;
itemElement.setAttribute( "label", m_Label );
} else if (m_pObject->getBaseType() == Uml::ot_Folder) {
extFolder = static_cast<UMLFolder*>(m_pObject);
if (!extFolder->getFolderFile().isEmpty()) {
itemElement.setAttribute("open", "0");
qElement.appendChild(itemElement);
return;
}
}
itemElement.setAttribute("open", isOpen());
TQDomElement folderRoot;
UMLListViewItem *childItem = static_cast<UMLListViewItem*>( firstChild() );
while (childItem) {
childItem->saveToXMI(qDoc, itemElement);
childItem = dynamic_cast<UMLListViewItem *> ( childItem->nextSibling() );
}
qElement.appendChild( itemElement );
}
bool UMLListViewItem::loadFromXMI(TQDomElement& qElement) {
TQString id = qElement.attribute( "id", "-1" );
TQString type = qElement.attribute( "type", "-1" );
TQString label = qElement.attribute( "label", "" );
TQString open = qElement.attribute( "open", "1" );
if (!label.isEmpty())
setText( label );
else if (id == "-1") {
kError() << "UMLListViewItem::loadFromXMI: Item of type "
<< type << " has neither ID nor label" << endl;
return false;
}
m_nChildren = qElement.childNodes().count();
m_nId = STR2ID(id);
if (m_nId != Uml::id_None)
m_pObject = s_pListView->getDocument()->findObjectById( m_nId );
m_Type = (Uml::ListView_Type)(type.toInt());
if (m_pObject)
updateObject();
setOpen( (bool)open.toInt() );
return true;
}
View Git Blame Copy Permalink