← Back to branch summary

~ubuntu-branches/ubuntu/utopic/eclipse-linuxtools/utopic

« back to all changes in this revision

Viewing changes to profiling/org.eclipse.linuxtools.dataviewers/src/org/eclipse/linuxtools/dataviewers/dialogs/STDataViewersHideShowColumnsDialog.java

  • Committer: Package Import Robot
  • Author(s): Jakub Adam
  • Date: 2014-05-12 18:11:40 UTC
  • mfrom: (3.1.2 sid)
  • Revision ID: package-import@ubuntu.com-20140512181140-w237r3vsah1tmybz
Tags: 2.2.1-1
* New upstream release.
* Refreshed d/patches.
* Removed eclipse-cdt-valgrind-remote package, all its functionality
  is now provided by eclipse-cdt-profiling-framework-remote.
* Added remove-license-feature.patch.
* Bump Standards-Version to 3.9.5.
* Enable eclipse-changelog package.
* Enable eclipse-rpm-editor package.

Show diffs side-by-side

added added

removed removed

Lines of Context:
profiling/org.eclipse.linuxtools.dataviewers/src/org/eclipse/linuxtools/dataviewers/dialogs/STDataViewersHideShowColumnsDialog.java
1
 
/*******************************************************************************
2
 
 * Copyright (c) 2009 STMicroelectronics.
3
 
 * All rights reserved. This program and the accompanying materials
4
 
 * are made available under the terms of the Eclipse Public License v1.0
5
 
 * which accompanies this distribution, and is available at
6
 
 * http://www.eclipse.org/legal/epl-v10.html
7
 
 *
8
 
 * Contributors:
9
 
 *    Marzia Maugeri <marzia.maugeri@st.com> - initial API and implementation
10
 
 *******************************************************************************/
11
 
package org.eclipse.linuxtools.dataviewers.dialogs;
12
 
 
13
 
import org.eclipse.jface.dialogs.Dialog;
14
 
import org.eclipse.jface.viewers.CheckStateChangedEvent;
15
 
import org.eclipse.jface.viewers.CheckboxTableViewer;
16
 
import org.eclipse.jface.viewers.ICheckStateListener;
17
 
import org.eclipse.jface.viewers.IStructuredContentProvider;
18
 
import org.eclipse.jface.viewers.LabelProvider;
19
 
import org.eclipse.jface.viewers.Viewer;
20
 
import org.eclipse.linuxtools.dataviewers.abstractviewers.AbstractSTViewer;
21
 
import org.eclipse.linuxtools.dataviewers.abstractviewers.STDataViewersHideShowManager;
22
 
import org.eclipse.linuxtools.dataviewers.abstractviewers.STDataViewersMessages;
23
 
import org.eclipse.swt.SWT;
24
 
import org.eclipse.swt.events.SelectionEvent;
25
 
import org.eclipse.swt.events.SelectionListener;
26
 
import org.eclipse.swt.layout.GridData;
27
 
import org.eclipse.swt.layout.GridLayout;
28
 
import org.eclipse.swt.widgets.Button;
29
 
import org.eclipse.swt.widgets.Composite;
30
 
import org.eclipse.swt.widgets.Control;
31
 
import org.eclipse.swt.widgets.Item;
32
 
import org.eclipse.swt.widgets.Label;
33
 
import org.eclipse.swt.widgets.Shell;
34
 
 
35
 
 
36
 
/**
37
 
 * This dialog allows the user to show/hide some columns of the viewer
38
 
 * The status of shown/hidden columns is saved in the dialog settings of the view.
39
 
 *
40
 
 */
41
 
public class STDataViewersHideShowColumnsDialog extends Dialog {
42
 
        
43
 
        private boolean dirty;
44
 
        
45
 
        private STDataViewersHideShowManager manager;
46
 
        
47
 
        private CheckboxTableViewer checkButtonsTable;
48
 
        
49
 
