[deliverable/tracecompass.git] / org.eclipse.linuxtools.tmf.ui / src / org / eclipse / linuxtools / tmf / ui / project / wizards / importtrace / ImportTraceWizardScanPage.java

/*******************************************************************************
 * Copyright (c) 2013 Ericsson
 *
 * 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:
 *   Matthew Khouzam - Initial API and implementation
 *******************************************************************************/

package org.eclipse.linuxtools.tmf.ui.project.wizards.importtrace;

import java.io.File;
import java.text.DecimalFormat;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.SubMonitor;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jface.viewers.CellEditor;
import org.eclipse.jface.viewers.CheckStateChangedEvent;
import org.eclipse.jface.viewers.CheckboxTreeViewer;
import org.eclipse.jface.viewers.ColumnLabelProvider;
import org.eclipse.jface.viewers.ColumnViewer;
import org.eclipse.jface.viewers.ColumnViewerEditor;
import org.eclipse.jface.viewers.ColumnViewerEditorActivationStrategy;
import org.eclipse.jface.viewers.EditingSupport;
import org.eclipse.jface.viewers.FocusCellOwnerDrawHighlighter;
import org.eclipse.jface.viewers.ICheckStateListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.TextCellEditor;
import org.eclipse.jface.viewers.TreeViewerColumn;
import org.eclipse.jface.viewers.TreeViewerEditor;
import org.eclipse.jface.viewers.TreeViewerFocusCellManager;
import org.eclipse.linuxtools.internal.tmf.ui.Activator;
import org.eclipse.linuxtools.internal.tmf.ui.ITmfImageConstants;
import org.eclipse.linuxtools.tmf.ui.project.model.TmfTraceType;
import org.eclipse.linuxtools.tmf.ui.project.model.TraceValidationHelper;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.ui.IWorkbench;

/**
 * <b>Import page that scans files, can be cancelled</b> this page is the third
 * of three pages shown. This one selects the traces to be imported that are to
 * be scanned.
 *
 * @author Matthew Khouzam
 * @since 2.0
 */
public class ImportTraceWizardScanPage extends AbstractImportTraceWizardPage {

    private static final int COL_WIDTH = 200;
    private static final int MAX_TRACES = 65536;
    private CheckboxTreeViewer traceTypeViewer;

    final ScanRunnable fRunnable = new ScanRunnable("Scan job"); //$NON-NLS-1$
    final private BlockingQueue<TraceValidationHelper> fTracesToScan = new ArrayBlockingQueue<>(MAX_TRACES);
    private volatile boolean fCanRun = true;

    // --------------------------------------------------------------------------------
    // Constructor and destructor
    // --------------------------------------------------------------------------------

    /**
     * Import page that scans files, can be cancelled.
     *
     * @param name
     *            The name of the page.
     * @param selection
     *            The current selection
     */
    protected ImportTraceWizardScanPage(String name, IStructuredSelection selection) {
        super(name, selection);
    }

    /**
     * Import page that scans files, can be cancelled
     *
     * @param workbench
     *            The workbench reference.
     * @param selection
     *            The current selection
     */
    public ImportTraceWizardScanPage(IWorkbench workbench, IStructuredSelection selection) {
        super(workbench, selection);
    }

    @Override
    public void dispose() {
        fCanRun = false;
        fRunnable.done(Status.OK_STATUS);
        super.dispose();
    }

    /*
     * Init
     */

