/*
 * Copyright 2011 gitblit.com.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.gitblit.client;

import java.io.IOException;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

import com.gitblit.Constants;
import com.gitblit.Constants.AccessPermission;
import com.gitblit.Constants.AccessRestrictionType;
import com.gitblit.Constants.AuthorizationControl;
import com.gitblit.Constants.PermissionType;
import com.gitblit.Constants.RegistrantType;
import com.gitblit.GitBlitException.ForbiddenException;
import com.gitblit.GitBlitException.NotAllowedException;
import com.gitblit.GitBlitException.UnauthorizedException;
import com.gitblit.GitBlitException.UnknownRequestException;
import com.gitblit.Keys;
import com.gitblit.models.FederationModel;
import com.gitblit.models.FeedEntryModel;
import com.gitblit.models.FeedModel;
import com.gitblit.models.RegistrantAccessPermission;
import com.gitblit.models.RepositoryModel;
import com.gitblit.models.ServerSettings;
import com.gitblit.models.ServerStatus;
import com.gitblit.models.TeamModel;
import com.gitblit.models.UserModel;
import com.gitblit.utils.ArrayUtils;
import com.gitblit.utils.RpcUtils;
import com.gitblit.utils.StringUtils;
import com.gitblit.utils.SyndicationUtils;

/**
 * GitblitClient is a object that retrieves data from a Gitblit server, caches
 * it for local operations, and allows updating or creating Gitblit objects.
 *
 * @author James Moger
 *
 */
public class GitblitClient implements Serializable {

	private static final long serialVersionUID = 1L;

	private static final Date NEVER = new Date(0);

	protected final GitblitRegistration reg;

	public final String url;

	public final String account;

	private final char[] password;

	private volatile int protocolVersion;

	private volatile boolean allowManagement;

	private volatile boolean allowAdministration;

	private volatile ServerSettings settings;

	private final List<RepositoryModel> allRepositories;

	private final List<UserModel> allUsers;

	private final List<TeamModel> allTeams;

	private final List<FederationModel> federationRegistrations;

	private final List<FeedModel> availableFeeds;

	private final List<FeedEntryModel> syndicatedEntries;

	private final Set<String> subscribedRepositories;

	private ServerStatus status;

	public GitblitClient(GitblitRegistration reg) {
		this.reg = reg;
		this.url = reg.url;
		this.account = reg.account;
		this.password = reg.password;

		this.allUsers = new ArrayList<UserModel>();
		this.allTeams = new ArrayList<TeamModel>();
		this.allRepositories = new ArrayList<RepositoryModel>();
		this.federationRegistrations = new ArrayList<FederationModel>();
		this.availableFeeds = new ArrayList<FeedModel>();
		this.syndicatedEntries = new ArrayList<FeedEntryModel>();
		this.subscribedRepositories = new HashSet<String>();
	}