        private Button selectAllButton;
50
 
        
51
 
        private Button deselectAllButton;
52
 
 
53
 
        private AbstractSTViewer stViewer;
54
 
        
55
 
        /**
56
 
         * Constructor
57
 
         * @param parentShell
58
 
         * @param view
59
 
         */
60
 
        public STDataViewersHideShowColumnsDialog(
61
 
                        AbstractSTViewer stViewer) {
62
 
                super(stViewer.getViewer().getControl().getShell());
63
 
                this.dirty = false;
64
 
                this.stViewer = stViewer;
65
 
                this.manager = stViewer.getHideShowManager();
66
 
        }
67
 
        
68
 
        /* (non-Javadoc)
69
 
     * Method declared on Window.
70
 
     */
71
 
    protected void configureShell(Shell newShell) {
72
 
        super.configureShell(newShell);
73
 
        newShell.setText(STDataViewersMessages.hideshowDialog_title);
74
 
    }
75
 
        
76
 
    /* (non-Javadoc)
77
 
     * Method declared on Dialog.
78
 
     */
79
 
    protected Control createDialogArea(Composite parent) {
80
 
        Composite composite = (Composite) super.createDialogArea(parent);
81
 
        GridData layoutData = new GridData(SWT.FILL, SWT.FILL, false, false, 2, 1);
82
 
        composite.setLayoutData(layoutData);
83
 
        GridLayout layout = new GridLayout(2, true);
84
 
        composite.setLayout(layout);
85
 
        
86
 
        initializeDialogUnits(composite);
87
 
        
88
 
        layoutData = new GridData(SWT.FILL, SWT.FILL, true, false, 2, 1);
89
 
        checkButtonsTable = createCheckboxTable(composite, layoutData);
90
 
        checkButtonsTable.setInput(stViewer.getColumns());
91
 
        checkButtonsTable.addCheckStateListener(checkStateListener);
92
 
        
93
 
        selectAllButton = new Button(composite, SWT.NONE);
94
 
        selectAllButton.setText(STDataViewersMessages.selectAll_text);
95
 
        selectAllButton.addSelectionListener(
96
 
                        new SelectionListener() {
97
 
                                        public void widgetDefaultSelected(SelectionEvent e) {
98
 
                                                widgetSelected(e);
99
 
                                        }
100
 
                                        public void widgetSelected(SelectionEvent e) {
101
 
                                                markDirty();
102
 
                                                checkButtonsTable.setAllChecked(true);
103
 
                                        }
104
 
                        }
105
 
        );
106
 
        layoutData = new GridData(SWT.FILL, SWT.TOP, false, false, 1, 1);
107
 
        selectAllButton.setLayoutData(layoutData);
108
 
        
109
 
        deselectAllButton = new Button(composite, SWT.NONE);
110
 
        deselectAllButton.setText(STDataViewersMessages.deselectAll_text);
111
 
        deselectAllButton.addSelectionListener(
112
 
                        new SelectionListener() {
113
 
                                        public void widgetDefaultSelected(SelectionEvent e) {
114
 
                                                widgetSelected(e);
115
 
                                        }
116
 
                                        public void widgetSelected(SelectionEvent e) {
117
 
                                                markDirty();
118
 
                                                checkButtonsTable.setAllChecked(false);
119
 
                                        }
120
 
                        }
121
 
        );
122
 
        layoutData = new GridData(SWT.FILL, SWT.TOP, false, false, 1, 1);
123
 
        deselectAllButton.setLayoutData(layoutData);
124
 
        
125
 
        createSeparatorLine(composite);
126
 
        Dialog.applyDialogFont(composite);
127
 
 
128
 
        setDefaultWidgetsValues();
129
 
        
130
 
        return composite;
131
 
    }
132
 
        
133
 