    @Override
    public void createControl(Composite parent) {
        super.createControl(parent);
        final Composite control = (Composite) this.getControl();
        setTitle(Messages.ImportTraceWizardScanPageTitle);
        traceTypeViewer = new CheckboxTreeViewer(control, SWT.CHECK);
        traceTypeViewer.setContentProvider(getBatchWizard().getScannedTraces());
        traceTypeViewer.getTree().setHeaderVisible(true);
        traceTypeViewer.getControl().setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
        traceTypeViewer.setInput(getBatchWizard().getScannedTraces());
        traceTypeViewer.addCheckStateListener(new ImportTraceCheckStateListener());

        TreeViewerFocusCellManager focusCellManager = new TreeViewerFocusCellManager(traceTypeViewer, new FocusCellOwnerDrawHighlighter(traceTypeViewer));
        ColumnViewerEditorActivationStrategy actSupport = new ColumnViewerEditorActivationStrategy(traceTypeViewer) {
        };
        TreeViewerEditor.create(traceTypeViewer, focusCellManager, actSupport, ColumnViewerEditor.TABBING_HORIZONTAL
                | ColumnViewerEditor.TABBING_MOVE_TO_ROW_NEIGHBOR
                | ColumnViewerEditor.TABBING_VERTICAL | ColumnViewerEditor.KEYBOARD_ACTIVATION);

        final TextCellEditor textCellEditor = new TextCellEditor(traceTypeViewer.getTree());
        // --------------------
        // Column 1
        // --------------------
        TreeViewerColumn column = new TreeViewerColumn(traceTypeViewer, SWT.NONE);
        column.getColumn().setWidth(COL_WIDTH);
        column.getColumn().setText(Messages.ImportTraceWizardTraceDisplayName);
        column.setLabelProvider(new FirstColumnLabelProvider());
        column.setEditingSupport(new ColumnEditorSupport(traceTypeViewer, textCellEditor));

        // --------------------
        // Column 2
        // --------------------

        column = new TreeViewerColumn(traceTypeViewer, SWT.NONE);
        column.getColumn().setWidth(500);
        column.getColumn().setText(Messages.ImportTraceWizardImportCaption);
        column.setLabelProvider(new ColumnLabelProvider() {
            @Override
            public String getText(Object element) {
                if (element instanceof FileAndName) {
                    FileAndName elem = (FileAndName) element;
                    return elem.getFile().getPath();
                }
                return null;
            }
        });
        // --------------------
        // Column 3
        // --------------------

        column = new TreeViewerColumn(traceTypeViewer, SWT.NONE);

        column.getColumn().setWidth(80);
        column.getColumn().setText(Messages.ImportTraceWizardScanPageSize);
        column.getColumn().setAlignment(SWT.RIGHT);
        column.setLabelProvider(new ColumnLabelProvider() {

            @Override
            public String getText(Object element) {
                if (element instanceof FileAndName) {

                    FileAndName elem = (FileAndName) element;
                    long len = recurseSize(elem.getFile());
                    if (len > 0) {
                        double sizeb10 = Math.log10(len);
                        DecimalFormat df = new DecimalFormat();
                        df.setMaximumFractionDigits(2);
                        df.setMinimumFractionDigits(0);
                        if (sizeb10 > 12) {
                            final double tbSize = len / 1024.0 / 1024 / 1024 / 1024;
                            return df.format(tbSize) + Messages.ImportTraceWizardScanPageTerabyte;
                        }
                        if (sizeb10 > 9) {
                            final double gbSize = len / 1024.0 / 1024 / 1024;
                            return df.format(gbSize) + Messages.ImportTraceWizardScanPageGigabyte;
                        }
                        if (sizeb10 > 6) {
                            final double mbSize = len / 1024.0 / 1024;
                            return df.format(mbSize) + Messages.ImportTraceWizardScanPageMegabyte;
                        }
                        if (sizeb10 > 3) {
                            final double kbSize = len / 1024.0;
                            return df.format(kbSize) + Messages.ImportTraceWizardScanPageKilobyte;
                        }
                    }
                    return Long.toString(len) + Messages.ImportTraceWizardScanPagebyte;

                }
                return null;
            }

            private long recurseSize(File file) {
                if (file.isFile() && file.canRead()) {
                    return file.length();
                }
                long size = 0;
                if (file.exists() && file.isDirectory() && file.canRead()) {
                    final File[] listFiles = file.listFiles();
                    if (listFiles != null) {
                        for (File child : listFiles) {
                            if (child.isFile() && child.canRead()) {
                                size += child.length();
                            } else if (child.isDirectory()) {
                                size += recurseSize(child);
                            } else {
                                Activator.getDefault().logError("Unknown \"file\" type for " + child + ' ' + child.toString()); //$NON-NLS-1$
                            }
                        }
                    }
                }
                return size;
            }
        });

        init();
        getBatchWizard().setTracesToScan(fTracesToScan);
        getBatchWizard().setTraceFolder(fTargetFolder);

        fRunnable.schedule();
        setErrorMessage(Messages.ImportTraceWizardScanPageSelectAtleastOne);
    }

    private void init() {
        Composite optionPane = (Composite) this.getControl();

        optionPane.setLayout(new GridLayout());
        optionPane.setLayoutData(new GridData(SWT.LEFT, SWT.TOP, true, true));

        final Button fLink = new Button(optionPane, SWT.RADIO);
        fLink.setText(Messages.ImportTraceWizardLinkTraces);
        fLink.setSelection(true);
        fLink.setLayoutData(new GridData());

        final Button fCopy = new Button(optionPane, SWT.RADIO);
        fCopy.setText(Messages.ImportTraceWizardCopyTraces);
        fCopy.setLayoutData(new GridData());

        final SelectionListener linkedListener = new RadioChooser(fLink);

        fLink.addSelectionListener(linkedListener);
        fCopy.addSelectionListener(linkedListener);

        Button fOverwrite = new Button(optionPane, SWT.CHECK);
        fOverwrite.setText(Messages.ImportTraceWizardOverwriteTraces);
        fOverwrite.setLayoutData(new GridData());
        fOverwrite.setSelection(true);
        fOverwrite.addSelectionListener(new SelectionListener() {

            @Override
            public void widgetSelected(SelectionEvent e) {
                getBatchWizard().setOverwrite(((Button) e.widget).getSelection());
            }

            @Override
            public void widgetDefaultSelected(SelectionEvent e) {
            }
        });
    }

    /*
     * Helper classes
     */

    private final class RadioChooser implements SelectionListener {
        final private Button isLinked;

        public RadioChooser(Button desiredButton) {
            isLinked = desiredButton;
        }

        @Override
        public void widgetSelected(SelectionEvent e) {

            final Button widget = (Button) e.widget;
            getBatchWizard().setLinked(widget.equals(isLinked));
        }

        @Override
        public void widgetDefaultSelected(SelectionEvent e) {

        }
    }

    private final class ColumnEditorSupport extends EditingSupport {
        private final TextCellEditor textCellEditor;

        private ColumnEditorSupport(ColumnViewer viewer, TextCellEditor textCellEditor) {
            super(viewer);
            this.textCellEditor = textCellEditor;
        }

        @Override
        protected boolean canEdit(Object element) {
            return element instanceof FileAndName;
        }

