Blame - examples/org.eclipse.graphiti.doc/resources/docu/gfw/drill-down.htm - graphiti/org.eclipse.graphiti

2011-07-21 12:45:27 +0000

[diff] [blame]

1

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

2

<html>

mwenz

2010-06-16 13:24:52 +0000

[diff] [blame]

3

4

<head>

jpasch

2011-07-04 12:22:21 +0000

[diff] [blame]

5

mwenz

2010-06-16 13:24:52 +0000

[diff] [blame]

6

<title>Providing drill-down behavior</title>

jpasch

2011-07-04 12:22:21 +0000

[diff] [blame]

7

8

mwenz

2010-06-16 13:24:52 +0000

[diff] [blame]

9

</head>

10

jpasch

2011-07-04 12:22:21 +0000

[diff] [blame]

11

<body>

mwenz

2010-06-16 13:24:52 +0000

[diff] [blame]

12

jpasch

2011-07-04 12:22:21 +0000

[diff] [blame]

13

<h1>Providing Drill-Down Behavior</h1>

14

Often the information which is shown in a diagram has a certain abstraction level,

15

and the further details are shown in a separate diagram. For example if a workflow

16

connects several sub-workflows, then one overview-diagram might show the complete

17

workflow without the inner details of the sub-workflows, and several detail-diagrams

18

show the inner details of each sub-workflow.

19

In this case the user wants to have an easy possibility to navigate from the

20

overview-diagram into the detail-diagrams and vice versa. We call this "drill-down"

21

behavior.

22

Although going from overview to detail is the most typical example, there are

23

other examples, where the user navigates to more independent diagrams.

24

All those use cases have one thing in common: the user wants to navigate to a

jpasch

2011-07-21 12:45:27 +0000

[diff] [blame]

25

diagram, which "represents" the selected business object (meaning this business

jpasch

2011-07-04 12:22:21 +0000

[diff] [blame]

26

object is central for the diagram).

27

Graphiti offers the possibility to link business objects to pictogram elements

28

(including the diagram). The drill-down feature works in a way that it searches

29

for all diagrams having a given business object associated. Then the user can choose

30

from the found diagrams to which to navigate (if only one diagram is found, than

31

this is directly opened).

32

This is different to a where-used functionality, where the user would search

33

for all diagrams using a business object, no matter if the diagram really "represents"

34

the business object.

35

<h2>Creating a Drill-Down Feature</h2>

36

In this example we want to enable the users to navigate to the diagram(s) which

37

have the currently selected EClass associated. Therefore we have to create a drill-down

38

feature and make it available in the feature provider.

jpasch

2011-07-21 12:45:27 +0000

[diff] [blame]

39

<ul>

40

<li>A drill-down feature is a <a href="custom-feature.htm">custom feature</a>

41

which can easily be implemented by extending the base class

42

43

AbstractDrillDownFeature</a>.</li>

44

</ul>

45

The functionality of the AbstractDrillDownFeature

46

is not tool-independent, so the method getDiagrams()

47

can be implemented only by the tool efficiently. Furthermore we just overwrite the

48

canExecute() method, so that the feature is only

49

enabled if exactly one EClass is selected.

jpasch

2011-07-04 12:22:21 +0000

[diff] [blame]

50

You can see the complete implementation of the drill-down feature here:

51

package org.eclipse.graphiti.examples.tutorial.features;

56

public class TutorialDrillDownEClassFeature

57

