/*
 * Copyright 2009 Google Inc.
 * 
 * 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.google.gwt.layout.client;

import com.google.gwt.dom.client.Element;
import com.google.gwt.dom.client.Node;
import com.google.gwt.dom.client.NodeList;
import com.google.gwt.dom.client.Style;
import com.google.gwt.dom.client.Style.Display;
import com.google.gwt.dom.client.Style.Unit;
import com.google.gwt.layout.client.Layout.Layer;

/**
 * This implementation is used on IE8. Unlike {@code LayoutImpl}, it converts
 * all values to pixels before setting them. This is necessary because this
 * browser incorrectly calculates the relative sizes and positions of CSS
 * properties specified in certain units (e.g., when the value of an 'em' is
 * non-integral in pixels).
 */
public class LayoutImplIE8 extends LayoutImpl {

  private static native Layer getLayer(Element container) /*-{
    return container.__layer;
  }-*/;

  private static native void setLayer(Element container, Layer layer) /*-{
    // Potential leak: This is cleaned up in detach().
    container.__layer = layer;
  }-*/;

  @Override
  public void layout(Layer layer) {
    Style style = layer.container.getStyle();
    setLayer(layer.container, layer);

    // Whenever the visibility of a layer changes, we need to ensure that
    // layout() is run again for it. This is because the translation of units
    // to pixel values will be incorrect for invisible elements, and thus must
    // be fixed when they become visible.
    if (layer.visible) {
      String oldDisplay = style.getDisplay();
      style.clearDisplay();

      // We control the layer element, so assume that any non-zero display
      // property means it was set to 'none'.
      if (oldDisplay.length() > 0) {
        updateVisibility(layer.container);
      }
    } else {
      style.setDisplay(Display.NONE);
    }

    if (layer.setLeft) {
      setValue(layer, "left", layer.left, layer.leftUnit, false, false);
    } else {
      style.clearLeft();
    }
    if (layer.setRight) {
      setValue(layer, "right", layer.right, layer.rightUnit, false, false);
    } else {
      style.clearRight();
    }
    if (layer.setTop) {
      setValue(layer, "top", layer.top, layer.topUnit, true, false);
    } else {
      style.clearTop();
    }
    if (layer.setBottom) {
      setValue(layer, "bottom", layer.bottom, layer.bottomUnit, true, false);
    } else {
      style.clearBottom();
    }
    if (layer.setWidth) {
      setValue(layer, "width", layer.width, layer.widthUnit, false, true);
    } else {
      style.clearWidth();
    }
    if (layer.setHeight) {
      setValue(layer, "height", layer.height, layer.heightUnit, true, true);
    } else {
      style.clearHeight();
    }

    style = layer.child.getStyle();
    switch (layer.hPos) {
      case BEGIN:
        style.setLeft(0, Unit.PX);
        style.clearRight();
        break;
      case END:
        style.clearLeft();
        style.setRight(0, Unit.PX);
        break;
      case STRETCH:
        style.setLeft(0, Unit.PX);
        style.setRight(0, Unit.PX);
        break;
    }

    switch (layer.vPos) {
      case BEGIN:
        style.setTop(0, Unit.PX);
        style.clearBottom();
        break;
      case END:
        style.clearTop();
        style.setBottom(0, Unit.PX);
        break;
      case STRETCH:
        style.setTop(0, Unit.PX);
        style.setBottom(0, Unit.PX);
        break;
    }
  }

  @Override
  public void onDetach(Element parent) {
    removeLayerRefs(parent);
  }

  private native void removeLayerRefs(Element parent) /*-{
    for (var i = 0; i < parent.childNodes.length; ++i) {
      var container = parent.childNodes[i];
      if (container.__layer) {
        container.__layer = null;
      }
    }
  }-*/;

  private void setValue(Layer layer, String prop, double value, Unit unit,
      boolean vertical, boolean noNegative) {
    switch (unit) {
      case PX:
      case PCT:
        // Leave PX and PCT alone. PX doesn't need to be translated, and PCT
        // can't be.
        break;

      default:
        value = value * getUnitSizeInPixels(layer.container, unit, vertical);
        value = (int) (value + 0.5); // Round to the nearest pixel.
        unit = Unit.PX;
        break;
    }

    if (noNegative) {
      if (value < 0) {
        value = 0;
      }
    }

    layer.getContainerElement().getStyle().setProperty(prop, value, unit);
  }

  private void updateVisibility(Element container) {
    // If this element has an associated layer, re-run layout for it.
    Layer layer = getLayer(container);
    if (layer != null) {
      layout(layer);
    }

    // Walk all children, looking for elements with a '__layer' property. If one
    // exists, call layout() for that element. This is not cheap, but it's the
    // only way to correctly ensure that layout units get translated correctly.
    NodeList<Node> nodes = container.getChildNodes();
    for (int i = 0; i < nodes.getLength(); ++i) {
      Node node = nodes.getItem(i);
      if (node.getNodeType() == Node.ELEMENT_NODE) {
        updateVisibility(node.<Element>cast());
      }
    }
  }
}