    private void setDefaultWidgetsValues() {
134
 
                Item[] columns = stViewer.getColumns();
135
 
                for (int i = columns.length; i-->0;) {
136
 
                        boolean state = (manager.getState(i) == STDataViewersHideShowManager.STATE_SHOWN);
137
 
                        checkButtonsTable.setChecked(columns[i], state);
138
 
                }
139
 
        }
140
 
        
141
 
        private ICheckStateListener checkStateListener = new ICheckStateListener() {
142
 
                public void checkStateChanged(CheckStateChangedEvent event) {
143
 
                        markDirty();
144
 
                }
145
 
    };
146
 
    
147
 
    /**
148
 
         * Creates a separator line above the OK/Cancel buttons bar
149
 
         * 
150
 
         * @param parent
151
 
         *            the parent composite
152
 
         */
153
 
        protected void createSeparatorLine(Composite parent) {
154
 
                GridLayout parentLayout = (GridLayout)parent.getLayout();
155
 
                
156
 
                // Build the separator line
157
 
                Label separator = new Label(parent, SWT.HORIZONTAL | SWT.SEPARATOR);
158
 
                GridData layoutData = new GridData(SWT.FILL, SWT.FILL, true, true, parentLayout.numColumns, 1);
159
 
                separator.setLayoutData(layoutData);
160
 
        }
161
 
        
162
 
        private CheckboxTableViewer createCheckboxTable(Composite parent, GridData layoutData) {
163
 
                CheckboxTableViewer tableViewer = CheckboxTableViewer.newCheckList(
164
 
                                parent,
165
 
                                SWT.SINGLE
166
 
                                | SWT.HIDE_SELECTION
167
 
                                | SWT.H_SCROLL
168
 
                                | SWT.V_SCROLL
169
 
                                | SWT.BORDER);
170
 
                tableViewer.getControl().setLayoutData(layoutData);
171
 
                
172
 
                tableViewer.setContentProvider(new IStructuredContentProvider() {
173
 
                        public Object[] getElements(Object inputElement) {
174
 
                                if (inputElement instanceof Item[]) {
175
 
                                        Item[] columns = (Item[])inputElement;
176
 
                                        int[] order = stViewer.getColumnOrder();
177
 
                                        Item[] elements = new Item[columns.length];
178
 
                                        
179
 
                                        // sort the columns according to their actual display order
180
 
                                        for (int i = columns.length; i-->0;) {
181
 
                                                elements[i] = columns[order[i]];
182
 
                                        }
183
 
                                        
184
 
                                        return elements;
185
 
                                }
186
 
                                return new Object[]{};
187
 
                        }
188
 
                        public void dispose() {}
189
 
                        public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {}
190
 
                });
191
 
 
192
 
                tableViewer.setLabelProvider(new LabelProvider() {
193
 
                        public String getText(Object element) {
194
 
                                if (element instanceof Item) {
195
 
                                        Item column = (Item)element;
196
 
                                        
197
 
                                        if (manager.getWidth(stViewer.getColumnIndex(column)) == 0) {
198
 
                                                return column.getText() + " (width = 0)";
199
 
                                        }
200
 
                                        return column.getText();
201
 
                                }
202
 
                                return element.toString();
203
 
                        }
204
 
                });
205
 
                
206
 
                return tableViewer;
207
 
        }
208
 
        
209
 
    @Override
210
 
    public int open() {
211
 
        dirty = false;
212
 
        return super.open();
213
 
    }
214
 
        
215
 
        @Override
216
 
        protected void okPressed() {
217
 
                if (isDirty()) {
218
 
                        saveManagerSettings();
219
 
                }
220
 
                super.okPressed();
221
 
        }
222
 
        
223
 
        private void saveManagerSettings() {
224
 
                Item[] columns = stViewer.getColumns();
225
 
                for (int i = columns.length; i-->0;) {
226
 
                        int state = checkButtonsTable.getChecked(columns[i])?
227
 
                                        STDataViewersHideShowManager.STATE_SHOWN :
228
 
                                        STDataViewersHideShowManager.STATE_HIDDEN;
229
 
                        manager.setState(i, state);
230
 
                }
231
 
        }
232
 
        
233
 
