Closes the currently opened window.<p>

@param updateTable <code>true</code> to update the jobs table
188115
public void closeDialogWindow(boolean updateTable) {

        if (m_dialogWindow != null) {
            m_dialogWindow.close();
            m_dialogWindow = null;
        }
        if (updateTable) {
            m_jobTable.reloadJobs();
        }
    }
844313
public static final void close(Closeable closeable) {
        if (closeable == null) {
            return;
        }
        try {
            closeable.close();
        } catch (IOException e) {
            Log.e(TAG, "something went wrong on close", e);
        }
    }
1190095
public boolean close() {
        List t = (List)((ArrayList)windows).clone();
        Iterator e = t.iterator();
        while (e.hasNext()) {
            ApplicationWindow window = (ApplicationWindow)e.next();
            if (!window.close()) { return false; }
        }
        if (subManagers != null) {
            e = subManagers.iterator();
            while (e.hasNext()) {
                WindowManager wm = (WindowManager)e.next();
                if (!wm.close()) { return false; }
            }
        }
        return true;
    }
36401
protected void onClose(boolean reload) {

        if (reload) {
            Scheduler.get().scheduleDeferred(new ScheduledCommand() {

                public void execute() {

                    String url = Window.Location.getHref();
                    m_menuHandler.leavePage(url);

                }
            });
        }
    }
727387
public synchronized void close()
    {
        Preconditions.checkState(state.compareAndSet(State.STARTED, State.CLOSED), "Already closed or has not been started");

        client.getConnectionStateListenable().removeListener(listener);
        executorService.close();
        ourTask.set(null);
    }
227747
@Override
	public void close() throws IOException {
		try {
			upload.executeBatch();
			batchCount = 0;
			upload.close();
			dbConn.close();
		} catch (SQLException sqe) {
			throw new IllegalArgumentException("close() failed:\t", sqe);
		}
	}
829559
protected void close() {

        if (!m_enabled) {
            return;
        }
        m_openClose.setDown(false);
        m_popup.hide();
        m_selectBoxState.setValue(I_CmsLayoutBundle.INSTANCE.generalCss().cornerAll());
    }
496716
public void close(AutoCloseable closeable) {
    try {
      closeable.close();
    } catch (Exception e) {
      throw new IllegalStateException("Fail to close " + closeable, e);
    }
  }
346056
public boolean close() {
    if (open.compareAndSet(true, false)) {
      futures.forEach(future -> future.completeExceptionally(new IllegalStateException("Closed session")));
      return true;
    }
    return false;
  }
1210332
@Override
    public void close() {
        this.createSegment.close();
        this.deleteSegment.close();
        this.updateConditional.close();
        this.updateUnconditional.close();
        this.removeConditional.close();
        this.removeUnconditional.close();
        this.getKeys.close();
        this.iterateKeys.close();
        this.iterateEntries.close();
    }
52241
@Override
    public synchronized void close() {

        if (isClosed) {
            return;
        }

        rollback(false);

        try {
            database.logger.writeToLog(this, Tokens.T_DISCONNECT);
        } catch (HsqlException e) {}

        sessionData.closeAllNavigators();
        sessionData.persistentStoreCollection.clearAllTables();
        sessionData.closeResultCache();
        database.compiledStatementManager.removeSession(sessionId);
        database.sessionManager.removeSession(this);
        database.closeIfLast();

        database                  = null;
        user                      = null;
        rowActionList             = null;
        sessionContext.savepoints = null;
        intConnection             = null;
        sessionContext            = null;
        lastIdentity              = null;
        isClosed                  = true;
    }
194494
private void closeOnSuccess() {

        Timer closeTimer = new Timer() {

            /**
             * @see com.google.gwt.user.client.Timer#run()
             */
            @Override
            public void run() {

                CmsReplaceDialog.this.hide();
            }
        };
        closeTimer.schedule(1000);
    }
1270565
static void close(boolean delete) {
        if (openedFile != null) {
            out.close();
            out = System.err;

            if (delete) {
                openedFile.delete();
            }
        }
    }
235717
public void close() {
		JWindow w;
		synchronized (this) {
			if (!synch.isUnblocked()) synch.unblock();
			if (win == null) return;
			w = win;
			win = null;
		}
		if (event != null)
			event.fire();
		w.setVisible(false);
		w.removeAll();
		w.dispose();
		RepaintManager.setCurrentManager(null);
		logoContainer = null;
		titleContainer = null;
		bottom = null;
		progressText = null;
		progressSubText = null;
		progressBar = null;
		poweredBy = null;
		logo = null;
		title = null;
		text = null;
		subText = null;
		event = null;
	}
1071432
void closeDelayed() {

        Scheduler.RepeatingCommand command = new Scheduler.RepeatingCommand() {

            public boolean execute() {

                if (CmsErrorDialog.isShowingErrorDialogs()) {
                    return true;
                } else {
                    Window.Location.assign(m_closeLink);
                    return false;
                }

            }
        };
        Scheduler.get().scheduleFixedDelay(command, 300);
    }
1155184
@Override
    public void close() {
        synchronized (startedTasks) {
            if (executor.isShutdown()) {
                return;
            }
            // ... stop updater thread. Do not interrupt.
            executor.shutdown();
            try {
                updater.get();
            } catch (InterruptedException | CancellationException | ExecutionException ignore) {
                // Ignore these closing thread errors.
            }
            // And stop all the tasks, do interrupting.
            for (InternalTask task : startedTasks) {
                task.cancel(true);
            }
            for (InternalTask task : queuedTasks) {
                task.close();
            }

            try {
                executor.awaitTermination(100L, TimeUnit.MILLISECONDS);
            } catch (InterruptedException ignore) {
                Thread.currentThread().interrupt();
            }
        }
    }
174199
public void close() {
    try {
      if (is != null) is.close();
    } catch (IOException e) {
      log.error(null, e);
      throw new RuntimeException(e);
    }
    isClosed = true;
  }