ssddiagram.c

这个工具集提供以下结构化分析和UML分析中所用的图形化绘图工具：ER-diagrams, data and event flow diagrams and state-transition diagr

		SetNodeShapeType(Code::MINI_ELLIPSE);
		SetNodeLineStyle(LineStyle::SOLID);
		break;
	case 10: SetNodeType(Code::SSD_AGGREGATION_NODE);
		SetNodeShapeType(Code::BLACK_DOT);
		SetNodeLineStyle(LineStyle::SOLID);
		break;
	default:
		error("%s, line %d: impl error: "
			"unknown node type selected\n", __FILE__,__LINE__);
	}
}

void SSDDiagram::UpdateEdgeType(int num) {
	((DiagramWindow *)GetMainWindow())->SetEdgeName(num);
	switch(num) {
	case 1: SetEdgeType(Code::SSD_BINARY_ASSOCIATION_EDGE);
		SetLineType(Code::C2R2_LINE);
		SetEdgeLineStyle(LineStyle::SOLID);
		SetLineEnd1(LineEnd::EMPTY);
                SetLineEnd2(LineEnd::EMPTY);
		break;
	case 2: SetEdgeType(Code::SSD_PARTICIPANT_LINK_EDGE);
		SetLineType(Code::SSD_RCLINE);
		SetEdgeLineStyle(LineStyle::SOLID);
		SetLineEnd1(LineEnd::EMPTY);
                SetLineEnd2(LineEnd::EMPTY);
		break;
	case 3: SetEdgeType(Code::SSD_ASSOCIATION_LINK_EDGE);
		SetLineType(Code::LINE);
		SetEdgeLineStyle(LineStyle::DASHED);
		SetLineEnd1(LineEnd::EMPTY);
                SetLineEnd2(LineEnd::EMPTY);
		break;
	case 4: SetEdgeType(Code::COMMENT_LINK);
		SetLineType(Code::LINE);
		SetEdgeLineStyle(LineStyle::WIDE_DOTTED);
		SetLineEnd1(LineEnd::EMPTY);
                SetLineEnd2(LineEnd::EMPTY);
		break;
	case 5: SetEdgeType(Code::SSD_OBJECT_LINK_EDGE);
		SetLineType(Code::SSD_R2LINE);
		SetEdgeLineStyle(LineStyle::SOLID);
		SetLineEnd1(LineEnd::EMPTY);
                SetLineEnd2(LineEnd::EMPTY);
		break;
	case 6: SetEdgeType(Code::SSD_GENERALIZATION_EDGE);
		SetLineType(Code::LINE);
		SetEdgeLineStyle(LineStyle::SOLID);
		SetLineEnd1(LineEnd::EMPTY);
                SetLineEnd2(LineEnd::WHITE_TRIANGLE);
		break;
	case 7: SetEdgeType(Code::SSD_AGGREGATION_EDGE);
		SetLineType(Code::C2R2_LINE);
		SetEdgeLineStyle(LineStyle::SOLID);
		SetLineEnd1(LineEnd::EMPTY);
                SetLineEnd2(LineEnd::WHITE_DIAMOND);
		break;
	case 8: SetEdgeType(Code::SSD_COMPOSITION_EDGE);
		SetLineType(Code::C2R2_LINE);
		SetEdgeLineStyle(LineStyle::SOLID);
		SetLineEnd1(LineEnd::EMPTY);
                SetLineEnd2(LineEnd::BLACK_DIAMOND);
		break;
	default:
		error("%s, line %d: impl error: "
			"unknown edge type selected\n", __FILE__,__LINE__);
	}
}

bool SSDDiagram::SetText(TextShape *t, const string *s) {
	const string *d = t->GetDescription();
	Subject *subj = t->GetParent()->GetSubject();
	if (*d == "Attribute" && subj->GetClassType()==Code::SSD_CLASS_NODE)
		return SetAttribute((StringListNode*)subj, s, t->GetSequence());
	else if (*d == "Attribute" && subj->GetClassType()==Code::SSD_OBJECT_NODE)
		return SetAttribute((StringListNode*)subj, s, t->GetSequence());
	else if (*d == "Operation" && subj->GetClassType()==Code::SSD_CLASS_NODE)
		return SetOperation((StringListNode2 *)subj, s, t->GetSequence());
	else if (*d == "Stereotype" && subj->GetClassType()==Code::SSD_CLASS_NODE)
		return SetStereotype((SSDClassNode*)subj, s);
	else if (*d == "Properties" && subj->GetClassType()==Code::SSD_CLASS_NODE)
		return SetProperties((SSDClassNode*)subj, s);
	else if (*d == "Role Name" && subj->GetClassType()==Code::SSD_OBJECT_LINK_EDGE)
		return SetRoleName(subj, s, t->GetSequence());
	else if (*d == "Role Name" && subj->GetClassType()==Code::SSD_PARTICIPANT_LINK_EDGE)
		return SetRoleName(subj, s, t->GetSequence());
	else
		return ERDiagram::SetText(t, s);
}