        @Override
        protected CellEditor getCellEditor(Object element) {
            return textCellEditor;
        }

        @Override
        protected Object getValue(Object element) {
            if (element instanceof FileAndName) {
                return ((FileAndName) element).getName();
            }
            return null;
        }

        @Override
        protected void setValue(Object element, Object value) {
            FileAndName fan = (FileAndName) element;
            fan.setName((String) value);
            getBatchWizard().updateConflicts();
            traceTypeViewer.update(element, null);
            traceTypeViewer.refresh();
        }
    }

    private final class FirstColumnLabelProvider extends ColumnLabelProvider {
        Image fConflict;

        @Override
        public Image getImage(Object element) {
            if (element instanceof FileAndName) {
                final FileAndName fan = (FileAndName) element;
                if (fan.isConflictingName()) {
                    if (fConflict == null) {
                        fConflict = Activator.getDefault().getImageFromImageRegistry(ITmfImageConstants.IMG_UI_CONFLICT);
                    }
                    return fConflict;
                }
            }
            return null;
        }

        @Override
        public String getText(Object element) {
            if (element instanceof FileAndName) {
                FileAndName elem = (FileAndName) element;
                return elem.getName();
            }
            if (element instanceof String) {
                return (String) element;
            }
            return null;
        }
    }

    private final class ImportTraceCheckStateListener implements ICheckStateListener {
        @Override
        public void checkStateChanged(CheckStateChangedEvent event) {
            final CheckboxTreeViewer tv = (CheckboxTreeViewer)
                    event.getSource();
            if (event.getElement() instanceof FileAndName) {
                final FileAndName element = (FileAndName) event.getElement();
                if (event.getChecked()) {
                    getBatchWizard().addFileToImport(element);
                    traceTypeViewer.update(element, null);
                }
                else {
                    getBatchWizard().removeFileToImport(element);
                    traceTypeViewer.update(element, null);
                }
                maintainCheckIntegrity(tv, element);
            }
            if (event.getElement() instanceof String) {

                tv.setSubtreeChecked(event.getElement(), event.getChecked());
                final Object[] children =
                        getBatchWizard().getScannedTraces().getChildren(event.getElement());
                if (event.getChecked()) {
                    for (int i = 0; i < children.length; i++) {
                        final FileAndName element = (FileAndName) children[i];
                        getBatchWizard().addFileToImport(element);
                        traceTypeViewer.update(children[i], null);
                    }
                }
                else {
                    for (int i = 0; i < children.length; i++) {
                        getBatchWizard().removeFileToImport((FileAndName) children[i]);

                    }
                }

            }
            getBatchWizard().updateConflicts();
            if (getBatchWizard().hasConflicts()) {
                setErrorMessage(Messages.ImportTraceWizardScanPageRenameError);
            } else if (!getBatchWizard().hasTracesToImport()) {
                setErrorMessage(Messages.ImportTraceWizardScanPageSelectAtleastOne);
            } else {
                setErrorMessage(null);
            }
            getWizard().getContainer().updateButtons();
            traceTypeViewer.update(event.getElement(), null);
        }

        private void maintainCheckIntegrity(final CheckboxTreeViewer viewer, final FileAndName element) {
            final ImportTraceContentProvider scannedTraces = getBatchWizard().getScannedTraces();
            String parentElement = (String) scannedTraces.getParent(element);
            boolean allChecked = true;
            final FileAndName[] siblings = scannedTraces.getSiblings(element);
            if (siblings != null) {
                for (FileAndName child : siblings) {
                    allChecked &= viewer.getChecked(child);
                }
            }
            viewer.setChecked(parentElement, allChecked);
        }
    }

    private final class ScanRunnable extends Job {

        // monitor is stored here, starts as the main monitor but becomes a
        // submonitor
        private IProgressMonitor fMonitor;

        public ScanRunnable(String name) {
            super(name);
            this.setSystem(true);
        }

        private synchronized IProgressMonitor getMonitor() {
            return fMonitor;
        }

