diff options
Diffstat (limited to 'src/plugins/emulator/src/com/motorola/studio/android/emulator/skin/android/parser/LayoutFileModel.java')
| -rw-r--r-- | src/plugins/emulator/src/com/motorola/studio/android/emulator/skin/android/parser/LayoutFileModel.java | 706 |
1 files changed, 706 insertions, 0 deletions
diff --git a/src/plugins/emulator/src/com/motorola/studio/android/emulator/skin/android/parser/LayoutFileModel.java b/src/plugins/emulator/src/com/motorola/studio/android/emulator/skin/android/parser/LayoutFileModel.java new file mode 100644 index 0000000..922b396 --- /dev/null +++ b/src/plugins/emulator/src/com/motorola/studio/android/emulator/skin/android/parser/LayoutFileModel.java @@ -0,0 +1,706 @@ +/* +* Copyright (C) 2012 The Android Open Source Project +* +* 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.motorola.studio.android.emulator.skin.android.parser; + +import java.io.File; +import java.util.Collection; +import java.util.Iterator; +import java.util.LinkedHashSet; +import java.util.LinkedList; +import java.util.List; + +import org.eclipse.swt.graphics.ImageData; +import org.eclipse.swt.graphics.Point; +import org.eclipse.swt.graphics.RGB; + +/** + * DESCRIPTION: + * This class represents a skin layout file + * + * RESPONSIBILITY: + * Represent all the contents of a skin layout file + * + * COLABORATORS: + * None. + * + * USAGE: + * Use the class public APIs to retrieve data of the skin + */ +public class LayoutFileModel +{ + /** + * Event to rotate the screen + */ + private static final String ROTATE_SCREEN_EVENT = "EV_SW:0:0"; + + /** + * Command to rotate the screen + */ + private static final String ROTATE_SCREEN_CMD = "5 0 0"; + + /** + * Command to get the screen back to its default orientation + */ + private static final String RETURN_TO_DEFAULT_SCREEN_CMD = "5 0 1"; + + /** + * A collection containing all layouts read from the layout file + */ + private Collection<LayoutBean> layouts; + + /** + * A collection containing all parts read from the layout file + */ + private Collection<PartBean> parts = new LinkedHashSet<PartBean>(); + + /** + * The keyboard charmap used by this skin + */ + private String keyboardCharmap; + + /** + * The default network speed used by this skin + */ + private String networkSpeed; + + /** + * The default network delay used by this skin + */ + private String networkDelay; + + /** + * Sets the keyboard charmap used by this skin + * + * @param keyboardCharmap The keyboard charmap name + */ + void setKeyboardCharmap(String keyboardCharmap) + { + this.keyboardCharmap = keyboardCharmap; + } + + /** + * Sets the default network speed used by this skin + * + * @param keyboardCharmap The default network speed used by this skin + */ + void setNetworkSpeed(String networkSpeed) + { + this.networkSpeed = networkSpeed; + } + + /** + * Sets the default network delay of this skin + * + * @param The default network delay + */ + void setNetworkDelay(String networkDelay) + { + this.networkDelay = networkDelay; + } + + /** + * Creates a new part, registers it and returns it to the user + * + * This version is used when the skin is simple, i.e. when there is a single + * part and no layouts defined. To support landscape/portrait rotation, we create + * "pseudo-layouts" at memory as well. + * + * @return The part + */ + PartBean newPart() + { + return newPart(PartBean.UNIQUE_PART); + } + + /** + * Creates a new part, registers it and returns it to the user + * Use this version when the skin have multiple parts + * (i.e., if there is a "parts" element in the layout file) + * + * @param name The part name + * + * @return The part + */ + PartBean newPart(String name) + { + PartBean bean = new PartBean(name); + parts.add(bean); + return bean; + } + + /** + * Creates a new layout, registers it and returns it to the user + * + * @param name The layout name + * + * @return The layout + */ + LayoutBean newLayout(String name) + { + LayoutBean bean = new LayoutBean(name); + if (layouts == null) + { + layouts = new LinkedHashSet<LayoutBean>(); + } + layouts.add(bean); + + return bean; + } + + /** + * Retrieves the keyboard charmap used by this skin + * + * @return The keyboard charmap name + */ + public String getKeyboardCharmap() + { + return keyboardCharmap; + } + + /** + * Retrieves the default network speed of this skin + * + * @return The default network speed + */ + public String getNetworkSpeed() + { + return networkSpeed; + } + + /** + * Retrieves the default network delay of this skin + * + * @return The default network delay + */ + public String getNetworkDelay() + { + return networkDelay; + } + + public List<String> getLayoutNames() + { + List<String> layoutNames = new LinkedList<String>(); + if (layouts != null) + { + for (LayoutBean bean : layouts) + { + layoutNames.add(bean.getName()); + } + } + + return layoutNames; + } + + public Collection<String> getPartNames() + { + Collection<String> partNames = new LinkedHashSet<String>(); + for (PartBean bean : parts) + { + partNames.add(bean.getName()); + } + + return partNames; + } + + public Collection<String> getLayoutPartNames(String layoutName) + { + Collection<String> layoutPartNames = new LinkedHashSet<String>(); + LayoutBean bean = getLayoutByName(layoutName); + if (bean != null) + { + Collection<PartRefBean> partRefs = bean.getPartRefs(); + if (partRefs != null) + { + for (PartRefBean aRef : partRefs) + { + layoutPartNames.add(aRef.getPartName()); + } + } + } + + return layoutPartNames; + } + + public Point getPartPositionAtLayout(String layoutName, String partName, File skinFilesPath) + { + Point partPosition = null; + + LayoutBean bean = getLayoutByName(layoutName); + if (bean != null) + { + Collection<PartRefBean> partRefs = bean.getPartRefs(); + for (PartRefBean prBean : partRefs) + { + if (prBean.getPartName().equals(partName)) + { + int x = Integer.parseInt(prBean.getX()); + String yStr = prBean.getY(); + int y; + if (yStr == null) + { + y = getBackgroundWidth(partName, skinFilesPath); + } + else + { + y = Integer.parseInt(yStr); + } + + partPosition = new Point(x, y); + break; + } + } + } + else + { + partPosition = new Point(0, 0); + } + + return partPosition; + } + + public int getPartRotationAtLayout(String layoutName, String partName) + { + int partRotation = 0; + + LayoutBean bean = getLayoutByName(layoutName); + if (bean != null) + { + Collection<PartRefBean> partRefs = bean.getPartRefs(); + for (PartRefBean prBean : partRefs) + { + if (prBean.getPartName().equals(partName)) + { + String rotStr = prBean.getRotation(); + if (rotStr != null) + { + partRotation = Integer.parseInt(rotStr); + } + break; + } + } + } + + return partRotation; + } + + public int getDpadRotation(String layoutName) + { + int dPadRotation = 0; + LayoutBean bean = getLayoutByName(layoutName); + if (bean != null) + { + dPadRotation = bean.getDpadRotation(); + } + + return dPadRotation; + } + + public Collection<String> getButtonNames(String partName) + { + Collection<String> buttonNames = new LinkedHashSet<String>(); + + PartBean bean = getPartByName(partName); + if (bean != null) + { + Collection<ImagePositionBean> buttons = bean.getButtons(); + if (buttons != null) + { + for (ImagePositionBean button : buttons) + { + buttonNames.add(button.getName()); + } + } + } + return buttonNames; + } + + public int getLayoutWidth(String layoutName) + { + int width = 0; + LayoutBean layout = getLayoutByName(layoutName); + if (layout != null) + { + width = Integer.parseInt(layout.getWidth()); + } + + return width; + } + + public int getLayoutHeight(String layoutName) + { + int height = 0; + LayoutBean layout = getLayoutByName(layoutName); + if (layout != null) + { + height = Integer.parseInt(layout.getHeight()); + } + + return height; + } + + public RGB getLayoutColor(String layoutName, File skinFilesPath) + { + RGB color = null; + LayoutBean layout = getLayoutByName(layoutName); + if (layout != null) + { + color = layout.getColor(); + if (color == null) + { + String mainPart = getMainPartName(layoutName); + File image = getBackgroundImage(mainPart, skinFilesPath); + ImageData img = new ImageData(image.getAbsolutePath()); + int pixel = img.getPixel(0, 0); + color = img.palette.getRGB(pixel); + layout.setKeyValue(ILayoutConstants.LAYOUT_COLOR, + "0x" + Integer.toHexString(color.red) + Integer.toHexString(color.green) + + Integer.toHexString(color.blue)); + } + } + else + { + color = new RGB(255, 255, 255); + } + + return color; + } + + public String getLayoutEvent(String layoutName) + { + String event = ""; + LayoutBean layout = getLayoutByName(layoutName); + if (layout != null) + { + event = layout.getEvent(); + } + + return event; + } + + public String getLayoutSwitchCommand(String layoutName) + { + LayoutBean bean = getLayoutByName(layoutName); + String event = bean.getEvent(); + if (ROTATE_SCREEN_EVENT.equals(event)) + { + return ROTATE_SCREEN_CMD; + } + else + { + return RETURN_TO_DEFAULT_SCREEN_CMD; + } + } + + public boolean isSwapWidthHeightNeededAtLayout(String layoutName) + { + return isSwapWidthHeightNeededAtLayout(layoutName, getMainPartName(layoutName)); + } + + public boolean isSwapWidthHeightNeededAtLayout(String layoutName, String partName) + { + boolean isRotated = false; + if (partName != null) + { + int rotation = getPartRotationAtLayout(layoutName, partName); + isRotated = rotation % 2 != 0; + } + return isRotated; + } + + public File getBackgroundImage(String partName, File skinFilesPath) + { + File backgroundFile = null; + PartBean part = getPartByName(partName); + if (part != null) + { + ImagePositionBean backgroundBean = part.getBackground(); + if (backgroundBean != null) + { + backgroundFile = + new File(skinFilesPath, backgroundBean.getImageLocation().getName()); + } + } + + return backgroundFile; + } + + public Point getBackgroundPosition(String partName) + { + Point bgPosition = null; + PartBean part = getPartByName(partName); + if (part != null) + { + ImagePositionBean bgBean = part.getBackground(); + String xStr = null; + String yStr = null; + if (bgBean != null) + { + + xStr = bgBean.getXPos(); + yStr = bgBean.getYPos(); + } + + if ((xStr != null) && (yStr != null)) + { + bgPosition = new Point(Integer.parseInt(xStr), Integer.parseInt(yStr)); + } + else + { + bgPosition = new Point(0, 0); + } + } + + return bgPosition; + } + + public int getBackgroundWidth(String partName, File skinFilesPath) + { + int width = -1; + PartBean part = getPartByName(partName); + if (part != null) + { + ImagePositionBean bgBean = part.getBackground(); + if (bgBean != null) + { + width = bgBean.getWidth(skinFilesPath); + } + } + + return width; + } + + public int getBackgroundHeight(String partName, File skinFilesPath) + { + int height = -1; + PartBean part = getPartByName(partName); + if (part != null) + { + ImagePositionBean bgBean = part.getBackground(); + if (bgBean != null) + { + height = bgBean.getHeight(skinFilesPath); + } + } + + return height; + } + + public File getButtonImage(String partName, String buttonName) + { + File buttonFile = null; + ImagePositionBean button = getButtonByName(partName, buttonName); + if (button != null) + { + buttonFile = button.getImageLocation(); + } + + return buttonFile; + } + + public Point getButtonPosition(String partName, String buttonName) + { + Point buttonPos = null; + ImagePositionBean button = getButtonByName(partName, buttonName); + if (button != null) + { + buttonPos = + new Point(Integer.parseInt(button.getXPos()), + Integer.parseInt(button.getYPos())); + } + + return buttonPos; + } + + public int getButtonWidth(String partName, String buttonName, File skinFilesPath) + { + int width = -1; + ImagePositionBean button = getButtonByName(partName, buttonName); + if (button != null) + { + width = button.getWidth(skinFilesPath); + } + + return width; + } + + public int getButtonHeight(String partName, String buttonName, File skinFilesPath) + { + int height = -1; + ImagePositionBean button = getButtonByName(partName, buttonName); + if (button != null) + { + height = button.getHeight(skinFilesPath); + } + + return height; + } + + public Point getDisplayPosition(String partName) + { + Point displayPos = null; + + PartBean bean = getPartByName(partName); + if (bean != null) + { + RectangleBean dispBean = bean.getDisplay(); + displayPos = + new Point(Integer.parseInt(dispBean.getXPos()), Integer.parseInt(dispBean + .getYPos())); + } + + return displayPos; + } + + public int getDisplayWidth(String partName) + { + int width = -1; + + PartBean bean = getPartByName(partName); + if (bean != null) + { + RectangleBean dispBean = bean.getDisplay(); + width = Integer.parseInt(dispBean.getWidth()); + } + + return width; + } + + public int getDisplayHeight(String partName) + { + int height = -1; + + PartBean bean = getPartByName(partName); + if (bean != null) + { + RectangleBean dispBean = bean.getDisplay(); + height = Integer.parseInt(dispBean.getHeight()); + } + + return height; + } + + private LayoutBean getLayoutByName(String layoutName) + { + LayoutBean layoutToReturn = null; + + if (layouts != null) + { + Iterator<LayoutBean> it = layouts.iterator(); + while (it.hasNext()) + { + LayoutBean bean = it.next(); + if (bean.getName().equals(layoutName)) + { + layoutToReturn = bean; + break; + } + } + } + + return layoutToReturn; + } + + public PartBean getPartByName(String partName) + { + PartBean partToReturn = null; + + Iterator<PartBean> it = parts.iterator(); + while (it.hasNext()) + { + PartBean bean = it.next(); + if (bean.getName().equals(partName)) + { + partToReturn = bean; + break; + } + } + + return partToReturn; + } + + private ImagePositionBean getButtonByName(String partName, String buttonName) + { + ImagePositionBean buttonToReturn = null; + PartBean pBean = getPartByName(partName); + if (pBean != null) + { + Collection<ImagePositionBean> buttons = pBean.getButtons(); + if (buttons != null) + { + for (ImagePositionBean bBean : buttons) + { + if (bBean.getName().equals(buttonName)) + { + buttonToReturn = bBean; + break; + } + } + } + } + + return buttonToReturn; + } + + /** + * Retrieves a layout main part, i.e. the first part that contains a display + * In future releases, check if it is needed to change this concept of "main part" + * + * @param layoutName The layout which main part is to be discovered + * + * @return The name of the layout main part + */ + public String getMainPartName(String layoutName) + { + String mainPartName = null; + for (LayoutBean layout : layouts) + { + if (layout.getName().equals(layoutName)) + { + Collection<PartRefBean> allRefs = layout.getPartRefs(); + for (PartRefBean partRef : allRefs) + { + String partName = partRef.getPartName(); + for (PartBean aPart : parts) + { + String aPartName = aPart.getName(); + if ((aPartName.equals(partName)) && (aPart.getDisplay() != null)) + { + mainPartName = aPartName; + break; + } + } + if (mainPartName != null) + { + break; + } + } + } + if (mainPartName != null) + { + break; + } + } + + return mainPartName; + } + + public boolean partHasBg(String partName) + { + PartBean part = getPartByName(partName); + ImagePositionBean background = part.getBackground(); + return background != null; + } +} |