import com.google.gwt.core.client.RunAsyncCallback; //导入依赖的package包/类
public void initPageAsync(final String page) {
	GWT.runAsync(new RunAsyncCallback() {
		public void onSuccess() {
			init(page);
			LoadingWidget.getInstance().hide();
		}
		public void onFailure(Throwable reason) {
			Label error = new Label(MESSAGES.failedToLoadPage(reason.getMessage()));
			error.setStyleName("unitime-ErrorMessage");
			RootPanel loading = RootPanel.get("UniTimeGWT:Loading");
			if (loading != null) loading.setVisible(false);
			RootPanel.get("UniTimeGWT:Body").add(error);
			LoadingWidget.getInstance().hide();
			UniTimeNotifications.error(MESSAGES.failedToLoadPage(reason.getMessage()), reason);
		}
	});
}
 

import com.google.gwt.core.client.RunAsyncCallback; //导入依赖的package包/类
private void init() {
       logger.info("Init...");

	addMetaElements();

	// Disable Back Button
	setupHistory();
	setupBootbox();

	GWT.runAsync(new RunAsyncCallback() {
		@Override
		public void onFailure(Throwable reason) {
			logger.info("Error on Async!");
		}

		@Override
		public void onSuccess() {
			createViews();
			removeLoadingImage();

               // Example calling JavaScript with JSNI - old style
               // alert("Lofi Old Style...");
		}
	});
}
 

import com.google.gwt.core.client.RunAsyncCallback; //导入依赖的package包/类
String[] getClassesToImport() {
  return new String[] { com.mvp4g.client.history.PlaceService.class.getName(),
                        GWT.class.getName(),
                        com.google.gwt.user.client.History.class.getName(),
                        ServiceDefTarget.class.getName(),
                        PresenterInterface.class.getName(),
                        EventBus.class.getName(),
                        Mvp4gException.class.getName(),
                        HistoryConverter.class.getName(),
                        Mvp4gEventPasser.class.getName(),
                        Mvp4gModule.class.getName(),
                        GinModules.class.getName(),
                        Ginjector.class.getName(),
                        BaseEventBus.class.getName(),
                        EventFilter.class.getName(),
                        EventHandlerInterface.class.getName(),
                        List.class.getName(),
                        NavigationEventCommand.class.getName(),
                        NavigationConfirmationInterface.class.getName(),
                        RunAsyncCallback.class.getName(),
                        Mvp4gRunAsync.class.getName(),
                        Command.class.getName(),
                        HistoryProxyProvider.class.getName(),
                        DefaultHistoryProxy.class.getName() };
}
 

import com.google.gwt.core.client.RunAsyncCallback; //导入依赖的package包/类
protected void loadTests(final boolean forReal) {
  GWT.runAsync(JUnit4Runner.class, new RunAsyncCallback() {

    @Override
    public void onSuccess() {
      if (forReal) {
        displayTests();
        runTests();
      }
    }

    @Override
    public void onFailure(final Throwable reason) {
      X_Log.error(JUnitUi.class, "RunAsync Failed", reason);
    }
  });
}
 

import com.google.gwt.core.client.RunAsyncCallback; //导入依赖的package包/类
protected void loadTests(final boolean forReal) {
  GWT.runAsync(JUnit4Executor.class, new RunAsyncCallback() {

    @Override
    public void onSuccess() {
      if (forReal) {
        displayTests();
        runTests();
      }
    }

    @Override
    public void onFailure(final Throwable reason) {

    }
  });
}
 

import com.google.gwt.core.client.RunAsyncCallback; //导入依赖的package包/类
protected void addAnnotationTests() {
  GWT.runAsync(AnnotationTests.class, new RunAsyncCallback() {
    @Override
    public void onSuccess() {
      magicClass(AnnotationTests.class);
      try {
        addTests(AnnotationTests.class);
      } catch (final Throwable e) {
        print("Error adding AnnotationTests", e);
      }
    }

    @Override
    public void onFailure(final Throwable reason) {
      print("Error loading AnnotationTests", reason);
    }
  });
}
 

