org.eclipse.linuxtools.tmf.ui/src/org/eclipse/linuxtools/internal/tmf/ui/project/wizards/tracepkg/importexport/ExportTracePackageWizardPage.java

   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  *     Marc-Andre Laperle - Initial API and implementation
  11  *******************************************************************************/
  12
  13 package org.eclipse.linuxtools.internal.tmf.ui.project.wizards.tracepkg.importexport;
  14
  15 import java.io.File;
  16 import java.lang.reflect.InvocationTargetException;
  17 import java.text.MessageFormat;
  18 import java.util.ArrayList;
  19 import java.util.List;
  20
  21 import org.eclipse.core.resources.IFile;
  22 import org.eclipse.core.resources.IMarker;
  23 import org.eclipse.core.resources.IResource;
  24 import org.eclipse.core.runtime.CoreException;
  25 import org.eclipse.core.runtime.IProgressMonitor;
  26 import org.eclipse.core.runtime.IStatus;
  27 import org.eclipse.jface.dialogs.IDialogSettings;
  28 import org.eclipse.jface.dialogs.MessageDialog;
  29 import org.eclipse.jface.operation.IRunnableWithProgress;
  30 import org.eclipse.jface.viewers.CheckboxTreeViewer;
  31 import org.eclipse.jface.viewers.ColumnLabelProvider;
  32 import org.eclipse.jface.viewers.IStructuredSelection;
  33 import org.eclipse.jface.viewers.TreeViewerColumn;
  34 import org.eclipse.linuxtools.internal.tmf.ui.Activator;
  35 import org.eclipse.linuxtools.internal.tmf.ui.project.wizards.tracepkg.AbstractTracePackageWizardPage;
  36 import org.eclipse.linuxtools.internal.tmf.ui.project.wizards.tracepkg.TracePackageBookmarkElement;
  37 import org.eclipse.linuxtools.internal.tmf.ui.project.wizards.tracepkg.TracePackageElement;
  38 import org.eclipse.linuxtools.internal.tmf.ui.project.wizards.tracepkg.TracePackageFilesElement;
  39 import org.eclipse.linuxtools.internal.tmf.ui.project.wizards.tracepkg.TracePackageLabelProvider;
  40 import org.eclipse.linuxtools.internal.tmf.ui.project.wizards.tracepkg.TracePackageSupplFileElement;
  41 import org.eclipse.linuxtools.internal.tmf.ui.project.wizards.tracepkg.TracePackageSupplFilesElement;
  42 import org.eclipse.linuxtools.internal.tmf.ui.project.wizards.tracepkg.TracePackageTraceElement;
  43 import org.eclipse.linuxtools.tmf.ui.project.model.TmfTraceElement;
  44 import org.eclipse.swt.SWT;
  45 import org.eclipse.swt.events.ModifyEvent;
  46 import org.eclipse.swt.events.ModifyListener;
  47 import org.eclipse.swt.events.SelectionAdapter;
  48 import org.eclipse.swt.events.SelectionEvent;
  49 import org.eclipse.swt.layout.GridData;
  50 import org.eclipse.swt.layout.GridLayout;
  51 import org.eclipse.swt.layout.RowLayout;
  52 import org.eclipse.swt.widgets.Button;
  53 import org.eclipse.swt.widgets.Composite;
  54 import org.eclipse.swt.widgets.Group;
  55 import org.eclipse.swt.widgets.Label;
  56
  57 /**
  58  * Wizard page for the export trace package wizard
  59  *
  60  * @author Marc-Andre Laperle
  61  */
  62 public class ExportTracePackageWizardPage extends AbstractTracePackageWizardPage {
  63
  64     private static final int CONTENT_COL_WIDTH = 300;
  65     private static final int SIZE_COL_WIDTH = 100;
  66
  67     private static final String ZIP_EXTENSION = ".zip"; //$NON-NLS-1$
  68     private static final String TAR_EXTENSION = ".tar"; //$NON-NLS-1$
  69     private static final String TAR_GZ_EXTENSION = ".tar.gz"; //$NON-NLS-1$
  70     private static final String TGZ_EXTENSION = ".tgz"; //$NON-NLS-1$
  71
  72     private static final String ICON_PATH = "icons/wizban/export_wiz.png"; //$NON-NLS-1$
  73
  74     /**
  75      * The page name, can be referenced from other pages
  76      */
  77     public static final String PAGE_NAME = "ExportTracePackageWizardPage"; //$NON-NLS-1$
  78     // dialog store id constants
  79     private static final String STORE_COMPRESS_CONTENTS_ID = PAGE_NAME + ".STORE_COMPRESS_CONTENTS_ID"; //$NON-NLS-1$
  80     private static final String STORE_FORMAT_ID = PAGE_NAME + ".STORE_FORMAT_ID"; //$NON-NLS-1$
  81
  82     private Button fCompressContentsCheckbox;
  83     private Button fZipFormatButton;
  84     private Button fTargzFormatButton;
  85     private Label fApproximateSizeLabel;
  86     private List<TmfTraceElement> fSelectedTraces;
  87
  88     /**
  89      * Constructor for the export trace package wizard page
  90      *
  91      * @param selection
  92      *            the current object selection
  93      */
  94     public ExportTracePackageWizardPage(IStructuredSelection selection) {
  95         super(PAGE_NAME, Messages.ExportTracePackageWizardPage_Title, Activator.getDefault().getImageDescripterFromPath(ICON_PATH), selection);
  96
  97         Object[] selectedElements = getSelection().toArray();
  98         fSelectedTraces = new ArrayList<TmfTraceElement>();
  99         for (Object selectedElement : selectedElements) {
 100             if (selectedElement instanceof TmfTraceElement) {
 101                 fSelectedTraces.add(((TmfTraceElement) selectedElement).getElementUnderTraceFolder());
 102             }
 103         }
 104     }
 105
 106     /**
 107      * Set the selected trace from the previous page to be displayed in the
 108      * element viewer
 109      *
 110      * @param selectedTraces
 111      *            the selected trace
 112      */
 113     public void setSelectedTraces(List<TmfTraceElement> selectedTraces) {
 114         if (!fSelectedTraces.containsAll(selectedTraces) || !selectedTraces.containsAll(fSelectedTraces)) {
 115             fSelectedTraces = selectedTraces;
 116             CheckboxTreeViewer elementViewer = getElementViewer();
 117             elementViewer.setInput(createElementViewerInput());
 118             elementViewer.expandToLevel(2);
 119             setAllChecked(elementViewer, false, true);
 120             updateApproximateSelectedSize();
 121         }
 122     }
 123
 124     @Override
 125     public void createControl(Composite parent) {
 126
 127         initializeDialogUnits(parent);
 128
 129         Composite composite = new Composite(parent, SWT.NULL);
 130         composite.setLayout(new GridLayout());
 131         composite.setLayoutData(new GridData(GridData.VERTICAL_ALIGN_FILL | GridData.HORIZONTAL_ALIGN_FILL));
 132
 133         createElementViewer(composite);
 134         createButtonsGroup(composite);
 135         createFilePathGroup(composite, Messages.ExportTracePackageWizardPage_ToArchive, SWT.SAVE);
 136         createOptionsGroup(composite);
 137
 138         restoreWidgetValues();
 139         setMessage(Messages.ExportTracePackageWizardPage_ChooseContent);
 140
 141         updateApproximateSelectedSize();
 142         updatePageCompletion();
 143
 144         setControl(composite);
 145     }
 146
 147     /**
 148      * Restore widget values to the values that they held last time this wizard
 149      * was used to completion.
 150      */
 151     @Override
 152     protected void restoreWidgetValues() {
 153         super.restoreWidgetValues();
 154
 155         IDialogSettings settings = getDialogSettings();
 156         if (settings != null) {
 157             if (getFilePathCombo().getItemCount() > 0) {
 158                 String item = getFilePathCombo().getItem(0);
 159                 setFilePathValue(item);
 160             }
 161             fCompressContentsCheckbox.setSelection(settings.getBoolean(STORE_COMPRESS_CONTENTS_ID));
 162             fZipFormatButton.setSelection(settings.getBoolean(STORE_FORMAT_ID));
 163             fTargzFormatButton.setSelection(!settings.getBoolean(STORE_FORMAT_ID));
 164             updateWithFilePathSelection();
 165         }
 166     }
 167
 168     @Override
 169     protected void createFilePathGroup(Composite parent, String label, int fileDialogStyle) {
 170         super.createFilePathGroup(parent, label, fileDialogStyle);
 171
 172         getFilePathCombo().addModifyListener(new ModifyListener() {
 173             @Override
 174             public void modifyText(ModifyEvent e) {
 175                 updatePageCompletion();
 176             }
 177         });
 178     }
 179
 180     private void createOptionsGroup(Composite parent) {
 181         Group optionsGroup = new Group(parent, SWT.NONE);
 182         optionsGroup.setLayout(new RowLayout(SWT.VERTICAL));
 183         optionsGroup.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_FILL
 184                 | GridData.GRAB_HORIZONTAL));
 185         optionsGroup.setText(Messages.ExportTracePackageWizardPage_Options);
 186
 187         SelectionAdapter listener = new SelectionAdapter() {
 188             @Override
 189             public void widgetSelected(SelectionEvent e) {
 190                 updateWithFilePathSelection();
 191             }
 192         };
 193
 194         fZipFormatButton = new Button(optionsGroup, SWT.RADIO | SWT.LEFT);
 195         fZipFormatButton.setText(Messages.ExportTracePackageWizardPage_SaveInZipFormat);
 196         fZipFormatButton.setSelection(true);
 197         fZipFormatButton.addSelectionListener(listener);
 198
 199         fTargzFormatButton = new Button(optionsGroup, SWT.RADIO | SWT.LEFT);
 200         fTargzFormatButton.setText(Messages.ExportTracePackageWizardPage_SaveInTarFormat);
 201         fTargzFormatButton.setSelection(false);
 202         fTargzFormatButton.addSelectionListener(listener);
 203
 204         fCompressContentsCheckbox = new Button(optionsGroup, SWT.CHECK | SWT.LEFT);
 205         fCompressContentsCheckbox.setText(Messages.ExportTracePackageWizardPage_CompressContents);
 206         fCompressContentsCheckbox.setSelection(true);
 207         fCompressContentsCheckbox.addSelectionListener(listener);
 208     }
 209
 210     @Override
 211     protected void createElementViewer(Composite parent) {
 212         super.createElementViewer(parent);
 213
 214         CheckboxTreeViewer elementViewer = getElementViewer();
 215         elementViewer.getTree().setHeaderVisible(true);
 216         // Content column
 217         TreeViewerColumn column = new TreeViewerColumn(elementViewer, SWT.NONE);
 218         column.getColumn().setWidth(CONTENT_COL_WIDTH);
 219         column.getColumn().setText(Messages.ExportTracePackageWizardPage_ContentColumnName);
 220         column.setLabelProvider(new TracePackageLabelProvider());
 221
 222         // Size column
 223         column = new TreeViewerColumn(elementViewer, SWT.NONE);
 224         column.getColumn().setWidth(SIZE_COL_WIDTH);
 225         column.getColumn().setText(Messages.ExportTracePackageWizardPage_SizeColumnName);
 226         column.setLabelProvider(new ColumnLabelProvider() {
 227             @Override
 228             public String getText(Object element) {
 229                 TracePackageElement tracePackageElement = (TracePackageElement) element;
 230                 long size = tracePackageElement.getSize(false);
 231                 if (size == 0) {
 232                     return null;
 233                 }
 234                 int level = 0;
 235                 TracePackageElement curElement = tracePackageElement.getParent();
 236                 while (curElement != null) {
 237                     curElement = curElement.getParent();
 238                     ++level;
 239                 }
 240
 241                 return indent(getHumanReadable(size), level);
 242             }
 243
 244             private String indent(String humanReadable, int level) {
 245                 StringBuilder s = new StringBuilder(humanReadable);
 246                 for (int i = 0; i < level; ++i) {
 247                     final String indentStr = "  "; //$NON-NLS-1$
 248                     s.insert(0, indentStr);
 249                 }
 250                 return s.toString();
 251             }
 252         });
 253
 254         elementViewer.setInput(createElementViewerInput());
 255         elementViewer.expandToLevel(2);
 256         setAllChecked(elementViewer, false, true);
 257     }
 258
 259     @Override
 260     protected void updateApproximateSelectedSize() {
 261         long checkedSize = 0;
 262         TracePackageElement[] tracePackageElements = (TracePackageElement[]) getElementViewer().getInput();
 263         for (TracePackageElement element : tracePackageElements) {
 264             checkedSize += element.getSize(true);
 265         }
 266         checkedSize = Math.max(0, checkedSize);
 267         fApproximateSizeLabel.setText(MessageFormat.format(Messages.ExportTracePackageWizardPage_ApproximateSizeLbl, getHumanReadable(checkedSize)));
 268     }
 269
 270     /**
 271      * Get the human readable string for a size in bytes. (KB, MB, etc).
 272      *
 273      * @param size
 274      *            the size to print in human readable,
 275      * @return the human readable string
 276      */
 277     private static String getHumanReadable(long size) {
 278         String humanSuffix[] = { Messages.ExportTracePackageWizardPage_SizeByte, Messages.ExportTracePackageWizardPage_SizeKilobyte,
 279                 Messages.ExportTracePackageWizardPage_SizeMegabyte, Messages.ExportTracePackageWizardPage_SizeGigabyte,
 280                 Messages.ExportTracePackageWizardPage_SizeTerabyte };
 281         long curSize = size;
 282
 283         int suffixIndex = 0;
 284         while (curSize >= 1024) {
 285             curSize /= 1024;
 286             ++suffixIndex;
 287         }
 288
 289         return Long.toString(curSize) + " " + humanSuffix[suffixIndex]; //$NON-NLS-1$
 290     }
 291
 292     @Override
 293     protected Object createElementViewerInput() {
 294         List<TracePackageTraceElement> traceElements = new ArrayList<TracePackageTraceElement>();
 295         for (TmfTraceElement tmfTraceElement : fSelectedTraces) {
 296             TracePackageTraceElement traceElement = new TracePackageTraceElement(null, tmfTraceElement);
 297
 298             // Trace files
 299             List<TracePackageElement> children = new ArrayList<TracePackageElement>();
 300             TracePackageFilesElement filesElement = new TracePackageFilesElement(traceElement, tmfTraceElement.getResource());
 301             filesElement.setChecked(true);
 302             // Always export the files
 303             filesElement.setEnabled(false);
 304             children.add(filesElement);
 305
 306             // Supplementary files
 307             IResource[] supplementaryResources = tmfTraceElement.getSupplementaryResources();
 308             List<TracePackageElement> suppFilesChildren = new ArrayList<TracePackageElement>();
 309             TracePackageSupplFilesElement suppFilesElement = new TracePackageSupplFilesElement(traceElement);
 310             children.add(suppFilesElement);
 311             for (IResource res : supplementaryResources) {
 312                 suppFilesChildren.add(new TracePackageSupplFileElement(res, suppFilesElement));
 313             }
 314             suppFilesElement.setChildren(suppFilesChildren.toArray(new TracePackageElement[] {}));
 315
 316             // Bookmarks
 317             IFile bookmarksFile = tmfTraceElement.getBookmarksFile();
 318             if (bookmarksFile != null && bookmarksFile.exists()) {
 319                 IMarker[] findMarkers;
 320                 try {
 321                     findMarkers = bookmarksFile.findMarkers(IMarker.BOOKMARK, false, IResource.DEPTH_ZERO);
 322                     if (findMarkers.length > 0) {
 323                         children.add(new TracePackageBookmarkElement(traceElement, null));
 324                     }
 325                 } catch (CoreException e) {
 326                     // Should not happen since we just checked bookmarksFile.exists() but log it just in case
 327                     Activator.getDefault().logError("Error finding bookmarks", e); //$NON-NLS-1$
 328                 }
 329             }
 330
 331             traceElement.setChildren(children.toArray(new TracePackageElement[] {}));
 332
 333             traceElements.add(traceElement);
 334
 335         }
 336
 337         return traceElements.toArray(new TracePackageTraceElement[] {});
 338     }
 339
 340     @Override
 341     protected final Composite createButtonsGroup(Composite parent) {
 342         Composite buttonGroup = super.createButtonsGroup(parent);
 343
 344         // Add the label on the same row of the select/deselect all buttons
 345         fApproximateSizeLabel = new Label(buttonGroup, SWT.RIGHT);
 346         GridData layoutData = new GridData(GridData.FILL_HORIZONTAL);
 347         layoutData.grabExcessHorizontalSpace = true;
 348         fApproximateSizeLabel.setLayoutData(layoutData);
 349
 350         return buttonGroup;
 351     }
 352
 353     /**
 354      * Save widget values to Dialog settings
 355      */
 356     @Override
 357     protected void saveWidgetValues() {
 358         super.saveWidgetValues();
 359
 360         IDialogSettings settings = getDialogSettings();
 361         if (settings != null) {
 362             settings.put(STORE_COMPRESS_CONTENTS_ID, fCompressContentsCheckbox.getSelection());
 363             settings.put(STORE_FORMAT_ID, fZipFormatButton.getSelection());
 364         }
 365     }
 366
 367     private String getOutputExtension() {
 368         if (fZipFormatButton.getSelection()) {
 369             return ZIP_EXTENSION;
 370         } else if (fCompressContentsCheckbox.getSelection()) {
 371             return TAR_GZ_EXTENSION;
 372         } else {
 373             return TAR_EXTENSION;
 374         }
 375     }
 376
 377     @Override
 378     protected void updateWithFilePathSelection() {
 379         String filePathValue = getFilePathValue();
 380         if (filePathValue.isEmpty()) {
 381             return;
 382         }
 383
 384         filePathValue = stripKnownExtension(filePathValue);
 385         filePathValue = filePathValue.concat(getOutputExtension());
 386
 387         setFilePathValue(filePathValue);
 388     }
 389
 390     private static String stripKnownExtension(String str) {
 391         String ret = str;
 392         if (str.endsWith(TAR_GZ_EXTENSION)) {
 393             ret = ret.substring(0, ret.lastIndexOf(".")); //$NON-NLS-1$
 394         }
 395
 396         if (ret.endsWith(ZIP_EXTENSION) | ret.endsWith(TAR_EXTENSION) | ret.endsWith(TGZ_EXTENSION)) {
 397             ret = ret.substring(0, ret.lastIndexOf(".")); //$NON-NLS-1$
 398         }
 399
 400         return ret;
 401     }
 402
 403     /**
 404      * Finish the wizard page
 405      *
 406      * @return true on success
 407      */
 408     public boolean finish() {
 409         if (!checkForOverwrite()) {
 410             return false;
 411         }
 412
 413         saveWidgetValues();
 414
 415         TracePackageTraceElement[] traceExportElements = (TracePackageTraceElement[]) getElementViewer().getInput();
 416         boolean useCompression = fCompressContentsCheckbox.getSelection();
 417         boolean useTar = fTargzFormatButton.getSelection();
 418         String fileName = getFilePathValue();
 419         final TracePackageExportOperation exporter = new TracePackageExportOperation(traceExportElements, useCompression, useTar, fileName);
 420
 421         try {
 422             getContainer().run(true, true, new IRunnableWithProgress() {
 423
 424                 @Override
 425                 public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
 426                     exporter.run(monitor);
 427                 }
 428             });
 429
 430             IStatus status = exporter.getStatus();
 431             if (status.getSeverity() == IStatus.ERROR) {
 432                 handleErrorStatus(status);
 433             }
 434
 435         } catch (InvocationTargetException e) {
 436             handleError(org.eclipse.linuxtools.internal.tmf.ui.project.wizards.tracepkg.Messages.TracePackage_ErrorOperation, e);
 437         } catch (InterruptedException e) {
 438         }
 439
 440         return exporter.getStatus().getSeverity() == IStatus.OK;
 441     }
 442
 443     private boolean checkForOverwrite() {
 444         File file = new File(getFilePathValue());
 445         if (file.exists()) {
 446             return MessageDialog.openQuestion(getContainer().getShell(), null, Messages.ExportTracePackageWizardPage_AlreadyExitst);
 447         }
 448         return true;
 449     }
 450 }