        /**
234
 
         * @return the hideShowManager
235
 
         */
236
 
        public STDataViewersHideShowManager getManager() {
237
 
                return manager;
238
 
        }
239
 
        
240
 
    /**
241
 
     * @return boolean
242
 
     */
243
 
    public boolean isDirty() {
244
 
        return dirty;
245
 
    }
246
 
 
247
 
    /**
248
 
     * Sets the dirty flag to true.
249
 
     */
250
 
    public void markDirty() {
251
 
        dirty = true;
252
 
    }
253
 
 
254
 
}
 
1
/*******************************************************************************
 
2
 * Copyright (c) 2009 STMicroelectronics.
 
3
 * All rights reserved. This program and the accompanying materials
 
4
 * are made available under the terms of the Eclipse Public License v1.0
 
5
 * which accompanies this distribution, and is available at
 
6
 * http://www.eclipse.org/legal/epl-v10.html
 
7
 *
 
8
 * Contributors:
 
9
 *    Marzia Maugeri <marzia.maugeri@st.com> - initial API and implementation
 
10
 *******************************************************************************/
 
11
package org.eclipse.linuxtools.dataviewers.dialogs;
 
12
 
 
13
import org.eclipse.jface.dialogs.Dialog;
 
14
import org.eclipse.jface.viewers.CheckStateChangedEvent;
 
15
import org.eclipse.jface.viewers.CheckboxTableViewer;
 
16
import org.eclipse.jface.viewers.ICheckStateListener;
 
17
import org.eclipse.jface.viewers.IStructuredContentProvider;
 
18
import org.eclipse.jface.viewers.LabelProvider;
 
19
import org.eclipse.jface.viewers.Viewer;
 
20
import org.eclipse.linuxtools.dataviewers.abstractviewers.AbstractSTViewer;
 
21
import org.eclipse.linuxtools.dataviewers.abstractviewers.STDataViewersHideShowManager;
 
22
import org.eclipse.linuxtools.dataviewers.abstractviewers.STDataViewersMessages;
 
23
import org.eclipse.swt.SWT;
 
24
import org.eclipse.swt.events.SelectionEvent;
 
25
import org.eclipse.swt.events.SelectionListener;
 
26
import org.eclipse.swt.layout.GridData;
 
27
import org.eclipse.swt.layout.GridLayout;
 
28
import org.eclipse.swt.widgets.Button;
 
29
import org.eclipse.swt.widgets.Composite;
 
30
import org.eclipse.swt.widgets.Control;
 
31
import org.eclipse.swt.widgets.Item;
 
32
import org.eclipse.swt.widgets.Label;
 
33
import org.eclipse.swt.widgets.Shell;
 
34
 
 
35
/**
 
36
 * This dialog allows the user to show/hide some columns of the viewer The status of shown/hidden columns is saved in
 
37
 * the dialog settings of the view.
 
38
 *
 
39
 */
 