bool SSDDiagram::SetStereotype(SSDClassNode *object, const string *s) {
        // StringListNode::StringErrorType reason = object->SetStereotype(s);
        (void)object->SetStereotype(s);
        // update all shapes in the viewer.
        List<GShape *> shapes;
        GetDiagramViewer()->GetShapes(object, &shapes);
        for (check(shapes.first()); !shapes.done(); shapes.next()) {
                const string *str = object->GetStereotype();
                GShape *shape = shapes.cur();
                if (check(!shape->IsTextShape())) {
			if (shape->GetClassType()==Code::SSD_SINGLE_CLASS_BOX) { 
				SSDSingleClassBox *bs = (SSDSingleClassBox *)shape;
				bs->UpdateStereotypeLabelString(str); 
			}
			else if (shape->GetClassType()==Code::SSD_DOUBLE_CLASS_BOX) { 
				SSDDoubleClassBox *dbs = (SSDDoubleClassBox *)shape;
				dbs->UpdateStereotypeLabelString(str); 
			}
			else if (shape->GetClassType()==Code::SSD_TRIPLE_CLASS_BOX) { 
				SSDTripleClassBox *tbs = (SSDTripleClassBox *)shape;
				tbs->UpdateStereotypeLabelString(str); 
			}
                        if (GetDiagramViewer()->IsAutoResize())
                                shape->AdjustSize();
                }
        }
        IncChanges();
	return True;
}

bool SSDDiagram::SetProperties(SSDClassNode *object, const string *s) {
        (void) object->SetProperties(s);
        // StringListNode::StringErrorType reason = object->SetProperties(s);
        // update all shapes in the viewer.
        List<GShape *> shapes;
        GetDiagramViewer()->GetShapes(object, &shapes);
        for (check(shapes.first()); !shapes.done(); shapes.next()) {
                const string *str = object->GetProperties();
                GShape *shape = shapes.cur();
                if (check(!shape->IsTextShape())) {
			if (shape->GetClassType()==Code::SSD_SINGLE_CLASS_BOX) { 
				SSDSingleClassBox *bs = (SSDSingleClassBox *)shape;
				bs->UpdatePropertiesLabelString(str); 
			}
			else if (shape->GetClassType()==Code::SSD_DOUBLE_CLASS_BOX) { 
				SSDDoubleClassBox *dbs = (SSDDoubleClassBox *)shape;
				dbs->UpdatePropertiesLabelString(str); 
			}
			else if (shape->GetClassType()==Code::SSD_TRIPLE_CLASS_BOX) { 
				SSDTripleClassBox *tbs = (SSDTripleClassBox *)shape;
				tbs->UpdatePropertiesLabelString(str); 
			}
                        if (GetDiagramViewer()->IsAutoResize())
                                shape->AdjustSize();
                }
        }
        IncChanges();
	return True;
}

bool SSDDiagram::SetRoleName(Subject *subject, const string *s, unsigned nr) {
	List<GShape *> shapes;
	GetDiagramViewer()->GetShapes(subject, &shapes);
	bool succes = True;
	if (subject->GetClassType() == Code::SSD_OBJECT_LINK_EDGE) {
		SSDObjectLinkEdge *edge = (SSDObjectLinkEdge *)subject;
		if (nr == 1) {
			if (!edge->SetRoleName1(s))
				succes = False;
		}
		else {
			if (!edge->SetRoleName2(s))
				succes = False;
		}
	}
	else if (subject->GetClassType() == Code::SSD_PARTICIPANT_LINK_EDGE) {
		succes = ((SSDParticipantLinkEdge *)subject)->SetRoleName(s);
	}

	if (!succes) {
		string txt = "'" + *s + "' is not a possible role name";
		ShowDialog(MessageDialog::ERROR, "Error", &txt);
		return False;
	}
	if (check(shapes.first())) {
		do {
			Shape *shape = shapes.cur();
			if (shape->GetClassType()==Code::SSD_R2LINE) {
				if (nr == 1)
					((SSDR2Line *)shape)->UpdateTextShape1(s);
				else 
					((SSDR2Line *)shape)->UpdateTextShape2(s);
			}
			else if (shape->GetClassType()==Code::SSD_RCLINE)
				((SSDRCLine *)shape)->UpdateTextShape2(s);
		} while (shapes.next());
	}
	else 
		return False;
	return True;
}

void SSDDiagram::MakeErrorMessage(StringListNode *,
                StringListNode::StringErrorType result, const string *s, string *txt) {
        if (result == StringListNode::STRING_SYNTAX_ERROR)
                *txt += "syntax error: '" + *s + "'";
        else if (result == StringListNode::STRING_ALREADY_EXISTS)
                *txt += "'" + *s + "' already exists";
}

