umbrello
widget_factory.cpp

00001 /***************************************************************************
00002  *                                                                         *
00003  *   This program is free software; you can redistribute it and/or modify  *
00004  *   it under the terms of the GNU General Public License as published by  *
00005  *   the Free Software Foundation; either version 2 of the License, or     *
00006  *   (at your option) any later version.                                   *
00007  *                                                                         *
00008  *   copyright (C) 2006-2007                                               *
00009  *   Umbrello UML Modeller Authors <uml-devel@uml.sf.net>                  *
00010  ***************************************************************************/
00011 
00012 // own header
00013 #include "widget_factory.h"
00014 
00015 // qt/kde includes
00016 #include <kdebug.h>
00017 
00018 // app includes
00019 #include "uml.h"
00020 #include "umldoc.h"
00021 #include "umlview.h"
00022 #include "object_factory.h"
00023 #include "floatingtextwidget.h"
00024 #include "classifierwidget.h"
00025 #include "classifier.h"
00026 #include "packagewidget.h"
00027 #include "package.h"
00028 #include "folder.h"
00029 #include "componentwidget.h"
00030 #include "component.h"
00031 #include "nodewidget.h"
00032 #include "node.h"
00033 #include "artifactwidget.h"
00034 #include "artifact.h"
00035 #include "datatypewidget.h"
00036 #include "enumwidget.h"
00037 #include "enum.h"
00038 #include "entitywidget.h"
00039 #include "entity.h"
00040 #include "actorwidget.h"
00041 #include "actor.h"
00042 #include "usecasewidget.h"
00043 #include "usecase.h"
00044 #include "notewidget.h"
00045 #include "boxwidget.h"
00046 #include "associationwidget.h"
00047 #include "messagewidget.h"
00048 #include "objectwidget.h"
00049 #include "statewidget.h"
00050 #include "forkjoinwidget.h"
00051 #include "activitywidget.h"
00052 #include "seqlinewidget.h"
00053 
00054 namespace Widget_Factory {
00055 
00056 UMLWidget *createWidget(UMLView *view, UMLObject *o) {
00057     QPoint pos = view->getPos();
00058     int y = pos.y();
00059     Uml::Diagram_Type diagramType = view->getType();
00060     Uml::Object_Type type = o->getBaseType();
00061     UMLWidget *newWidget = NULL;
00062     switch (type) {
00063     case Uml::ot_Actor:
00064         if (diagramType == Uml::dt_Sequence) {
00065             ObjectWidget *ow = new ObjectWidget(view, o, view->getLocalID());
00066             ow->setDrawAsActor(true);
00067             y = ow->topMargin();
00068             newWidget = ow;
00069         } else
00070             newWidget = new ActorWidget(view, static_cast<UMLActor*>(o));
00071         break;
00072     case Uml::ot_UseCase:
00073         newWidget = new UseCaseWidget(view, static_cast<UMLUseCase*>(o));
00074         break;
00075     case Uml::ot_Package:
00076         newWidget = new PackageWidget(view, static_cast<UMLPackage*>(o));
00077         break;
00078     case Uml::ot_Component:
00079         newWidget = new ComponentWidget(view, static_cast<UMLComponent*>(o));
00080         if (diagramType == Uml::dt_Deployment) {
00081             newWidget->setIsInstance(true);
00082         }
00083         break;
00084     case Uml::ot_Node:
00085         newWidget = new NodeWidget(view, static_cast<UMLNode*>(o));
00086         break;
00087     case Uml::ot_Artifact:
00088         newWidget = new ArtifactWidget(view, static_cast<UMLArtifact*>(o));
00089         break;
00090     case Uml::ot_Datatype:
00091         newWidget = new DatatypeWidget(view, static_cast<UMLClassifier*>(o));
00092         break;
00093     case Uml::ot_Enum:
00094         newWidget = new EnumWidget(view, static_cast<UMLEnum*>(o));
00095         break;
00096     case Uml::ot_Entity:
00097         newWidget = new EntityWidget(view, static_cast<UMLEntity*>(o));
00098         break;
00099     case Uml::ot_Interface:
00100         if (diagramType == Uml::dt_Sequence || diagramType == Uml::dt_Collaboration) {
00101             ObjectWidget *ow = new ObjectWidget(view, o, view->getLocalID() );
00102             if (diagramType == Uml::dt_Sequence) {
00103                 y = ow->topMargin();
00104             }
00105             newWidget = ow;
00106         } else {
00107             UMLClassifier *c = static_cast<UMLClassifier*>(o);
00108             ClassifierWidget* interfaceWidget = new ClassifierWidget(view, c);
00109             if (diagramType == Uml::dt_Component || diagramType == Uml::dt_Deployment) {
00110                 interfaceWidget->setDrawAsCircle(true);
00111             }
00112             newWidget = interfaceWidget;
00113         }
00114         break;
00115     case Uml::ot_Class:
00116         //see if we really want an object widget or class widget
00117         if (diagramType == Uml::dt_Class || diagramType == Uml::dt_Component) {
00118             UMLClassifier *c = static_cast<UMLClassifier*>(o);
00119             ClassifierWidget *cw = new ClassifierWidget(view, c);
00120             if (diagramType == Uml::dt_Component)
00121                 cw->setDrawAsCircle(true);
00122             newWidget = cw;
00123         } else {
00124             ObjectWidget *ow = new ObjectWidget(view, o, view->getLocalID() );
00125             if (diagramType == Uml::dt_Sequence) {
00126                 y = ow->topMargin();
00127             }
00128             newWidget = ow;
00129         }
00130         break;
00131     default:
00132         kWarning() << "trying to create an invalid widget" << endl;
00133     }
00134 
00135     if (newWidget) {
00136         newWidget->setX( pos.x() );
00137         newWidget->setY( y );
00138     }
00139     return newWidget;
00140 }
00141 
00142 bool validateObjType(Uml::Object_Type expected, UMLObject* &o, Uml::IDType id) {
00143     if (o == NULL) {
00144         kDebug() << "Widget_Factory::validateObjType: creating new object of type "
00145                  << expected << endl;
00146         QString artificialName = "LOST_" + ID2STR(id);
00147         o = Object_Factory::createUMLObject(expected, artificialName, NULL, false);
00148         if (o == NULL)
00149             return false;
00150         o->setID(id);
00151         UMLPackage *parentPkg = o->getUMLPackage();
00152         parentPkg->addObject(o);
00153         return true;
00154     }
00155     Uml::Object_Type actual = o->getBaseType();
00156     if (actual == expected)
00157         return true;
00158     kError() << "validateObjType(" << o->getName()
00159         << "): expected type " << expected << ", actual type "
00160         << actual << endl;
00161     return false;
00162 }
00163 
00164 UMLWidget* makeWidgetFromXMI(const QString& tag,
00165                              const QString& idStr, UMLView *view) {
00166     UMLWidget *widget = NULL;
00167 
00168         // Loading of widgets which do NOT represent any UMLObject,
00169         // just graphic stuff with no real model information
00170         //FIXME while boxes and texts are just diagram objects, activities and
00171         // states should be UMLObjects
00172     if (tag == "statewidget" || tag == "UML:StateWidget") {
00173         widget = new StateWidget(view, StateWidget::Normal, Uml::id_Reserved);
00174     } else if (tag == "notewidget" || tag == "UML:NoteWidget") {
00175         widget = new NoteWidget(view, Uml::id_Reserved);
00176     } else if (tag == "boxwidget") {
00177         widget = new BoxWidget(view, Uml::id_Reserved);
00178     } else if (tag == "floatingtext" || tag == "UML:FloatingTextWidget") {
00179         widget = new FloatingTextWidget(view, Uml::tr_Floating, "", Uml::id_Reserved);
00180     } else if (tag == "activitywidget" || tag == "UML:ActivityWidget") {
00181         widget = new ActivityWidget(view, ActivityWidget::Initial, Uml::id_Reserved);
00182     } else if (tag == "messagewidget") {
00183         widget = new MessageWidget(view, Uml::sequence_message_asynchronous, Uml::id_Reserved);
00184     } else if (tag == "forkjoin") {
00185         widget = new ForkJoinWidget(view, false, Uml::id_Reserved);
00186     } else {
00187         // Loading of widgets which represent an UMLObject
00188 
00189         // Find the UMLObject and create the Widget to represent it
00190         Uml::IDType id = STR2ID(idStr);
00191         UMLDoc *umldoc = UMLApp::app()->getDocument();
00192         UMLObject *o = umldoc->findObjectById(id);
00193         if (o == NULL) {
00194             kDebug() << "makeWidgetFromXMI: cannot find object with id "
00195                       << ID2STR(id) << endl;
00196         }
00197 
00198         if (tag == "actorwidget" || tag == "UML:ActorWidget") {
00199             if (validateObjType(Uml::ot_Actor, o, id))
00200                 widget = new ActorWidget(view, static_cast<UMLActor*>(o));
00201         } else if (tag == "usecasewidget" || tag ==  "UML:UseCaseWidget") {
00202             if (validateObjType(Uml::ot_UseCase, o, id))
00203                 widget = new UseCaseWidget(view, static_cast<UMLUseCase*>(o));
00204         } else if (tag == "classwidget" || tag == "UML:ClassWidget") {
00205             if (validateObjType(Uml::ot_Class, o, id))
00206                 widget = new ClassifierWidget(view, static_cast<UMLClassifier*>(o));
00207         } else if (tag == "packagewidget") {
00208             if (validateObjType(Uml::ot_Package, o, id))
00209                 widget = new PackageWidget(view, static_cast<UMLPackage*>(o));
00210         } else if (tag == "componentwidget") {
00211             if (validateObjType(Uml::ot_Component, o, id))
00212                 widget = new ComponentWidget(view, static_cast<UMLComponent*>(o));
00213         } else if (tag == "nodewidget") {
00214             if (validateObjType(Uml::ot_Node, o, id))
00215                 widget = new NodeWidget(view, static_cast<UMLNode*>(o));
00216         } else if (tag == "artifactwidget") {
00217             if (validateObjType(Uml::ot_Artifact, o, id))
00218                 widget = new ArtifactWidget(view, static_cast<UMLArtifact*>(o));
00219         } else if (tag == "interfacewidget") {
00220             if (validateObjType(Uml::ot_Interface, o, id))
00221                 widget = new ClassifierWidget(view, static_cast<UMLClassifier*>(o));
00222         } else if (tag == "datatypewidget") {
00223             if (validateObjType(Uml::ot_Datatype, o, id))
00224                 widget = new DatatypeWidget(view, static_cast<UMLClassifier*>(o));
00225         } else if (tag == "enumwidget") {
00226             if (validateObjType(Uml::ot_Enum, o, id))
00227                 widget = new EnumWidget(view, static_cast<UMLEnum*>(o));
00228         } else if (tag == "entitywidget") {
00229             if (validateObjType(Uml::ot_Entity, o, id))
00230                 widget = new EntityWidget(view, static_cast<UMLEntity*>(o));
00231         } else if (tag == "objectwidget" || tag == "UML:ObjectWidget") {
00232             widget = new ObjectWidget(view, o );
00233         } else {
00234             kWarning() << "Trying to create an unknown widget:" << tag << endl;
00235         }
00236     }
00237     return widget;
00238 }
00239 
00240 }   // end namespace Widget_Factory
00241
umbrello API Documentation

widget_factory.cpp
