1 /*******************************************************************************
2 * Copyright (c) 2007, 2010, 2018 Association for Decentralized Information Management
4 * All rights reserved. This program and the accompanying materials
5 * are made available under the terms of the Eclipse Public License v1.0
6 * which accompanies this distribution, and is available at
7 * http://www.eclipse.org/legal/epl-v10.html
10 * VTT Technical Research Centre of Finland - initial API and implementation
11 *******************************************************************************/
12 package org.simantics.ui;
14 import org.eclipse.jface.resource.ImageDescriptor;
15 import org.eclipse.jface.viewers.ISelection;
16 import org.eclipse.swt.widgets.Display;
17 import org.eclipse.swt.widgets.Widget;
18 import org.eclipse.ui.PlatformUI;
19 import org.simantics.DatabaseJob;
20 import org.simantics.Simantics;
21 import org.simantics.db.Resource;
22 import org.simantics.db.Session;
23 import org.simantics.db.common.primitiverequest.Adapter;
24 import org.simantics.db.common.utils.Logger;
25 import org.simantics.db.common.utils.RequestUtil;
26 import org.simantics.db.exception.DatabaseException;
27 import org.simantics.db.management.ISessionContext;
28 import org.simantics.db.management.ISessionContextProvider;
29 import org.simantics.db.management.ISessionContextProviderSource;
30 import org.simantics.project.IProject;
31 import org.simantics.project.ProjectKeys;
32 import org.simantics.utils.datastructures.Arrays;
33 import org.simantics.utils.ui.BundleUtils;
34 import org.simantics.utils.ui.ISelectionUtils;
35 import org.simantics.utils.ui.SWTUtils;
39 public class SimanticsUI {
41 public static final String PLUGIN_ID = "org.simantics.ui";
44 * The maximum amount of time in milliseconds to wait for the execution of a
45 * database request to start when the request is executed synchronously in
46 * the UI thread. The timeout counting starts from the moment the request is
47 * first scheduled into the database {@link Session}. The purpose is to
48 * prevent synchronous UI thread database requests from locking the whole UI
52 * The default value is 20. The default value can be customized at class
53 * load time by setting the system property
54 * <code>simantics.ui.request.start.timeout</code> to the desired value at
59 public static final long UI_THREAD_REQUEST_START_TIMEOUT;
61 * The maximum amount of time in milliseconds to wait for the execution of a
62 * database request to complete when the request is executed synchronously
63 * in the UI thread. The timeout counting starts from the moment the request
64 * execution is scheduled. The purpose is to prevent synchronous UI thread
65 * database requests from locking the whole UI thread up.
68 * The default value is 50. The default value can be customized at class
69 * load time by setting the system property
70 * <code>simantics.ui.request.execution.timeout</code> to the desired value
75 public static final long UI_THREAD_REQUEST_EXECUTION_TIMEOUT;
79 * The default value is 100. The default value can be customized at class
80 * load time by setting the system property
81 * <code>simantics.ui.request.execution.timeout.long</code> to the desired
82 * value at JVM startup.
86 public static final long UI_THREAD_REQUEST_EXECUTION_TIMEOUT_LONG;
89 UI_THREAD_REQUEST_START_TIMEOUT = parseLongProperty("simantics.ui.request.start.timeout", 500L);
90 UI_THREAD_REQUEST_EXECUTION_TIMEOUT = parseLongProperty("simantics.ui.request.exec.timeout", 50L);
91 UI_THREAD_REQUEST_EXECUTION_TIMEOUT_LONG = parseLongProperty("simantics.ui.request.exec.timeout.long", 100L);
95 * Information of the currently open database session for the Simantics UI.
96 * Contains just the vital information to connect to the database. Is
97 * <code>null</code> when there is no open database session.
99 private static ISessionContextProviderSource providerSource = null;
102 // * TODO: support different contexts
103 // * @deprecated no replacement
106 // public static void undo() {
108 // PlatformUI.getWorkbench().getOperationSupport().getOperationHistory().undo(
109 // IOperationHistory.GLOBAL_UNDO_CONTEXT, null, null);
110 // } catch (ExecutionException e) {
111 // // TODO Auto-generated catch block
112 // e.printStackTrace();
117 // * TODO: support different contexts
118 // * @deprecated no replacement
121 // public static void redo() {
123 // PlatformUI.getWorkbench().getOperationSupport().getOperationHistory().redo(
124 // IOperationHistory.GLOBAL_UNDO_CONTEXT, null, null);
125 // } catch (ExecutionException e) {
126 // // TODO Auto-generated catch block
127 // e.printStackTrace();
132 * Only for use in application startup code such as the workbench window
133 * advisor. Must be invoked before calling any other methods in this class.
135 * @param manager the ISessionManager to be used by the application
136 * @throw IllegalArgumentException if manager is <code>null</code>
138 public static void setSessionContextProviderSource(ISessionContextProviderSource source) {
140 throw new IllegalArgumentException("null provider source");
141 providerSource = source;
145 * Asserts that the current context provider source has been initialized
146 * before allowing access to it.
148 * @return current context provider source
150 public static ISessionContextProviderSource getProviderSource() {
151 if (providerSource == null)
152 throw new IllegalStateException(
153 "providerSource must be initialized by the application before using SimanticsUI");
154 return providerSource;
158 * Close and remove the current session contexts of the UI. Afterwards
159 * getSessionContext will return <code>null</code>.
161 * Not for client use, only for internal purposes.
163 public static synchronized void closeSessions() {
164 ISessionContextProviderSource source = providerSource;
167 for (ISessionContextProvider p : source.getAll()) {
168 ISessionContext ctx = p.setSessionContext(null);
176 * @return <code>true</code> if the session manager contains the specified
179 public static synchronized boolean isInUse(ISessionContext ctx) {
180 for (ISessionContextProvider p : getProviderSource().getAll()) {
181 if (p.getSessionContext() == ctx)
188 * @param project the project to check
190 * @return <code>true</code> if the session manager contains an
191 * ISessionContext that contains a reference to the specified
192 * project, disregarding the excluded ISessionContexts listed
194 public static synchronized boolean isInUse(IProject project, ISessionContext... excluding) {
195 for (ISessionContextProvider p : getProviderSource().getAll()) {
196 ISessionContext ctx = p.getSessionContext();
198 if (Arrays.indexOf(excluding, ctx) == -1) {
199 if (ctx.getHint(ProjectKeys.KEY_PROJECT) == project)
208 // * Looks if there is an ISessionContextProvider within the Simantics workbench
209 // * that is currently using a ProCore database server at the specified
212 // * @param address the address to look for connections to
213 // * @return <code>null</code> if there is currently no session in use to the
214 // * specified address.
216 // public static synchronized ISessionContext findSessionTo(ServerAddress address) {
217 // if (address == null)
218 // throw new IllegalArgumentException("null address");
219 // for (ISessionContextProvider provider : getProviderSource().getAll()) {
220 // ISessionContext ctx = provider.getSessionContext();
221 // if (ctx != null) {
222 // ServerAddress addr = ctx.getAddress();
223 // if (address.equals(addr))
231 * Returns the session context provider of the curretly active workbench
232 * window. This method will always return a valid session context provider.
234 * @return a valid ISessionContextProvider
237 public static ISessionContextProvider getSessionContextProvider() {
238 return Simantics.getSessionContextProvider();
242 * Returns the session context provider for the specified handle if one
243 * exists. Workbench windows (IWorkbenchWindow) are currently used as
246 * @param handle the handle associated with the requested session context
248 * @return <code>null</code> if there is no session associated to the
251 public static ISessionContextProvider getSessionContextProvider(Object handle) {
252 return getProviderSource().get(handle);
256 * Returns the database session context associated with the currently active
257 * workbench window. This method should be used to retrieve session contexts
258 * only when the client is sure that the correct workbench window has focus.
261 * If the client knows the workbench window it is working with, but it isn't
262 * sure that the correct workbench window has focus, use
263 * {@link #getSessionContext(Object)} instead.
266 * @return the session context associated with the currently active
267 * workbench window or <code>null</code> if the active window has no
271 public static ISessionContext getSessionContext() {
272 return Simantics.getSessionContext();
276 * Returns the database session context associated with the specified
277 * handle. Workbench windows (IWorkbenchWindow) are currently used as
278 * handles. This method should be used to retrieve session contexts in cases
279 * where the workbench window is known, but the thread of execution is such
280 * that the client cannot be certain that the same workbench window has
283 * @return the session context associated with the specified handle
286 public static ISessionContext getSessionContext(Object handle) {
287 return getSessionContextProvider(handle).getSessionContext();
291 * Associates the specified ISessionContext with the currently active
292 * workbench window. To remove an ISessionContext association from the
293 * active workbench window, specify <code>null</code> as ctx.
296 * After invoking this method you should be able to retrieve the same
297 * ISessionContext through {@link #getSessionContext()}, provided that the
298 * same workbench window has focus at that time.
301 * @param ctx the new UI database session context or <code>null</code> to
302 * replace the current UI session with no session.
303 * @return The previous session context if one existed, otherwise
304 * <code>null</code>. If the specified <code>ctx</code> matched the
305 * current session context (<code>null</code> or
306 * <code>non-null</code>), null is also returned and nothing is
309 public static synchronized ISessionContext setSessionContext(ISessionContext ctx) {
310 return getSessionContextProvider().setSessionContext(ctx);
314 * Associates the specified ISessionContext with the specified handle
318 * Currently IWorkbenchWindow's are used as handles. This implies
319 * that each workbench window can only have one active ISessionContext bound
320 * to it. After invoking this method with a valid workbench window handle
321 * you should be able to retrieve the same ISessionContext through
322 * {@link #getSessionContext(Object)} with the same workbench window
323 * specified as the handle.
326 * @param handle the handle to associate the specified ISessionContext with.
327 * @param ctx the new UI database session context or <code>null</code> to
328 * replace the current UI session with no session.
329 * @return The previous session context if one existed, otherwise
330 * <code>null</code>. If the specified <code>ctx</code> matched the
331 * current session context (<code>null</code> or
332 * <code>non-null</code>), null is also returned and nothing is
335 public static synchronized ISessionContext setSessionContext(Object handle, ISessionContext ctx) {
336 ISessionContextProvider provider = getProviderSource().get(handle);
337 if (provider != null)
338 return provider.setSessionContext(ctx);
343 * Returns the database Session bound to the currently active workbench
347 * This method should only be invoked in cases where it is certain that the
348 * correct workbench window has focus or it is the latest of all workbench
349 * windows to have had focus. Basically any invocation from the SWT UI
350 * thread is safe, since because in those cases the currently active
351 * workbench window is generally known. Instead invocations from any other
352 * thread should be carefully considered. The rule of thumb is that if you
353 * cannot be sure that the correct workbench window has focus, you should
354 * always get a hold of the Session to be used in some other manner.
358 * The method always returns a non-null Session or produces an
359 * IllegalStateException if a Session was not attainable.
362 * @return the Session bound to the currently active workbench window
363 * @throws IllegalStateException if no Session was available
366 public static Session getSession() {
367 return Simantics.getSession();
371 * Returns the database Session bound to the currently active workbench
372 * window. Differently from {@link #getSession()}, this method returns
373 * <code>null</code> if there is no current Session available.
376 * This method should only be invoked from the SWT UI thread. Check the
377 * explanations given in {@link #getSession()}. The same applies to this
381 * @return the Session bound to the currently active workbench window or
385 public static Session peekSession() {
386 return Simantics.peekSession();
390 * @return the currently open and active project as an IProject or
391 * <code>null</code> if there is no active session or project
394 public static IProject peekProject() {
395 return Simantics.peekProject();
399 * @return the currently open and active project for the specified database
400 * session or <code>null</code> if there is no current project
403 public static IProject peekProject(ISessionContext ctx) {
406 return ctx.getHint(ProjectKeys.KEY_PROJECT);
410 * @return the currently open and active project as an IProject
411 * @throws IllegalStateException if there is no currently active database
412 * session, which also means there is no active project at the
416 public static IProject getProject() {
417 return Simantics.getProject();
421 * TODO: refactor this out of here
423 * @param imageFilePath
426 public static ImageDescriptor getImageDescriptor(String imageFilePath) {
427 return BundleUtils.getImageDescriptorFromPlugin(PLUGIN_ID, imageFilePath);
431 * TODO: [Tuukka] I'm really unsure this belongs here.
435 * @param assignableFrom
438 public static <T> T filterSingleSelection(ISelection sel, Class<T> assignableFrom) {
440 T result = ISelectionUtils.filterSingleSelection(sel, assignableFrom);
444 Resource resource = ISelectionUtils.filterSingleSelection(sel, Resource.class);
445 if(resource == null) return null;
448 return getSession().syncRequest(new Adapter<T>(resource, assignableFrom));
449 } catch (DatabaseException e) {
450 Logger.defaultLogError(e);
456 public static <T> T filterSingleWorkbenchSelection(Class<T> assignableFrom) {
457 return filterSingleSelection(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getSelectionService().getSelection(), assignableFrom);
461 public static void asyncExecSWT(final Widget widget, final Runnable runnable) {
462 SWTUtils.asyncExec(widget, delayedExecSWT(null, widget, runnable));
465 public static void asyncExecSWT(final Display display, final Runnable runnable) {
466 SWTUtils.asyncExec(display, delayedExecSWT(display, null, runnable));
469 private static Runnable delayedExecSWT(final Display display, final Widget widget, final Runnable runnable) {
470 if (display == null && widget == null)
471 throw new IllegalArgumentException("both display and widget are null");
473 return new Runnable() {
476 if (display != null && display.isDisposed())
478 if (widget != null && widget.isDisposed())
480 if (DatabaseJob.inProgress()) {
481 Display d = display != null ? display : widget.getDisplay();
482 d.timerExec(50, this);
490 private static long parseLongProperty(String propertyName, long defaultValue) {
491 String value = System.getProperty(propertyName, null);
493 return value != null ? Long.parseLong(value) : defaultValue;
494 } catch (NumberFormatException e) {
499 public static boolean isLinuxGTK() {
500 String ws = System.getProperty("osgi.ws");
501 return ws != null && "gtk".equals(ws);