org.eclipse.cdt.debug.internal.ui.views.executables.BaseViewer.java Source code

Introduction

Here is the source code for org.eclipse.cdt.debug.internal.ui.views.executables.BaseViewer.java

Source

/*******************************************************************************
 * Copyright (c) 2008 Nokia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Nokia - Initial API and implementation
 *******************************************************************************/

package org.eclipse.cdt.debug.internal.ui.views.executables;

import org.eclipse.core.runtime.Preferences;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.ViewerComparator;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeColumn;

/**
 * Base viewer used by both the executables viewers and the source files viewer.
 */
abstract class BaseViewer extends TreeViewer {

    // Common columns
    protected TreeColumn nameColumn;
    protected TreeColumn locationColumn;
    protected TreeColumn sizeColumn;
    protected TreeColumn modifiedColumn;
    protected TreeColumn typeColumn;

    private static final int NUM_COLUMNS = 7;
    int column_sort_order[] = new int[NUM_COLUMNS];

    private ExecutablesView executablesView;

    class ColumnSelectionAdapter extends SelectionAdapter {

        private int selector;

        public ColumnSelectionAdapter(int selector) {
            this.selector = selector;
        }

        @Override
        public void widgetSelected(SelectionEvent e) {
            setComparator(getViewerComparator(selector));
            getTree().setSortColumn((TreeColumn) e.getSource());
            getTree()
                    .setSortDirection(column_sort_order[selector] == ExecutablesView.ASCENDING ? SWT.UP : SWT.DOWN);
            column_sort_order[selector] *= -1;
        }

    }

    public BaseViewer(ExecutablesView view, Composite parent, int style) {
        super(parent, style);
        executablesView = view;

        // default all columns sort order to ascending
        for (int i = 0; i < NUM_COLUMNS; i++) {
            column_sort_order[i] = ExecutablesView.ASCENDING;
        }
    }

    public ExecutablesView getExecutablesView() {
        return executablesView;
    }

    protected void packColumns() {
        TreeColumn[] columns = getTree().getColumns();
        for (TreeColumn treeColumn : columns) {
            if (treeColumn.getWidth() > 0) {
                treeColumn.pack();
                treeColumn.setWidth(treeColumn.getWidth() + ExecutablesView.COLUMN_WIDTH_PADDING);
            }
        }
    }

    protected void saveColumnSettings(Preferences preferences) {
        Tree tree = getTree();

        // save the column order
        StringBuilder columnOrder = new StringBuilder();
        for (int index : tree.getColumnOrder()) {
            columnOrder.append(","); //$NON-NLS-1$
            columnOrder.append(Integer.toString(index));
        }
        // trim the leading comma
        columnOrder.deleteCharAt(0);
        preferences.setValue(getColumnOrderKey(), columnOrder.toString());

        // save which column was sorted and in which direction
        TreeColumn sortedColumn = tree.getSortColumn();
        for (int i = 0; i < tree.getColumnCount(); i++) {
            if (sortedColumn.equals(tree.getColumn(i))) {
                preferences.setValue(getSortedColumnIndexKey(), i);
                preferences.setValue(getSortedColumnDirectionKey(), tree.getSortDirection());
                break;
            }
        }

        // save the visible state of each columns (1 is visible, 0 is not)
        String visibleColumns = ""; //$NON-NLS-1$
        for (int i = 0; i < tree.getColumnCount(); i++) {
            if (tree.getColumn(i).getWidth() > 0) {
                visibleColumns += ",1"; //$NON-NLS-1$
            } else {
                visibleColumns += ",0"; //$NON-NLS-1$
            }
        }
        // trim the leading comma
        visibleColumns = visibleColumns.substring(1);
        preferences.setValue(getVisibleColumnsKey(), visibleColumns);
    }

    protected void restoreColumnSettings(Preferences preferences) {
        Tree tree = getTree();

        // restore the column order
        String columnOrder = preferences.getString(getColumnOrderKey());
        if (columnOrder.length() > 0) {
            String[] columns = columnOrder.split(","); //$NON-NLS-1$
            int[] columnNumbers = new int[columns.length];
            for (int i = 0; i < columns.length; i++) {
                columnNumbers[i] = Integer.parseInt(columns[i]);
            }
            tree.setColumnOrder(columnNumbers);
        }

        // restore the sorted column
        int sortedColumnIndex = preferences.getInt(getSortedColumnIndexKey());
        int sortedColumnDirection = preferences.getInt(getSortedColumnDirectionKey());
        tree.setSortColumn(tree.getColumn(sortedColumnIndex));
        tree.setSortDirection(sortedColumnDirection == 0 ? SWT.UP : sortedColumnDirection);

        setComparator(getViewerComparator(sortedColumnIndex));

        // remember the sort order for the column
        column_sort_order[sortedColumnIndex] = sortedColumnDirection == SWT.UP ? ExecutablesView.ASCENDING
                : ExecutablesView.DESCENDING;

        // restore the visible state of each columns (1 is visible, 0 is not)
        String visibleColumns = preferences.getString(getVisibleColumnsKey());
        if (visibleColumns.length() <= 0) {
            visibleColumns = getDefaultVisibleColumnsValue();
        }
        String[] columns = visibleColumns.split(","); //$NON-NLS-1$
        for (int i = 0; i < columns.length; i++) {
            if (columns[i].equals("0")) { //$NON-NLS-1$
                tree.getColumn(i).setWidth(0);
            }
        }
    }

    abstract protected ViewerComparator getViewerComparator(int sortType);

    abstract protected String getColumnOrderKey();

    abstract protected String getSortedColumnIndexKey();

    abstract protected String getSortedColumnDirectionKey();

    abstract protected String getVisibleColumnsKey();

    abstract protected String getDefaultVisibleColumnsValue();
}