/** * Flush template parameters pending in m_templateParams to the klass. */ void CppTree2Uml::flushTemplateParams(UMLClassifier *klass) { if (m_templateParams.count()) { Model_Utils::NameAndType_ListIt it; for (it = m_templateParams.begin(); it != m_templateParams.end(); ++it) { const Model_Utils::NameAndType &nt = *it; uDebug() << "adding template param: " << nt.m_name; UMLTemplate *tmpl = klass->addTemplate(nt.m_name); tmpl->setType(nt.m_type); } m_templateParams.clear(); } }
/** * Reimplemented from UMLWidget::updateTextItemGroups to * calculate the Text strings, their properties and also hide/show * them based on the current state. */ void ClassifierWidget::updateTextItemGroups() { // Invalidate stuff and recalculate them. invalidateDummies(); TextItemGroup *headerGroup = textItemGroupAt(HeaderGroupIndex); TextItemGroup *attribOpGroup = textItemGroupAt(AttribOpGroupIndex); TextItemGroup *templateGroup = textItemGroupAt(TemplateGroupIndex); attribOpGroup->setAlignment(Qt::AlignVCenter | Qt::AlignLeft); templateGroup->setAlignment(Qt::AlignVCenter | Qt::AlignLeft); UMLClassifier *umlC = classifier(); UMLClassifierListItemList attribList = umlC->getFilteredList(UMLObject::ot_Attribute); UMLClassifierListItemList opList = umlC->getFilteredList(UMLObject::ot_Operation); // Set up template group and template text items. UMLTemplateList tlist = umlC->getTemplateList(); templateGroup->setTextItemCount(tlist.size()); bool templateHide = shouldDrawAsCircle(); // Hide if draw as circle. for(int i = 0; i < tlist.size(); ++i) { UMLTemplate *t = tlist[i]; templateGroup->textItemAt(i)->setText(t->toString()); templateGroup->textItemAt(i)->setExplicitVisibility(!templateHide); } // Stereo type and name. const int headerItemCount = 2; headerGroup->setTextItemCount(headerItemCount); const int cnt = attribList.count() + opList.count(); attribOpGroup->setTextItemCount(cnt); // Setup Stereo text item. TextItem *stereoItem = headerGroup->textItemAt(StereotypeItemIndex); stereoItem->setBold(true); stereoItem->setText(umlC->stereotype(true)); bool v = !shouldDrawAsCircle() && visualProperty(ShowStereotype) && !(umlC->stereotype(false).isEmpty()); stereoItem->setExplicitVisibility(v); // name item is always visible. TextItem *nameItem = headerGroup->textItemAt(NameItemIndex); nameItem->setBold(true); nameItem->setItalic(umlC->isAbstract()); nameItem->setUnderline(shouldDrawAsCircle()); QString nameText = name(); if (visualProperty(ShowPackage) == true) { nameText = umlC->fullyQualifiedName(); } bool showNameOnly = (!visualProperty(ShowAttributes) && !visualProperty(ShowOperations) && !visualProperty(ShowStereotype) && !shouldDrawAsCircle()); nameItem->setText(nameText); int attribStartIndex = 0; int opStartIndex = attribStartIndex + attribList.size(); // Now setup attribute texts. int visibleAttributes = 0; for (int i=0; i < attribList.size(); ++i) { UMLClassifierListItem *obj = attribList[i]; TextItem *item = attribOpGroup->textItemAt(attribStartIndex + i); item->setItalic(obj->isAbstract()); item->setUnderline(obj->isStatic()); item->setText(obj->toString(m_attributeSignature)); bool v = !shouldDrawAsCircle() && ( !visualProperty(ShowPublicOnly) || obj->visibility() == Uml::Visibility::Public) && visualProperty(ShowAttributes) == true; item->setExplicitVisibility(v); if (v) { ++visibleAttributes; } } // Update expander box to reflect current state and also visibility m_attributeExpanderBox->setExpanded(visualProperty(ShowAttributes)); const QString dummyText; // Setup line and dummies. if (!showNameOnly) { // Stuff in a dummy item as spacer if there are no attributes, if (!shouldDrawAsCircle() && (visibleAttributes == 0 || !visualProperty(ShowAttributes))) { m_dummyAttributeItem = new TextItem(dummyText); int index = attribStartIndex; if (visibleAttributes == 0 && !attribList.isEmpty()) { index = opStartIndex; } attribOpGroup->insertTextItemAt(index, m_dummyAttributeItem); m_lineItem2Index = index; ++opStartIndex; } else { // Now set the second index. m_lineItem2Index = opStartIndex - 1; } } int visibleOperations = 0; for (int i=0; i < opList.size(); ++i) { UMLClassifierListItem *obj = opList[i]; TextItem *item = attribOpGroup->textItemAt(opStartIndex + i); item->setItalic(obj->isAbstract()); item->setUnderline(obj->isStatic()); item->setText(obj->toString(m_operationSignature)); bool v = !shouldDrawAsCircle() && ( !visualProperty(ShowPublicOnly) || obj->visibility() == Uml::Visibility::Public) && visualProperty(ShowOperations); item->setExplicitVisibility(v); if (v) { ++visibleOperations; } } m_operationExpanderBox->setExpanded(visualProperty(ShowOperations)); if (!showNameOnly) { if (!shouldDrawAsCircle() && (visibleOperations == 0 || !visualProperty(ShowOperations))) { m_dummyOperationItem = new TextItem(dummyText); attribOpGroup->insertTextItemAt(opStartIndex+opList.size(), m_dummyOperationItem); } } UMLWidget::updateTextItemGroups(); }
/** * This slot is called to finish item editing */ void UMLListViewItem::slotEditFinished(const QString &newText) { m_label = text(0); DEBUG(DBG_LVI) << this << "text=" << newText; UMLListView* listView = static_cast<UMLListView*>(treeWidget()); UMLDoc* doc = listView->document(); if (newText == m_label) { return; } if (newText.isEmpty()) { cancelRenameWithMsg(); return; } switch (m_type) { case lvt_UseCase: case lvt_Actor: case lvt_Class: case lvt_Package: case lvt_UseCase_Folder: case lvt_Logical_Folder: case lvt_Component_Folder: case lvt_Deployment_Folder: case lvt_EntityRelationship_Folder: case lvt_Interface: case lvt_Datatype: case lvt_Enum: case lvt_EnumLiteral: case lvt_Subsystem: case lvt_Component: case lvt_Port: case lvt_Node: case lvt_Category: if (m_object == 0 || !doc->isUnique(newText)) { cancelRenameWithMsg(); return; } UMLApp::app()->executeCommand(new Uml::CmdRenameUMLObject(m_object, newText)); doc->setModified(true); m_label = newText; break; case lvt_Operation: { if (m_object == 0) { cancelRenameWithMsg(); return; } UMLOperation *op = static_cast<UMLOperation*>(m_object); 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. UMLApp::app()->executeCommand(new Uml::CmdRenameUMLObject(op, od.m_name)); op->setType(od.m_pReturnType); UMLAttributeList parmList = op->getParmList(); const int newParmListCount = parmList.count(); if (newParmListCount > od.m_args.count()) { // Remove parameters at end of of list that no longer exist. for (int 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 (int 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()); } UMLApp::app()->executeCommand(new Uml::CmdRenameUMLObject(a, 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::SignatureType::SigNoVis); } else { KMessageBox::error(0, Model_Utils::psText(st), i18n("Rename canceled")); } setText(m_label); break; } case lvt_Attribute: case lvt_EntityAttribute: { if (m_object == 0) { cancelRenameWithMsg(); return; } UMLClassifier *parent = static_cast<UMLClassifier*>(m_object->parent()); Model_Utils::NameAndType nt; Uml::Visibility::Enum 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; } UMLApp::app()->executeCommand(new Uml::CmdRenameUMLObject(m_object, nt.m_name)); UMLAttribute *pAtt = static_cast<UMLAttribute*>(m_object); pAtt->setType(nt.m_type); pAtt->setVisibility(vis); pAtt->setParmKind(nt.m_direction); pAtt->setInitialValue(nt.m_initialValue); m_label = pAtt->toString(Uml::SignatureType::SigNoVis); } else { KMessageBox::error(0, Model_Utils::psText(st), i18n("Rename canceled")); } setText(m_label); break; } case lvt_PrimaryKeyConstraint: case lvt_UniqueConstraint: case lvt_ForeignKeyConstraint: case lvt_CheckConstraint: { if (m_object == 0) { cancelRenameWithMsg(); return; } UMLEntity *parent = static_cast<UMLEntity*>(m_object->parent()); QString name; Model_Utils::Parse_Status st; st = Model_Utils::parseConstraint(newText, name, parent); if (st == Model_Utils::PS_OK) { UMLObject *exists = parent->findChildObject(name); if (exists) { cancelRenameWithMsg(); return; } UMLApp::app()->executeCommand(new Uml::CmdRenameUMLObject(m_object, name)); UMLEntityConstraint* uec = static_cast<UMLEntityConstraint*>(m_object); m_label = uec->toString(Uml::SignatureType::SigNoVis); } else { KMessageBox::error(0, Model_Utils::psText(st), i18n("Rename canceled")); } setText(m_label); break; } case lvt_Template: { if (m_object == 0) { cancelRenameWithMsg(); return; } UMLClassifier *parent = static_cast<UMLClassifier*>(m_object->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; } UMLApp::app()->executeCommand(new Uml::CmdRenameUMLObject(m_object, nt.m_name)); UMLTemplate *tmpl = static_cast<UMLTemplate*>(m_object); tmpl->setType(nt.m_type); m_label = tmpl->toString(Uml::SignatureType::SigNoVis); } else { KMessageBox::error(0, Model_Utils::psText(st), i18n("Rename canceled")); } setText(m_label); break; } case lvt_UseCase_Diagram: case lvt_Class_Diagram: case lvt_Sequence_Diagram: case lvt_Collaboration_Diagram: case lvt_State_Diagram: case lvt_Activity_Diagram: case lvt_Component_Diagram: case lvt_Deployment_Diagram: { UMLView *view = doc->findView(ID()); if (view == 0) { cancelRenameWithMsg(); return; } UMLView *anotherView = doc->findView(view->umlScene()->type(), newText); if (anotherView && anotherView->umlScene()->ID() == ID()) { anotherView = 0; } if (anotherView) { cancelRenameWithMsg(); return; } view->umlScene()->setName(newText); setText(newText); doc->signalDiagramRenamed(view); break; } default: KMessageBox::error(0, i18n("Renaming an item of listview type %1 is not yet implemented.", m_type), i18n("Function Not Implemented")); setText(m_label); break; } doc->setModified(true); }