import com.google.gwt.core.client.RunAsyncCallback; //导入依赖的package包/类
protected void addArrayTests() {
  GWT.runAsync(ArrayTests.class, new RunAsyncCallback() {
    @Override
    public void onSuccess() {
      magicClass(ArrayTests.class);
      try {
        addTests(ArrayTests.class);
      } catch (final Throwable e) {
        print("Error adding ArrayTests", e);
      }
    }

    @Override
    public void onFailure(final Throwable reason) {
      print("Error loading ArrayTests", reason);
    }
  });
}
 

import com.google.gwt.core.client.RunAsyncCallback; //导入依赖的package包/类
protected void addConstructorTests() {
  GWT.runAsync(ConstructorTests.class, new RunAsyncCallback() {
    @Override
    public void onSuccess() {
      magicClass(ConstructorTests.class);
      try {
        addTests(ConstructorTests.class);
      } catch (final Throwable e) {
        print("Error adding ConstructorTests", e);
      }
    }

    @Override
    public void onFailure(final Throwable reason) {
      print("Error loading ConstructorTests", reason);
    }
  });
}
 

import com.google.gwt.core.client.RunAsyncCallback; //导入依赖的package包/类
protected void addFieldTests() {
  GWT.runAsync(FieldTests.class, new RunAsyncCallback() {
    @Override
    public void onSuccess() {
      magicClass(FieldTests.class);
      try {
        addTests(FieldTests.class);
      } catch (final Throwable e) {
        print("Error adding FieldTests", e);
      }
    }

    @Override
    public void onFailure(final Throwable reason) {
      print("Error loading FieldTests", reason);
    }
  });
}
 

import com.google.gwt.core.client.RunAsyncCallback; //导入依赖的package包/类
protected void addMethodTests() {
  GWT.runAsync(MethodTests.class, new RunAsyncCallback() {
    @Override
    public void onSuccess() {
      magicClass(MethodTests.class).getMethods();
      try {
        addTests(MethodTests.class);
      } catch (final Throwable e) {
        print("Error adding MethodTests", e);
      }
    }

    @Override
    public void onFailure(final Throwable reason) {
      print("Error loading MethodTests", reason);
    }
  });
}
 

import com.google.gwt.core.client.RunAsyncCallback; //导入依赖的package包/类
public void test(Runnable onDone) {
  SplitPointTest.onDone = onDone;
  // start with a regular gwt code split, which forces all our code into split points
  // this makes it more difficult for the auto-generated code splitting to make clean cuts
  InstanceInterface instance = X_Inject.instance(InstanceInterface.class);
  instance.test();
  com.google.gwt.core.client.GWT.runAsync(X_Inject.class, new RunAsyncCallback() {
    @Override
    public void onSuccess() {
      X_Inject.singletonAsync(LogService.class, StartTest.class);
      X_Inject.singletonAsync(ImportTestInterface.class, ImportTestReceiver.class);
      X_Inject.singletonAsync(ImportTestInterface.class, ImportTestCallback.class);
      X_Inject.singletonAsync(ServiceTestInterface.class, ServiceTestCallback.class);
    }

    @Override
    public void onFailure(Throwable reason) {
    }
  });
}
 

import com.google.gwt.core.client.RunAsyncCallback; //导入依赖的package包/类
public static void junitRunAsync(final RunAsyncCallback callback)
{
    new Thread()
    {
        @Override
        public void run()
        {
            if (RUN_ASYNC_DELAY > 0)
            {
                try
                {
                    Thread.sleep(RUN_ASYNC_DELAY);
                }
                catch (InterruptedException e)
                {
                    LOG.error("Could not wait", e);
                }
            }
            callback.onSuccess();
        }
    }.start();

}
 

import com.google.gwt.core.client.RunAsyncCallback; //导入依赖的package包/类
@Override
public void runAsync(AsyncTask asyncTask) {
    GWT.runAsync(new RunAsyncCallback() {
        @Override
        public void onFailure(Throwable reason) {
            asyncTask.onFailed(reason);
        }

        @Override
        public void onSuccess() {
            asyncTask.onSuccess();
        }
    });
}
 