40
public class STDataViewersHideShowColumnsDialog extends Dialog {
 
41
 
 
42
    private boolean dirty;
 
43
 
 
44
    private STDataViewersHideShowManager manager;
 
45
 
 
46
    private CheckboxTableViewer checkButtonsTable;
 
47
 
 
48
    private Button selectAllButton;
 
49
 
 
50
    private Button deselectAllButton;
 
51
 
 
52
    private AbstractSTViewer stViewer;
 
53
 
 
54
    /**
 
55
     * Constructor
 
56
     *
 
57
     * @param stViewer
 
58
     */
 
59
    public STDataViewersHideShowColumnsDialog(AbstractSTViewer stViewer) {
 
60
        super(stViewer.getViewer().getControl().getShell());
 
61
        this.dirty = false;
 
62
        this.stViewer = stViewer;
 
63
        this.manager = stViewer.getHideShowManager();
 
64
    }
 
65
 
 
66
    /*
 
67
     * (non-Javadoc) Method declared on Window.
 
68
     */
 
69
    @Override
 
70
        protected void configureShell(Shell newShell) {
 
71
        super.configureShell(newShell);
 
72
        newShell.setText(STDataViewersMessages.hideshowDialog_title);
 
73
    }
 
74
 
 
75
    /*
 
76
     * (non-Javadoc) Method declared on Dialog.
 
77
     */
 
78
    @Override
 
79
        protected Control createDialogArea(Composite parent) {
 
80
        Composite composite = (Composite) super.createDialogArea(parent);
 
81
        GridData layoutData = new GridData(SWT.FILL, SWT.FILL, false, false, 2, 1);
 
82
        composite.setLayoutData(layoutData);
 
83
        GridLayout layout = new GridLayout(2, true);
 
84
        composite.setLayout(layout);
 
85
 
 
86
        initializeDialogUnits(composite);
 
87
 
 
88
        layoutData = new GridData(SWT.FILL, SWT.FILL, true, false, 2, 1);
 
89
        checkButtonsTable = createCheckboxTable(composite, layoutData);
 
90
        checkButtonsTable.setInput(stViewer.getColumns());
 
91
        checkButtonsTable.addCheckStateListener(checkStateListener);
 
92
 
 
93
        selectAllButton = new Button(composite, SWT.NONE);
 
94
        selectAllButton.setText(STDataViewersMessages.selectAll_text);
 
95
        selectAllButton.addSelectionListener(new SelectionListener() {
 
96
            @Override
 
97
                        public void widgetDefaultSelected(SelectionEvent e) {
 
98
                widgetSelected(e);
 
99
            }
 
100
 
 
101
            @Override
 
102
                        public void widgetSelected(SelectionEvent e) {
 
103
                markDirty();
 
104
                checkButtonsTable.setAllChecked(true);
 
105
            }
 
106
        });
 
107
        layoutData = new GridData(SWT.FILL, SWT.TOP, false, false, 1, 1);
 
108
        selectAllButton.setLayoutData(layoutData);
 
109
 
 
110
        deselectAllButton = new Button(composite, SWT.NONE);
 
111
        deselectAllButton.setText(STDataViewersMessages.deselectAll_text);
 
112
        deselectAllButton.addSelectionListener(new SelectionListener() {
 
113
            @Override
 
114
                        public void widgetDefaultSelected(SelectionEvent e) {
 
115
                widgetSelected(e);
 
116
            }
 
117
 
 
118
            @Override
 
119
                        public void widgetSelected(SelectionEvent e) {
 
120
                markDirty();
 
121
                checkButtonsTable.setAllChecked(false);
 
122
            }
 
123
        });
 
124
        layoutData = new GridData(SWT.FILL, SWT.TOP, false, false, 1, 1);
 
125
        deselectAllButton.setLayoutData(layoutData);
 
126
 
 
127
        createSeparatorLine(composite);
 
128
        Dialog.applyDialogFont(composite);
 
129
 
 
130
        setDefaultWidgetsValues();
 
131
 
 
132
        return composite;
 
133
    }
 
134
 
 
135
    private void setDefaultWidgetsValues() {
 
136
        Item[] columns = stViewer.getColumns();
 
137
        for (int i = columns.length; i-- > 0;) {
 
138
            boolean state = (manager.getState(i) == STDataViewersHideShowManager.STATE_SHOWN);
 
139
            checkButtonsTable.setChecked(columns[i], state);
 
140
        }
 
141
    }
 
142
 
 
143
    private ICheckStateListener checkStateListener = new ICheckStateListener() {
 
144
        @Override
 
145
                public void checkStateChanged(CheckStateChangedEvent event) {
 
146
            markDirty();
 
147
        }
 
148
    };
 
149
 
 
150
    /**
 
151
     * Creates a separator line above the OK/Cancel buttons bar
 
152
     *
 
153
     * @param parent
 
154
     *            the parent composite
 
155
     */
 
156
    protected void createSeparatorLine(Composite parent) {
 
157
        GridLayout parentLayout = (GridLayout) parent.getLayout();
 
158
 
 
159
        // Build the separator line
 
160
        Label separator = new Label(parent, SWT.HORIZONTAL | SWT.SEPARATOR);
 
161
        GridData layoutData = new GridData(SWT.FILL, SWT.FILL, true, true, parentLayout.numColumns, 1);
 
162
        separator.setLayoutData(layoutData);
 
163
    }
 
164
 
 
165
    private CheckboxTableViewer createCheckboxTable(Composite parent, GridData layoutData) {
 
166
        CheckboxTableViewer tableViewer = CheckboxTableViewer.newCheckList(parent, SWT.SINGLE | SWT.HIDE_SELECTION
 
167
                | SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER);
 
168
        tableViewer.getControl().setLayoutData(layoutData);
 
169
 
 
170
        tableViewer.setContentProvider(new IStructuredContentProvider() {
 
171
            @Override
 
172
                        public Object[] getElements(Object inputElement) {
 
173
                if (inputElement instanceof Item[]) {
 
174
                    Item[] columns = (Item[]) inputElement;
 
175
                    int[] order = stViewer.getColumnOrder();
 
176
                    Item[] elements = new Item[columns.length];
 
177
 
 
178
                    // sort the columns according to their actual display order
 
179
                    for (int i = columns.length; i-- > 0;) {
 
180
                        elements[i] = columns[order[i]];
 
181
                    }
 
182
 
 
183
                    return elements;
 
184
                }
 
185
                return new Object[] {};
 
186
            }
 
187
 
 
188
            @Override
 
189
                        public void dispose() {
 
190
            }
 
191
 
 
192
            @Override
 
193
                        public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 
194
            }
 
195
        });
 
196
 
 
197
        tableViewer.setLabelProvider(new LabelProvider() {
 
198
            @Override
 
199
                        public String getText(Object element) {
 
200
                if (element instanceof Item) {
 
201
                    Item column = (Item) element;
 
202
 
 
203
                    if (manager.getWidth(stViewer.getColumnIndex(column)) == 0) {
 
204
                        return column.getText() + " (width = 0)";
 
205
                    }
 
206
                    return column.getText();
 
207
                }
 
208
                return element.toString();
 
209
            }
 
210
        });
 
211
 
 
212
        return tableViewer;
 
213
    }
 