bool SSDDiagram::SetAttribute(StringListNode *node, const string *s, unsigned nr) {
	List <GShape *> shapes;
	GetDiagramViewer()->GetShapes(node, &shapes);
	unsigned m = nr;
	// split string in different strings (separated by newline).
	// each string becomes a new attribute.
	string ss(*s);
	char *str = (char *)ss.getstr();
	char *x = strtok(str, "\r");
	char empty[2] = "";
	if (x == 0)
		x = empty;
	while (x != 0) {
		string *ns = new string(x);
		bool update = True;
		StringListNode::StringErrorType result;
		if (m == nr)
			result = node->SetString(ns, m, True);
		else { // m != r
			result = node->SetString(ns, m, False);
			update = False;
		}
		string txt;
		MakeErrorMessage(node, result, ns, &txt);
		if (result != StringListNode::STRING_OK) {
			ShowDialog(MessageDialog::ERROR, "Error", &txt);
			// delete the newly created attributes.
			*ns = "";
			for (shapes.first(); !shapes.done(); shapes.next()) {
				int type = shapes.cur()->GetClassType();
				if (type != Code::BOX && 
				    type != Code::SSD_SINGLE_CLASS_BOX) {
					DoubleBox *db = 
						(DoubleBox *)(shapes.cur());
					if (db->NrLabels()-1 == m)
						db->UpdateLabel(ns, m, update);
				}
			}
			delete ns;
			return False;
		}
		// update the double box shapes.
		for (shapes.first(); !shapes.done(); shapes.next()) {
			int type = shapes.cur()->GetClassType();
			if (type != Code::BOX && 
			    type != Code::SSD_SINGLE_CLASS_BOX)
				((DoubleBox *)shapes.cur())->UpdateLabel(ns, m, update);
		}
		if (!shapes.first()) {
			error( "%s, line %d: impl error: "
				"shape does not exist!\n", __FILE__, __LINE__);
			return False;
		}
		m++;
		x = strtok(0, "\r");
		delete ns;
	}
	return True;
}

bool SSDDiagram::SetOperation(StringListNode2 *node, const string *s, unsigned nr) {
	List<GShape *> shapes;
	GetDiagramViewer()->GetShapes(node, &shapes);
	string ss(*s);
	char *str = (char *)ss.getstr();
	unsigned m = nr;
	char *x = strtok(str, "\r");
	char empty[2] = "";
	if (x == 0)
		x = empty;
	while (x != 0) {
		string *ns = new string(x);
		bool update = True;
		StringListNode::StringErrorType result;
		if (m == nr) {
			result = node->SetString2(ns, m, True);
		}
		else { // m != r
			result = node->SetString2(ns, m, False);
			update = False;
		}
		string txt;
		MakeErrorMessage(node, result, ns, &txt);
		if (result != StringListNode::STRING_OK) {
			ShowDialog(MessageDialog::ERROR, "Error", &txt);
			// delete the newly created operations.
			*ns = "";
			for (shapes.first(); !shapes.done(); shapes.next()) {
				if (shapes.cur()->GetClassType() == 
						Code::SSD_TRIPLE_CLASS_BOX) {
					TripleBox *tb = 
						(TripleBox *)(shapes.cur());
					if (tb->NrLabels2()-1 == m)
						tb->UpdateLabel2(ns, m, update);
				}
			}
			delete ns;
			return False;
		}
		// update the triple box shapes.
		for (shapes.first(); !shapes.done(); shapes.next()) {
			if (shapes.cur()->GetClassType() == Code::SSD_TRIPLE_CLASS_BOX) 
				((TripleBox *)shapes.cur())->
					UpdateLabel2(ns, m, update);
		} 
		if (!shapes.first()) {
			error( "%s, line %d: impl error: "
				"shape does not exist!\n", __FILE__, __LINE__);
			return False;
		}
		m++;
		x = strtok(0, "\r");
		delete ns;
	}
	return True;
}


void SSDDiagram::CheckDocument() {
	chkbuf = "";
	unsigned total = 0;
	total += ssdChecks->CheckDoubleNamelessEdges(
			Code::SSD_BINARY_ASSOCIATION_EDGE, Code::SSD_CLASS_NODE, 
			Code::SSD_CLASS_NODE, chkbuf);
	// Check that object classes are named.
	total += ssdChecks->CheckNamelessNodes(Code::SSD_CLASS_NODE, chkbuf);
	total += ssdChecks->CheckNamelessNodes(Code::SSD_ASSOCIATION_NODE, chkbuf);
	total += ssdChecks->CheckNamelessNodes(Code::SSD_OBJECT_NODE, chkbuf);
	// double nodes can occur after cut-copy-paste
	total += ssdChecks->CheckDoubleNodes(Code::SSD_CLASS_NODE, chkbuf);
	total += ssdChecks->CheckDoubleNodes(Code::SSD_OBJECT_NODE, chkbuf);
	ReportCheck(total, &chkbuf);
}