← Back to branch summary

~ubuntu-branches/ubuntu/trusty/eclipse-linuxtools/trusty

« back to all changes in this revision

Viewing changes to lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/internal/lttng/ui/views/latency/dialogs/AddDialog.java

  • Committer: Package Import Robot
  • Author(s): Jakub Adam
  • Date: 2012-06-29 12:07:30 UTC
  • Revision ID: package-import@ubuntu.com-20120629120730-bfri1xys1i71dpn6
Tags: upstream-1.0.0
Import upstream version 1.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/internal/lttng/ui/views/latency/dialogs/AddDialog.java
 
1
/*******************************************************************************
 
2
 * Copyright (c) 2010, 2011 Ericsson
 
3
 * 
 
4
 * All rights reserved. This program and the accompanying materials are
 
5
 * made available under the terms of the Eclipse Public License v1.0 which
 
6
 * accompanies this distribution, and is available at
 
7
 * http://www.eclipse.org/legal/epl-v10.html
 
8
 * 
 
9
 * Contributors:
 
10
 *   Philippe Sawicki (INF4990.A2010@gmail.com)   - Initial API and implementation
 
11
 *   Mathieu Denis    (mathieu.denis55@gmail.com) - Refactored code
 
12
 *   Bernd Hufmann - Adapted to new messages file, fixed warnings
 
13
 *******************************************************************************/
 
14
package org.eclipse.linuxtools.internal.lttng.ui.views.latency.dialogs;
 
15
 
 
16
import java.util.Vector;
 
17
 
 
18
import org.eclipse.linuxtools.internal.lttng.core.latency.analyzer.EventMatcher;
 
19
import org.eclipse.linuxtools.internal.lttng.core.util.EventsPair;
 
20
import org.eclipse.linuxtools.internal.lttng.ui.views.latency.Messages;
 
21
import org.eclipse.swt.SWT;
 
22
import org.eclipse.swt.layout.GridData;
 
23
import org.eclipse.swt.layout.GridLayout;
 
24
import org.eclipse.swt.widgets.Button;
 
25
import org.eclipse.swt.widgets.Composite;
 
26
import org.eclipse.swt.widgets.Control;
 
27
import org.eclipse.swt.widgets.Event;
 
28
import org.eclipse.swt.widgets.Listener;
 
29
import org.eclipse.swt.widgets.Shell;
 
30
import org.eclipse.swt.widgets.Table;
 
31
import org.eclipse.swt.widgets.TableColumn;
 
32
import org.eclipse.swt.widgets.TableItem;
 
33
 
 
34
/**
 
35
 * <b><u>AddDialog</u></b>
 
36
 * <p>
 
37
 * Add dialog, lets the user add custom start/end event pairs.
 
38
 * 
 
39
 * @author Philippe Sawicki
 
40
 */
 
