# HG changeset patch # User dadubrow # Date 1265052782 21600 # Node ID fd6ae4e6e3d9089c7f2a2bb20a389665e25ef702 # Parent a163687f3d89ca6bdfa72e17a434b27458350733 (no commit message) diff -r a163687f3d89 -r fd6ae4e6e3d9 core/com.nokia.cpp.utils.ui/src/com/nokia/cpp/internal/api/utils/ui/BrowseDialogUtils.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/core/com.nokia.cpp.utils.ui/src/com/nokia/cpp/internal/api/utils/ui/BrowseDialogUtils.java Mon Feb 01 13:33:02 2010 -0600 @@ -0,0 +1,183 @@ +/* +* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +package com.nokia.cpp.internal.api.utils.ui; + +import java.io.File; + +import org.eclipse.core.runtime.IPath; +import org.eclipse.swt.widgets.DirectoryDialog; +import org.eclipse.swt.widgets.FileDialog; +import org.eclipse.swt.widgets.Text; + +/** + * Utilities to make it easier to use file and directory dialogs which are associated + * with text entry fields. + *

+ * First, promote UI where Browse... starts from the current textual entry rather than + * some random place. + *

+ * Second, overcome terrible SWT behavior: even if you do set the filter path, then if it + * is not 100% correct, it will again revert to the home directory. So, find the nearest + * directory that does exist. + */ +public class BrowseDialogUtils { + /** + * When issuing a "Browse..." command next to a text entry field, initialize + * the dialog with the nearest existing file or directory in that text field. + * @param dialog + * @param textEntry + * @pathm defaultPath the path to use when the text entry is empty + */ + public static void initializeFrom(FileDialog dialog, Text textEntry, IPath defaultPath) { + if (textEntry != null) { + String existing = textEntry.getText().trim(); + if (existing.length() > 0) { + initializeFrom(dialog, existing); + return; + } + } + if (defaultPath != null) { + initializeFrom(dialog, defaultPath); + } + } + + /** + * When issuing a "Browse..." command next to a text entry field, initialize + * the dialog with the nearest existing file or directory in that text field. + * @param dialog + * @param textEntry + */ + public static void initializeFrom(FileDialog dialog, Text textEntry) { + if (textEntry == null) + return; + String existing = textEntry.getText().trim(); + initializeFrom(dialog, existing); + } + + /** + * When issuing a "Browse..." command with an expected file, initialize + * the dialog with the nearest existing file or directory. + * @param dialog + * @param path + */ + public static void initializeFrom(FileDialog dialog, IPath path) { + if (path != null) { + initializeFrom(dialog, path.toOSString()); + } + } + + /** + * When issuing a "Browse..." command with an expected file, initialize + * the dialog with the nearest existing file or directory. + * @param dialog + * @param path + */ + public static void initializeFrom(FileDialog dialog, String path) { + if (path != null && path.length() > 0) { + boolean isDirectory = path.endsWith("/") || path.endsWith("\\"); + File file = new File(path); + boolean exists = file.exists(); + if (exists) { + isDirectory = file.isDirectory(); + } + if (!isDirectory) { + dialog.setFileName(file.getName()); + } + if (exists) { + if (file.isAbsolute()) { + dialog.setFilterPath(isDirectory ? file.getAbsolutePath() : file.getParent()); + } + } else { + if (!file.isAbsolute()) + return; + File dir = file.getParentFile(); + while (dir != null && !dir.exists()) { + dir = dir.getParentFile(); + } + if (dir != null) { + dialog.setFilterPath(dir.getAbsolutePath()); + } + } + } + } + + /** + * When issuing a "Browse..." command next to a text entry field, initialize + * the dialog with the nearest existing directory in that text field. + * @param dialog + * @param textEntry + * @param defaultPath the default path if the text entry is empty + */ + public static void initializeFrom(DirectoryDialog dialog, Text textEntry, IPath defaultPath) { + if (textEntry != null) { + String existing = textEntry.getText().trim(); + if (existing.length() > 0) { + initializeFrom(dialog, existing); + return; + } + } + if (defaultPath != null) { + initializeFrom(dialog, defaultPath); + } + } + + /** + * When issuing a "Browse..." command next to a text entry field, initialize + * the dialog with the nearest existing directory in that text field. + * @param dialog + * @param textEntry + */ + public static void initializeFrom(DirectoryDialog dialog, Text textEntry) { + if (textEntry == null) + return; + String existing = textEntry.getText().trim(); + initializeFrom(dialog, existing); + } + + /** + * When issuing a "Browse..." command with an expected directory, initialize + * the dialog with the nearest existing path. + * @param dialog + * @param path + */ + public static void initializeFrom(DirectoryDialog dialog, IPath path) { + if (path != null) { + initializeFrom(dialog, path.toOSString()); + } + } + + /** + * When issuing a "Browse..." command with an expected directory, initialize + * the dialog with the nearest existing path. + * @param dialog + * @param path + */ + public static void initializeFrom(DirectoryDialog dialog, String path) { + if (path != null && path.length() > 0) { + File file = new File(path); + if (!file.isAbsolute()) + return; + while (file != null && !file.exists()) { + file = file.getParentFile(); + } + if (file != null) { + dialog.setFilterPath(file.getAbsolutePath()); + } + } + } +} diff -r a163687f3d89 -r fd6ae4e6e3d9 debuggercdi/com.nokia.carbide.trk.support/src/com/nokia/carbide/trk/support/service/RemoteConnectedService.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/debuggercdi/com.nokia.carbide.trk.support/src/com/nokia/carbide/trk/support/service/RemoteConnectedService.java Mon Feb 01 13:33:02 2010 -0600 @@ -0,0 +1,136 @@ +/* +* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + + +package com.nokia.carbide.trk.support.service; + +import org.osgi.framework.Version; + +import com.nokia.carbide.remoteconnections.Messages; +import com.nokia.carbide.remoteconnections.interfaces.IConnectedService; +import com.nokia.carbide.remoteconnections.interfaces.IService; +import com.nokia.cpp.internal.api.utils.core.IListenerFiring; +import com.nokia.cpp.internal.api.utils.core.ListenerList; + +/** + * This is a stub for the TRK and Trace connected services used when the host + * does not support Chad's TCF. This reconciles the fact that a TRK connection publishes + * these services, but we cannot actually instantiate them. + *

+ * In the future this should find a way to talk to the device over Eclipse TCF or something. + */ +public class RemoteConnectedService implements IConnectedService { + + private boolean enabled = true; + private final IService service; + private IStatus unknownStatus = new IStatus() { + + public IConnectedService getConnectedService() { + return RemoteConnectedService.this; + } + + public EStatus getEStatus() { + return EStatus.UNKNOWN; + } + + public String getLongDescription() { + return "The device is connected remotely; testing not yet implemented."; + } + + public String getShortDescription() { + return "Unknown"; + } + + }; + + private IStatus noStatus = new IStatus() { + + public IConnectedService getConnectedService() { + return RemoteConnectedService.this; + } + + public EStatus getEStatus() { + return EStatus.UNKNOWN; + } + + public String getLongDescription() { + return Messages.getString("AbstractConnectedService.UserDisabledMessage"); + } + + public String getShortDescription() { + return Messages.getString("AbstractConnectedService.NoTestingLabel"); + } + + }; + private ListenerList listeners; + private IStatus currentStatus; + /** + * + */ + public RemoteConnectedService(IService service) { + this.service = service; + listeners = new ListenerList(); + currentStatus = noStatus; + } + public void addStatusChangedListener(IStatusChangedListener listener) { + listeners.add(listener); + } + + public void dispose() { + } + + public IService getService() { + return service; + } + + public IStatus getStatus() { + return currentStatus; + } + + public void removeStatusChangedListener(IStatusChangedListener listener) { + listeners.remove(listener); + } + + public void testStatus() { + } + + public void setDeviceOS(String familyName, Version version) { + } + + public boolean isEnabled() { + return enabled; + } + + public void setEnabled(boolean enabled) { + this.enabled = enabled; + + currentStatus = enabled ? unknownStatus : noStatus; + + fireListeners(); + } + /** + * + */ + private void fireListeners() { + listeners.fireListeners(new IListenerFiring() { + + public void fire(IStatusChangedListener listener) { + listener.statusChanged(getStatus()); + } + }); + } +} diff -r a163687f3d89 -r fd6ae4e6e3d9 debuggercdi/com.nokia.carbide.trk.support/src/com/nokia/carbide/trk/support/status/ConnectionStatusReconciler.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/debuggercdi/com.nokia.carbide.trk.support/src/com/nokia/carbide/trk/support/status/ConnectionStatusReconciler.java Mon Feb 01 13:33:02 2010 -0600 @@ -0,0 +1,290 @@ +/** +* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +package com.nokia.carbide.trk.support.status; + +import java.util.ArrayList; +import java.util.List; + +import org.eclipse.ui.PartInitException; + +import com.nokia.carbide.remoteconnections.RemoteConnectionsActivator; +import com.nokia.carbide.remoteconnections.interfaces.IConnectedService; +import com.nokia.carbide.remoteconnections.interfaces.IConnection; +import com.nokia.carbide.remoteconnections.interfaces.IConnectionsManager; +import com.nokia.carbide.remoteconnections.interfaces.AbstractConnection.ConnectionStatus; +import com.nokia.carbide.remoteconnections.interfaces.IConnectedService.IStatus; +import com.nokia.carbide.remoteconnections.interfaces.IConnectedService.IStatusChangedListener; +import com.nokia.carbide.remoteconnections.interfaces.IConnectedService.IStatus.EStatus; +import com.nokia.carbide.remoteconnections.interfaces.IConnectionsManager.IConnectionListener; +import com.nokia.carbide.remoteconnections.internal.api.IConnection2; +import com.nokia.carbide.remoteconnections.internal.api.IConnection2.IConnectionStatus; +import com.nokia.carbide.remoteconnections.internal.api.IConnection2.IConnectionStatus.EConnectionStatus; +import com.nokia.carbide.trk.support.Messages; +import com.nokia.carbide.trk.support.connection.USBConnectionType; +import com.nokia.carbide.trk.support.service.TRKConnectedService; +import com.nokia.carbide.trk.support.service.TracingConnectedService; +import com.nokia.cpp.internal.api.utils.ui.RunRunnableWhenWorkbenchVisibleJob; +import com.nokia.cpp.internal.api.utils.ui.WorkbenchUtils; + +/** + * A singleton object that manages the device status of dynamic connections + * based on the status of the TRK and Tracing services. + */ +public class ConnectionStatusReconciler { + + private static final String CONNECTIONS_VIEW_ID = + "com.nokia.carbide.remoteconnections.view.ConnectionsView"; //$NON-NLS-1$ + + private class ConnectionListener implements IConnectionListener { + + public void connectionAdded(IConnection connection) { + addConnection(connection); + } + + public void connectionRemoved(IConnection connection) { + if (connection.equals(userSetCurrentConnection)) + userSetCurrentConnection = null; + removeConnection(connection); + } + + public void currentConnectionSet(IConnection connection) { + if (connection != null && !connection.equals(reconcilerSetCurrentConnection)) + userSetCurrentConnection = connection; + } + + } + + private class ServiceStatusListener implements IStatusChangedListener { + + public void statusChanged(IStatus status) { + handleServiceStatusChange(status); + } + + } + + private static ConnectionStatusReconciler instance; + private IConnectionsManager manager; + private IConnectionListener connectionListener; + private List handledConnections; + private ServiceStatusListener serviceStatusListener; + private IConnection reconcilerSetCurrentConnection; + private IConnection userSetCurrentConnection; + + private ConnectionStatusReconciler() { + connectionListener = new ConnectionListener(); + manager = RemoteConnectionsActivator.getConnectionsManager(); + manager.addConnectionListener(connectionListener); + handledConnections = new ArrayList(); + serviceStatusListener = new ServiceStatusListener(); + } + + public static ConnectionStatusReconciler getInstance() { + if (instance == null) + instance = new ConnectionStatusReconciler(); + + return instance; + } + + public void dispose() { + manager.removeConnectionListener(connectionListener); + for (IConnection connection : new ArrayList(handledConnections)) { + removeConnection(connection); + } + } + + private boolean isDynamic(IConnection connection) { + return connection instanceof IConnection2 && ((IConnection2) connection).isDynamic(); + } + + private boolean isSysTRK(TRKConnectedService service) { + String value = service.getProperties().get(TRKConnectedService.PROP_SYS_TRK); + return Boolean.parseBoolean(value); + } + + private void addConnection(IConnection connection) { + handledConnections.add(connection); + for (IConnectedService service : manager.getConnectedServices(connection)) { + if (service instanceof TRKConnectedService || + service instanceof TracingConnectedService) { + service.addStatusChangedListener(serviceStatusListener); + } + } + showConnectionsView(); + } + + private void showConnectionsView() { + RunRunnableWhenWorkbenchVisibleJob.start(new Runnable() { + public void run() { + // try to show the connections view to start service testers + try { + WorkbenchUtils.getView(CONNECTIONS_VIEW_ID); + } catch (PartInitException e) { + } + } + }); + } + + private void reconcileAsCurrent(IConnection connection) { + if (canBeSetToCurrent(connection)) { + if (isReady(connection)) { // set as current + reconcilerSetCurrentConnection = connection; + manager.setCurrentConnection(connection); + } else if (isNotReady(connection) && connection.equals(manager.getCurrentConnection())) { + // unset current or set something else current + if (isDynamic(connection) && userSetCurrentConnection != null) { + manager.setCurrentConnection(userSetCurrentConnection); + } + else { + // look for some other existing connection that is ready + for (IConnection c : manager.getConnections()) { + if (canBeSetToCurrent(c) && isReady(c)) { + reconcilerSetCurrentConnection = connection; + manager.setCurrentConnection(connection); + return; + } + } + // set to no current connection + manager.setCurrentConnection(null); + } + } + } + } + + private boolean isReady(IConnection connection) { + return equalsConnectionStatus(connection, EConnectionStatus.READY); + } + + private boolean isNotReady(IConnection connection) { + return equalsConnectionStatus(connection, EConnectionStatus.NOT_READY); + } + + private boolean equalsConnectionStatus(IConnection connection, EConnectionStatus status) { + if (connection instanceof IConnection2) { + IConnectionStatus connectionStatus = ((IConnection2) connection).getStatus(); + if (connectionStatus != null) + return connectionStatus.getEConnectionStatus().equals(status); + } + return false; + } + + private boolean canBeSetToCurrent(IConnection connection) { + // USB connections for now + return USBConnectionType.ID.equals(connection.getConnectionType().getIdentifier()); + } + + private void reconcileStatus(IConnection connection) { + if (!isDynamic(connection)) // don't set status for user generated connections + return; + + boolean isSysTRK = false; + EStatus trkStatus = EStatus.UNKNOWN; + EStatus traceStatus = EStatus.UNKNOWN; + for (IConnectedService service : manager.getConnectedServices(connection)) { + if (service instanceof TRKConnectedService) { + isSysTRK = isSysTRK((TRKConnectedService) service); + trkStatus = service.getStatus().getEStatus(); + } + if (service instanceof TracingConnectedService) { + traceStatus = service.getStatus().getEStatus(); + } + } + setConnectionStatus((IConnection2) connection, isSysTRK, trkStatus, traceStatus); + } + + private void setConnectionStatus(IConnection2 connection, boolean isSysTRK, EStatus trkStatus, EStatus traceStatus) { + // use trk status + EConnectionStatus connectionStatus = service2ConnectionStatus(trkStatus); + // if sys trk, tracing also used + if (isSysTRK && connectionStatus.equals(EConnectionStatus.READY)) { + connectionStatus = service2ConnectionStatus(traceStatus); + } + + String shortDesc = getShortDescriptionForStatus(connectionStatus); + StringBuilder longDesc = new StringBuilder(Messages.getString("ConnectionStatusReconciler_TRKServicePrefix")); //$NON-NLS-1$ + longDesc.append(getServiceStatusString(trkStatus)); + if (isSysTRK) { + longDesc.append(Messages.getString("ConnectionStatusReconciler_TracingServicePrefix")); //$NON-NLS-1$ + longDesc.append(getServiceStatusString(traceStatus)); + } + + connection.setStatus(new ConnectionStatus(connectionStatus, shortDesc, longDesc.toString())); + } + + private String getShortDescriptionForStatus(EConnectionStatus connectionStatus) { + switch (connectionStatus) { + case READY: + return Messages.getString("ConnectionStatusReconciler_ReadyLabel"); //$NON-NLS-1$ + case NOT_READY: + return Messages.getString("ConnectionStatusReconciler_NotReadyLabel"); //$NON-NLS-1$ + case IN_USE: + return Messages.getString("ConnectionStatusReconciler_InUseLabel"); //$NON-NLS-1$ + case IN_USE_DISCONNECTED: + return Messages.getString("ConnectionStatusReconciler_DisconnectedLabel"); //$NON-NLS-1$ + } + return ""; //$NON-NLS-1$ + } + + private String getServiceStatusString(EStatus status) { + switch (status) { + case UP: + return Messages.getString("ConnectionStatusReconciler_availableLabel"); //$NON-NLS-1$ + case DOWN: + return Messages.getString("ConnectionStatusReconciler_unavailableLabel"); //$NON-NLS-1$ + case IN_USE: + return Messages.getString("ConnectionStatusReconciler_inUseLabel_lower"); //$NON-NLS-1$ + } + return ""; //$NON-NLS-1$ + } + + private EConnectionStatus service2ConnectionStatus(EStatus serviceStatus) { + switch (serviceStatus) { + case UP: + return EConnectionStatus.READY; + case DOWN: + return EConnectionStatus.NOT_READY; + case IN_USE: + return EConnectionStatus.IN_USE; + } + return EConnectionStatus.NONE; + } + + private void removeConnection(IConnection connection) { + handledConnections.remove(connection); + } + + private IConnection findConnection(IConnectedService cs) { + for (IConnection connection : handledConnections) { + for (IConnectedService connectedService : manager.getConnectedServices(connection)) { + if (cs.equals(connectedService)) + return connection; + } + } + return null; + } + + public void handleServiceStatusChange(IStatus status) { + IConnectedService service = status.getConnectedService(); + IConnection connection = findConnection(service); + if (connection instanceof IConnection2) { + reconcileStatus((IConnection2) connection); + } + if (connection != null) + reconcileAsCurrent(connection); + } + +}