import com.google.gwt.core.client.RunAsyncCallback; //导入依赖的package包/类
public void onModuleLoadDeferred() {
	// register triggers
	GWT.runAsync(new RunAsyncCallback() {
		@Override
		public void onSuccess() {
			for (Triggers t: Triggers.values())
				t.register();
			callGwtOnLoadIfExists();
		}
		@Override
		public void onFailure(Throwable reason) {
		}
	});
	
	// load page
	if (RootPanel.get("UniTimeGWT:Body") != null) {
		LoadingWidget.getInstance().show(MESSAGES.waitLoadingPage());
		Scheduler.get().scheduleDeferred(new ScheduledCommand() {
			@Override
			public void execute() {
				initPageAsync(Window.Location.getParameter("page"));
			}
		});
	}
	
	// load components
	for (final Components c: Components.values()) {
		final RootPanel p = RootPanel.get(c.id());
		if (p != null) {
			Scheduler.get().scheduleDeferred(new ScheduledCommand() {
				@Override
				public void execute() {
					initComponentAsync(p, c);
				}
			});
		}
		if (p == null && c.isMultiple()) {
			NodeList<Element> x = getElementsByName(c.id());
			if (x != null && x.getLength() > 0)
				for (int i = 0; i < x.getLength(); i++) {
					Element e = x.getItem(i);
					e.setId(DOM.createUniqueId());
					final RootPanel q = RootPanel.get(e.getId());
					Scheduler.get().scheduleDeferred(new ScheduledCommand() {
						@Override
						public void execute() {
							initComponentAsync(q, c);
						}
					});
				}
		}
	}
	
	Window.addWindowClosingHandler(new Window.ClosingHandler() {
		@Override
		public void onWindowClosing(Window.ClosingEvent event) {
			if (isLoadingDisplayed() || LoadingWidget.getInstance().isShowing()) return;
			LoadingWidget.showLoading(MESSAGES.waitPlease());
			iPageLoadingTimer = new Timer() {
				@Override
				public void run() {
					RPC.execute(new IsSessionBusyRpcRequest(), new AsyncCallback<GwtRpcResponseBoolean>() {
						@Override
						public void onFailure(Throwable caught) {
							LoadingWidget.hideLoading();
						}
						@Override
						public void onSuccess(GwtRpcResponseBoolean result) {
							if (result.getValue()) {
								iPageLoadingTimer.schedule(500);
							} else {
								LoadingWidget.hideLoading();
							}
						}
					});
				}
			};
			iPageLoadingTimer.schedule(500);
		}
	});
}
 

import com.google.gwt.core.client.RunAsyncCallback; //导入依赖的package包/类
public void initComponentAsync(final RootPanel panel, final Components comp) {
	GWT.runAsync(new RunAsyncCallback() {
		public void onSuccess() {
			comp.insert(panel);
		}
		public void onFailure(Throwable reason) {
		}
	});
}
 

import com.google.gwt.core.client.RunAsyncCallback; //导入依赖的package包/类
private void openDialogAsync() {
       GWT.runAsync(new RunAsyncCallback() {
       	public void onSuccess() {
       		openDialog();
       	}
       	public void onFailure(Throwable reason) {
       		UniTimeNotifications.error(MESSAGES.failedToLoadTheApp(reason.getMessage()));
       	}
       });
}
 

import com.google.gwt.core.client.RunAsyncCallback; //导入依赖的package包/类
public void showSuggestionsAsync(final int rowIndex) {
	if (rowIndex < 0) return;
	GWT.runAsync(new RunAsyncCallback() {
		public void onSuccess() {
			openSuggestionsBox(rowIndex);
		}
		public void onFailure(Throwable caught) {
			iStatus.error(MESSAGES.exceptionSuggestionsFailed(caught.getMessage()), caught);
		}
	});
}
 