41
public class AddDialog extends AbstractDialog {
 
42
 
 
43
    // ------------------------------------------------------------------------
 
44
    // Attributes
 
45
    // ------------------------------------------------------------------------
 
46
 
 
47
    /**
 
48
     * The dialog's start table.
 
49
     */
 
50
    protected Table fStartTable;
 
51
 
 
52
    /**
 
53
     * The dialog's end table.
 
54
     */
 
55
    protected Table fEndTable;
 
56
 
 
57
    /**
 
58
     * The dialog's list table.
 
59
     */
 
60
    protected Table fListTable;
 
61
 
 
62
    /**
 
63
     * Start table columns.
 
64
     */
 
65
    protected TableColumn[] fStartColumns;
 
66
 
 
67
    /**
 
68
     * End table columns.
 
69
     */
 
70
    protected TableColumn[] fEndColumns;
 
71
 
 
72
    /**
 
73
     * List table columns.
 
74
     */
 
75
    protected TableColumn[] fListColumns;
 
76
 
 
77
    /**
 
78
     * Start table column names (header titles).
 
79
     */
 
80
    static final String[] START_COLUMN_NAMES = { "", Messages.LatencyView_Dialogs_AddEvents_Columns_Start }; //$NON-NLS-1$
 
81
 
 
82
    /**
 
83
     * End table column names (header titles).
 
84
     */
 
85
    static final String[] END_COLUMN_NAMES = { "", Messages.LatencyView_Dialogs_AddEvents_Columns_End }; //$NON-NLS-1$
 
86
 
 
87
    /**
 
88
     * List table column names (header titles).
 
89
     */
 
90
    static final String[] LIST_COLUMN_NAMES = {
 
91
            "#", //$NON-NLS-1$
 
92
            Messages.LatencyView_Dialogs_AddEvents_Columns_List_Trigger,
 
93
            Messages.LatencyView_Dialogs_AddEvents_Columns_List_End };
 
94
 
 
95
    /**
 
96
     * Column widths.
 
97
     */
 
98
    static final int[] COLUMN_WIDTHS = { 25, 250, 250 };
 
99
 
 
100
    /**
 
101
     * Possible event types.
 
102
     */
 
103
    protected Vector<String> fEventTypes = new Vector<String>();
 
104
 
 
105
    /**
 
106
     * Start event types.
 
107
     */
 
108
    protected Vector<String> fEventStartTypes;
 
109
 
 
110
    /**
 
111
     * End event types.
 
112
     */
 
113
    protected Vector<String> fEventEndTypes;
 
114
 
 
115
    /**
 
116
     * Selected start type.
 
117
     */
 
118
    protected String fStartType;
 
119
 
 
120
    /**
 
121
     * Selected end type.
 
122
     */
 
123
    protected String fEndType;
 
124
 
 
125
    // ------------------------------------------------------------------------
 
126
    // Constructors
 
127
    // ------------------------------------------------------------------------
 
128
 
 
129
    /**
 
130
     * Constructor.
 
131
     * @param parentShell
 
132
     *            The parent shell.
 
133
     * @param title
 
134
     *            The dialog's window title.
 
135
     * @param message
 
136
     *            The dialog's window message.
 
137
     */
 
138
    public AddDialog(Shell parentShell, String title, String message) {
 
139
        super(parentShell, title, message);
 
140
 
 
141
        // Get the possible events from the list
 
142
        fEventTypes = EventMatcher.getInstance().getTypeList();
 
143
 
 
144
        // Get the list of start and end types from the EventMatcher
 
145
        EventsPair pair = getMatchPairs();
 
146
        fEventStartTypes = pair.getFirst();
 
147
        fEventEndTypes = pair.getSecond();
 
148
    }
 
149
 
 
150
    // ------------------------------------------------------------------------
 
151
    // Operations
 
152
    // ------------------------------------------------------------------------
 
153
 
 
154
    /**
 
155
     * Creates the start table's columns (i.e. the table header).
 
156
     */
 
157
    protected void createStartColumns() {
 
158
        fStartColumns = new TableColumn[START_COLUMN_NAMES.length];
 
159
        for (int i = 0; i < START_COLUMN_NAMES.length; i++) {
 
160
            fStartColumns[i] = new TableColumn(fStartTable, SWT.LEFT);
 
161
            fStartColumns[i].setText(START_COLUMN_NAMES[i]);
 
162
            fStartColumns[i].setWidth(COLUMN_WIDTHS[i]);
 
163
        }
 
164
    }
 
165
 
 
166
    /**
 
167
     * Creates the end table's columns (i.e. the table header).
 
168
     */
 
169
    protected void createEndColumns() {
 
170
        fEndColumns = new TableColumn[END_COLUMN_NAMES.length];
 
171
        for (int i = 0; i < END_COLUMN_NAMES.length; i++) {
 
172
            fEndColumns[i] = new TableColumn(fEndTable, SWT.LEFT);
 
173
            fEndColumns[i].setText(END_COLUMN_NAMES[i]);
 
174
            fEndColumns[i].setWidth(COLUMN_WIDTHS[i]);
 
175
        }
 
176
    }
 
177
 
 
178
    /**
 
179
     * Creates the list table's columns (i.e. the table header).
 
180
     */
 
181
    protected void createListColumns() {
 
182
        fListColumns = new TableColumn[LIST_COLUMN_NAMES.length];
 
183
        for (int i = 0; i < LIST_COLUMN_NAMES.length; i++) {
 
184
            fListColumns[i] = new TableColumn(fListTable, SWT.LEFT);
 
185
            fListColumns[i].setText(LIST_COLUMN_NAMES[i]);
 
186
            fListColumns[i].setWidth(COLUMN_WIDTHS[i]);
 
187
        }
 
188
    }
 
189
 
 
190
    /**
 
191
     * Creates the start column list.
 
192
     * @param parent
 
193
     *            The parent composite.
 
194
     */
 
195
    protected void createStartColumn(Composite parent) {
 
196
        final int style = SWT.SINGLE | SWT.CHECK | SWT.FULL_SELECTION | SWT.BORDER | SWT.V_SCROLL;
 
197
        GridData layoutData = new GridData(SWT.FILL, SWT.FILL, true, true);
 
198
        fStartTable = new Table(parent, style);
 
199
        fStartTable.setLayoutData(layoutData);
 
200
 
 
201
        // Some cosmetic enhancements
 
202
        fStartTable.setHeaderVisible(true);
 
203
        fStartTable.setLinesVisible(true);
 
204
 
 
205
        createStartColumns();
 
206
 
 
207
        for (int i = 0; i < fEventTypes.size(); i++) {
 
208
            TableItem item = new TableItem(fStartTable, SWT.RIGHT);
 
209
 
 
210
            String[] columns = { fEventTypes.get(i), fEventTypes.get(i) };
 
211
 
 
212
            item.setText(columns);
 
213
        }
 
214
 
 
215
        fStartTable.setItemCount(fEventTypes.size());
 
216
 
 
217
        fStartTable.addListener(SWT.Selection, new Listener() {
 
218
            @Override
 
219
            public void handleEvent(Event event) {
 
220
                if (event.detail == SWT.CHECK) {
 
221
                    TableItem[] items = fStartTable.getItems();
 
222
                    for (TableItem item : items) {
 
223
                        if (item != event.item) {
 
224
                            item.setChecked(false);
 
225
                        }
 
226
                    }
 
227
                }
 
228
            }
 
229
        });
 
230
    }
 
231
 
 
232
    /**
 
233
     * Creates the end column list.
 
234
     * @param parent
 
235
     *            The parent composite.
 
236
     */
 
237
    protected void createEndColumn(Composite parent) {
 
238
        final int style = SWT.SINGLE | SWT.CHECK | SWT.FULL_SELECTION | SWT.BORDER | SWT.V_SCROLL;
 
239
        GridData layoutData = new GridData(SWT.FILL, SWT.FILL, true, true);
 
240
        fEndTable = new Table(parent, style);
 
241
        fEndTable.setLayoutData(layoutData);
 
242
 
 
243
        // Some cosmetic enhancements
 
244
        fEndTable.setHeaderVisible(true);
 
245
        fEndTable.setLinesVisible(true);
 
246
 
 
247
        createEndColumns();
 
248
 
 
249
        for (int i = 0; i < fEventTypes.size(); i++) {
 
250
            TableItem item = new TableItem(fEndTable, SWT.RIGHT);
 
251
 
 
252
            String[] columns = { fEventTypes.get(i), fEventTypes.get(i) };
 
253
 
 
254
            item.setText(columns);
 
255
        }
 
256
 
 
257
        fEndTable.setItemCount(fEventTypes.size());
 
258
 
 
259
        fEndTable.addListener(SWT.Selection, new Listener() {
 
260
            @Override
 
261
            public void handleEvent(Event event) {
 
262
                if (event.detail == SWT.CHECK) {
 
263
                    TableItem[] items = fEndTable.getItems();
 
264
                    for (TableItem item : items) {
 
265
                        if (item != event.item) {
 
266
                            item.setChecked(false);
 
267
                        }
 
268
                    }
 
269
                }
 
270
            }
 
271
        });
 
272
    }
 
273
 
 
274
    /**
 
275
     * Creates the list column for already existing event pairs.
 
276
     * @param parent
 
277
     *            The parent composite.
 
278
     */
 
279
    protected void createListColumn(Composite parent) {
 
280
        final int style = SWT.SINGLE | SWT.FULL_SELECTION | SWT.BORDER | SWT.V_SCROLL;
 
281
        GridData layoutData = new GridData(SWT.FILL, SWT.FILL, true, true);
 
282
        layoutData.horizontalSpan = 2;
 
283
        fListTable = new Table(parent, style);
 
284
        fListTable.setLayoutData(layoutData);
 
285
 
 
286
        // Some cosmetic enhancements
 
287
        fListTable.setHeaderVisible(true);
 
288
        fListTable.setLinesVisible(true);
 
289
 
 
290
        createListColumns();
 
291
 
 
292
        for (int i = 0; i < fEventStartTypes.size(); i++) {
 
293
            TableItem item = new TableItem(fListTable, SWT.RIGHT);
 
294
 
 
295
            String max = String.valueOf(fEventStartTypes.size());
 
296
            String number = formatListNumber(i + 1, max.length());
 
297
 
 
298
            String[] columns = { number, fEventStartTypes.get(i), fEventEndTypes.get(i) };
 
299
 
 
300
            item.setText(columns);
 
301
        }
 
302
 
 
303
        fListTable.setItemCount(103);
 
304
        fListTable.remove(fEventTypes.size(), 103 - 1);
 
305
    }
 
306
 
 
307
    /*
 
308
     * (non-Javadoc)
 
309
     * @see org.eclipse.linuxtools.lttng.ui.views.latency.dialogs.AbstractDialog#createDialogArea(org.eclipse.swt.widgets.Composite)
 
310
     */
 
311
    @Override
 
312
    protected Control createDialogArea(Composite parent) {
 
313
        GridLayout layout = new GridLayout(2, true);
 
314
        parent.setLayout(layout);
 
315
 
 
316
        createStartColumn(parent);
 
317
        createEndColumn(parent);
 
318
        createListColumn(parent);
 
319
 
 
320
        return parent;
 
321
    }
 
322
 
 
323
    /*
 
324
     * (non-Javadoc)
 
325
     * @see org.eclipse.linuxtools.lttng.ui.views.latency.dialogs.AbstractDialog#createButtonsForButtonBar(org.eclipse.swt.widgets.Composite)
 
326
     */
 
327
    @Override
 
328
    protected void createButtonsForButtonBar(Composite parent) {
 
329
        GridData gridData = new GridData();
 
330
        gridData.verticalAlignment = GridData.FILL;
 
331
        gridData.horizontalSpan = 1;
 
332
        gridData.grabExcessHorizontalSpace = true;
 
333
        gridData.grabExcessVerticalSpace = true;
 
334
        gridData.horizontalAlignment = SWT.RIGHT;
 
335
 
 
336
        parent.setLayoutData(gridData);
 
337
 
 
338
        // Create the "Add" button
 
339
        Button addButton = createButton(parent, ADD, Messages.LatencyView_Dialogs_AddEvents_Buttons_Add, false);
 
340
        addButton.addListener(SWT.Selection, new Listener() {
 
341
            @Override
 
342
            public void handleEvent(Event event) {
 
343
                if (isValidInput()) {
 
344
                    // Add the event pair to the EventMatcher and save the pairs
 
345
                    EventMatcher.getInstance().addMatch(fStartType, fEndType);
 
346
                    fEventStartTypes.add(fStartType);
 
347
                    fEventEndTypes.add(fEndType);
 
348
                    saveMatchPairs(fEventStartTypes, fEventEndTypes);
 
349
 
 
350
                    EventsPair pairs = EventMatcher.getInstance().getEvents();
 
351
                    fEventStartTypes = pairs.getFirst();
 
352
                    fEventEndTypes = pairs.getSecond();
 
353
 
 
354
                    fListTable.removeAll();
 
355
 
 
356
                    for (int i = 0; i < fEventStartTypes.size(); i++) {
 
357
                        TableItem item = new TableItem(fListTable, SWT.RIGHT);
 
358
 
 
359
                        String max = String.valueOf(fEventStartTypes.size());
 
360
                        String number = formatListNumber(i + 1, max.length());
 
361
 
 
362
                        String[] columns = { number, fEventStartTypes.get(i), fEventEndTypes.get(i) };
 
363
 
 
364
                        item.setText(columns);
 
365
                    }
 
366
 
 
367
                    saveMatchPairs(fEventStartTypes, fEventEndTypes);
 
368
                }
 
369
 
 
370
                fRedrawGraphs = true;
 
371
            }
 
372
        });
 
373
 
 
374
        // Create the "Close" button
 
375
        Button closeButton = createButton(parent, CANCEL, Messages.LatencyView_Dialogs_AddEvents_Buttons_Close, false);
 
376
        closeButton.addListener(SWT.Selection, new Listener() {
 
377
            @Override
 
378
            public void handleEvent(Event event) {
 
379
                setReturnCode(CANCEL);
 
380
 
 
381
                if (fRedrawGraphs == true)
 
382
                    redrawGraphs();
 
383
 
 
384
                close();
 
385
            }
 
386
        });
 
387
    }
 
388
 
 
389
    /**
 
390
     * Validate the list before adding event pairs.
 
391
     * @return "true" if the input is valid, "false" otherwise.
 
392
     */
 
393
    protected boolean isValidInput() {
 
394
        // Remove the previous error message
 
395
        setErrorMessage(null);
 
396
 
 
397
        boolean valid = true;
 
398
 
 
399
        // Check if an item from the start list is selected
 
400
        TableItem[] items = fStartTable.getItems();
 
401
        fStartType = null;
 
402
        boolean startHasSelectedItem = false;
 
403
        for (int i = 0; i < items.length && !startHasSelectedItem; i++) {
 
404
            if (items[i].getChecked() == true) {
 
405
                fStartType = items[i].getText();
 
406
                startHasSelectedItem = true;
 
407
            }
 
408
        }
 
409
 
 
410
        // Check if an item from the end list is selected
 
411
        items = fEndTable.getItems();
 
412
        fEndType = null;
 
413
        boolean endHasSelectedItem = false;
 
414
        for (int i = 0; i < items.length && !endHasSelectedItem; i++) {
 
415
            if (items[i].getChecked() == true) {
 
416
                fEndType = items[i].getText();
 
417
                endHasSelectedItem = true;
 
418
            }
 
419
        }
 
420
 
 
421
        // Print error message if needed.
 
422
        if (!startHasSelectedItem && !endHasSelectedItem) {
 
423
            setErrorMessage(Messages.LatencyView_Dialogs_AddEvents_Errors_NoSelection);
 
424
            valid = false;
 
425
        } else if (!startHasSelectedItem) {
 
426
            setErrorMessage(Messages.LatencyView_Dialogs_AddEvents_Errors_StartNotSelected);
 
427
            valid = false;
 
428
        } else if (!endHasSelectedItem) {
 
429
            setErrorMessage(Messages.LatencyView_Dialogs_AddEvents_Errors_EndNotSelected);
 
430
            valid = false;
 
431
        }
 
432
 
 
433
        // Check if the same item is selected in both lists
 
434
        if (startHasSelectedItem && endHasSelectedItem) {
 
435
            if (fStartType.equalsIgnoreCase(fEndType)) {
 
436
                setErrorMessage(Messages.LatencyView_Dialogs_AddEvents_Errors_SameSelected);
 
437
                valid = false;
 
438
            }
 
439
        }
 
440
 
 
441
        // Check if the selected item is already in the list
 
442
        if (startHasSelectedItem && endHasSelectedItem) {
 
443
            EventsPair pairs = getMatchPairs();
 
444
            Vector<String> startEvents = pairs.getFirst();
 
445
            Vector<String> endEvents = pairs.getSecond();
 
446
 
 
447
            boolean startAlreadyUsed = false;
 
448
            boolean endAlreadyUsed = false;
 
449
            boolean startAsEndAlreadyUsed = false;
 
450
            boolean endAsStartAlreadyUsed = false;
 
451
 
 
452
            if (startEvents.contains(fStartType)) {
 
453
                startAlreadyUsed = true;
 
454
            }
 
455
            if (endEvents.contains(fEndType)) {
 
456
                endAlreadyUsed = true;
 
457
            }
 
458
            if (startEvents.contains(fEndType)) {
 
459
                endAsStartAlreadyUsed = true;
 
460
            }
 
461
            if (endEvents.contains(fStartType)) {
 
462
                startAsEndAlreadyUsed = true;
 
463
            }
 
464
 
 
465
            if (startAlreadyUsed && endAlreadyUsed) {
 
466
                setErrorMessage(Messages.LatencyView_Dialogs_AddEvents_Errors_AlreadyMatched);
 
467
                valid = false;
 
468
            } else if (startAlreadyUsed) {
 
469
                setErrorMessage(Messages.LatencyView_Dialogs_AddEvents_Errors_StartAlreadyMatched);
 
470
                valid = false;
 
471
            } else if (endAlreadyUsed) {
 
472
                setErrorMessage(Messages.LatencyView_Dialogs_AddEvents_Errors_EndAlreadyMatched);
 
473
                valid = false;
 
474
            }
 
475
 
 
476
            if (startAsEndAlreadyUsed) {
 
477
                setErrorMessage(Messages.LatencyView_Dialogs_AddEvents_Errors_StartAsEnd);
 
478
                valid = false;
 
479
            }
 
480
            if (endAsStartAlreadyUsed) {
 
481
                setErrorMessage(Messages.LatencyView_Dialogs_AddEvents_Errors_EndAsStart);
 
482
                valid = false;
 
483
            }
 
484
        }
 
485
 
 
486
        return valid;
 
487
    }
 
488
}
 
 
b'\\ No newline at end of file'