214
 
 
215
    @Override
 
216
    public int open() {
 
217
        dirty = false;
 
218
        return super.open();
 
219
    }
 
220
 
 
221
    @Override
 
222
    protected void okPressed() {
 
223
        if (isDirty()) {
 
224
            saveManagerSettings();
 
225
        }
 
226
        super.okPressed();
 
227
    }
 
228
 
 
229
    private void saveManagerSettings() {
 
230
        Item[] columns = stViewer.getColumns();
 
231
        for (int i = columns.length; i-- > 0;) {
 
232
            int state = checkButtonsTable.getChecked(columns[i]) ? STDataViewersHideShowManager.STATE_SHOWN
 
233
                    : STDataViewersHideShowManager.STATE_HIDDEN;
 
234
            manager.setState(i, state);
 
235
        }
 
236
    }
 
237
 
 
238
    /**
 
239
     * @return the hideShowManager
 
240
     */
 
241
    public STDataViewersHideShowManager getManager() {
 
242
        return manager;
 
243
    }
 
244
 
 
245
    /**
 
246
     * @return boolean
 
247
     */
 
248
    public boolean isDirty() {
 
249
        return dirty;
 
250
    }
 
251
 
 
252
    /**
 
253
     * Sets the dirty flag to true.
 
254
     */
 
255
    public void markDirty() {
 
256
        dirty = true;
 
257
    }
 
258
 
 
259
}