import com.google.gwt.core.client.RunAsyncCallback; //导入依赖的package包/类
private static void loadFacade(final Callback<Void, String> aCallback) {
	final CumulativeCallbackAdapter<Void, String> facadeProcess = new CumulativeCallbackAdapter<Void, String>(2) {

		@Override
		protected void doWork(Void aResult) throws Exception {
			GWT.runAsync(new RunAsyncCallback() {

				@Override
				public void onSuccess() {
					if (!asyncRan.contains(FACADE_HUB)) {
						asyncRan.add(FACADE_HUB);
						JsFacade.init();
					}
					aCallback.onSuccess(null);
				}

				@Override
				public void onFailure(Throwable reason) {
					aCallback.onFailure(reason.toString());
				}
			});
		}

		@Override
		protected void failed(List<String> aReasons) {
			aCallback.onFailure(errorsToString(aReasons));
		}

	};
	loadForms(facadeProcess);
	loadHub(MODEL_HUB, facadeProcess);
}
 

import com.google.gwt.core.client.RunAsyncCallback; //导入依赖的package包/类
@Inject
public CodeMirrorEditorExtension(final EditorTypeRegistry editorTypeRegistry,
                                 final RequireJsLoader requireJsLoader,
                                 final NotificationManager notificationManager,
                                 final CodeMirrorEditorModule editorModule,
                                 final BaseCodemirrorPromise basePromise,
                                 final BaseCodemirrorInitializer baseInitializer,
                                 final CodeMirrorTextEditorFactory codeMirrorTextEditorFactory,
                                 final CompletionResources completionResources,
                                 final BasePathConstant basePathConstant) {
    this.notificationManager = notificationManager;
    this.requireJsLoader = requireJsLoader;
    this.editorModule = editorModule;
    this.editorTypeRegistry = editorTypeRegistry;
    this.codeMirrorTextEditorFactory = codeMirrorTextEditorFactory;
    this.codemirrorBase = basePathConstant.basePath();

    completionResources.completionCss().ensureInjected();

    Log.debug(CodeMirrorEditorExtension.class, "Codemirror extension module=" + editorModule);
    editorModule.setEditorInitializer(new EditorInitializer() {
        @Override
        public void initialize(final InitializerCallback callback) {
            // add code-splitting of the whole orion editor
            GWT.runAsync(new RunAsyncCallback() {
                @Override
                public void onSuccess() {
                    initBaseCodeMirror(basePromise, baseInitializer, callback);
                }
                @Override
                public void onFailure(final Throwable reason) {
                    callback.onFailure(reason);
                }
            });
        }
    });
    // must not delay
    registerEditor();
    CodeMirrorKeymaps.init();
}
 

import com.google.gwt.core.client.RunAsyncCallback; //导入依赖的package包/类
private SourceWriter getSourceWriter(PrintWriter printWriter, GeneratorContext ctx) {
	ClassSourceFileComposerFactory composerFactory =
		new ClassSourceFileComposerFactory(this.packageName, this.viewProxySimpleName);

	composerFactory.setSuperclass(this.placeType.getSimpleSourceName());

	composerFactory.addImport(GWT.class.getName());
	composerFactory.addImport(RunAsyncCallback.class.getName());
	composerFactory.addImport(ViewProxy.class.getName());
	composerFactory.addImport(Place.class.getName());
	composerFactory.addImport(ViewPlace.class.getName());
	composerFactory.addImport(Activity.class.getName());
	composerFactory.addImport(ViewActivity.class.getName());
	composerFactory.addImport(ApplicationUnreachableException.class.getName());
	composerFactory.addImport(this.placeType.getQualifiedSourceName());
	composerFactory.addImport(this.activityDescrition.view().getCanonicalName());
	if (this.placeTokenizerClass != null) {
		composerFactory.addImport(this.placeTokenizerClass.getCanonicalName());
	}
	if (this.viewDecoratorClass != null) {
		composerFactory.addImport(this.viewDecoratorClass.getCanonicalName());
	}

	composerFactory.addImplementedInterface(
		ViewProxy.class.getSimpleName() + "<" + this.placeType.getSimpleSourceName() + ">");

	return composerFactory.createSourceWriter(ctx, printWriter);
}