        @Override
        public IStatus run(IProgressMonitor monitor) {
            /*
             * Set up phase, it is synchronous
             */
            fMonitor = monitor;
            final Control control = traceTypeViewer.getControl();
            // please note the sync exec here is to allow us to set
            control.getDisplay().syncExec(new Runnable() {
                @Override
                public void run() {
                    // monitor gets overwritten here so it's necessary to save
                    // it in a field.
                    fMonitor = SubMonitor.convert(getMonitor());
                    getMonitor().setTaskName(Messages.ImportTraceWizardPageScanScanning + ' ');
                    ((SubMonitor) getMonitor()).setWorkRemaining(IProgressMonitor.UNKNOWN);
                }
            });
            /*
             * At this point we start calling async execs and updating the view.
             * This is a good candidate to parallelise.
             */
            while (fCanRun == true) {
                boolean updated = false;
                boolean validCombo;
                if (fTracesToScan.isEmpty() && !control.isDisposed()) {
                    control.getDisplay().asyncExec(new Runnable() {

                        @Override
                        public void run() {
                            if (!control.isDisposed()) {
                                getMonitor().setTaskName(Messages.ImportTraceWizardPageScanScanning + ' ');
                                getMonitor().subTask(Messages.ImportTraceWizardPageScanDone);
                                ImportTraceWizardScanPage.this.setMessage(Messages.ImportTraceWizardPageScanScanning + ' ' + Messages.ImportTraceWizardPageScanDone);
                            }
                        }
                    });
                }
                try {
                    final TraceValidationHelper traceToScan = fTracesToScan.take();

                    if (!getBatchWizard().hasScanned(traceToScan)) {
                        getBatchWizard().addResult(traceToScan, TmfTraceType.getInstance().validate(traceToScan));
                    }

                    /*
                     * The following is to update the UI
                     */
                    validCombo = getBatchWizard().getResult(traceToScan);
                    if (validCombo) {
                        // Synched on it's parent

                        getBatchWizard().getScannedTraces().addCandidate(traceToScan.getTraceType(), new File(traceToScan.getTraceToScan()));
                        updated = true;
                    }
                    final int scanned = getBatchWizard().getNumberOfResults();
                    final int total = scanned + fTracesToScan.size();
                    final int prevVal = (int) ((scanned - 1) * 100.0 / total);
                    final int curVal = (int) ((scanned) * 100.0 / total);
                    if (curVal != prevVal) {
                        updated = true;
                    }
                    /*
                     * update the progress
                     */
                    if (updated) {
                        if (!control.isDisposed()) {
                            control.getDisplay().asyncExec(new Runnable() {
                                @Override
                                public void run() {
                                    if (!control.isDisposed()) {
                                        getMonitor().setTaskName(Messages.ImportTraceWizardPageScanScanning + ' ');
                                        getMonitor().subTask(traceToScan.getTraceToScan());
                                        getMonitor().worked(1);
                                        ImportTraceWizardScanPage.this.setMessage(Messages.ImportTraceWizardPageScanScanning + ' '
                                                + Integer.toString(curVal)
                                                + '%');
                                    }
                                }
                            }
                                    );
                        }
                    }

                    /*
                     * here we update the table
                     */
                    final boolean editing = traceTypeViewer.isCellEditorActive();
                    if (updated && !editing) {
                        if (!control.isDisposed()) {
                            control.getDisplay().asyncExec(new Runnable() {

                                @Override
                                public void run() {
                                    if (!control.isDisposed()) {
                                        if (!traceTypeViewer.isCellEditorActive()) {
                                            traceTypeViewer.refresh();
                                        }
                                    }
                                }
                            });
                        }
                    }
                } catch (InterruptedException e) {
                    return new Status(IStatus.CANCEL, Activator.PLUGIN_ID, new String());
                }
            }
            return Status.OK_STATUS;
        }
    }

    /**
     * Refresh the view and the corresponding model.
     */
    public void refresh() {
        final Control control = traceTypeViewer.getControl();
        if (!control.isDisposed()) {
            control.getDisplay().asyncExec(new Runnable() {
                @Override
                public void run() {
                    if (!control.isDisposed()) {
                        traceTypeViewer.refresh();
                    }
                }
            });
        }
    }
}
Commit	Line	Data
d04ec5a7 MK	1	/*******************************************************************************
	2	* Copyright (c) 2013 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	* Matthew Khouzam - Initial API and implementation
	11	*******************************************************************************/
	12
	13	package org.eclipse.linuxtools.tmf.ui.project.wizards.importtrace;
	14
	15	import java.io.File;
de2501f8	16	import java.text.DecimalFormat;
d04ec5a7 MK	17	import java.util.concurrent.ArrayBlockingQueue;
	18	import java.util.concurrent.BlockingQueue;
	19
	20	import org.eclipse.core.runtime.IProgressMonitor;
