| /* |
| * Copyright (C) 2012 The Android Open Source Project |
| * |
| * Licensed under the Eclipse Public License, Version 1.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.eclipse.org/org/documents/epl-v10.php |
| * |
| * 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.android.ide.eclipse.adt.internal.editors.layout.configuration; |
| |
| import com.android.annotations.NonNull; |
| import com.android.annotations.Nullable; |
| import com.android.ide.common.resources.configuration.FolderConfiguration; |
| import com.android.resources.NightMode; |
| import com.android.resources.UiMode; |
| import com.android.sdklib.IAndroidTarget; |
| import com.android.sdklib.devices.Device; |
| import com.android.sdklib.devices.State; |
| import com.google.common.base.Objects; |
| |
| /** |
| * An {@linkplain NestedConfiguration} is a {@link Configuration} which inherits |
| * all of its values from a different configuration, except for one or more |
| * attributes where it overrides a custom value. |
| * <p> |
| * Unlike a {@link VaryingConfiguration}, a {@linkplain NestedConfiguration} |
| * will always return the same overridden value, regardless of the inherited |
| * value. |
| * <p> |
| * For example, an {@linkplain NestedConfiguration} may fix the locale to always |
| * be "en", but otherwise inherit everything else. |
| */ |
| public class NestedConfiguration extends Configuration { |
| /** The configuration we are inheriting non-overridden values from */ |
| protected Configuration mParent; |
| |
| /** Bitmask of attributes to be overridden in this configuration */ |
| private int mOverride; |
| |
| /** |
| * Constructs a new {@linkplain NestedConfiguration}. |
| * Construct via |
| * |
| * @param chooser the associated chooser |
| * @param configuration the configuration to inherit from |
| */ |
| protected NestedConfiguration( |
| @NonNull ConfigurationChooser chooser, |
| @NonNull Configuration configuration) { |
| super(chooser); |
| mParent = configuration; |
| |
| mFullConfig.set(mParent.mFullConfig); |
| if (mParent.getEditedConfig() != null) { |
| mEditedConfig = new FolderConfiguration(); |
| mEditedConfig.set(mParent.mEditedConfig); |
| } |
| } |
| |
| /** |
| * Returns the override flags for this configuration. Corresponds to |
| * the {@code CFG_} flags in {@link ConfigurationClient}. |
| * |
| * @return the bitmask |
| */ |
| public int getOverrideFlags() { |
| return mOverride; |
| } |
| |
| /** |
| * Creates a new {@linkplain NestedConfiguration} that has the same overriding |
| * attributes as the given other {@linkplain NestedConfiguration}, and gets |
| * its values from the given {@linkplain Configuration}. |
| * |
| * @param other the configuration to copy overrides from |
| * @param values the configuration to copy values from |
| * @param parent the parent to tie the configuration to for inheriting values |
| * @return a new configuration |
| */ |
| @NonNull |
| public static NestedConfiguration create( |
| @NonNull NestedConfiguration other, |
| @NonNull Configuration values, |
| @NonNull Configuration parent) { |
| NestedConfiguration configuration = |
| new NestedConfiguration(other.mConfigChooser, parent); |
| initFrom(configuration, other, values, true /*sync*/); |
| return configuration; |
| } |
| |
| /** |
| * Initializes a new {@linkplain NestedConfiguration} with the overriding |
| * attributes as the given other {@linkplain NestedConfiguration}, and gets |
| * its values from the given {@linkplain Configuration}. |
| * |
| * @param configuration the configuration to initialize |
| * @param other the configuration to copy overrides from |
| * @param values the configuration to copy values from |
| * @param sync if true, sync the folder configuration from |
| */ |
| protected static void initFrom(NestedConfiguration configuration, |
| NestedConfiguration other, Configuration values, boolean sync) { |
| configuration.mOverride = other.mOverride; |
| configuration.setDisplayName(values.getDisplayName()); |
| configuration.setActivity(values.getActivity()); |
| |
| if (configuration.isOverridingLocale()) { |
| configuration.setLocale(values.getLocale(), true); |
| } |
| if (configuration.isOverridingTarget()) { |
| configuration.setTarget(values.getTarget(), true); |
| } |
| if (configuration.isOverridingDevice()) { |
| configuration.setDevice(values.getDevice(), true); |
| } |
| if (configuration.isOverridingDeviceState()) { |
| configuration.setDeviceState(values.getDeviceState(), true); |
| } |
| if (configuration.isOverridingNightMode()) { |
| configuration.setNightMode(values.getNightMode(), true); |
| } |
| if (configuration.isOverridingUiMode()) { |
| configuration.setUiMode(values.getUiMode(), true); |
| } |
| if (sync) { |
| configuration.syncFolderConfig(); |
| } |
| } |
| |
| /** |
| * Sets the parent configuration that this configuration is inheriting from. |
| * |
| * @param parent the parent configuration |
| */ |
| public void setParent(@NonNull Configuration parent) { |
| mParent = parent; |
| } |
| |
| /** |
| * Creates a new {@linkplain Configuration} which inherits values from the |
| * given parent {@linkplain Configuration}, possibly overriding some as |
| * well. |
| * |
| * @param chooser the associated chooser |
| * @param parent the configuration to inherit values from |
| * @return a new configuration |
| */ |
| @NonNull |
| public static NestedConfiguration create(@NonNull ConfigurationChooser chooser, |
| @NonNull Configuration parent) { |
| return new NestedConfiguration(chooser, parent); |
| } |
| |
| @Override |
| @Nullable |
| public String getTheme() { |
| // Never overridden: this is a static attribute of a layout, not something which |
| // varies by configuration or at runtime |
| return mParent.getTheme(); |
| } |
| |
| @Override |
| public void setTheme(String theme) { |
| // Never overridden |
| mParent.setTheme(theme); |
| } |
| |
| /** |
| * Sets whether the locale should be overridden by this configuration |
| * |
| * @param override if true, override the inherited value |
| */ |
| public void setOverrideLocale(boolean override) { |
| mOverride |= CFG_LOCALE; |
| } |
| |
| /** |
| * Returns true if the locale is overridden |
| * |
| * @return true if the locale is overridden |
| */ |
| public final boolean isOverridingLocale() { |
| return (mOverride & CFG_LOCALE) != 0; |
| } |
| |
| @Override |
| @NonNull |
| public Locale getLocale() { |
| if (isOverridingLocale()) { |
| return super.getLocale(); |
| } else { |
| return mParent.getLocale(); |
| } |
| } |
| |
| @Override |
| public void setLocale(@NonNull Locale locale, boolean skipSync) { |
| if (isOverridingLocale()) { |
| super.setLocale(locale, skipSync); |
| } else { |
| mParent.setLocale(locale, skipSync); |
| } |
| } |
| |
| /** |
| * Sets whether the rendering target should be overridden by this configuration |
| * |
| * @param override if true, override the inherited value |
| */ |
| public void setOverrideTarget(boolean override) { |
| mOverride |= CFG_TARGET; |
| } |
| |
| /** |
| * Returns true if the target is overridden |
| * |
| * @return true if the target is overridden |
| */ |
| public final boolean isOverridingTarget() { |
| return (mOverride & CFG_TARGET) != 0; |
| } |
| |
| @Override |
| @Nullable |
| public IAndroidTarget getTarget() { |
| if (isOverridingTarget()) { |
| return super.getTarget(); |
| } else { |
| return mParent.getTarget(); |
| } |
| } |
| |
| @Override |
| public void setTarget(IAndroidTarget target, boolean skipSync) { |
| if (isOverridingTarget()) { |
| super.setTarget(target, skipSync); |
| } else { |
| mParent.setTarget(target, skipSync); |
| } |
| } |
| |
| /** |
| * Sets whether the device should be overridden by this configuration |
| * |
| * @param override if true, override the inherited value |
| */ |
| public void setOverrideDevice(boolean override) { |
| mOverride |= CFG_DEVICE; |
| } |
| |
| /** |
| * Returns true if the device is overridden |
| * |
| * @return true if the device is overridden |
| */ |
| public final boolean isOverridingDevice() { |
| return (mOverride & CFG_DEVICE) != 0; |
| } |
| |
| @Override |
| @Nullable |
| public Device getDevice() { |
| if (isOverridingDevice()) { |
| return super.getDevice(); |
| } else { |
| return mParent.getDevice(); |
| } |
| } |
| |
| @Override |
| public void setDevice(Device device, boolean skipSync) { |
| if (isOverridingDevice()) { |
| super.setDevice(device, skipSync); |
| } else { |
| mParent.setDevice(device, skipSync); |
| } |
| } |
| |
| /** |
| * Sets whether the device state should be overridden by this configuration |
| * |
| * @param override if true, override the inherited value |
| */ |
| public void setOverrideDeviceState(boolean override) { |
| mOverride |= CFG_DEVICE_STATE; |
| } |
| |
| /** |
| * Returns true if the device state is overridden |
| * |
| * @return true if the device state is overridden |
| */ |
| public final boolean isOverridingDeviceState() { |
| return (mOverride & CFG_DEVICE_STATE) != 0; |
| } |
| |
| @Override |
| @Nullable |
| public State getDeviceState() { |
| if (isOverridingDeviceState()) { |
| return super.getDeviceState(); |
| } else { |
| State state = mParent.getDeviceState(); |
| if (isOverridingDevice()) { |
| // If the device differs, I need to look up a suitable equivalent state |
| // on our device |
| if (state != null) { |
| Device device = super.getDevice(); |
| if (device != null) { |
| return device.getState(state.getName()); |
| } |
| } |
| } |
| |
| return state; |
| } |
| } |
| |
| @Override |
| public void setDeviceState(State state, boolean skipSync) { |
| if (isOverridingDeviceState()) { |
| super.setDeviceState(state, skipSync); |
| } else { |
| if (isOverridingDevice()) { |
| Device device = super.getDevice(); |
| if (device != null) { |
| State equivalentState = device.getState(state.getName()); |
| if (equivalentState != null) { |
| state = equivalentState; |
| } |
| } |
| } |
| mParent.setDeviceState(state, skipSync); |
| } |
| } |
| |
| /** |
| * Sets whether the night mode should be overridden by this configuration |
| * |
| * @param override if true, override the inherited value |
| */ |
| public void setOverrideNightMode(boolean override) { |
| mOverride |= CFG_NIGHT_MODE; |
| } |
| |
| /** |
| * Returns true if the night mode is overridden |
| * |
| * @return true if the night mode is overridden |
| */ |
| public final boolean isOverridingNightMode() { |
| return (mOverride & CFG_NIGHT_MODE) != 0; |
| } |
| |
| @Override |
| @NonNull |
| public NightMode getNightMode() { |
| if (isOverridingNightMode()) { |
| return super.getNightMode(); |
| } else { |
| return mParent.getNightMode(); |
| } |
| } |
| |
| @Override |
| public void setNightMode(@NonNull NightMode night, boolean skipSync) { |
| if (isOverridingNightMode()) { |
| super.setNightMode(night, skipSync); |
| } else { |
| mParent.setNightMode(night, skipSync); |
| } |
| } |
| |
| /** |
| * Sets whether the UI mode should be overridden by this configuration |
| * |
| * @param override if true, override the inherited value |
| */ |
| public void setOverrideUiMode(boolean override) { |
| mOverride |= CFG_UI_MODE; |
| } |
| |
| /** |
| * Returns true if the UI mode is overridden |
| * |
| * @return true if the UI mode is overridden |
| */ |
| public final boolean isOverridingUiMode() { |
| return (mOverride & CFG_UI_MODE) != 0; |
| } |
| |
| @Override |
| @NonNull |
| public UiMode getUiMode() { |
| if (isOverridingUiMode()) { |
| return super.getUiMode(); |
| } else { |
| return mParent.getUiMode(); |
| } |
| } |
| |
| @Override |
| public void setUiMode(@NonNull UiMode uiMode, boolean skipSync) { |
| if (isOverridingUiMode()) { |
| super.setUiMode(uiMode, skipSync); |
| } else { |
| mParent.setUiMode(uiMode, skipSync); |
| } |
| } |
| |
| /** |
| * Returns the configuration this {@linkplain NestedConfiguration} is |
| * inheriting from |
| * |
| * @return the configuration this configuration is inheriting from |
| */ |
| @NonNull |
| public Configuration getParent() { |
| return mParent; |
| } |
| |
| @Override |
| @Nullable |
| public String getActivity() { |
| return mParent.getActivity(); |
| } |
| |
| @Override |
| public void setActivity(String activity) { |
| super.setActivity(activity); |
| } |
| |
| /** |
| * Returns a computed display name (ignoring the value stored by |
| * {@link #setDisplayName(String)}) by looking at the override flags |
| * and picking a suitable name. |
| * |
| * @return a suitable display name |
| */ |
| @Nullable |
| public String computeDisplayName() { |
| return computeDisplayName(mOverride, this); |
| } |
| |
| /** |
| * Computes a display name for the given configuration, using the given |
| * override flags (which correspond to the {@code CFG_} constants in |
| * {@link ConfigurationClient} |
| * |
| * @param flags the override bitmask |
| * @param configuration the configuration to fetch values from |
| * @return a suitable display name |
| */ |
| @Nullable |
| public static String computeDisplayName(int flags, @NonNull Configuration configuration) { |
| if ((flags & CFG_LOCALE) != 0) { |
| return ConfigurationChooser.getLocaleLabel(configuration.mConfigChooser, |
| configuration.getLocale(), false); |
| } |
| |
| if ((flags & CFG_TARGET) != 0) { |
| return ConfigurationChooser.getRenderingTargetLabel(configuration.getTarget(), false); |
| } |
| |
| if ((flags & CFG_DEVICE) != 0) { |
| return ConfigurationChooser.getDeviceLabel(configuration.getDevice(), true); |
| } |
| |
| if ((flags & CFG_DEVICE_STATE) != 0) { |
| State deviceState = configuration.getDeviceState(); |
| if (deviceState != null) { |
| return deviceState.getName(); |
| } |
| } |
| |
| if ((flags & CFG_NIGHT_MODE) != 0) { |
| return configuration.getNightMode().getLongDisplayValue(); |
| } |
| |
| if ((flags & CFG_UI_MODE) != 0) { |
| configuration.getUiMode().getLongDisplayValue(); |
| } |
| |
| return null; |
| } |
| |
| @Override |
| public String toString() { |
| return Objects.toStringHelper(this.getClass()) |
| .add("parent", mParent.getDisplayName()) //$NON-NLS-1$ |
| .add("display", getDisplayName()) //$NON-NLS-1$ |
| .add("overrideLocale", isOverridingLocale()) //$NON-NLS-1$ |
| .add("overrideTarget", isOverridingTarget()) //$NON-NLS-1$ |
| .add("overrideDevice", isOverridingDevice()) //$NON-NLS-1$ |
| .add("overrideDeviceState", isOverridingDeviceState()) //$NON-NLS-1$ |
| .add("persistent", toPersistentString()) //$NON-NLS-1$ |
| .toString(); |
| } |
| } |
