service/simulator/java/eclipse-plugin/ServiceProviderPlugin/src/oic/simulator/serviceprovider/view/LogView.java

   1 /*
   2  * Copyright 2015 Samsung Electronics All Rights Reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package oic.simulator.serviceprovider.view;
  18
  19 import java.io.BufferedWriter;
  20 import java.io.FileWriter;
  21 import java.io.IOException;
  22 import java.text.DateFormat;
  23 import java.text.SimpleDateFormat;
  24 import java.util.HashMap;
  25 import java.util.List;
  26
  27 import oic.simulator.logger.LogContentProvider;
  28 import oic.simulator.logger.LogEntry;
  29 import oic.simulator.logger.LogLabelProvider;
  30 import oic.simulator.serviceprovider.Activator;
  31 import oic.simulator.serviceprovider.listener.ILogUIListener;
  32 import oic.simulator.serviceprovider.manager.LogManager;
  33 import oic.simulator.serviceprovider.utils.Constants;
  34 import oic.simulator.serviceprovider.view.dialogs.FilterDialog;
  35 import oic.simulator.serviceprovider.view.dialogs.LogDetailsDialog;
  36
  37 import org.eclipse.jface.action.Action;
  38 import org.eclipse.jface.action.IAction;
  39 import org.eclipse.jface.action.IContributionItem;
  40 import org.eclipse.jface.action.IMenuManager;
  41 import org.eclipse.jface.action.IToolBarManager;
  42 import org.eclipse.jface.action.MenuManager;
  43 import org.eclipse.jface.action.Separator;
  44 import org.eclipse.jface.dialogs.MessageDialog;
  45 import org.eclipse.jface.resource.ImageDescriptor;
  46 import org.eclipse.jface.viewers.DoubleClickEvent;
  47 import org.eclipse.jface.viewers.IDoubleClickListener;
  48 import org.eclipse.jface.viewers.ISelectionChangedListener;
  49 import org.eclipse.jface.viewers.IStructuredSelection;
  50 import org.eclipse.jface.viewers.SelectionChangedEvent;
  51 import org.eclipse.jface.viewers.StructuredSelection;
  52 import org.eclipse.jface.viewers.TreeViewer;
  53 import org.eclipse.jface.viewers.Viewer;
  54 import org.eclipse.jface.viewers.ViewerComparator;
  55 import org.eclipse.jface.window.Window;
  56 import org.eclipse.swt.SWT;
  57 import org.eclipse.swt.events.KeyEvent;
  58 import org.eclipse.swt.events.KeyListener;
  59 import org.eclipse.swt.events.SelectionAdapter;
  60 import org.eclipse.swt.events.SelectionEvent;
  61 import org.eclipse.swt.layout.GridData;
  62 import org.eclipse.swt.widgets.Composite;
  63 import org.eclipse.swt.widgets.Display;
  64 import org.eclipse.swt.widgets.FileDialog;
  65 import org.eclipse.swt.widgets.Text;
  66 import org.eclipse.swt.widgets.Tree;
  67 import org.eclipse.swt.widgets.TreeColumn;
  68 import org.eclipse.swt.widgets.TreeItem;
  69 import org.eclipse.ui.IActionBars;
  70 import org.eclipse.ui.IWorkbenchActionConstants;
  71 import org.eclipse.ui.IWorkbenchPage;
  72 import org.eclipse.ui.dialogs.FilteredTree;
  73 import org.eclipse.ui.dialogs.PatternFilter;
  74 import org.eclipse.ui.part.ViewPart;
  75 import org.oic.simulator.ILogger.Level;
  76
  77 /**
  78  * This class manages and shows the log view in the perspective.
  79  */
  80 public class LogView extends ViewPart {
  81
  82     public static final String        VIEW_ID              = "oic.simulator.serviceprovider.view.log";
  83
  84     private LogManager                logManager;
  85     private ILogUIListener            logListener;
  86
  87     private LogContentProvider        treeContentProvider;
  88
  89     private FilteredTree              tree;
  90     private TreeColumn                severityColumn;
  91     private TreeColumn                dateColumn;
  92     private TreeColumn                messageColumn;
  93
  94     private IAction                   exportLogAction;
  95     private IAction                   clearLogAction;
  96     private IAction                   deleteLogAction;
  97     private IAction                   scrollLockAction;
  98     private IAction                   logDetailsAction;
  99     private IAction                   filterAction;
 100     private IAction                   activateViewAction;
 101     private IAction                   showTextFilter;
 102     private IContributionItem         groupByAction;
 103
 104     private HashMap<Integer, Boolean> shownSeverities      = new HashMap<Integer, Boolean>();
 105
 106     private boolean                   activateOnChange     = false;
 107
 108     private boolean                   hideTextFilter       = false;
 109
 110     private boolean                   scrollLockDisabled;
 111
 112     public static final int           ORDER_BY_TIME        = 0;
 113     public static final int           ORDER_BY_SEVERITY    = 1;
 114     public static final int           ORDER_BY_MESSAGE     = 2;
 115
 116     int                               sortCandidate        = ORDER_BY_TIME;
 117
 118     SortAction                        sortByTimeAction     = new SortAction(
 119                                                                    "Order by Time",
 120                                                                    ORDER_BY_TIME);
 121     SortAction                        sortBySeverityAction = new SortAction(
 122                                                                    "Order by Severity",
 123                                                                    ORDER_BY_SEVERITY);
 124     SortAction                        sortByMessageAction  = new SortAction(
 125                                                                    "Order by Message",
 126                                                                    ORDER_BY_MESSAGE);
 127
 128     private ViewerComparator          dateComparator;
 129     private ViewerComparator          severityComparator;
 130     private ViewerComparator          messageComparator;
 131
 132     private TreeColumn                sortColumn           = null;
 133     private static int                DOWN                 = 1;
 134     private static int                UP                   = -1;
 135     private int                       sortDirection        = DOWN;
 136
 137     public LogView() {
 138
 139         logListener = new ILogUIListener() {
 140
 141             @Override
 142             public void logChanged(final List<LogEntry> entry) {
 143                 Display.getDefault().asyncExec(new Runnable() {
 144
 145                     @Override
 146                     public void run() {
 147                         TreeViewer viewer = tree.getViewer();
 148                         if (viewer.getControl().isDisposed()) {
 149                             return;
 150                         }
 151                         viewer.setInput(entry);
 152                         updateTree(false);
 153                     }
 154                 });
 155             }
 156
 157             @Override
 158             public void logAdded(final LogEntry added) {
 159                 Display.getDefault().asyncExec(new Runnable() {
 160
 161                     @Override
 162                     public void run() {
 163                         TreeViewer viewer = tree.getViewer();
 164                         if (viewer.getControl().isDisposed()) {
 165                             return;
 166                         }
 167                         LogContentProvider provider = (LogContentProvider) viewer
 168                                 .getContentProvider();
 169                         provider.addLog(added);
 170                         tree.getViewer().add(viewer.getInput(), added);
 171                         @SuppressWarnings("unchecked")
 172                         List<LogEntry> input = (List<LogEntry>) viewer
 173                                 .getInput();
 174                         if (input.size() > Constants.LOG_SIZE) {
 175                             viewer.remove(viewer.getInput(), 0);
 176                         }
 177                         updateTree(true);
 178                     }
 179                 });
 180             }
 181
 182             private void updateTree(boolean needscroll) {
 183                 if (activateOnChange) {
 184                     IWorkbenchPage page = Activator.getDefault().getWorkbench()
 185                             .getActiveWorkbenchWindow().getActivePage();
 186                     if (page != null) {
 187                         page.bringToTop(LogView.this);
 188                     }
 189                 }
 190                 if (scrollLockDisabled && needscroll) {
 191                     Tree tree2 = tree.getViewer().getTree();
 192                     if (tree2.getItemCount() > 0) {
 193                         TreeItem item = tree2.getItem(tree2.getItemCount() - 1);
 194                         tree2.setTopItem(item);
 195                         deleteLogAction.setEnabled(true);
 196                     }
 197                 }
 198             }
 199         };
 200
 201         logManager = Activator.getDefault().getLogManager();
 202
 203         // Initially state of scroll lock
 204         scrollLockDisabled = true;
 205     }
 206
 207     @Override
 208     public void createPartControl(Composite parent) {
 209         PatternFilter filter = new PatternFilter() {
 210
 211             DateFormat dateFormat = new SimpleDateFormat("HH:mm:ss.SSS");
 212
 213             @Override
 214             protected boolean isLeafMatch(Viewer viewer, Object element) {
 215                 if (element instanceof LogEntry) {
 216                     LogEntry logEntry = (LogEntry) element;
 217                     String severity = LogManager.getSeverityName(logEntry
 218                             .getSeverity());
 219                     String date = dateFormat.format(logEntry.getDate());
 220                     String message = logEntry.getMessage();
 221                     return wordMatches(severity) || wordMatches(date)
 222                             || wordMatches(message);
 223                 }
 224                 return false;
 225             }
 226         };
 227         filter.setIncludeLeadingWildcard(true);
 228         tree = new FilteredTree(parent, SWT.SINGLE | SWT.H_SCROLL
 229                 | SWT.V_SCROLL | SWT.FULL_SELECTION, filter, true);
 230
 231         setupFilteredTree();
 232
 233         createColumnComparators();
 234
 235         createActions();
 236
 237         setDefaultShownSeverities();
 238
 239         IActionBars actionBars = getViewSite().getActionBars();
 240         IToolBarManager toolBarManager = actionBars.getToolBarManager();
 241         toolBarManager.add(exportLogAction);
 242         toolBarManager.add(clearLogAction);
 243         toolBarManager.add(deleteLogAction);
 244         toolBarManager.add(scrollLockAction);
 245         toolBarManager
 246                 .add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
 247
 248         IMenuManager mgr = actionBars.getMenuManager();
 249         mgr.add(groupByAction);
 250         mgr.add(new Separator());
 251         mgr.add(filterAction);
 252         mgr.add(new Separator());
 253         mgr.add(activateViewAction);
 254         mgr.add(showTextFilter);
 255
 256         addManagerListeners();
 257
 258         if (sortCandidate == ORDER_BY_TIME) {
 259             sortByTimeAction.run();
 260         } else if (sortCandidate == ORDER_BY_SEVERITY) {
 261             sortBySeverityAction.run();
 262         } else { // order_selected == ORDER_BY_NONE
 263             sortByMessageAction.run();
 264         }
 265
 266     }
 267
 268     private void setupFilteredTree() {
 269         tree.setLayoutData(new GridData(GridData.FILL_BOTH));
 270         final Tree innerTree = tree.getViewer().getTree();
 271         innerTree.setLinesVisible(true);
 272
 273         severityColumn = new TreeColumn(innerTree, SWT.LEFT);
 274         severityColumn.setText("Severity");
 275         severityColumn.setWidth(110);
 276         severityColumn.addSelectionListener(new SelectionAdapter() {
 277
 278             @Override
 279             public void widgetSelected(SelectionEvent e) {
 280                 sortBySeverityAction.run();
 281             }
 282         });
 283         dateColumn = new TreeColumn(innerTree, SWT.LEFT);
 284         dateColumn.setText("Time");
 285         dateColumn.setWidth(110);
 286         dateColumn.addSelectionListener(new SelectionAdapter() {
 287
 288             @Override
 289             public void widgetSelected(SelectionEvent e) {
 290                 sortByTimeAction.run();
 291             }
 292         });
 293         messageColumn = new TreeColumn(innerTree, SWT.LEFT);
 294         messageColumn.setText("Message");
 295         messageColumn.setWidth(180);
 296         messageColumn.addSelectionListener(new SelectionAdapter() {
 297             @Override
 298             public void widgetSelected(SelectionEvent e) {
 299                 sortByMessageAction.run();
 300             }
 301         });
 302
 303         innerTree.setHeaderVisible(true);
 304
 305         treeContentProvider = new LogContentProvider();
 306
 307         tree.getViewer().setContentProvider(treeContentProvider);
 308         tree.getViewer().setLabelProvider(new LogLabelProvider());
 309
 310         tree.getViewer().setInput(logManager.getLogEntries());
 311
 312         tree.getViewer().addSelectionChangedListener(
 313                 new ISelectionChangedListener() {
 314
 315                     @Override
 316                     public void selectionChanged(SelectionChangedEvent event) {
 317                         deleteLogAction.setEnabled(!tree.getViewer()
 318                                 .getSelection().isEmpty());
 319                         logDetailsAction.setEnabled(!tree.getViewer()
 320                                 .getSelection().isEmpty());
 321                     }
 322                 });
 323
 324         tree.getViewer().getTree().addKeyListener(new KeyListener() {
 325
 326             @Override
 327             public void keyReleased(KeyEvent e) {
 328             }
 329
 330             @Override
 331             public void keyPressed(KeyEvent e) {
 332                 if (e.character == (char) 127) { // If delete key is pressed
 333                     if (deleteLogAction.isEnabled()) {
 334                         deleteLogAction.run();
 335                     }
 336                 }
 337             }
 338         });
 339
 340         tree.getViewer().addDoubleClickListener(new IDoubleClickListener() {
 341
 342             @Override
 343             public void doubleClick(DoubleClickEvent event) {
 344                 logDetailsAction.run();
 345             }
 346         });
 347     }
 348
 349     private void createColumnComparators() {
 350         dateComparator = new ViewerComparator() {
 351
 352             @Override
 353             public int compare(Viewer viewer, Object e1, Object e2) {
 354                 LogEntry l1 = (LogEntry) e1;
 355                 LogEntry l2 = (LogEntry) e2;
 356                 return l1.getDate().compareTo(l2.getDate()) * sortDirection;
 357             }
 358         };
 359
 360         severityComparator = new ViewerComparator() {
 361
 362             @Override
 363             public int compare(Viewer viewer, Object e1, Object e2) {
 364                 LogEntry l1 = (LogEntry) e1;
 365                 LogEntry l2 = (LogEntry) e2;
 366                 if (l1.getSeverity() < l2.getSeverity()) {
 367                     return -1 * sortDirection;
 368                 }
 369                 if (l1.getSeverity() > l2.getSeverity()) {
 370                     return 1 * sortDirection;
 371                 }
 372                 return 0;
 373             }
 374         };
 375
 376         messageComparator = new ViewerComparator() {
 377
 378             @Override
 379             public int compare(Viewer viewer, Object e1, Object e2) {
 380                 LogEntry l1 = (LogEntry) e1;
 381                 LogEntry l2 = (LogEntry) e2;
 382                 return l1.getMessage().compareTo(l2.getMessage())
 383                         * sortDirection;
 384             }
 385         };
 386
 387     }
 388
 389     private void setDefaultShownSeverities() {
 390         shownSeverities.put(Level.INFO.ordinal(), true);
 391         shownSeverities.put(Level.DEBUG.ordinal(), true);
 392         shownSeverities.put(Level.WARNING.ordinal(), true);
 393         shownSeverities.put(Level.ERROR.ordinal(), true);
 394     }
 395
 396     private void addManagerListeners() {
 397         logManager.addLogListener(logListener);
 398         logManager.applyFilter(shownSeverities);
 399     }
 400
 401     private void createActions() {
 402         exportLogAction = createExportLogAction();
 403         clearLogAction = createClearLogAction();
 404         deleteLogAction = createDeleteLogAction();
 405         scrollLockAction = createScrollLockAction();
 406         logDetailsAction = createLogDetailsAction();
 407
 408         filterAction = createFilterAction();
 409         activateViewAction = createActivateViewAction();
 410         showTextFilter = createShowTextFilter();
 411         groupByAction = createGroupByAction();
 412     }
 413
 414     private IAction createExportLogAction() {
 415         Action action = new Action("Export log") {
 416             @Override
 417             public void run() {
 418                 FileDialog fd = new FileDialog(Display.getDefault()
 419                         .getActiveShell(), SWT.SAVE);
 420                 fd.setOverwrite(true);
 421                 fd.setFileName("OIC_Simulator_ServerLog.log");
 422                 fd.setFilterExtensions(Constants.SAVE_LOG_FILTER_EXTENSIONS);
 423                 String name = fd.open();
 424                 List<LogEntry> logEntries = logManager.getLogEntries();
 425                 StringBuilder sb = new StringBuilder();
 426                 for (LogEntry entry : logEntries) {
 427                     sb.append(entry.toString());
 428                 }
 429                 String data = sb.toString();
 430                 BufferedWriter out = null;
 431                 try {
 432                     out = new BufferedWriter(new FileWriter(name));
 433                     out.write(data);
 434                 } catch (IOException e) {
 435                     e.printStackTrace();
 436                     MessageDialog.openError(
 437                             Display.getDefault().getActiveShell(),
 438                             "Export error",
 439                             "Could not export log. IO exception: "
 440                                     + e.getMessage());
 441                 } finally {
 442                     try {
 443                         out.close();
 444                     } catch (IOException e) {
 445                         // Error occurred during close. Ignoring
 446                     }
 447                 }
 448             }
 449         };
 450         action.setToolTipText("Export log");
 451
 452         action.setImageDescriptor(ImageDescriptor.createFromFile(
 453                 this.getClass(), "/icons/export_log_e.gif"));
 454         action.setDisabledImageDescriptor(ImageDescriptor.createFromFile(
 455                 this.getClass(), "/icons/export_log_d.gif"));
 456         action.setEnabled(true);
 457
 458         return action;
 459     }
 460
 461     private IAction createClearLogAction() {
 462         Action action = new Action("Clear log") {
 463
 464             @Override
 465             public void run() {
 466                 logManager.clearLog();
 467             }
 468         };
 469         action.setToolTipText("Clear log");
 470
 471         action.setImageDescriptor(ImageDescriptor.createFromFile(
 472                 this.getClass(), "/icons/clear_e.gif"));
 473         action.setDisabledImageDescriptor(ImageDescriptor.createFromFile(
 474                 this.getClass(), "/icons/clear_d.gif"));
 475         action.setEnabled(true);
 476         return action;
 477     }
 478
 479     private IAction createDeleteLogAction() {
 480         Action action = new Action("Delete log entry") {
 481
 482             @Override
 483             @SuppressWarnings("unchecked")
 484             public void run() {
 485                 IStructuredSelection selection = (IStructuredSelection) tree
 486                         .getViewer().getSelection();
 487                 List<LogEntry> entries = (List<LogEntry>) tree.getViewer()
 488                         .getInput();
 489                 LogEntry selectedEntry = (LogEntry) selection.getFirstElement();
 490                 if (null != selectedEntry) {
 491                     LogEntry toBeShownEntry = null;
 492                     for (LogEntry entry : entries) {
 493                         if (entry.equals(selectedEntry)) {
 494                             int size = entries.size();
 495                             int index = entries.indexOf(selectedEntry);
 496                             if (index + 1 < size) {
 497                                 toBeShownEntry = entries.get(index + 1);
 498                             } else if (index > 0) {
 499                                 toBeShownEntry = entries.get(index - 1);
 500                             }
 501                             break;
 502                         }
 503                     }
 504                     logManager.removeEntry(selectedEntry);
 505                     if (null != toBeShownEntry) {
 506                         tree.getViewer().setSelection(
 507                                 new StructuredSelection(toBeShownEntry));
 508                     }
 509                 }
 510             }
 511         };
 512         action.setToolTipText("Delete log entry");
 513         action.setImageDescriptor(ImageDescriptor.createFromFile(
 514                 this.getClass(), "/icons/delete_e.gif"));
 515         action.setDisabledImageDescriptor(ImageDescriptor.createFromFile(
 516                 this.getClass(), "/icons/delete_d.gif"));
 517         action.setEnabled(false);
 518         return action;
 519     }
 520
 521     private IAction createScrollLockAction() {
 522         Action action = new Action("Scroll lock") {
 523
 524             @Override
 525             public void run() {
 526                 scrollLockDisabled = !this.isChecked();
 527             };
 528
 529             @Override
 530             public int getStyle() {
 531                 return IAction.AS_CHECK_BOX;
 532             }
 533         };
 534         action.setToolTipText("Scroll lock");
 535         action.setImageDescriptor(ImageDescriptor.createFromFile(
 536                 this.getClass(), "/icons/lock_e.gif"));
 537         action.setDisabledImageDescriptor(ImageDescriptor.createFromFile(
 538                 this.getClass(), "/icons/lock_d.gif"));
 539         action.setEnabled(true);
 540         return action;
 541     }
 542
 543     private IAction createLogDetailsAction() {
 544         Action action = new Action("Details...") {
 545
 546             @Override
 547             public void run() {
 548                 Display.getDefault().asyncExec(new Runnable() {
 549
 550                     @Override
 551                     public void run() {
 552                         LogEntry x = (LogEntry) ((IStructuredSelection) tree
 553                                 .getViewer().getSelection()).getFirstElement();
 554
 555                         new LogDetailsDialog(Display.getDefault()
 556                                 .getActiveShell(), LogManager.getSeverityName(x
 557                                 .getSeverity()), LogManager.getSeverityIcon(x
 558                                 .getSeverity()), x.getDate(), x.getMessage())
 559                                 .open();
 560                     }
 561                 });
 562             }
 563         };
 564         action.setToolTipText("Details...");
 565         action.setImageDescriptor(ImageDescriptor.createFromFile(
 566                 this.getClass(), "/icons/log_details_e.gif"));
 567         action.setDisabledImageDescriptor(ImageDescriptor.createFromFile(
 568                 this.getClass(), "/icons/log_details_e.gif"));
 569         action.setEnabled(false);
 570         return action;
 571     }
 572
 573     private IAction createFilterAction() {
 574         Action action = new Action("Filters ...") {
 575
 576             @Override
 577             public void run() {
 578                 FilterDialog fd = new FilterDialog(Display.getDefault()
 579                         .getActiveShell(), shownSeverities);
 580                 if (fd.open() == Window.OK) {
 581                     logManager.applyFilter(shownSeverities);
 582                 }
 583                 tree.getViewer().refresh();
 584             }
 585         };
 586         action.setToolTipText("Filters ...");
 587
 588         action.setImageDescriptor(ImageDescriptor.createFromFile(
 589                 this.getClass(), "/icons/filter_e.gif"));
 590         action.setDisabledImageDescriptor(ImageDescriptor.createFromFile(
 591                 this.getClass(), "/icons/filter_d.gif"));
 592         action.setEnabled(true);
 593         return action;
 594     }
 595
 596     private IAction createActivateViewAction() {
 597         Action action = new Action("Activate view on new events",
 598                 IAction.AS_CHECK_BOX) {
 599
 600             @Override
 601             public void run() {
 602                 activateOnChange = this.isChecked();
 603             }
 604         };
 605         action.setChecked(activateOnChange);
 606         action.setToolTipText("Activate view on new events");
 607
 608         action.setImageDescriptor(ImageDescriptor.createFromFile(
 609                 this.getClass(), "/icons/prop_e.gif"));
 610         action.setDisabledImageDescriptor(ImageDescriptor.createFromFile(
 611                 this.getClass(), "/icons/prop_d.gif"));
 612         action.setEnabled(true);
 613         return action;
 614     }
 615
 616     private IAction createShowTextFilter() {
 617         Action action = new Action("Show text filter", IAction.AS_CHECK_BOX) {
 618
 619             @Override
 620             public void run() {
 621                 Text filterControl = tree.getFilterControl();
 622                 Composite filterComposite = filterControl.getParent();
 623                 GridData gd = (GridData) filterComposite.getLayoutData();
 624                 boolean visible = isChecked();
 625                 gd.exclude = !visible;
 626                 filterComposite.setVisible(visible);
 627                 filterControl.setText("");
 628                 if (visible) {
 629                     filterControl.selectAll();
 630                     setFocus();
 631                 }
 632                 tree.layout(false);
 633                 hideTextFilter = !visible;
 634             }
 635         };
 636         action.setToolTipText("Show text filter");
 637
 638         action.setImageDescriptor(ImageDescriptor.createFromFile(
 639                 this.getClass(), "/icons/tree_mode_e.gif"));
 640         action.setDisabledImageDescriptor(ImageDescriptor.createFromFile(
 641                 this.getClass(), "/icons/tree_mode_d.gif"));
 642         action.setEnabled(true);
 643         action.setChecked(!hideTextFilter);
 644         if (hideTextFilter) {
 645             action.run();
 646         }
 647         return action;
 648     }
 649
 650     private IContributionItem createGroupByAction() {
 651         IMenuManager manager = new MenuManager("Order by");
 652         manager.add(sortByTimeAction);
 653         manager.add(sortBySeverityAction);
 654         manager.add(sortByMessageAction);
 655         return manager;
 656     }
 657
 658     class SortAction extends Action {
 659
 660         private final int sortBy;
 661
 662         public SortAction(String text, int sortBy) {
 663             super(text, IAction.AS_RADIO_BUTTON);
 664             this.sortBy = sortBy;
 665
 666             if (sortCandidate == sortBy) {
 667                 setChecked(true);
 668             }
 669         }
 670
 671         @Override
 672         public void run() {
 673             sortBySeverityAction.setChecked(false);
 674             sortByTimeAction.setChecked(false);
 675             sortCandidate = sortBy;
 676             setChecked(true);
 677
 678             ViewerComparator comparator;
 679             TreeColumn column;
 680             if (sortBy == ORDER_BY_SEVERITY) {
 681                 comparator = severityComparator;
 682                 column = severityColumn;
 683             } else if (sortBy == ORDER_BY_TIME) {
 684                 comparator = dateComparator;
 685                 column = dateColumn;
 686             } else { // Order by message
 687                 comparator = messageComparator;
 688                 column = messageColumn;
 689             }
 690             TreeViewer viewer = tree.getViewer();
 691             viewer.setComparator(comparator);
 692             viewer.getTree().setSortColumn(column);
 693             if (column.equals(sortColumn)) { // reverse sorting order
 694                 sortDirection = viewer.getTree().getSortDirection() == SWT.UP ? DOWN
 695                         : UP;
 696                 viewer.getTree().setSortDirection(
 697                         sortDirection == UP ? SWT.UP : SWT.DOWN);
 698                 viewer.refresh();
 699             } else { // set this column as the one to sort by
 700                 sortDirection = DOWN;
 701                 viewer.getTree().setSortDirection(SWT.DOWN);
 702             }
 703             sortColumn = column;
 704             refresh();
 705         }
 706     }
 707
 708     private void refresh() {
 709         tree.getViewer().refresh();
 710     }
 711
 712     @Override
 713     public void setFocus() {
 714         tree.setFocus();
 715     }
 716
 717     @Override
 718     public void dispose() {
 719         logManager.removeLogListener(logListener);
 720         super.dispose();
 721     }
 722 }