11c9462b MK	21	import org.eclipse.core.runtime.IStatus;
11c9462b MK	22	import org.eclipse.core.runtime.Status;
d04ec5a7	23	import org.eclipse.core.runtime.SubMonitor;
11c9462b	24	import org.eclipse.core.runtime.jobs.Job;
d04ec5a7 MK	25	import org.eclipse.jface.viewers.CellEditor;
	26	import org.eclipse.jface.viewers.CheckStateChangedEvent;
	27	import org.eclipse.jface.viewers.CheckboxTreeViewer;
	28	import org.eclipse.jface.viewers.ColumnLabelProvider;
	29	import org.eclipse.jface.viewers.ColumnViewer;
	30	import org.eclipse.jface.viewers.ColumnViewerEditor;
	31	import org.eclipse.jface.viewers.ColumnViewerEditorActivationStrategy;
	32	import org.eclipse.jface.viewers.EditingSupport;
	33	import org.eclipse.jface.viewers.FocusCellOwnerDrawHighlighter;
	34	import org.eclipse.jface.viewers.ICheckStateListener;
	35	import org.eclipse.jface.viewers.IStructuredSelection;
	36	import org.eclipse.jface.viewers.TextCellEditor;
	37	import org.eclipse.jface.viewers.TreeViewerColumn;
	38	import org.eclipse.jface.viewers.TreeViewerEditor;
	39	import org.eclipse.jface.viewers.TreeViewerFocusCellManager;
	40	import org.eclipse.linuxtools.internal.tmf.ui.Activator;
	41	import org.eclipse.linuxtools.internal.tmf.ui.ITmfImageConstants;
	42	import org.eclipse.linuxtools.tmf.ui.project.model.TmfTraceType;
	43	import org.eclipse.linuxtools.tmf.ui.project.model.TraceValidationHelper;
	44	import org.eclipse.swt.SWT;
	45	import org.eclipse.swt.events.SelectionEvent;
	46	import org.eclipse.swt.events.SelectionListener;
	47	import org.eclipse.swt.graphics.Image;
	48	import org.eclipse.swt.layout.GridData;
	49	import org.eclipse.swt.layout.GridLayout;
	50	import org.eclipse.swt.widgets.Button;
	51	import org.eclipse.swt.widgets.Composite;
	52	import org.eclipse.swt.widgets.Control;
	53	import org.eclipse.ui.IWorkbench;
	54
	55	/**
	56	* <b>Import page that scans files, can be cancelled</b> this page is the third
	57	* of three pages shown. This one selects the traces to be imported that are to
	58	* be scanned.
	59	*
	60	* @author Matthew Khouzam
	61	* @since 2.0
	62	*/
	63	public class ImportTraceWizardScanPage extends AbstractImportTraceWizardPage {
	64
11c9462b	65	private static final int COL_WIDTH = 200;
d04ec5a7 MK	66	private static final int MAX_TRACES = 65536;
	67	private CheckboxTreeViewer traceTypeViewer;
	68
11c9462b	69	final ScanRunnable fRunnable = new ScanRunnable("Scan job"); //$NON-NLS-1$
507b1336	70	final private BlockingQueue<TraceValidationHelper> fTracesToScan = new ArrayBlockingQueue<>(MAX_TRACES);
d04ec5a7 MK	71	private volatile boolean fCanRun = true;
	72
	73	// --------------------------------------------------------------------------------
	74	// Constructor and destructor
	75	// --------------------------------------------------------------------------------
	76
	77	/**
	78	* Import page that scans files, can be cancelled.
	79	*
	80	* @param name
	81	* The name of the page.
	82	* @param selection
	83	* The current selection
	84	*/
	85	protected ImportTraceWizardScanPage(String name, IStructuredSelection selection) {
	86	super(name, selection);
	87	}
	88
	89	/**
	90	* Import page that scans files, can be cancelled
	91	*
	92	* @param workbench
	93	* The workbench reference.
	94	* @param selection
	95	* The current selection
	96	*/
	97	public ImportTraceWizardScanPage(IWorkbench workbench, IStructuredSelection selection) {
	98	super(workbench, selection);
	99	}
	100
	101	@Override
	102	public void dispose() {
	103	fCanRun = false;
11c9462b	104	fRunnable.done(Status.OK_STATUS);
d04ec5a7 MK	105	super.dispose();
	106	}
	107
	108	/*
	109	* Init
	110	*/
	111
	112	@Override
	113	public void createControl(Composite parent) {
	114	super.createControl(parent);
	115	final Composite control = (Composite) this.getControl();
32a0863e	116	setTitle(Messages.ImportTraceWizardScanPageTitle);
d04ec5a7 MK	117	traceTypeViewer = new CheckboxTreeViewer(control, SWT.CHECK);
	118	traceTypeViewer.setContentProvider(getBatchWizard().getScannedTraces());
	119	traceTypeViewer.getTree().setHeaderVisible(true);
	120	traceTypeViewer.getControl().setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
	121	traceTypeViewer.setInput(getBatchWizard().getScannedTraces());
	122	traceTypeViewer.addCheckStateListener(new ImportTraceCheckStateListener());
	123
	124	TreeViewerFocusCellManager focusCellManager = new TreeViewerFocusCellManager(traceTypeViewer, new FocusCellOwnerDrawHighlighter(traceTypeViewer));
	125	ColumnViewerEditorActivationStrategy actSupport = new ColumnViewerEditorActivationStrategy(traceTypeViewer) {
	126	};
	127	TreeViewerEditor.create(traceTypeViewer, focusCellManager, actSupport, ColumnViewerEditor.TABBING_HORIZONTAL
	128	\| ColumnViewerEditor.TABBING_MOVE_TO_ROW_NEIGHBOR
	129	\| ColumnViewerEditor.TABBING_VERTICAL \| ColumnViewerEditor.KEYBOARD_ACTIVATION);
	130
	131	final TextCellEditor textCellEditor = new TextCellEditor(traceTypeViewer.getTree());
	132	// --------------------
	133	// Column 1
	134	// --------------------
	135	TreeViewerColumn column = new TreeViewerColumn(traceTypeViewer, SWT.NONE);
11c9462b	136	column.getColumn().setWidth(COL_WIDTH);
a2d29ca1	137	column.getColumn().setText(Messages.ImportTraceWizardTraceDisplayName);
d04ec5a7 MK	138	column.setLabelProvider(new FirstColumnLabelProvider());
	139	column.setEditingSupport(new ColumnEditorSupport(traceTypeViewer, textCellEditor));
	140
	141	// --------------------
	142	// Column 2
	143	// --------------------
	144
	145	column = new TreeViewerColumn(traceTypeViewer, SWT.NONE);
de2501f8	146	column.getColumn().setWidth(500);
a2d29ca1	147	column.getColumn().setText(Messages.ImportTraceWizardImportCaption);
d04ec5a7 MK	148	column.setLabelProvider(new ColumnLabelProvider() {
	149	@Override
	150	public String getText(Object element) {
	151	if (element instanceof FileAndName) {
	152	FileAndName elem = (FileAndName) element;
	153	return elem.getFile().getPath();
	154	}
	155	return null;
	156	}
	157	});
de2501f8 MK	158	// --------------------
	159	// Column 3
	160	// --------------------
	161
	162	column = new TreeViewerColumn(traceTypeViewer, SWT.NONE);
	163
	164	column.getColumn().setWidth(80);
	165	column.getColumn().setText(Messages.ImportTraceWizardScanPageSize);
	166	column.getColumn().setAlignment(SWT.RIGHT);
	167	column.setLabelProvider(new ColumnLabelProvider() {
	168
	169	@Override
	170	public String getText(Object element) {
	171	if (element instanceof FileAndName) {
	172
	173	FileAndName elem = (FileAndName) element;
	174	long len = recurseSize(elem.getFile());
	175	if (len > 0) {
	176	double sizeb10 = Math.log10(len);
	177	DecimalFormat df = new DecimalFormat();
	178	df.setMaximumFractionDigits(2);
	179	df.setMinimumFractionDigits(0);
	180	if (sizeb10 > 12) {
	181	final double tbSize = len / 1024.0 / 1024 / 1024 / 1024;
	182	return df.format(tbSize) + Messages.ImportTraceWizardScanPageTerabyte;
	183	}
	184	if (sizeb10 > 9) {
	185	final double gbSize = len / 1024.0 / 1024 / 1024;
	186	return df.format(gbSize) + Messages.ImportTraceWizardScanPageGigabyte;
	187	}
	188	if (sizeb10 > 6) {
	189	final double mbSize = len / 1024.0 / 1024;
	190	return df.format(mbSize) + Messages.ImportTraceWizardScanPageMegabyte;
	191	}
	192	if (sizeb10 > 3) {
	193	final double kbSize = len / 1024.0;
	194	return df.format(kbSize) + Messages.ImportTraceWizardScanPageKilobyte;
	195	}
	196	}
	197	return Long.toString(len) + Messages.ImportTraceWizardScanPagebyte;
	198
	199	}
	200	return null;
	201	}
	202
	203	private long recurseSize(File file) {
	204	if (file.isFile() && file.canRead()) {
	205	return file.length();
	206	}
	207	long size = 0;
	208	if (file.exists() && file.isDirectory() && file.canRead()) {
	209	final File[] listFiles = file.listFiles();
	210	if (listFiles != null) {
	211	for (File child : listFiles) {
	212	if (child.isFile() && child.canRead()) {
	213	size += child.length();
	214	} else if (child.isDirectory()) {
	215	size += recurseSize(child);
	216	} else {
	217	Activator.getDefault().logError("Unknown \"file\" type for " + child + ' ' + child.toString()); //$NON-NLS-1$
	218	}
	219	}
	220	}
	221	}
222	return size;
223	}
224	});
d04ec5a7 MK	225
	226	init();
	227	getBatchWizard().setTracesToScan(fTracesToScan);
	228	getBatchWizard().setTraceFolder(fTargetFolder);
ba486486	229
11c9462b	230	fRunnable.schedule();
97c6e624	231	setErrorMessage(Messages.ImportTraceWizardScanPageSelectAtleastOne);
d04ec5a7 MK	232	}
	233
	234	private void init() {
	235	Composite optionPane = (Composite) this.getControl();
	236
	237	optionPane.setLayout(new GridLayout());
	238	optionPane.setLayoutData(new GridData(SWT.LEFT, SWT.TOP, true, true));
	239
	240	final Button fLink = new Button(optionPane, SWT.RADIO);
	241	fLink.setText(Messages.ImportTraceWizardLinkTraces);
	242	fLink.setSelection(true);
	243	fLink.setLayoutData(new GridData());
	244
	245	final Button fCopy = new Button(optionPane, SWT.RADIO);
	246	fCopy.setText(Messages.ImportTraceWizardCopyTraces);
	247	fCopy.setLayoutData(new GridData());
	248
	249	final SelectionListener linkedListener = new RadioChooser(fLink);
	250
	251	fLink.addSelectionListener(linkedListener);
	252	fCopy.addSelectionListener(linkedListener);
	253
	254	Button fOverwrite = new Button(optionPane, SWT.CHECK);
	255	fOverwrite.setText(Messages.ImportTraceWizardOverwriteTraces);
	256	fOverwrite.setLayoutData(new GridData());
	257	fOverwrite.setSelection(true);
	258	fOverwrite.addSelectionListener(new SelectionListener() {
	259
	260	@Override
	261	public void widgetSelected(SelectionEvent e) {
	262	getBatchWizard().setOverwrite(((Button) e.widget).getSelection());
	263	}
	264
	265	@Override
	266	public void widgetDefaultSelected(SelectionEvent e) {
	267	}
	268	});
	269	}
	270
	271	/*
	272	* Helper classes
	273	*/
	274
	275	private final class RadioChooser implements SelectionListener {
	276	final private Button isLinked;
	277
	278	public RadioChooser(Button desiredButton) {
	279	isLinked = desiredButton;
	280	}
	281
	282	@Override
	283	public void widgetSelected(SelectionEvent e) {
	284
	285	final Button widget = (Button) e.widget;
	286	getBatchWizard().setLinked(widget.equals(isLinked));
	287	}
	288
	289	@Override
	290	public void widgetDefaultSelected(SelectionEvent e) {
d04ec5a7 MK	291
	292	}
	293	}
	294
	295	private final class ColumnEditorSupport extends EditingSupport {
	296	private final TextCellEditor textCellEditor;
	297
	298	private ColumnEditorSupport(ColumnViewer viewer, TextCellEditor textCellEditor) {
	299	super(viewer);
	300	this.textCellEditor = textCellEditor;
	301	}
	302
	303	@Override
	304	protected boolean canEdit(Object element) {
	305	return element instanceof FileAndName;
	306	}
	307
	308	@Override
	309	protected CellEditor getCellEditor(Object element) {
	310	return textCellEditor;
	311	}
	312
	313	@Override
	314	protected Object getValue(Object element) {
	315	if (element instanceof FileAndName) {
	316	return ((FileAndName) element).getName();
	317	}
	318	return null;
	319	}
	320
	321	@Override
	322	protected void setValue(Object element, Object value) {
	323	FileAndName fan = (FileAndName) element;
	324	fan.setName((String) value);
	325	getBatchWizard().updateConflicts();
	326	traceTypeViewer.update(element, null);
	327	traceTypeViewer.refresh();
	328	}
	329	}
	330
	331	private final class FirstColumnLabelProvider extends ColumnLabelProvider {
	332	Image fConflict;
	333
	334	@Override
	335	public Image getImage(Object element) {
	336	if (element instanceof FileAndName) {
	337	final FileAndName fan = (FileAndName) element;
	338	if (fan.isConflictingName()) {
	339	if (fConflict == null) {
	340	fConflict = Activator.getDefault().getImageFromImageRegistry(ITmfImageConstants.IMG_UI_CONFLICT);
	341	}
	342	return fConflict;
	343	}
	344	}
	345	return null;
	346	}
	347
	348	@Override
	349	public String getText(Object element) {
	350	if (element instanceof FileAndName) {
	351	FileAndName elem = (FileAndName) element;
	352	return elem.getName();
	353	}
	354	if (element instanceof String) {
355	return (String) element;
356	}
357	return null;
358	}
359	}
360
361	private final class ImportTraceCheckStateListener implements ICheckStateListener {
362	@Override
363	public void checkStateChanged(CheckStateChangedEvent event) {
364	final CheckboxTreeViewer tv = (CheckboxTreeViewer)
365	event.getSource();
366	if (event.getElement() instanceof FileAndName) {
367	final FileAndName element = (FileAndName) event.getElement();
368	if (event.getChecked()) {
369	getBatchWizard().addFileToImport(element);
370	traceTypeViewer.update(element, null);
371	}
372	else {
373	getBatchWizard().removeFileToImport(element);
374	traceTypeViewer.update(element, null);
375	}
376	maintainCheckIntegrity(tv, element);
377	}
378	if (event.getElement() instanceof String) {
379
380	tv.setSubtreeChecked(event.getElement(), event.getChecked());
381	final Object[] children =
382	getBatchWizard().getScannedTraces().getChildren(event.getElement());
383	if (event.getChecked()) {
384	for (int i = 0; i < children.length; i++) {
385	final FileAndName element = (FileAndName) children[i];
386	getBatchWizard().addFileToImport(element);
387	traceTypeViewer.update(children[i], null);
388	}
389	}
390	else {
391	for (int i = 0; i < children.length; i++) {
392	getBatchWizard().removeFileToImport((FileAndName) children[i]);
393
394	}
395	}
396
397	}
398	getBatchWizard().updateConflicts();
399	if (getBatchWizard().hasConflicts()) {
97c6e624	400	setErrorMessage(Messages.ImportTraceWizardScanPageRenameError);
d04ec5a7	401	} else if (!getBatchWizard().hasTracesToImport()) {
97c6e624	402	setErrorMessage(Messages.ImportTraceWizardScanPageSelectAtleastOne);
d04ec5a7 MK	403	} else {
	404	setErrorMessage(null);
	405	}
	406	getWizard().getContainer().updateButtons();
	407	traceTypeViewer.update(event.getElement(), null);
	408	}
	409
	410	private void maintainCheckIntegrity(final CheckboxTreeViewer viewer, final FileAndName element) {
	411	final ImportTraceContentProvider scannedTraces = getBatchWizard().getScannedTraces();
	412	String parentElement = (String) scannedTraces.getParent(element);
	413	boolean allChecked = true;
	414	final FileAndName[] siblings = scannedTraces.getSiblings(element);
	415	if (siblings != null) {
	416	for (FileAndName child : siblings) {
	417	allChecked &= viewer.getChecked(child);
	418	}
	419	}
	420	viewer.setChecked(parentElement, allChecked);
	421	}
	422	}
	423
11c9462b MK	424	private final class ScanRunnable extends Job {
11c9462b MK	425
32a0863e MK	426	// monitor is stored here, starts as the main monitor but becomes a
32a0863e MK	427	// submonitor
ba486486 MK	428	private IProgressMonitor fMonitor;
ba486486 MK	429
11c9462b MK	430	public ScanRunnable(String name) {
11c9462b MK	431	super(name);
bb416b02	432	this.setSystem(true);
11c9462b MK	433	}
11c9462b MK	434
d04ec5a7 MK	435	private synchronized IProgressMonitor getMonitor() {
	436	return fMonitor;
	437	}
	438
	439	@Override
11c9462b	440	public IStatus run(IProgressMonitor monitor) {
32a0863e MK	441	/*
	442	* Set up phase, it is synchronous
	443	*/
d04ec5a7 MK	444	fMonitor = monitor;
d04ec5a7 MK	445	final Control control = traceTypeViewer.getControl();
32a0863e	446	// please note the sync exec here is to allow us to set
d04ec5a7 MK	447	control.getDisplay().syncExec(new Runnable() {
	448	@Override
	449	public void run() {
32a0863e MK	450	// monitor gets overwritten here so it's necessary to save
32a0863e MK	451	// it in a field.
d04ec5a7	452	fMonitor = SubMonitor.convert(getMonitor());
97c6e624	453	getMonitor().setTaskName(Messages.ImportTraceWizardPageScanScanning + ' ');
d04ec5a7 MK	454	((SubMonitor) getMonitor()).setWorkRemaining(IProgressMonitor.UNKNOWN);
	455	}
	456	});
32a0863e MK	457	/*
	458	* At this point we start calling async execs and updating the view.
	459	* This is a good candidate to parallelise.
	460	*/
d04ec5a7 MK	461	while (fCanRun == true) {
	462	boolean updated = false;
	463	boolean validCombo;
	464	if (fTracesToScan.isEmpty() && !control.isDisposed()) {
	465	control.getDisplay().asyncExec(new Runnable() {
	466
	467	@Override
	468	public void run() {
	469	if (!control.isDisposed()) {
97c6e624 MK	470	getMonitor().setTaskName(Messages.ImportTraceWizardPageScanScanning + ' ');
97c6e624 MK	471	getMonitor().subTask(Messages.ImportTraceWizardPageScanDone);
32a0863e	472	ImportTraceWizardScanPage.this.setMessage(Messages.ImportTraceWizardPageScanScanning + ' ' + Messages.ImportTraceWizardPageScanDone);
d04ec5a7 MK	473	}
	474	}
	475	});
	476	}
11c9462b MK	477	try {
11c9462b MK	478	final TraceValidationHelper traceToScan = fTracesToScan.take();
d04ec5a7	479
11c9462b MK	480	if (!getBatchWizard().hasScanned(traceToScan)) {
	481	getBatchWizard().addResult(traceToScan, TmfTraceType.getInstance().validate(traceToScan));
	482	}
bb416b02 MK	483
	484	/*
	485	* The following is to update the UI
	486	*/
11c9462b MK	487	validCombo = getBatchWizard().getResult(traceToScan);
	488	if (validCombo) {
	489	// Synched on it's parent
d04ec5a7	490
11c9462b MK	491	getBatchWizard().getScannedTraces().addCandidate(traceToScan.getTraceType(), new File(traceToScan.getTraceToScan()));
	492	updated = true;
	493	}
bb416b02 MK	494	final int scanned = getBatchWizard().getNumberOfResults();
	495	final int total = scanned + fTracesToScan.size();
	496	final int prevVal = (int) ((scanned - 1) * 100.0 / total);
	497	final int curVal = (int) ((scanned) * 100.0 / total);
	498	if (curVal != prevVal) {
	499	updated = true;
	500	}
	501	/*
	502	* update the progress
	503	*/
11c9462b MK	504	if (updated) {
	505	if (!control.isDisposed()) {
	506	control.getDisplay().asyncExec(new Runnable() {
	507	@Override
	508	public void run() {
	509	if (!control.isDisposed()) {
97c6e624	510	getMonitor().setTaskName(Messages.ImportTraceWizardPageScanScanning + ' ');
11c9462b MK	511	getMonitor().subTask(traceToScan.getTraceToScan());
11c9462b MK	512	getMonitor().worked(1);
bb416b02 MK	513	ImportTraceWizardScanPage.this.setMessage(Messages.ImportTraceWizardPageScanScanning + ' '
	514	+ Integer.toString(curVal)
	515	+ '%');
11c9462b	516	}
d04ec5a7 MK	517	}
d04ec5a7 MK	518	}
11c9462b	519	);
d04ec5a7	520	}
d04ec5a7	521	}
d04ec5a7	522
bb416b02 MK	523	/*
	524	* here we update the table
	525	*/
11c9462b MK	526	final boolean editing = traceTypeViewer.isCellEditorActive();
	527	if (updated && !editing) {
	528	if (!control.isDisposed()) {
	529	control.getDisplay().asyncExec(new Runnable() {
	530
	531	@Override
	532	public void run() {
	533	if (!control.isDisposed()) {
	534	if (!traceTypeViewer.isCellEditorActive()) {
	535	traceTypeViewer.refresh();
	536	}
d04ec5a7 MK	537	}
d04ec5a7 MK	538	}
11c9462b MK	539	});
11c9462b MK	540	}
d04ec5a7	541	}
11c9462b MK	542	} catch (InterruptedException e) {
11c9462b MK	543	return new Status(IStatus.CANCEL, Activator.PLUGIN_ID, new String());
d04ec5a7 MK	544	}
d04ec5a7 MK	545	}
11c9462b	546	return Status.OK_STATUS;
d04ec5a7 MK	547	}
d04ec5a7 MK	548	}
ba486486 MK	549
	550	/**
	551	* Refresh the view and the corresponding model.
	552	*/
	553	public void refresh() {
	554	final Control control = traceTypeViewer.getControl();
	555	if (!control.isDisposed()) {
	556	control.getDisplay().asyncExec(new Runnable() {
	557	@Override
	558	public void run() {
	559	if (!control.isDisposed()) {
	560	traceTypeViewer.refresh();
	561	}
	562	}
	563	});
	564	}
	565	}
d04ec5a7	566	}