org.eclipse.ote.ui.eviewer/src/org/eclipse/ote/ui/eviewer/view/ElementContentProvider.java - osee/org.eclipse.ote - Git at Google

 /*******************************************************************************
  * Copyright (c) 2013 Boeing.
  * 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:
  *     Boeing - initial API and implementation
  *******************************************************************************/
 package org.eclipse.ote.ui.eviewer.view;

 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.PrintWriter;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.locks.ReentrantLock;
 import java.util.logging.Level;

 import org.eclipse.jface.viewers.IStructuredContentProvider;
 import org.eclipse.jface.viewers.TableViewer;
 import org.eclipse.jface.viewers.Viewer;
 import org.eclipse.osee.framework.logging.OseeLog;
 import org.eclipse.osee.framework.plugin.core.util.OseeData;
 import org.eclipse.osee.ote.client.msg.IOteMessageService;
 import org.eclipse.osee.ote.message.ElementPath;
 import org.eclipse.ote.ui.eviewer.Activator;
 import org.eclipse.ote.ui.eviewer.jobs.CopyToClipboardJob;
 import org.eclipse.ote.ui.eviewer.jobs.CopyToCsvFileJob;
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.dnd.Clipboard;
 import org.eclipse.swt.widgets.Event;
 import org.eclipse.swt.widgets.Listener;

 /**
  * @author Ken J. Aguilar
  */
 public class ElementContentProvider implements Listener, IStructuredContentProvider, IUpdateListener {
 	private static final String INTERNAL_FILE_NAME = "element_viewer_column_state.csv";
 	private final ArrayList<SubscriptionDetails> subscriptions = new ArrayList<SubscriptionDetails>(32);
 	private TableViewer viewer;
 	private IOteMessageService service;
 	private final ArrayList<ElementColumn> elementColumns = new ArrayList<ElementColumn>();
 	private final int limit;
 	private ViewRefresher refresher;
 	private boolean autoReveal = true;

 	private volatile PrintWriter streamToFileWriter = null;

 	private HashMap<ElementColumn, Integer> valueMap = new HashMap<ElementColumn, Integer>();

 	private ElementUpdate last = null;
    private ReentrantLock streamWriteLock = new ReentrantLock();
    private volatile boolean acceptUpdates = true;

 	public ElementContentProvider(int limit) {
 		this.limit = limit;
 	}

 	@Override
 	public Object[] getElements(Object inputElement) {
 		return refresher.getUpdates();
 	}

 	@Override
 	public void dispose() {
 		if (refresher != null) {
 			refresher.clearUpdates();
 			refresher.stop();
 		}
 		disposeAllColumns();
 	}

 	public void forceUpdate(){
 	   refresher.forceUpdate();
 	}

 	@Override
 	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 		this.viewer = (TableViewer) viewer;
 		if (newInput != null) {
 			if (oldInput != null) {
 				dispose();
 			}
 			service = (IOteMessageService) newInput;
 			indexAndSortColumns();
 			last = null;
 			refresher = new ViewRefresher(this.viewer, limit);
 			refresher.setAutoReveal(autoReveal);
 			refresher.start();
 		}
 	}

 	public void add(ElementPath path) {
 		add(path, true);
 	}

 	public synchronized void add(ElementPath path, boolean save) {
 		if (findColumn(path)) {
 			return;
 		}
 		create(path);
 		if (save) {
 			updateInternalFile();
 		}
 	}

 	private ElementColumn create(ElementPath path) {
 		ElementColumn newColumn = new ElementColumn(viewer, elementColumns.size(), path);
 		SubscriptionDetails details = findDetails(path.getMessageClass());
 		if (details == null) {
 			details = new SubscriptionDetails(service.subscribe(path.getMessageClass()), this);
 			subscriptions.add(details);
 		}
 		details.addColumn(newColumn);
 		elementColumns.add(newColumn);
 		indexAndSortColumns();
 		newColumn.addMoveListener(this);
 		return newColumn;
 	}

 	private boolean findColumn(ElementPath path) {
 		String encodedPath = path.encode();
 		for (ElementColumn column : elementColumns) {
 			if (column.getElementPath().encode().equals(encodedPath)) {
 				return true;
 			}
 		}
 		return false;
 	}

 	private synchronized void add(Collection<ElementPath> columns, boolean save) {

 		HashSet<String> existingColumns = new HashSet<String>();
 		for (ElementColumn column : elementColumns) {
 			existingColumns.add(column.getElementPath().encode());
 		}
 		for (ElementPath path : columns) {
 			if (existingColumns.contains(path.encode())) {
 				continue;
 			}
 			create(path);
 		}
 		if (save) {
 			updateInternalFile();
 		}
 	}

 	public SubscriptionDetails findDetails(String messageClassName) {
 		for (SubscriptionDetails details : subscriptions) {
 			if (details.getSubscription().getMessageClassName().equals(messageClassName)) {
 				return details;
 			}
 		}
 		return null;
 	}

 	@Override
 	public  synchronized void update(SubscriptionDetails details) {
 	   if(acceptUpdates ){
 	      final ElementUpdate update;
 	      if (last == null) {
 	         update = new ElementUpdate(valueMap, elementColumns);
 	      } else {
 	         update = last.next(valueMap, elementColumns);
 	      }
 	      last = update;
 	      refresher.addUpdate(update);
 	      writeToStream(update);
 	   }
 	}

 	private void writeToStream(ElementUpdate update) {
 	   try{
 	      streamWriteLock.lock();
 	      if (streamToFileWriter != null) {
 	         int i;
 	         for (i = 0; i < elementColumns.size() - 1; i++) {
 	            Object o = update.getValue(elementColumns.get(i));
 	            if (o != null) {
 	               streamToFileWriter.append(o.toString());
 	            }
 	            streamToFileWriter.append(',');
 	         }
 	         Object o = update.getValue(elementColumns.get(i));
 	         if (o != null) {
 	            streamToFileWriter.append(o.toString());
 	         }
 	         streamToFileWriter.append('\n');
 	      }
 	   } finally {
 	      streamWriteLock.unlock();
 	   }
 	}

 	public void clearAllUpdates() {
 		refresher.clearUpdates();
 		last = null;
 	}

 	/**
 	 * @return the autoReveal
 	 */
 	public boolean isAutoReveal() {
 		return autoReveal;
 	}

 	private void indexAndSortColumns() {

 		valueMap = new HashMap<ElementColumn, Integer>();
 		ColumnSorter sorter = new ColumnSorter(viewer.getTable().getColumnOrder());
 		for (ElementColumn column : elementColumns) {
 			valueMap.put(column, sorter.orderOf(column.recheckIndex()));
 		}

 		determineConflicts();

 		sorter.sort(elementColumns);

 	}

 	void determineConflicts() {
 	   Map<String, Boolean> conflicts = new HashMap<String, Boolean>();
 	   for (ElementColumn column : elementColumns) {
 	      if(conflicts.containsKey(column.getElementText())){
 	         conflicts.put(column.getElementText(), true);
 	      } else {
 	         conflicts.put(column.getElementText(), false);
 	      }
       }
 	   for (ElementColumn column : elementColumns) {
          if(conflicts.get(column.getElementText())){
             column.setDuplicateName(true);
          } else {
             column.setDuplicateName(false);
          }
       }
    }

    /**
 	 * @param autoReveal the autoReveal to set
 	 */
 	public void setAutoReveal(boolean autoReveal) {
 		this.autoReveal = autoReveal;
 		if (refresher != null) {
 			refresher.setAutoReveal(autoReveal);
 		}
 	}

 	public synchronized List<ElementColumn> getColumns() {
 		return new ArrayList<ElementColumn>(elementColumns);
 	}

 	public synchronized void putColumnsInList(List<ElementColumn> list) {
 		list.addAll(elementColumns);
 	}
 	public synchronized void removeColumn(ElementColumn column) {
 		if (elementColumns.remove(column)) {
 			column.removeMoveListener(this);
 			SubscriptionDetails subscription = findDetails(column.getMessageClassName());
 			if (subscription.removeColumn(column)) {
 				subscription.dispose();
 				subscriptions.remove(subscription);
 			}
 			indexAndSortColumns();
 			updateInternalFile();
 		}
 	}

 	private void enableMoveListeneing(boolean enable) {
 		for (ElementColumn column : elementColumns) {
 			if (enable) {
 				column.addMoveListener(this);
 			} else {
 				column.removeMoveListener(this);
 			}
 		}
 	}

 	public synchronized void removeColumn(Collection<ElementColumn> columns) {
 		enableMoveListeneing(false);
 		elementColumns.removeAll(columns);
 		viewer.getTable().setRedraw(false);
 		for (ElementColumn column : columns) {
 			SubscriptionDetails subscription = findDetails(column.getMessageClassName());
 			if (subscription.removeColumn(column)) {
 				subscription.dispose();
 				subscriptions.remove(subscription);
 			}
 		}
 		enableMoveListeneing(true);
 		indexAndSortColumns();
 		viewer.getTable().setRedraw(true);
 		updateInternalFile();
 	}
 	private void updateInternalFile() {
 		try {
 			saveColumnsToFile(OseeData.getFile(INTERNAL_FILE_NAME));
 		} catch (Exception e) {
 			OseeLog.log(Activator.class, Level.SEVERE, "could not write columns", e);
 		}
 	}
 	public synchronized void saveColumnsToFile(File file) throws FileNotFoundException, IOException {
 		PrintWriter writer = new PrintWriter(new FileOutputStream(file));
 		try {
 			if (elementColumns.isEmpty()) {
 				return;
 			}
 			int i;
 			for (i = 0; i < elementColumns.size() - 1; i++) {
 				ElementColumn column = elementColumns.get(i);
 				writer.write(column.getElementPath().encode());
 				writer.write('=');
 				writer.write(column.isActive() ? "active" : "inactive");
 				writer.write(',');
 			}
 			ElementColumn column = elementColumns.get(i);
 			writer.write(column.getElementPath().encode());
 			writer.write('=');
 			writer.write(column.isActive() ? "active" : "inactive");
 			writer.write('\n');
 			writer.flush();
 		} finally {
 			writer.close();
 		}
 	}

 	private void loadColumns(String[] columnNames) {
 		LinkedList<ElementPath> columnsToAdd = new LinkedList<ElementPath>();
 		HashSet<ElementPath> inactiveColumns = new HashSet<ElementPath>();

 		viewer.getTable().setRedraw(false);
 		for (String name : columnNames) {
 			String[] parts = name.split("=");
 			ElementPath path = ElementPath.decode(parts[0]);
 			columnsToAdd.add(path);
 			if (parts.length > 1 && parts[1].equals("inactive")) {
 				inactiveColumns.add(path);
 			}
 		}
 		add(columnsToAdd, false);


 		for (ElementColumn column : elementColumns) {
 			if (inactiveColumns.contains(column.getElementPath())) {
 				column.setActive(false);
 			}
 		}
 		viewer.getTable().setRedraw(true);
 		updateInternalFile();
 	}

 	public void loadColumnsFromFile(File file) throws FileNotFoundException, IOException {
 		BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
 		try {
 			String line = reader.readLine();
 			if (line == null) {
 				// empty file
 				return;
 			}
 			String[] columnNames = line.split(",");
 			loadColumns(columnNames);
 		} finally {
 			reader.close();
 		}
 	}

 	public synchronized void removeAll() {
 		disposeAllColumns();
 		updateInternalFile();
 		refresher.clearUpdates();
 	}

 	private void disposeAllColumns() {
 		// we must remove all the move listeners first before we dispose or else bad things happen
 		enableMoveListeneing(false);
 		for (SubscriptionDetails details : subscriptions) {
 			details.dispose();
 		}
 		subscriptions.clear();
 		elementColumns.clear();
 	}

 	public void toClipboard(Clipboard clipboard) {
 		CopyToClipboardJob job = new CopyToClipboardJob(clipboard, elementColumns, refresher.getUpdates());
 		job.schedule();
 	}

 	public void toCsv(File file) throws IOException {
 		CopyToCsvFileJob job = new CopyToCsvFileJob(file, elementColumns, refresher.getUpdates());
 		job.schedule();
 	}

 	public void loadLastColumns() {
 		try {
 			File file = OseeData.getFile(INTERNAL_FILE_NAME);
 			if (file.isFile()) {
 				loadColumnsFromFile(file);
 			}

 		} catch (Exception e) {
 			OseeLog.log(Activator.class, Level.SEVERE, "could not read columns file", e);
 		}
 	}

 	public void streamToFile(File file) throws FileNotFoundException, IOException {
 	   try{
 	      streamWriteLock.lock();
 	      if (streamToFileWriter != null) {
 	         // stop streaming
 	         streamToFileWriter.flush();
 	         streamToFileWriter.close();
 	         streamToFileWriter = null;
 	      }
 	      if (file == null) {
 	         setMoveableColumns(true);
 	         return;
 	      }
 	      setMoveableColumns(false);

 	      streamToFileWriter = new PrintWriter(new FileOutputStream(file));
 	      int i;
 	      for (i = 0; i < elementColumns.size() - 1; i++) {
 	         streamToFileWriter.write(elementColumns.get(i).getName());
 	         streamToFileWriter.write(',');
 	      }
 	      if (elementColumns.size() > 0) {
 	         streamToFileWriter.write(elementColumns.get(i).getName());
 	         streamToFileWriter.write('\n');
 	      }

 	      streamToFileWriter.flush();
 	   } finally {
 	      streamWriteLock.unlock();
 	   }
 	}

 	private void setMoveableColumns(boolean moveable) {
 		for (ElementColumn column : elementColumns) {
 			column.getColumn().setMoveable(moveable);
 		}
 	}

 	/**
 	 * handles the reordering of columns
 	 */
 	@Override
 	public void handleEvent(Event event) {

 		if (event.widget.isDisposed() || event.type != SWT.Move) {
 			return;
 		}
 		synchronized (this) {
 			indexAndSortColumns();
 			updateInternalFile();
 		}

 	}

 	public TableViewer getViewer() {
 		return viewer;
 	}

    public void setUpdateView(boolean updateView) {
       refresher.setUpdateView(updateView);
    }

    public void togglePauseUpdates() {
       acceptUpdates = !acceptUpdates;
    }
 }
	/*******************************************************************************
	* Copyright (c) 2013 Boeing.
	* 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:
	* Boeing - initial API and implementation
	*******************************************************************************/
	package org.eclipse.ote.ui.eviewer.view;

	import java.io.BufferedReader;
	import java.io.File;
	import java.io.FileInputStream;
	import java.io.FileNotFoundException;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.io.InputStreamReader;
	import java.io.PrintWriter;
	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.LinkedList;
	import java.util.List;
	import java.util.Map;
	import java.util.concurrent.locks.ReentrantLock;
	import java.util.logging.Level;

	import org.eclipse.jface.viewers.IStructuredContentProvider;
	import org.eclipse.jface.viewers.TableViewer;
	import org.eclipse.jface.viewers.Viewer;
	import org.eclipse.osee.framework.logging.OseeLog;
	import org.eclipse.osee.framework.plugin.core.util.OseeData;
	import org.eclipse.osee.ote.client.msg.IOteMessageService;
	import org.eclipse.osee.ote.message.ElementPath;
	import org.eclipse.ote.ui.eviewer.Activator;
	import org.eclipse.ote.ui.eviewer.jobs.CopyToClipboardJob;
	import org.eclipse.ote.ui.eviewer.jobs.CopyToCsvFileJob;
	import org.eclipse.swt.SWT;
	import org.eclipse.swt.dnd.Clipboard;
	import org.eclipse.swt.widgets.Event;
	import org.eclipse.swt.widgets.Listener;

	/**
	* @author Ken J. Aguilar
	*/
	public class ElementContentProvider implements Listener, IStructuredContentProvider, IUpdateListener {
	private static final String INTERNAL_FILE_NAME = "element_viewer_column_state.csv";
	private final ArrayList<SubscriptionDetails> subscriptions = new ArrayList<SubscriptionDetails>(32);
	private TableViewer viewer;
	private IOteMessageService service;
	private final ArrayList<ElementColumn> elementColumns = new ArrayList<ElementColumn>();
	private final int limit;
	private ViewRefresher refresher;
	private boolean autoReveal = true;

	private volatile PrintWriter streamToFileWriter = null;

	private HashMap<ElementColumn, Integer> valueMap = new HashMap<ElementColumn, Integer>();

	private ElementUpdate last = null;
	private ReentrantLock streamWriteLock = new ReentrantLock();
	private volatile boolean acceptUpdates = true;

	public ElementContentProvider(int limit) {
	this.limit = limit;
	}

	@Override
	public Object[] getElements(Object inputElement) {
	return refresher.getUpdates();
	}

	@Override
	public void dispose() {
	if (refresher != null) {
	refresher.clearUpdates();
	refresher.stop();
	}
	disposeAllColumns();
	}

	public void forceUpdate(){
	refresher.forceUpdate();
	}

	@Override
	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
	this.viewer = (TableViewer) viewer;
	if (newInput != null) {
	if (oldInput != null) {
	dispose();
	}
	service = (IOteMessageService) newInput;
	indexAndSortColumns();
	last = null;
	refresher = new ViewRefresher(this.viewer, limit);
	refresher.setAutoReveal(autoReveal);
	refresher.start();
	}
	}

	public void add(ElementPath path) {
	add(path, true);
	}

	public synchronized void add(ElementPath path, boolean save) {
	if (findColumn(path)) {
	return;
	}
	create(path);
	if (save) {
	updateInternalFile();
	}
	}

	private ElementColumn create(ElementPath path) {
	ElementColumn newColumn = new ElementColumn(viewer, elementColumns.size(), path);
	SubscriptionDetails details = findDetails(path.getMessageClass());
	if (details == null) {
	details = new SubscriptionDetails(service.subscribe(path.getMessageClass()), this);
	subscriptions.add(details);
	}
	details.addColumn(newColumn);
	elementColumns.add(newColumn);
	indexAndSortColumns();
	newColumn.addMoveListener(this);
	return newColumn;
	}

	private boolean findColumn(ElementPath path) {
	String encodedPath = path.encode();
	for (ElementColumn column : elementColumns) {
	if (column.getElementPath().encode().equals(encodedPath)) {
	return true;
	}
	}
	return false;
	}

	private synchronized void add(Collection<ElementPath> columns, boolean save) {

	HashSet<String> existingColumns = new HashSet<String>();
	for (ElementColumn column : elementColumns) {
	existingColumns.add(column.getElementPath().encode());
	}
	for (ElementPath path : columns) {
	if (existingColumns.contains(path.encode())) {
	continue;
	}
	create(path);
	}
	if (save) {
	updateInternalFile();
	}
	}

	public SubscriptionDetails findDetails(String messageClassName) {
	for (SubscriptionDetails details : subscriptions) {
	if (details.getSubscription().getMessageClassName().equals(messageClassName)) {
	return details;
	}
	}
	return null;
	}

	@Override
	public synchronized void update(SubscriptionDetails details) {
	if(acceptUpdates ){
	final ElementUpdate update;
	if (last == null) {
	update = new ElementUpdate(valueMap, elementColumns);
	} else {
	update = last.next(valueMap, elementColumns);
	}
	last = update;
	refresher.addUpdate(update);
	writeToStream(update);
	}
	}

	private void writeToStream(ElementUpdate update) {
	try{
	streamWriteLock.lock();
	if (streamToFileWriter != null) {
	int i;
	for (i = 0; i < elementColumns.size() - 1; i++) {
	Object o = update.getValue(elementColumns.get(i));
	if (o != null) {
	streamToFileWriter.append(o.toString());
	}
	streamToFileWriter.append(',');
	}
	Object o = update.getValue(elementColumns.get(i));
	if (o != null) {
	streamToFileWriter.append(o.toString());
	}
	streamToFileWriter.append('\n');
	}
	} finally {
	streamWriteLock.unlock();
	}
	}

	public void clearAllUpdates() {
	refresher.clearUpdates();
	last = null;
	}

	/**
	* @return the autoReveal
	*/
	public boolean isAutoReveal() {
	return autoReveal;
	}

	private void indexAndSortColumns() {

	valueMap = new HashMap<ElementColumn, Integer>();
	ColumnSorter sorter = new ColumnSorter(viewer.getTable().getColumnOrder());
	for (ElementColumn column : elementColumns) {
	valueMap.put(column, sorter.orderOf(column.recheckIndex()));
	}

	determineConflicts();

	sorter.sort(elementColumns);

	}

	void determineConflicts() {
	Map<String, Boolean> conflicts = new HashMap<String, Boolean>();
	for (ElementColumn column : elementColumns) {
	if(conflicts.containsKey(column.getElementText())){
	conflicts.put(column.getElementText(), true);
	} else {
	conflicts.put(column.getElementText(), false);
	}
	}
	for (ElementColumn column : elementColumns) {
	if(conflicts.get(column.getElementText())){
	column.setDuplicateName(true);
	} else {
	column.setDuplicateName(false);
	}
	}
	}

	/**
	* @param autoReveal the autoReveal to set
	*/
	public void setAutoReveal(boolean autoReveal) {
	this.autoReveal = autoReveal;
	if (refresher != null) {
	refresher.setAutoReveal(autoReveal);
	}
	}

	public synchronized List<ElementColumn> getColumns() {
	return new ArrayList<ElementColumn>(elementColumns);
	}

	public synchronized void putColumnsInList(List<ElementColumn> list) {
	list.addAll(elementColumns);
	}
	public synchronized void removeColumn(ElementColumn column) {
	if (elementColumns.remove(column)) {
	column.removeMoveListener(this);
	SubscriptionDetails subscription = findDetails(column.getMessageClassName());
	if (subscription.removeColumn(column)) {
	subscription.dispose();
	subscriptions.remove(subscription);
	}
	indexAndSortColumns();
	updateInternalFile();
	}
	}

	private void enableMoveListeneing(boolean enable) {
	for (ElementColumn column : elementColumns) {
	if (enable) {
	column.addMoveListener(this);
	} else {
	column.removeMoveListener(this);
	}
	}
	}

	public synchronized void removeColumn(Collection<ElementColumn> columns) {
	enableMoveListeneing(false);
	elementColumns.removeAll(columns);
	viewer.getTable().setRedraw(false);
	for (ElementColumn column : columns) {
	SubscriptionDetails subscription = findDetails(column.getMessageClassName());
	if (subscription.removeColumn(column)) {
	subscription.dispose();
	subscriptions.remove(subscription);
	}
	}
	enableMoveListeneing(true);
	indexAndSortColumns();
	viewer.getTable().setRedraw(true);
	updateInternalFile();
	}
	private void updateInternalFile() {
	try {
	saveColumnsToFile(OseeData.getFile(INTERNAL_FILE_NAME));
	} catch (Exception e) {
	OseeLog.log(Activator.class, Level.SEVERE, "could not write columns", e);
	}
	}
	public synchronized void saveColumnsToFile(File file) throws FileNotFoundException, IOException {
	PrintWriter writer = new PrintWriter(new FileOutputStream(file));
	try {
	if (elementColumns.isEmpty()) {
	return;
	}
	int i;
	for (i = 0; i < elementColumns.size() - 1; i++) {
	ElementColumn column = elementColumns.get(i);
	writer.write(column.getElementPath().encode());
	writer.write('=');
	writer.write(column.isActive() ? "active" : "inactive");
	writer.write(',');
	}
	ElementColumn column = elementColumns.get(i);
	writer.write(column.getElementPath().encode());
	writer.write('=');
	writer.write(column.isActive() ? "active" : "inactive");
	writer.write('\n');
	writer.flush();
	} finally {
	writer.close();
	}
	}

	private void loadColumns(String[] columnNames) {
	LinkedList<ElementPath> columnsToAdd = new LinkedList<ElementPath>();
	HashSet<ElementPath> inactiveColumns = new HashSet<ElementPath>();

	viewer.getTable().setRedraw(false);
	for (String name : columnNames) {
	String[] parts = name.split("=");
	ElementPath path = ElementPath.decode(parts[0]);
	columnsToAdd.add(path);
	if (parts.length > 1 && parts[1].equals("inactive")) {
	inactiveColumns.add(path);
	}
	}
	add(columnsToAdd, false);


	for (ElementColumn column : elementColumns) {
	if (inactiveColumns.contains(column.getElementPath())) {
	column.setActive(false);
	}
	}
	viewer.getTable().setRedraw(true);
	updateInternalFile();
	}

	public void loadColumnsFromFile(File file) throws FileNotFoundException, IOException {
	BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
	try {
	String line = reader.readLine();
	if (line == null) {
	// empty file
	return;
	}
	String[] columnNames = line.split(",");
	loadColumns(columnNames);
	} finally {
	reader.close();
	}
	}

	public synchronized void removeAll() {
	disposeAllColumns();
	updateInternalFile();
	refresher.clearUpdates();
	}

	private void disposeAllColumns() {
	// we must remove all the move listeners first before we dispose or else bad things happen
	enableMoveListeneing(false);
	for (SubscriptionDetails details : subscriptions) {
	details.dispose();
	}
	subscriptions.clear();
	elementColumns.clear();
	}

	public void toClipboard(Clipboard clipboard) {
	CopyToClipboardJob job = new CopyToClipboardJob(clipboard, elementColumns, refresher.getUpdates());
	job.schedule();
	}

	public void toCsv(File file) throws IOException {
	CopyToCsvFileJob job = new CopyToCsvFileJob(file, elementColumns, refresher.getUpdates());
	job.schedule();
	}

	public void loadLastColumns() {
	try {
	File file = OseeData.getFile(INTERNAL_FILE_NAME);
	if (file.isFile()) {
	loadColumnsFromFile(file);
	}

	} catch (Exception e) {
	OseeLog.log(Activator.class, Level.SEVERE, "could not read columns file", e);
	}
	}

	public void streamToFile(File file) throws FileNotFoundException, IOException {
	try{
	streamWriteLock.lock();
	if (streamToFileWriter != null) {
	// stop streaming
	streamToFileWriter.flush();
	streamToFileWriter.close();
	streamToFileWriter = null;
	}
	if (file == null) {
	setMoveableColumns(true);
	return;
	}
	setMoveableColumns(false);

	streamToFileWriter = new PrintWriter(new FileOutputStream(file));
	int i;
	for (i = 0; i < elementColumns.size() - 1; i++) {
	streamToFileWriter.write(elementColumns.get(i).getName());
	streamToFileWriter.write(',');
	}
	if (elementColumns.size() > 0) {
	streamToFileWriter.write(elementColumns.get(i).getName());
	streamToFileWriter.write('\n');
	}

	streamToFileWriter.flush();
	} finally {
	streamWriteLock.unlock();
	}
	}

	private void setMoveableColumns(boolean moveable) {
	for (ElementColumn column : elementColumns) {
	column.getColumn().setMoveable(moveable);
	}
	}

	/**
	* handles the reordering of columns
	*/
	@Override
	public void handleEvent(Event event) {

	if (event.widget.isDisposed() \|\| event.type != SWT.Move) {
	return;
	}
	synchronized (this) {
	indexAndSortColumns();
	updateInternalFile();
	}

	}

	public TableViewer getViewer() {
	return viewer;
	}

	public void setUpdateView(boolean updateView) {
	refresher.setUpdateView(updateView);
	}

	public void togglePauseUpdates() {
	acceptUpdates = !acceptUpdates;
	}
	}