	public void login() throws IOException {
		protocolVersion = RpcUtils.getProtocolVersion(url, account, password);
		refreshSettings();
		refreshAvailableFeeds();
		refreshRepositories();
		refreshSubscribedFeeds(0);

		try {
			// credentials may not have administrator access
			// or server may have disabled rpc management
			refreshUsers();
			if (protocolVersion > 1) {
				refreshTeams();
			}
			allowManagement = true;
		} catch (UnauthorizedException e) {
		} catch (ForbiddenException e) {
		} catch (NotAllowedException e) {
		} catch (UnknownRequestException e) {
		} catch (IOException e) {
			e.printStackTrace();
		}

		try {
			// credentials may not have administrator access
			// or server may have disabled rpc administration
			refreshStatus();
			allowAdministration = true;
		} catch (UnauthorizedException e) {
		} catch (ForbiddenException e) {
		} catch (NotAllowedException e) {
		} catch (UnknownRequestException e) {
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public int getProtocolVersion() {
		return protocolVersion;
	}

	public boolean allowManagement() {
		return allowManagement;
	}

	public boolean allowAdministration() {
		return allowAdministration;
	}

	public boolean isOwner(RepositoryModel model) {
		return model.isOwner(account);
	}

	public String getURL(String action, String repository, String objectId) {
		boolean mounted = settings.get(Keys.web.mountParameters).getBoolean(true);
		StringBuilder sb = new StringBuilder();
		sb.append(url);
		sb.append('/');
		sb.append(action);
		sb.append('/');
		if (mounted) {
			// mounted url/action/repository/objectId
			sb.append(StringUtils.encodeURL(repository));
			if (!StringUtils.isEmpty(objectId)) {
				sb.append('/');
				sb.append(objectId);
			}
			return sb.toString();
		} else {
			// parameterized url/action/&r=repository&h=objectId
			sb.append("?r=");
			sb.append(repository);
			if (!StringUtils.isEmpty(objectId)) {
				sb.append("&h=");
				sb.append(objectId);
			}
			return sb.toString();
		}
	}

	public AccessRestrictionType getDefaultAccessRestriction() {
		String restriction = "PUSH";
		if (settings.hasKey(Keys.git.defaultAccessRestriction)) {
			restriction = settings.get(Keys.git.defaultAccessRestriction).currentValue;
		}
		return AccessRestrictionType.fromName(restriction);
	}

	public AuthorizationControl getDefaultAuthorizationControl() {
		String authorization = null;
		if (settings.hasKey(Keys.git.defaultAuthorizationControl)) {
			authorization = settings.get(Keys.git.defaultAuthorizationControl).currentValue;
		}
		return AuthorizationControl.fromName(authorization);
	}

	/**
	 * Returns the list of pre-receive scripts the repository inherited from the
	 * global settings and team affiliations.
	 *
	 * @param repository
	 *            if null only the globally specified scripts are returned
	 * @return a list of scripts
	 */
	public List<String> getPreReceiveScriptsInherited(RepositoryModel repository) {
		Set<String> scripts = new LinkedHashSet<String>();
		// Globals
		for (String script : settings.get(Keys.groovy.preReceiveScripts).getStrings()) {
			if (script.endsWith(".groovy")) {
				scripts.add(script.substring(0, script.lastIndexOf('.')));
			} else {
				scripts.add(script);
			}
		}

		// Team Scripts
		if (repository != null) {
			for (String teamname : getPermittedTeamnames(repository)) {
				TeamModel team = getTeamModel(teamname);
				if (!ArrayUtils.isEmpty(team.preReceiveScripts)) {
					scripts.addAll(team.preReceiveScripts);
				}
			}
		}
		return new ArrayList<String>(scripts);
	}

	/**
	 * Returns the list of all available Groovy pre-receive push hook scripts
	 * that are not already inherited by the repository. Script files must have
	 * .groovy extension
	 *
	 * @param repository
	 *            optional parameter
	 * @return list of available hook scripts
	 */
	public List<String> getPreReceiveScriptsUnused(RepositoryModel repository) {
		Set<String> inherited = new TreeSet<String>(getPreReceiveScriptsInherited(repository));

		// create list of available scripts by excluding inherited scripts
		List<String> scripts = new ArrayList<String>();
		for (String script : settings.pushScripts) {
			if (!inherited.contains(script)) {
				scripts.add(script);
			}
		}
		return scripts;
	}

	/**
	 * Returns the list of post-receive scripts the repository inherited from
	 * the global settings and team affiliations.
	 *
	 * @param repository
	 *            if null only the globally specified scripts are returned
	 * @return a list of scripts
	 */
	public List<String> getPostReceiveScriptsInherited(RepositoryModel repository) {
		Set<String> scripts = new LinkedHashSet<String>();
		// Global Scripts
		for (String script : settings.get(Keys.groovy.postReceiveScripts).getStrings()) {
			if (script.endsWith(".groovy")) {
				scripts.add(script.substring(0, script.lastIndexOf('.')));
			} else {
				scripts.add(script);
			}
		}
		// Team Scripts
		if (repository != null) {
			for (String teamname : getPermittedTeamnames(repository)) {
				TeamModel team = getTeamModel(teamname);
				if (!ArrayUtils.isEmpty(team.postReceiveScripts)) {
					scripts.addAll(team.postReceiveScripts);
				}
			}
		}
		return new ArrayList<String>(scripts);
	}

	/**
	 * Returns the list of unused Groovy post-receive push hook scripts that are
	 * not already inherited by the repository. Script files must have .groovy
	 * extension
	 *
	 * @param repository
	 *            optional parameter
	 * @return list of available hook scripts
	 */
	public List<String> getPostReceiveScriptsUnused(RepositoryModel repository) {
		Set<String> inherited = new TreeSet<String>(getPostReceiveScriptsInherited(repository));

		// create list of available scripts by excluding inherited scripts
		List<String> scripts = new ArrayList<String>();
		if (!ArrayUtils.isEmpty(settings.pushScripts)) {
			for (String script : settings.pushScripts) {
				if (!inherited.contains(script)) {
					scripts.add(script);
				}
			}
		}
		return scripts;
	}

	public ServerSettings getSettings() {
		return settings;
	}

	public ServerStatus getStatus() {
		return status;
	}

	public String getSettingDescription(String key) {
		return settings.get(key).description;
	}

	public List<RepositoryModel> refreshRepositories() throws IOException {
		Map<String, RepositoryModel> repositories = RpcUtils
				.getRepositories(url, account, password);
		allRepositories.clear();
		allRepositories.addAll(repositories.values());
		Collections.sort(allRepositories);
		markSubscribedFeeds();
		return allRepositories;
	}

	public List<UserModel> refreshUsers() throws IOException {
		List<UserModel> users = RpcUtils.getUsers(url, account, password);
		allUsers.clear();
		allUsers.addAll(users);
		Collections.sort(users);
		return allUsers;
	}

	public List<TeamModel> refreshTeams() throws IOException {
		List<TeamModel> teams = RpcUtils.getTeams(url, account, password);
		allTeams.clear();
		allTeams.addAll(teams);
		Collections.sort(teams);
		return allTeams;
	}

	public ServerSettings refreshSettings() throws IOException {
		settings = RpcUtils.getSettings(url, account, password);
		return settings;
	}

	public ServerStatus refreshStatus() throws IOException {
		status = RpcUtils.getStatus(url, account, password);
		return status;
	}

	public List<String> getBranches(String repository) {
		List<FeedModel> feeds = getAvailableFeeds(repository);
		List<String> branches = new ArrayList<String>();
		for (FeedModel feed : feeds) {
			branches.add(feed.branch);
		}
		Collections.sort(branches);
		return branches;
	}

	public List<FeedModel> getAvailableFeeds() {
		return availableFeeds;
	}

	public List<FeedModel> getAvailableFeeds(RepositoryModel repository) {
		return getAvailableFeeds(repository.name);
	}

	public List<FeedModel> getAvailableFeeds(String repository) {
		List<FeedModel> repositoryFeeds = new ArrayList<FeedModel>();
		if (repository == null) {
			return repositoryFeeds;
		}
		for (FeedModel feed : availableFeeds) {
			if (feed.repository.equalsIgnoreCase(repository)) {
				repositoryFeeds.add(feed);
			}
		}
		return repositoryFeeds;
	}

	public List<FeedModel> refreshAvailableFeeds() throws IOException {
		List<FeedModel> feeds = RpcUtils.getBranchFeeds(url, account, password);
		availableFeeds.clear();
		availableFeeds.addAll(feeds);
		markSubscribedFeeds();
		return availableFeeds;
	}

	public List<FeedEntryModel> refreshSubscribedFeeds(int page) throws IOException {
		Set<FeedEntryModel> allEntries = new HashSet<FeedEntryModel>();
		if (reg.feeds.size() > 0) {
			for (FeedModel feed : reg.feeds) {
				feed.lastRefreshDate = feed.currentRefreshDate;
				feed.currentRefreshDate = new Date();
				List<FeedEntryModel> entries = SyndicationUtils.readFeed(url, feed.repository,
						feed.branch, -1, page, account, password);
				allEntries.addAll(entries);
			}
		}
		reg.cacheFeeds();
		syndicatedEntries.clear();
		syndicatedEntries.addAll(allEntries);
		Collections.sort(syndicatedEntries);
		return syndicatedEntries;
	}

	public void updateSubscribedFeeds(List<FeedModel> list) {
		reg.updateSubscribedFeeds(list);
		markSubscribedFeeds();
	}

	private void markSubscribedFeeds() {
		subscribedRepositories.clear();
		for (FeedModel feed : availableFeeds) {
			// mark feed in the available list as subscribed
			feed.subscribed = reg.feeds.contains(feed);
			if (feed.subscribed) {
				subscribedRepositories.add(feed.repository.toLowerCase());
			}
		}
	}

	public Date getLastFeedRefresh(String repository, String branch) {
		FeedModel feed = new FeedModel();
		feed.repository = repository;
		feed.branch = branch;
		if (reg.feeds.contains(feed)) {
			int idx = reg.feeds.indexOf(feed);
			feed = reg.feeds.get(idx);
			return feed.lastRefreshDate;
		}
		return NEVER;
	}

	public boolean isSubscribed(RepositoryModel repository) {
		return subscribedRepositories.contains(repository.name.toLowerCase());
	}

	public List<FeedEntryModel> getSyndicatedEntries() {
		return syndicatedEntries;
	}

	public List<FeedEntryModel> log(String repository, String branch, int numberOfEntries, int page)
			throws IOException {
		return SyndicationUtils.readFeed(url, repository, branch, numberOfEntries, page, account,
				password);
	}

	public List<FeedEntryModel> search(String repository, String branch, String fragment,
			Constants.SearchType type, int numberOfEntries, int page) throws IOException {
		return SyndicationUtils.readSearchFeed(url, repository, branch, fragment, type,
				numberOfEntries, page, account, password);
	}

	public List<FederationModel> refreshFederationRegistrations() throws IOException {
		List<FederationModel> list = RpcUtils.getFederationRegistrations(url, account, password);
		federationRegistrations.clear();
		federationRegistrations.addAll(list);
		return federationRegistrations;
	}

	public List<UserModel> getUsers() {
		return allUsers;
	}

	public UserModel getUser(String username) {
		for (UserModel user : getUsers()) {
			if (user.username.equalsIgnoreCase(username)) {
				return user;
			}
		}
		return null;
	}

	public List<String> getUsernames() {
		List<String> usernames = new ArrayList<String>();
		for (UserModel user : this.allUsers) {
			usernames.add(user.username);
		}
		Collections.sort(usernames);
		return usernames;
	}

	public List<String> getPermittedUsernames(RepositoryModel repository) {
		List<String> usernames = new ArrayList<String>();
		for (UserModel user : this.allUsers) {
			if (user.hasRepositoryPermission(repository.name)) {
				usernames.add(user.username);
			}
		}
		return usernames;
	}

	/**
	 * Returns the effective list of permissions for this user, taking into account
	 * team memberships, ownerships.
	 *
	 * @param user
	 * @return the effective list of permissions for the user
	 */
	public List<RegistrantAccessPermission> getUserAccessPermissions(UserModel user) {
		Set<RegistrantAccessPermission> set = new LinkedHashSet<RegistrantAccessPermission>();
		set.addAll(user.getRepositoryPermissions());
		// Flag missing repositories
		for (RegistrantAccessPermission permission : set) {
			if (permission.mutable && PermissionType.EXPLICIT.equals(permission.permissionType)) {
				RepositoryModel rm = getRepository(permission.registrant);
				if (rm == null) {
					permission.permissionType = PermissionType.MISSING;
					permission.mutable = false;
					continue;
				}
			}
		}

		// TODO reconsider ownership as a user property
		// manually specify personal repository ownerships
		for (RepositoryModel rm : allRepositories) {
			if (rm.isUsersPersonalRepository(user.username) || rm.isOwner(user.username)) {
				RegistrantAccessPermission rp = new RegistrantAccessPermission(rm.name, AccessPermission.REWIND,
						PermissionType.OWNER, RegistrantType.REPOSITORY, null, false);
				// user may be owner of a repository to which they've inherited
				// a team permission, replace any existing perm with owner perm
				set.remove(rp);
				set.add(rp);
			}
		}

		List<RegistrantAccessPermission> list = new ArrayList<RegistrantAccessPermission>(set);
		Collections.sort(list);
		return list;
	}

	public List<RegistrantAccessPermission> getUserAccessPermissions(RepositoryModel repository) {
		List<RegistrantAccessPermission> list = new ArrayList<RegistrantAccessPermission>();
		if (AccessRestrictionType.NONE.equals(repository.accessRestriction)) {
			// no permissions needed, REWIND for everyone!
			return list;
		}
		if (AuthorizationControl.AUTHENTICATED.equals(repository.authorizationControl)) {
			// no permissions needed, REWIND for authenticated!
			return list;
		}
		// NAMED users and teams
		for (UserModel user : allUsers) {
			RegistrantAccessPermission ap = user.getRepositoryPermission(repository);
			if (ap.permission.exceeds(AccessPermission.NONE)) {
				list.add(ap);
			}
		}
		return list;
	}

	public boolean setUserAccessPermissions(RepositoryModel repository, List<RegistrantAccessPermission> permissions) throws IOException {
		return RpcUtils.setRepositoryMemberPermissions(repository, permissions, url, account, password);
	}

	public List<TeamModel> getTeams() {
		return allTeams;
	}

	public List<String> getTeamnames() {
		List<String> teamnames = new ArrayList<String>();
		for (TeamModel team : this.allTeams) {
			teamnames.add(team.name);
		}
		Collections.sort(teamnames);
		return teamnames;
	}

	public List<String> getPermittedTeamnames(RepositoryModel repository) {
		List<String> teamnames = new ArrayList<String>();
		for (TeamModel team : this.allTeams) {
			if (team.hasRepositoryPermission(repository.name)) {
				teamnames.add(team.name);
			}
		}
		return teamnames;
	}

	public List<RegistrantAccessPermission> getTeamAccessPermissions(RepositoryModel repository) {
		List<RegistrantAccessPermission> list = new ArrayList<RegistrantAccessPermission>();
		for (TeamModel team : allTeams) {
			RegistrantAccessPermission ap = team.getRepositoryPermission(repository);
			if (ap.permission.exceeds(AccessPermission.NONE)) {
				list.add(ap);
			}
		}
		Collections.sort(list);
		return list;
	}

	public boolean setTeamAccessPermissions(RepositoryModel repository, List<RegistrantAccessPermission> permissions) throws IOException {
		return RpcUtils.setRepositoryTeamPermissions(repository, permissions, url, account, password);
	}

	public TeamModel getTeamModel(String name) {
		for (TeamModel team : allTeams) {
			if (team.name.equalsIgnoreCase(name)) {
				return team;
			}
		}
		return null;
	}

	public List<String> getFederationSets() {
		return settings.get(Keys.federation.sets).getStrings();
	}

	public List<RepositoryModel> getRepositories() {
		return allRepositories;
	}

	public RepositoryModel getRepository(String name) {
		for (RepositoryModel repository : allRepositories) {
			if (repository.name.equalsIgnoreCase(name)) {
				return repository;
			}
		}
		return null;
	}

	public boolean createRepository(RepositoryModel repository, List<RegistrantAccessPermission> userPermissions)
			throws IOException {
		return createRepository(repository, userPermissions, null);
	}

	public boolean createRepository(RepositoryModel repository, List<RegistrantAccessPermission> userPermissions,
			List<RegistrantAccessPermission> teamPermissions) throws IOException {
		boolean success = true;
		success &= RpcUtils.createRepository(repository, url, account, password);
		if (userPermissions != null && userPermissions.size() > 0) {
			// if new repository has named members, set them
			success &= RpcUtils.setRepositoryMemberPermissions(repository, userPermissions, url, account,
					password);
		}
		if (teamPermissions != null && teamPermissions.size() > 0) {
			// if new repository has named teams, set them
			success &= RpcUtils.setRepositoryTeamPermissions(repository, teamPermissions, url, account,
					password);
		}
		return success;
	}

	public boolean updateRepository(String name, RepositoryModel repository,
			List<RegistrantAccessPermission> userPermissions) throws IOException {
		return updateRepository(name, repository, userPermissions, null);
	}

	public boolean updateRepository(String name, RepositoryModel repository,
			List<RegistrantAccessPermission> userPermissions,	List<RegistrantAccessPermission> teamPermissions) throws IOException {
		boolean success = true;
		success &= RpcUtils.updateRepository(name, repository, url, account, password);
		// set the repository members
		if (userPermissions != null) {
			success &= RpcUtils.setRepositoryMemberPermissions(repository, userPermissions, url, account,
					password);
		}
		if (teamPermissions != null) {
			success &= RpcUtils.setRepositoryTeamPermissions(repository, teamPermissions, url, account,
					password);
		}
		return success;
	}

	public boolean deleteRepository(RepositoryModel repository) throws IOException {
		return RpcUtils.deleteRepository(repository, url, account, password);
	}

	public boolean clearRepositoryCache() throws IOException {
		return RpcUtils.clearRepositoryCache(url, account, password);
	}

	public boolean createUser(UserModel user) throws IOException {
		return RpcUtils.createUser(user, url, account, password);
	}

	public boolean updateUser(String name, UserModel user) throws IOException {
		return RpcUtils.updateUser(name, user, url, account, password);
	}

	public boolean deleteUser(UserModel user) throws IOException {
		return RpcUtils.deleteUser(user, url, account, password);
	}

	public boolean createTeam(TeamModel team) throws IOException {
		return RpcUtils.createTeam(team, url, account, password);
	}

	public boolean updateTeam(String name, TeamModel team) throws IOException {
		return RpcUtils.updateTeam(name, team, url, account, password);
	}

	public boolean deleteTeam(TeamModel team) throws IOException {
		return RpcUtils.deleteTeam(team, url, account, password);
	}

	public boolean updateSettings(Map<String, String> newSettings) throws IOException {
		return RpcUtils.updateSettings(newSettings, url, account, password);
	}
}
f='#n416'>416</a>
<a id='n417' href='#n417'>417</a>
<a id='n418' href='#n418'>418</a>
<a id='n419' href='#n419'>419</a>
<a id='n420' href='#n420'>420</a>
<a id='n421' href='#n421'>421</a>
<a id='n422' href='#n422'>422</a>
</pre></td>
<td class='lines'><pre><code><style>pre { line-height: 125%; }
td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
.highlight .hll { background-color: #ffffcc }
.highlight .c { color: #888888 } /* Comment */
.highlight .err { color: #a61717; background-color: #e3d2d2 } /* Error */
.highlight .k { color: #008800; font-weight: bold } /* Keyword */
.highlight .ch { color: #888888 } /* Comment.Hashbang */
.highlight .cm { color: #888888 } /* Comment.Multiline */
.highlight .cp { color: #cc0000; font-weight: bold } /* Comment.Preproc */
.highlight .cpf { color: #888888 } /* Comment.PreprocFile */
.highlight .c1 { color: #888888 } /* Comment.Single */
.highlight .cs { color: #cc0000; font-weight: bold; background-color: #fff0f0 } /* Comment.Special */
.highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */
.highlight .ge { font-style: italic } /* Generic.Emph */
.highlight .gr { color: #aa0000 } /* Generic.Error */
.highlight .gh { color: #333333 } /* Generic.Heading */
.highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */
.highlight .go { color: #888888 } /* Generic.Output */
.highlight .gp { color: #555555 } /* Generic.Prompt */
.highlight .gs { font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #666666 } /* Generic.Subheading */
.highlight .gt { color: #aa0000 } /* Generic.Traceback */
.highlight .kc { color: #008800; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #008800; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #008800; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #008800 } /* Keyword.Pseudo */
.highlight .kr { color: #008800; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #888888; font-weight: bold } /* Keyword.Type */
.highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */
.highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */
.highlight .na { color: #336699 } /* Name.Attribute */
.highlight .nb { color: #003388 } /* Name.Builtin */
.highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */
.highlight .no { color: #003366; font-weight: bold } /* Name.Constant */
.highlight .nd { color: #555555 } /* Name.Decorator */
.highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */
.highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */
.highlight .nl { color: #336699; font-style: italic } /* Name.Label */
.highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */
.highlight .py { color: #336699; font-weight: bold } /* Name.Property */
.highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #336699 } /* Name.Variable */
.highlight .ow { color: #008800 } /* Operator.Word */
.highlight .w { color: #bbbbbb } /* Text.Whitespace */
.highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */
.highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */
.highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */
.highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */
.highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */
.highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */
.highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */
.highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */
.highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */
.highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */
.highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */
.highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */
.highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */
.highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */
.highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */
.highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */
.highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */
.highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */
.highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */
.highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */
.highlight .vc { color: #336699 } /* Name.Variable.Class */
.highlight .vg { color: #dd7700 } /* Name.Variable.Global */
.highlight .vi { color: #3333bb } /* Name.Variable.Instance */
.highlight .vm { color: #336699 } /* Name.Variable.Magic */
.highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */</style><div class="highlight"><pre><span></span><span class="cm">/*</span>
<span class="cm"> * Copyright 2000-2021 Vaadin Ltd.</span>
<span class="cm"> *</span>
<span class="cm"> * Licensed under the Apache License, Version 2.0 (the &quot;License&quot;); you may not</span>
<span class="cm"> * use this file except in compliance with the License. You may obtain a copy of</span>
<span class="cm"> * the License at</span>
<span class="cm"> *</span>
<span class="cm"> * http://www.apache.org/licenses/LICENSE-2.0</span>
<span class="cm"> *</span>
<span class="cm"> * Unless required by applicable law or agreed to in writing, software</span>
<span class="cm"> * distributed under the License is distributed on an &quot;AS IS&quot; BASIS, WITHOUT</span>
<span class="cm"> * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the</span>
<span class="cm"> * License for the specific language governing permissions and limitations under</span>
<span class="cm"> * the License.</span>
<span class="cm"> */</span>

<span class="kn">package</span><span class="w"> </span><span class="nn">com.vaadin.client.ui</span><span class="p">;</span>

<span class="kn">import</span><span class="w"> </span><span class="nn">java.util.List</span><span class="p">;</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">java.util.logging.Logger</span><span class="p">;</span>

<span class="kn">import</span><span class="w"> </span><span class="nn">com.google.gwt.dom.client.Element</span><span class="p">;</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">com.google.gwt.event.dom.client.HasScrollHandlers</span><span class="p">;</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">com.google.gwt.event.dom.client.ScrollEvent</span><span class="p">;</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">com.google.gwt.event.dom.client.ScrollHandler</span><span class="p">;</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">com.google.gwt.event.logical.shared.HasResizeHandlers</span><span class="p">;</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">com.google.gwt.event.logical.shared.ResizeEvent</span><span class="p">;</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">com.google.gwt.event.logical.shared.ResizeHandler</span><span class="p">;</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">com.google.gwt.event.shared.HandlerRegistration</span><span class="p">;</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">com.google.gwt.user.client.Timer</span><span class="p">;</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">com.google.gwt.user.client.Window</span><span class="p">;</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">com.google.gwt.user.client.ui.SimplePanel</span><span class="p">;</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">com.vaadin.client.ApplicationConnection</span><span class="p">;</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">com.vaadin.client.ComponentConnector</span><span class="p">;</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">com.vaadin.client.ConnectorMap</span><span class="p">;</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">com.vaadin.client.Focusable</span><span class="p">;</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">com.vaadin.client.LayoutManager</span><span class="p">;</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">com.vaadin.client.Profiler</span><span class="p">;</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">com.vaadin.client.WidgetUtil</span><span class="p">;</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">com.vaadin.client.ui.ShortcutActionHandler.ShortcutActionHandlerOwner</span><span class="p">;</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">com.vaadin.client.ui.TouchScrollDelegate.TouchScrollHandler</span><span class="p">;</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">com.vaadin.client.ui.ui.UIConnector</span><span class="p">;</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">com.vaadin.shared.ApplicationConstants</span><span class="p">;</span>

<span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">VUI</span><span class="w"> </span><span class="kd">extends</span><span class="w"> </span><span class="n">SimplePanel</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">ResizeHandler</span><span class="p">,</span>
<span class="w">        </span><span class="n">Window</span><span class="p">.</span><span class="na">ClosingHandler</span><span class="p">,</span><span class="w"> </span><span class="n">ShortcutActionHandlerOwner</span><span class="p">,</span><span class="w"> </span><span class="n">Focusable</span><span class="p">,</span>
<span class="w">        </span><span class="n">com</span><span class="p">.</span><span class="na">google</span><span class="p">.</span><span class="na">gwt</span><span class="p">.</span><span class="na">user</span><span class="p">.</span><span class="na">client</span><span class="p">.</span><span class="na">ui</span><span class="p">.</span><span class="na">Focusable</span><span class="p">,</span><span class="w"> </span><span class="n">HasResizeHandlers</span><span class="p">,</span>
<span class="w">        </span><span class="n">HasScrollHandlers</span><span class="w"> </span><span class="p">{</span>

<span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">MONITOR_PARENT_TIMER_INTERVAL</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">1000</span><span class="p">;</span>

<span class="w">    </span><span class="cm">/** For internal use only. May be removed or replaced in the future. */</span>
<span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">id</span><span class="p">;</span>

<span class="w">    </span><span class="cm">/** For internal use only. May be removed or replaced in the future. */</span>
<span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="n">ShortcutActionHandler</span><span class="w"> </span><span class="n">actionHandler</span><span class="p">;</span>

<span class="w">    </span><span class="cm">/*</span>
<span class="cm">     * Last known window size used to detect whether VView should be layouted</span>
<span class="cm">     * again. Detection must check window size, because the VView size might be</span>
<span class="cm">     * fixed and thus not automatically adapt to changed window sizes.</span>
<span class="cm">     */</span>
<span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">windowWidth</span><span class="p">;</span>
<span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">windowHeight</span><span class="p">;</span>

<span class="w">    </span><span class="cm">/*</span>
<span class="cm">     * Last know view size used to detect whether new dimensions should be sent</span>
<span class="cm">     * to the server.</span>
<span class="cm">     */</span>
<span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">viewWidth</span><span class="p">;</span>
<span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">viewHeight</span><span class="p">;</span>

<span class="w">    </span><span class="cm">/** For internal use only. May be removed or replaced in the future. */</span>
<span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="n">ApplicationConnection</span><span class="w"> </span><span class="n">connection</span><span class="p">;</span>

<span class="w">    </span><span class="cm">/**</span>
<span class="cm">     * Keep track of possible parent size changes when an embedded application.</span>
<span class="cm">     *</span>
<span class="cm">     * Uses {@link #parentWidth} and {@link #parentHeight} as an optimization to</span>
<span class="cm">     * keep track of when there is a real change.</span>
<span class="cm">     */</span>
<span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="n">Timer</span><span class="w"> </span><span class="n">resizeTimer</span><span class="p">;</span>

<span class="w">    </span><span class="cm">/** stored width of parent for embedded application auto-resize */</span>
<span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">parentWidth</span><span class="p">;</span>

<span class="w">    </span><span class="cm">/** stored height of parent for embedded application auto-resize */</span>
<span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">parentHeight</span><span class="p">;</span>

<span class="w">    </span><span class="cm">/** For internal use only. May be removed or replaced in the future. */</span>
<span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="n">resizeLazy</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="kc">false</span><span class="p">;</span>

<span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="n">TouchScrollHandler</span><span class="w"> </span><span class="n">touchScrollHandler</span><span class="p">;</span>

<span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="n">VLazyExecutor</span><span class="w"> </span><span class="n">delayedResizeExecutor</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">VLazyExecutor</span><span class="p">(</span><span class="mi">200</span><span class="p">,</span>
<span class="w">            </span><span class="p">()</span><span class="w"> </span><span class="o">-&gt;</span><span class="w"> </span><span class="n">performSizeCheck</span><span class="p">());</span>

<span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="n">Element</span><span class="w"> </span><span class="n">storedFocus</span><span class="p">;</span>

<span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="nf">VUI</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
<span class="w">        </span><span class="kd">super</span><span class="p">();</span>
<span class="w">        </span><span class="c1">// Allow focusing the view by using the focus() method, the view</span>
<span class="w">        </span><span class="c1">// should not be in the document focus flow</span>
<span class="w">        </span><span class="n">getElement</span><span class="p">().</span><span class="na">setTabIndex</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">);</span>
<span class="w">        </span><span class="n">makeScrollable</span><span class="p">();</span>
<span class="w">    </span><span class="p">}</span>

<span class="w">    </span><span class="cm">/**</span>
<span class="cm">     * Start to periodically monitor for parent element resizes if embedded</span>
<span class="cm">     * application (e.g. portlet).</span>
<span class="cm">     */</span>
<span class="w">    </span><span class="nd">@Override</span>
<span class="w">    </span><span class="kd">protected</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">onLoad</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
<span class="w">        </span><span class="kd">super</span><span class="p">.</span><span class="na">onLoad</span><span class="p">();</span>
<span class="w">        </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">isMonitoringParentSize</span><span class="p">())</span><span class="w"> </span><span class="p">{</span>
<span class="w">            </span><span class="n">resizeTimer</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Timer</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>

<span class="w">                </span><span class="nd">@Override</span>
<span class="w">                </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">run</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
<span class="w">                    </span><span class="c1">// trigger check to see if parent size has changed,</span>
<span class="w">                    </span><span class="c1">// recalculate layouts</span>
<span class="w">                    </span><span class="n">performSizeCheck</span><span class="p">();</span>
<span class="w">                    </span><span class="n">resizeTimer</span><span class="p">.</span><span class="na">schedule</span><span class="p">(</span><span class="n">MONITOR_PARENT_TIMER_INTERVAL</span><span class="p">);</span>
<span class="w">                </span><span class="p">}</span>
<span class="w">            </span><span class="p">};</span>
<span class="w">            </span><span class="n">resizeTimer</span><span class="p">.</span><span class="na">schedule</span><span class="p">(</span><span class="n">MONITOR_PARENT_TIMER_INTERVAL</span><span class="p">);</span>
<span class="w">        </span><span class="p">}</span>
<span class="w">    </span><span class="p">}</span>

<span class="w">    </span><span class="cm">/**</span>
<span class="cm">     * Stop monitoring for parent element resizes.</span>
<span class="cm">     */</span>

<span class="w">    </span><span class="nd">@Override</span>
<span class="w">    </span><span class="kd">protected</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">onUnload</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
<span class="w">        </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">resizeTimer</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="kc">null</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w">            </span><span class="n">resizeTimer</span><span class="p">.</span><span class="na">cancel</span><span class="p">();</span>
<span class="w">            </span><span class="n">resizeTimer</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="kc">null</span><span class="p">;</span>
<span class="w">        </span><span class="p">}</span>
<span class="w">        </span><span class="kd">super</span><span class="p">.</span><span class="na">onUnload</span><span class="p">();</span>
<span class="w">    </span><span class="p">}</span>

<span class="w">    </span><span class="cm">/**</span>
<span class="cm">     * Called when the window or parent div might have been resized.</span>
<span class="cm">     *</span>
<span class="cm">     * This immediately checks the sizes of the window and the parent div (if</span>
<span class="cm">     * monitoring it) and triggers layout recalculation if they have changed.</span>
<span class="cm">     */</span>
<span class="w">    </span><span class="kd">protected</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">performSizeCheck</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
<span class="w">        </span><span class="n">windowSizeMaybeChanged</span><span class="p">(</span><span class="n">Window</span><span class="p">.</span><span class="na">getClientWidth</span><span class="p">(),</span>
<span class="w">                </span><span class="n">Window</span><span class="p">.</span><span class="na">getClientHeight</span><span class="p">());</span>
<span class="w">    </span><span class="p">}</span>

<span class="w">    </span><span class="cm">/**</span>
<span class="cm">     * Called when the window or parent div might have been resized.</span>
<span class="cm">     *</span>
<span class="cm">     * This immediately checks the sizes of the window and the parent div (if</span>
<span class="cm">     * monitoring it) and triggers layout recalculation if they have changed.</span>
<span class="cm">     *</span>
<span class="cm">     * @param newWindowWidth</span>
<span class="cm">     *            The new width of the window</span>
<span class="cm">     * @param newWindowHeight</span>
<span class="cm">     *            The new height of the window</span>
<span class="cm">     *</span>
<span class="cm">     * @deprecated use {@link #performSizeCheck()}</span>
<span class="cm">     */</span>
<span class="w">    </span><span class="nd">@Deprecated</span>
<span class="w">    </span><span class="kd">protected</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">windowSizeMaybeChanged</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">newWindowWidth</span><span class="p">,</span>
<span class="w">            </span><span class="kt">int</span><span class="w"> </span><span class="n">newWindowHeight</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w">        </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">connection</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="kc">null</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w">            </span><span class="c1">// Connection is null if the timer fires before the first UIDL</span>
<span class="w">            </span><span class="c1">// update</span>
<span class="w">            </span><span class="k">return</span><span class="p">;</span>
<span class="w">        </span><span class="p">}</span>

<span class="w">        </span><span class="kt">boolean</span><span class="w"> </span><span class="n">changed</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="kc">false</span><span class="p">;</span>
<span class="w">        </span><span class="n">ComponentConnector</span><span class="w"> </span><span class="n">connector</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">ConnectorMap</span><span class="p">.</span><span class="na">get</span><span class="p">(</span><span class="n">connection</span><span class="p">)</span>
<span class="w">                </span><span class="p">.</span><span class="na">getConnector</span><span class="p">(</span><span class="k">this</span><span class="p">);</span>
<span class="w">        </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">windowWidth</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="n">newWindowWidth</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w">            </span><span class="n">windowWidth</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">newWindowWidth</span><span class="p">;</span>
<span class="w">            </span><span class="n">changed</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="kc">true</span><span class="p">;</span>
<span class="w">            </span><span class="n">connector</span><span class="p">.</span><span class="na">getLayoutManager</span><span class="p">().</span><span class="na">reportOuterWidth</span><span class="p">(</span><span class="n">connector</span><span class="p">,</span>
<span class="w">                    </span><span class="n">newWindowWidth</span><span class="p">);</span>
<span class="w">            </span><span class="n">getLogger</span><span class="p">().</span><span class="na">info</span><span class="p">(</span><span class="s">&quot;New window width: &quot;</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">windowWidth</span><span class="p">);</span>
<span class="w">        </span><span class="p">}</span>
<span class="w">        </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">windowHeight</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="n">newWindowHeight</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w">            </span><span class="n">windowHeight</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">newWindowHeight</span><span class="p">;</span>
<span class="w">            </span><span class="n">changed</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="kc">true</span><span class="p">;</span>
<span class="w">            </span><span class="n">connector</span><span class="p">.</span><span class="na">getLayoutManager</span><span class="p">().</span><span class="na">reportOuterHeight</span><span class="p">(</span><span class="n">connector</span><span class="p">,</span>
<span class="w">                    </span><span class="n">newWindowHeight</span><span class="p">);</span>
<span class="w">            </span><span class="n">getLogger</span><span class="p">().</span><span class="na">info</span><span class="p">(</span><span class="s">&quot;New window height: &quot;</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">windowHeight</span><span class="p">);</span>
<span class="w">        </span><span class="p">}</span>
<span class="w">        </span><span class="n">Element</span><span class="w"> </span><span class="n">parentElement</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">getElement</span><span class="p">().</span><span class="na">getParentElement</span><span class="p">();</span>
<span class="w">        </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">isMonitoringParentSize</span><span class="p">()</span><span class="w"> </span><span class="o">&amp;&amp;</span><span class="w"> </span><span class="n">parentElement</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="kc">null</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w">            </span><span class="c1">// check also for parent size changes</span>
<span class="w">            </span><span class="kt">int</span><span class="w"> </span><span class="n">newParentWidth</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">parentElement</span><span class="p">.</span><span class="na">getClientWidth</span><span class="p">();</span>
<span class="w">            </span><span class="kt">int</span><span class="w"> </span><span class="n">newParentHeight</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">parentElement</span><span class="p">.</span><span class="na">getClientHeight</span><span class="p">();</span>
<span class="w">            </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">parentWidth</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="n">newParentWidth</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w">                </span><span class="n">parentWidth</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">newParentWidth</span><span class="p">;</span>
<span class="w">                </span><span class="n">changed</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="kc">true</span><span class="p">;</span>
<span class="w">                </span><span class="n">getLogger</span><span class="p">().</span><span class="na">info</span><span class="p">(</span><span class="s">&quot;New parent width: &quot;</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">parentWidth</span><span class="p">);</span>
<span class="w">            </span><span class="p">}</span>
<span class="w">            </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">parentHeight</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="n">newParentHeight</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w">                </span><span class="n">parentHeight</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">newParentHeight</span><span class="p">;</span>
<span class="w">                </span><span class="n">changed</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="kc">true</span><span class="p">;</span>
<span class="w">                </span><span class="n">getLogger</span><span class="p">().</span><span class="na">info</span><span class="p">(</span><span class="s">&quot;New parent height: &quot;</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">parentHeight</span><span class="p">);</span>
<span class="w">            </span><span class="p">}</span>
<span class="w">        </span><span class="p">}</span>
<span class="w">        </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">changed</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w">            </span><span class="cm">/*</span>
<span class="cm">             * If the window size has changed, layout the VView again and send</span>
<span class="cm">             * new size to the server if the size changed. (Just checking VView</span>
<span class="cm">             * size would cause us to ignore cases when a relatively sized VView</span>
<span class="cm">             * should shrink as the content&#39;s size is fixed and would thus not</span>
<span class="cm">             * automatically shrink.)</span>
<span class="cm">             */</span>
<span class="w">            </span><span class="n">getLogger</span><span class="p">().</span><span class="na">info</span><span class="p">(</span>
<span class="w">                    </span><span class="s">&quot;Running layout functions due to window or parent resize&quot;</span><span class="p">);</span>

<span class="w">            </span><span class="c1">// update size to avoid (most) redundant re-layout passes</span>
<span class="w">            </span><span class="c1">// there can still be an extra layout recalculation if webkit</span>
<span class="w">            </span><span class="c1">// overflow fix updates the size in a deferred block</span>
<span class="w">            </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">isMonitoringParentSize</span><span class="p">()</span><span class="w"> </span><span class="o">&amp;&amp;</span><span class="w"> </span><span class="n">parentElement</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="kc">null</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w">                </span><span class="n">parentWidth</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">parentElement</span><span class="p">.</span><span class="na">getClientWidth</span><span class="p">();</span>
<span class="w">                </span><span class="n">parentHeight</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">parentElement</span><span class="p">.</span><span class="na">getClientHeight</span><span class="p">();</span>
<span class="w">            </span><span class="p">}</span>

<span class="w">            </span><span class="n">sendClientResized</span><span class="p">();</span>

<span class="w">            </span><span class="n">LayoutManager</span><span class="w"> </span><span class="n">layoutManager</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">connector</span><span class="p">.</span><span class="na">getLayoutManager</span><span class="p">();</span>
<span class="w">            </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">layoutManager</span><span class="p">.</span><span class="na">isLayoutRunning</span><span class="p">())</span><span class="w"> </span><span class="p">{</span>
<span class="w">                </span><span class="n">layoutManager</span><span class="p">.</span><span class="na">layoutLater</span><span class="p">();</span>
<span class="w">            </span><span class="p">}</span><span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="p">{</span>
<span class="w">                </span><span class="n">layoutManager</span><span class="p">.</span><span class="na">layoutNow</span><span class="p">();</span>
<span class="w">            </span><span class="p">}</span>
<span class="w">        </span><span class="p">}</span>
<span class="w">    </span><span class="p">}</span>

<span class="w">    </span><span class="cm">/**</span>
<span class="cm">     * @return the name of the theme in use by this UI.</span>
<span class="cm">     * @deprecated as of 7.3. Use {@link UIConnector#getActiveTheme()} instead.</span>
<span class="cm">     */</span>
<span class="w">    </span><span class="nd">@Deprecated</span>
<span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="nf">getTheme</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
<span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="p">((</span><span class="n">UIConnector</span><span class="p">)</span><span class="w"> </span><span class="n">ConnectorMap</span><span class="p">.</span><span class="na">get</span><span class="p">(</span><span class="n">connection</span><span class="p">).</span><span class="na">getConnector</span><span class="p">(</span><span class="k">this</span><span class="p">))</span>
<span class="w">                </span><span class="p">.</span><span class="na">getActiveTheme</span><span class="p">();</span>
<span class="w">    </span><span class="p">}</span>

<span class="w">    </span><span class="cm">/**</span>
<span class="cm">     * Returns true if the body is NOT generated, i.e if someone else has made</span>
<span class="cm">     * the page that we&#39;re running in. Otherwise we&#39;re in charge of the whole</span>
<span class="cm">     * page.</span>
<span class="cm">     *</span>
<span class="cm">     * @return true if we&#39;re running embedded</span>
<span class="cm">     */</span>
<span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">isEmbedded</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
<span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="o">!</span><span class="n">getElement</span><span class="p">().</span><span class="na">getOwnerDocument</span><span class="p">().</span><span class="na">getBody</span><span class="p">().</span><span class="na">getClassName</span><span class="p">()</span>
<span class="w">                </span><span class="p">.</span><span class="na">contains</span><span class="p">(</span><span class="n">ApplicationConstants</span><span class="p">.</span><span class="na">GENERATED_BODY_CLASSNAME</span><span class="p">);</span>
<span class="w">    </span><span class="p">}</span>

<span class="w">    </span><span class="cm">/**</span>
<span class="cm">     * Returns true if the size of the parent should be checked periodically and</span>
<span class="cm">     * the application should react to its changes.</span>
<span class="cm">     *</span>
<span class="cm">     * @return true if size of parent should be tracked</span>
<span class="cm">     */</span>
<span class="w">    </span><span class="kd">protected</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">isMonitoringParentSize</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
<span class="w">        </span><span class="c1">// could also perform a more specific check (Liferay portlet)</span>
<span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">isEmbedded</span><span class="p">();</span>
<span class="w">    </span><span class="p">}</span>

<span class="w">    </span><span class="cm">/*</span>
<span class="cm">     * (non-Javadoc)</span>
<span class="cm">     *</span>
<span class="cm">     * @see</span>
<span class="cm">     * com.google.gwt.event.logical.shared.ResizeHandler#onResize(com.google</span>
<span class="cm">     * .gwt.event.logical.shared.ResizeEvent)</span>
<span class="cm">     */</span>

<span class="w">    </span><span class="nd">@Override</span>
<span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">onResize</span><span class="p">(</span><span class="n">ResizeEvent</span><span class="w"> </span><span class="n">event</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w">        </span><span class="n">triggerSizeChangeCheck</span><span class="p">();</span>
<span class="w">    </span><span class="p">}</span>

<span class="w">    </span><span class="cm">/**</span>
<span class="cm">     * Called when a resize event is received.</span>
<span class="cm">     *</span>
<span class="cm">     * This may trigger a lazy refresh or perform the size check immediately</span>
<span class="cm">     * depending on the browser used and whether the server side requests</span>
<span class="cm">     * resizes to be lazy.</span>
<span class="cm">     */</span>
<span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">triggerSizeChangeCheck</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
<span class="w">        </span><span class="cm">/*</span>
<span class="cm">         * We may postpone these events to avoid slowness when resizing the</span>
<span class="cm">         * browser window. Constantly recalculating the layout causes the resize</span>
<span class="cm">         * operation to be really slow with complex layouts.</span>
<span class="cm">         */</span>
<span class="w">        </span><span class="kt">boolean</span><span class="w"> </span><span class="n">lazy</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">resizeLazy</span><span class="p">;</span>

<span class="w">        </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">lazy</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w">            </span><span class="n">delayedResizeExecutor</span><span class="p">.</span><span class="na">trigger</span><span class="p">();</span>
<span class="w">        </span><span class="p">}</span><span class="w"> </span><span class="k">else</span><span class="w"> </span><span class="p">{</span>
<span class="w">            </span><span class="n">performSizeCheck</span><span class="p">();</span>
<span class="w">        </span><span class="p">}</span>
<span class="w">    </span><span class="p">}</span>

<span class="w">    </span><span class="cm">/**</span>
<span class="cm">     * Send new dimensions to the server.</span>
<span class="cm">     * &lt;p&gt;</span>
<span class="cm">     * For internal use only. May be removed or replaced in the future.</span>
<span class="cm">     */</span>
<span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">sendClientResized</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
<span class="w">        </span><span class="n">Profiler</span><span class="p">.</span><span class="na">enter</span><span class="p">(</span><span class="s">&quot;VUI.sendClientResized&quot;</span><span class="p">);</span>
<span class="w">        </span><span class="n">Element</span><span class="w"> </span><span class="n">parentElement</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">getElement</span><span class="p">().</span><span class="na">getParentElement</span><span class="p">();</span>
<span class="w">        </span><span class="kt">int</span><span class="w"> </span><span class="n">viewHeight</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">parentElement</span><span class="p">.</span><span class="na">getClientHeight</span><span class="p">();</span>
<span class="w">        </span><span class="kt">int</span><span class="w"> </span><span class="n">viewWidth</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">parentElement</span><span class="p">.</span><span class="na">getClientWidth</span><span class="p">();</span>

<span class="w">        </span><span class="n">ResizeEvent</span><span class="p">.</span><span class="na">fire</span><span class="p">(</span><span class="k">this</span><span class="p">,</span><span class="w"> </span><span class="n">viewWidth</span><span class="p">,</span><span class="w"> </span><span class="n">viewHeight</span><span class="p">);</span>
<span class="w">        </span><span class="n">Profiler</span><span class="p">.</span><span class="na">leave</span><span class="p">(</span><span class="s">&quot;VUI.sendClientResized&quot;</span><span class="p">);</span>
<span class="w">    </span><span class="p">}</span>

<span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">native</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">goTo</span><span class="p">(</span><span class="n">String</span><span class="w"> </span><span class="n">url</span><span class="p">)</span>
<span class="w">    </span><span class="cm">/*-{</span>
<span class="cm">       $wnd.location = url;</span>
<span class="cm">     }-*/</span><span class="p">;</span>

<span class="w">    </span><span class="nd">@Override</span>
<span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">onWindowClosing</span><span class="p">(</span><span class="n">Window</span><span class="p">.</span><span class="na">ClosingEvent</span><span class="w"> </span><span class="n">event</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w">        </span><span class="c1">// Ensure that any change in the currently focused component is noted</span>
<span class="w">        </span><span class="c1">// before refreshing. Ensures that e.g. text in the focused text field</span>
<span class="w">        </span><span class="c1">// does not disappear on refresh (when preserve on refresh is enabled)</span>
<span class="w">        </span><span class="n">connection</span><span class="p">.</span><span class="na">flushActiveConnector</span><span class="p">();</span>
<span class="w">    </span><span class="p">}</span>

<span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">native</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">loadAppIdListFromDOM</span><span class="p">(</span><span class="n">List</span><span class="o">&lt;</span><span class="n">String</span><span class="o">&gt;</span><span class="w"> </span><span class="n">list</span><span class="p">)</span>
<span class="w">    </span><span class="cm">/*-{</span>
<span class="cm">         for (var j in $wnd.vaadin.vaadinConfigurations) {</span>
<span class="cm">            // $entry not needed as function is not exported</span>
<span class="cm">            list.@java.util.Collection::add(Ljava/lang/Object;)(j);</span>
<span class="cm">         }</span>
<span class="cm">     }-*/</span><span class="p">;</span>

<span class="w">    </span><span class="nd">@Override</span>
<span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="n">ShortcutActionHandler</span><span class="w"> </span><span class="nf">getShortcutActionHandler</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
<span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">actionHandler</span><span class="p">;</span>
<span class="w">    </span><span class="p">}</span>

<span class="w">    </span><span class="nd">@Override</span>
<span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">focus</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
<span class="w">        </span><span class="n">setFocus</span><span class="p">(</span><span class="kc">true</span><span class="p">);</span>
<span class="w">    </span><span class="p">}</span>

<span class="w">    </span><span class="cm">/**</span>
<span class="cm">     * Ensures the widget is scrollable e.g. after style name changes.</span>
<span class="cm">     * &lt;p&gt;</span>
<span class="cm">     * For internal use only. May be removed or replaced in the future.</span>
<span class="cm">     */</span>
<span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">makeScrollable</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
<span class="w">        </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">touchScrollHandler</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="kc">null</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w">            </span><span class="n">touchScrollHandler</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">TouchScrollDelegate</span><span class="p">.</span><span class="na">enableTouchScrolling</span><span class="p">(</span><span class="k">this</span><span class="p">);</span>
<span class="w">        </span><span class="p">}</span>
<span class="w">        </span><span class="n">touchScrollHandler</span><span class="p">.</span><span class="na">addElement</span><span class="p">(</span><span class="n">getElement</span><span class="p">());</span>
<span class="w">    </span><span class="p">}</span>

<span class="w">    </span><span class="nd">@Override</span>
<span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="n">HandlerRegistration</span><span class="w"> </span><span class="nf">addResizeHandler</span><span class="p">(</span><span class="n">ResizeHandler</span><span class="w"> </span><span class="n">resizeHandler</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">addHandler</span><span class="p">(</span><span class="n">resizeHandler</span><span class="p">,</span><span class="w"> </span><span class="n">ResizeEvent</span><span class="p">.</span><span class="na">getType</span><span class="p">());</span>
<span class="w">    </span><span class="p">}</span>

<span class="w">    </span><span class="nd">@Override</span>
<span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="n">HandlerRegistration</span><span class="w"> </span><span class="nf">addScrollHandler</span><span class="p">(</span><span class="n">ScrollHandler</span><span class="w"> </span><span class="n">scrollHandler</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">addHandler</span><span class="p">(</span><span class="n">scrollHandler</span><span class="p">,</span><span class="w"> </span><span class="n">ScrollEvent</span><span class="p">.</span><span class="na">getType</span><span class="p">());</span>
<span class="w">    </span><span class="p">}</span>

<span class="w">    </span><span class="nd">@Override</span>
<span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">getTabIndex</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
<span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">FocusUtil</span><span class="p">.</span><span class="na">getTabIndex</span><span class="p">(</span><span class="k">this</span><span class="p">);</span>
<span class="w">    </span><span class="p">}</span>

<span class="w">    </span><span class="nd">@Override</span>
<span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">setAccessKey</span><span class="p">(</span><span class="kt">char</span><span class="w"> </span><span class="n">key</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w">        </span><span class="n">FocusUtil</span><span class="p">.</span><span class="na">setAccessKey</span><span class="p">(</span><span class="k">this</span><span class="p">,</span><span class="w"> </span><span class="n">key</span><span class="p">);</span>
<span class="w">    </span><span class="p">}</span>

<span class="w">    </span><span class="nd">@Override</span>
<span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">setFocus</span><span class="p">(</span><span class="kt">boolean</span><span class="w"> </span><span class="n">focused</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w">        </span><span class="n">FocusUtil</span><span class="p">.</span><span class="na">setFocus</span><span class="p">(</span><span class="k">this</span><span class="p">,</span><span class="w"> </span><span class="n">focused</span><span class="p">);</span>
<span class="w">    </span><span class="p">}</span>

<span class="w">    </span><span class="nd">@Override</span>
<span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">setTabIndex</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">index</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w">        </span><span class="n">FocusUtil</span><span class="p">.</span><span class="na">setTabIndex</span><span class="p">(</span><span class="k">this</span><span class="p">,</span><span class="w"> </span><span class="n">index</span><span class="p">);</span>
<span class="w">    </span><span class="p">}</span>

<span class="w">    </span><span class="cm">/**</span>
<span class="cm">     * Allows to store the currently focused Element.</span>
<span class="cm">     *</span>
<span class="cm">     * Current use case is to store the focus when a Window is opened. Does</span>
<span class="cm">     * currently handle only a single value. Needs to be extended for #12158</span>
<span class="cm">     *</span>
<span class="cm">     * @param focusedElement</span>
<span class="cm">     */</span>
<span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">storeFocus</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
<span class="w">        </span><span class="n">storedFocus</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">WidgetUtil</span><span class="p">.</span><span class="na">getFocusedElement</span><span class="p">();</span>
<span class="w">    </span><span class="p">}</span>

<span class="w">    </span><span class="cm">/**</span>
<span class="cm">     * Restores the previously stored focus Element.</span>
<span class="cm">     *</span>
<span class="cm">     * Current use case is to restore the focus when a Window is closed. Does</span>
<span class="cm">     * currently handle only a single value. Needs to be extended for #12158</span>
<span class="cm">     */</span>
<span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">focusStoredElement</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
<span class="w">        </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">storedFocus</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="kc">null</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w">            </span><span class="n">storedFocus</span><span class="p">.</span><span class="na">focus</span><span class="p">();</span>
<span class="w">        </span><span class="p">}</span>
<span class="w">    </span><span class="p">}</span>

<span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="n">Logger</span><span class="w"> </span><span class="nf">getLogger</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
<span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">Logger</span><span class="p">.</span><span class="na">getLogger</span><span class="p">(</span><span class="n">VUI</span><span class="p">.</span><span class="na">class</span><span class="p">.</span><span class="na">getName</span><span class="p">());</span>
<span class="w">    </span><span class="p">}</span>
<span class="p">}</span>
</pre></div>