extends AbstractDrillDownFeature {

58

public TutorialDrillDownEClassFeature(IFeatureProvider

59

fp) {

60

super(fp);     }

61

@Override     public String

62

getName() {

63

return "Open associated

64

diagram";     }

65

@Override     public String

66

getDescription() {

67

return "Open the diagram

68

associated with this EClass";     }

69

@Override     public boolean

70

canExecute(ICustomContext context) {

71

PictogramElement[] pes = context.getPictogramElements();

72

// first check, if one EClass is selected

73

if (pes != null

74

&& pes.length == 1) {

75

Object bo = getBusinessObjectForPictogramElement(pes[0]);

76

if (bo instanceof

77

EClass) {

78

// then forward to super-implementation, which checks

79

if

80

// this EClass is associated with other diagrams

81

return super.canExecute(context);

82

}         }

83

return false;     }

84

@Override     protected Collection<Diagram>

85

getDiagrams() {        Collection<Diagram>

86

result = Collections.emptyList();

87

Resource resource = getDiagram().eResource();

88

URI uri = resource.getURI();        URI

89

uriTrimmed = uri.trimFragment();

90

if (uriTrimmed.isPlatformResource()){

91

String platformString = uriTrimmed.toPlatformString(true);

92

IResource fileResource = ResourcesPlugin.getWorkspace()

93

.getRoot().findMember(platformString);

94

if (fileResource != null){

95

IProject project = fileResource.getProject();

96

result = TutorialUtil.getDiagrams(project);

97

}        }

98

return result;     } }

</div>

</div>

jpasch

2011-07-21 12:45:27 +0000

[diff] [blame]

104

The complete implementation of class TutorialUtil

105

can be seen here:

jpasch

2011-07-04 12:22:21 +0000

[diff] [blame]

106

package org.eclipse.graphiti.examples.tutorial;

111

public class TutorialUtil {

112

public static Collection<Diagram> getDiagrams(IProject

113

p) {        final

114

List<IFile> files = getDiagramFiles(p);

115

final List<Diagram> diagramList =

jpasch

da3428a

2012-05-25 11:10:26 +0200

[diff] [blame^]

116

new ArrayList<Diagram>();

jpasch

2011-07-04 12:22:21 +0000

[diff] [blame]

117

final ResourceSet rSet =

118

new ResourceSetImpl();

119

for (final IFile

120

file : files) {

121

final Diagram diagram = getDiagramFromFile(file,

122

rSet);

123

if (diagram != null) {

124

diagramList.add(diagram);

125

}        }

126

return diagramList;     }

127

private static List<IFile> getDiagramFiles(IContainer

128

folder) {

129

final List<IFile> ret = new ArrayList<IFile>();

130

try {

131

final IResource[] members = folder.members();

132

for (final IResource

133

resource : members) {

134

if (resource instanceof

135

IContainer) {

136

ret.addAll(getDiagramFiles((IContainer) resource));

137

} else if (resource instanceof

138

IFile) {

139

final IFile file = (IFile) resource;

140

if (file.getName().endsWith(".diagram"))

{

ret.add(file);

}

}

}        } catch

(final CoreException e) {

147

e.printStackTrace();        }

148

return ret;     }

149

private static Diagram getDiagramFromFile(IFile

150

file,

151

ResourceSet resourceSet) {

152

// Get the URI of the model file.

153

final URI resourceURI = getFileURI(file, resourceSet);

154

// Demand load the resource for this file.

155

Resource resource;

jpasch

363344b

2011-07-04 12:27:23 +0000

[diff] [blame]

156

try {

jpasch

2011-07-04 12:22:21 +0000

[diff] [blame]

157

resource = resourceSet.getResource(resourceURI, true);

158

if (resource != null)

159

{

160

// does resource contain a diagram as root object?

161

final EList<EObject> contents = resource.getContents();

162

for (final EObject

163

object : contents) {

164

if (object instanceof

165

Diagram) {

166

return (Diagram) object;

}

}        }

} catch (final

WrappedException e) {

171

e.printStackTrace();        }

172

return null;     }

173

private static URI getFileURI(IFile file, ResourceSet

174

resourceSet) {        final

175

String pathName = file.getFullPath().toString();

176

URI resourceURI = URI.createFileURI(pathName);

177

resourceURI = resourceSet.getURIConverter().normalize(resourceURI);

178

return resourceURI;     }

}

</div>

</div>

184

Before we test our drill-down feature, we have link EClasses to our diagrams.

185

In our small example there is no obvious reasoning, which EClass to assign to a

186

diagram. Because of that we create a new custom feature, where the user himself

187

can assign selected EClasses to the current diagram.

188

You can see the complete implementation of this custom feature here:

189

package org.eclipse.graphiti.examples.tutorial.features;

194

public class TutorialAssociateDiagramEClassFeature

195

extends     AbstractCustomFeature

196

{       public TutorialAssociateDiagramEClassFeature(IFeatureProvider

197

fp) {

198

super(fp);     }

199

@Override     public String

200

getName() {

201

return "Associate diagram";

202

}       @Override

203

public String getDescription() {

204

return "Associate the

205

diagram with this EClass";     }

206

@Override     public boolean

207

canExecute(ICustomContext context) {

208

boolean ret = false;

209

PictogramElement[] pes = context.getPictogramElements();

210

if (pes != null

211

&& pes.length >= 1) {

212

ret = true;

213

for (PictogramElement pe : pes) {

214

Object bo = getBusinessObjectForPictogramElement(pe);

if (! (bo instanceof

EClass)) {

ret = false;

}               

}

}         return

ret;     }

public void

execute(ICustomContext context) {

224

PictogramElement[] pes = context.getPictogramElements();

225

EClass eClasses[] = new EClass[pes.length];

226

for (int i = 0; i < eClasses.length;

227

i++) {

228

eClasses[i] =

229

(EClass) getBusinessObjectForPictogramElement(pes[i]);

230

}

231

// associate selected EClass with diagram

232

link(getDiagram(), eClasses);     }   }

</div>

</div>

238

Finally the feature provider has to deliver our newly created custom features

239

(overwrite the method

240

241

getCustomFeatures</a>).

242

This implementation can be seen here:

243

@Override public ICustomFeature[]

248

getCustomFeatures(ICustomContext context) {

249

return new ICustomFeature[]

250

{ new TutorialRenameEClassFeature(this),

251

new TutorialDrillDownEClassFeature(this),

252

new TutorialAssociateDiagramEClassFeature(this)};

}

</div>

</div>

258

<h2>Test: Navigate to Diagram Associated with a EClass</h2>

259

Now start the editor and test this new drill-down feature:

260

<ol>

261

<li>create or open two diagrams</li>

262

<li>in the first diagram create a new EClass</li>

263

<li>use "copy & paste" to copy this EClass to the second diagram (the underlying

264

business object is remains the same!)</li>

265

<li>open the context menu on the EClass in the second diagram; choose "Associate

266

diagram"</li>

267

<li>save both diagrams and close the second diagram</li>

268

<li>open the context menu on the EClass in the first diagram; choose "Open associated

269

diagram"</li>

270

<li>now the second diagram is opened again</li>

mwenz

2010-06-16 13:24:52 +0000

[diff] [blame]

271

</ol>

jpasch

2011-07-21 12:45:27 +0000

[diff] [blame]

272

mwenz

2010-06-16 13:24:52 +0000

[diff] [blame]

273

mwenz