Label.java

Go to the documentation of this file.

// -*- mode: java; c-basic-offset: 2; -*-
// Copyright 2009-2011 Google, All Rights reserved
// Copyright 2011-2012 MIT, All rights reserved
// Released under the Apache License, Version 2.0
// http://www.apache.org/licenses/LICENSE-2.0
 
package com.google.appinventor.components.runtime;
 
import com.google.appinventor.components.annotations.DesignerComponent;
import com.google.appinventor.components.annotations.DesignerProperty;
import com.google.appinventor.components.annotations.IsColor;
import com.google.appinventor.components.annotations.PropertyCategory;
import com.google.appinventor.components.annotations.SimpleObject;
import com.google.appinventor.components.annotations.SimpleProperty;
import com.google.appinventor.components.common.ComponentCategory;
import com.google.appinventor.components.common.PropertyTypeConstants;
import com.google.appinventor.components.common.YaVersion;
import com.google.appinventor.components.runtime.util.TextViewUtil;
 
import android.util.Log;
import android.view.View;
import android.widget.LinearLayout;
import android.widget.TextView;
 
@DesignerComponent(version = YaVersion.LABEL_COMPONENT_VERSION,
    description = "A Label displays a piece of text, which is " +
    "specified through the <code>Text</code> property.  Other properties, " +
    "all of which can be set in the Designer or Blocks Editor, control " +
    "the appearance and placement of the text.",
    category = ComponentCategory.USERINTERFACE)
@SimpleObject
public final class Label extends AndroidViewComponent {
 
  // default margin around a label in DPs
  // note that the spacing between adjacent labels will be twice this value
  // because each label has a margin
  private static final int DEFAULT_LABEL_MARGIN = 2;
 
  // default margin in density-independent pixels. This must be
  // computed using the view
  private int defaultLabelMarginInDp = 0;
 
  private final TextView view;
 
  private final LinearLayout.LayoutParams linearLayoutParams;
 
  // Backing for text alignment
  private int textAlignment;
 
  // Backing for background color
  private int backgroundColor;
 
  // Backing for font typeface
  private int fontTypeface;
 
  // Backing for font bold
  private boolean bold;
 
  // Backing for font italic
  private boolean italic;
 
  // Whether or not the label should have a margin
  private boolean hasMargins;
 
  // Backing for text color
  private int textColor;
 
  // Label Format
  private boolean htmlFormat;
 
  // HTML content of the label
  private String htmlContent;
 
  public Label(ComponentContainer container) {
    super(container);
    view = new TextView(container.$context());
 
    // Adds the component to its designated container
    container.$add(this);
 
    // Get the layout parameters to use in setting margins (and potentially
    // other things.
    // There will be a bug if the label view does not have linear layout params.
    // TODO(hal): Generalize this for other types of layouts
    Object lp = view.getLayoutParams();
    // The following instanceof check will fail if we have not previously
    // added the label to the container (Why?)
    if (lp instanceof LinearLayout.LayoutParams) {
        linearLayoutParams = (LinearLayout.LayoutParams) lp;
        defaultLabelMarginInDp = dpToPx(view, DEFAULT_LABEL_MARGIN);
    } else {
      defaultLabelMarginInDp = 0;
      linearLayoutParams = null;
      Log.e("Label", "Error: The label's view does not have linear layout parameters");
      new RuntimeException().printStackTrace();
    }
 
    // Default property values
    TextAlignment(Component.ALIGNMENT_NORMAL);
    BackgroundColor(Component.COLOR_NONE);
    fontTypeface = Component.TYPEFACE_DEFAULT;
    TextViewUtil.setFontTypeface(view, fontTypeface, bold, italic);
    FontSize(Component.FONT_DEFAULT_SIZE);
    Text("");
    TextColor(Component.COLOR_DEFAULT);
    HTMLFormat(false);
    HasMargins(true);
  }
 
  // put this in the right file
  private static int dpToPx(View view, int dp) {
    float density = view.getContext().getResources().getDisplayMetrics().density;
    return Math.round((float)dp * density);
  }
 
  @Override
  public View getView() {
    return view;
  }
 
  @SimpleProperty(
      category = PropertyCategory.APPEARANCE,
      userVisible = false)
  public int TextAlignment() {
    return textAlignment;
  }
 
  @DesignerProperty(editorType = PropertyTypeConstants.PROPERTY_TYPE_TEXTALIGNMENT,
      defaultValue = Component.ALIGNMENT_NORMAL + "")
  @SimpleProperty(
      userVisible = false)
  public void TextAlignment(int alignment) {
    this.textAlignment = alignment;
    TextViewUtil.setAlignment(view, alignment, false);
  }
 
  @SimpleProperty(
      category = PropertyCategory.APPEARANCE)
  @IsColor
  public int BackgroundColor() {
    return backgroundColor;
  }
 
  @DesignerProperty(editorType = PropertyTypeConstants.PROPERTY_TYPE_COLOR,
      defaultValue = Component.DEFAULT_VALUE_COLOR_NONE)
  @SimpleProperty
  public void BackgroundColor(int argb) {
    backgroundColor = argb;
    if (argb != Component.COLOR_DEFAULT) {
      TextViewUtil.setBackgroundColor(view, argb);
    } else {
      TextViewUtil.setBackgroundColor(view, Component.COLOR_NONE);
    }
  }
 
  @SimpleProperty(
      category = PropertyCategory.APPEARANCE,
      userVisible = false)
  public boolean FontBold() {
    return bold;
  }
 
  @DesignerProperty(editorType = PropertyTypeConstants.PROPERTY_TYPE_BOOLEAN,
      defaultValue = "False")
  @SimpleProperty(
      userVisible = false)
  public void FontBold(boolean bold) {
    this.bold = bold;
    TextViewUtil.setFontTypeface(view, fontTypeface, bold, italic);
  }
 
  @SimpleProperty(
      category = PropertyCategory.APPEARANCE,
      userVisible = false)
  public boolean FontItalic() {
    return italic;
  }
 
  @DesignerProperty(editorType = PropertyTypeConstants.PROPERTY_TYPE_BOOLEAN,
      defaultValue = "False")
  @SimpleProperty(
      userVisible = false)
  public void FontItalic(boolean italic) {
    this.italic = italic;
    TextViewUtil.setFontTypeface(view, fontTypeface, bold, italic);
  }
 
  @SimpleProperty(
      category = PropertyCategory.APPEARANCE,
      description = "Reports whether or not the label appears with margins.  All four "
      + "margins (left, right, top, bottom) are the same.  This property has no effect "
      + "in the designer, where labels are always shown with margins.",
      userVisible = true)
  public boolean HasMargins() {
    return hasMargins;
  }
 
  @DesignerProperty(editorType = PropertyTypeConstants.PROPERTY_TYPE_BOOLEAN,
      defaultValue = "True")
  @SimpleProperty(
      userVisible = true)
  public void HasMargins(boolean hasMargins) {
    this.hasMargins = hasMargins;
    setLabelMargins(hasMargins);
  }
 
private void setLabelMargins(boolean hasMargins) {
  int m = hasMargins ? defaultLabelMarginInDp : 0 ;
  linearLayoutParams.setMargins(m, m, m, m);
  view.invalidate();
}
 
  @SimpleProperty(
      category = PropertyCategory.APPEARANCE)
  public float FontSize() {
    return TextViewUtil.getFontSize(view, container.$context());
  }
 
  @DesignerProperty(editorType = PropertyTypeConstants.PROPERTY_TYPE_NON_NEGATIVE_FLOAT,
      defaultValue = Component.FONT_DEFAULT_SIZE + "")
  @SimpleProperty
  public void FontSize(float size) {
    TextViewUtil.setFontSize(view, size);
  }
 
  @SimpleProperty(
      category = PropertyCategory.APPEARANCE,
      userVisible = false)
  public int FontTypeface() {
    return fontTypeface;
  }
 
  @DesignerProperty(editorType = PropertyTypeConstants.PROPERTY_TYPE_TYPEFACE,
      defaultValue = Component.TYPEFACE_DEFAULT + "")
  @SimpleProperty(
      userVisible = false)
  public void FontTypeface(int typeface) {
    fontTypeface = typeface;
    TextViewUtil.setFontTypeface(view, fontTypeface, bold, italic);
  }
 
  @SimpleProperty(
      category = PropertyCategory.APPEARANCE)
  public String Text() {
    return TextViewUtil.getText(view);
  }
 
  @DesignerProperty(editorType = PropertyTypeConstants.PROPERTY_TYPE_TEXTAREA,
      defaultValue = "")
  @SimpleProperty
  public void Text(String text) {
    if (htmlFormat) {
      TextViewUtil.setTextHTML(view, text);
    } else {
      TextViewUtil.setText(view, text);
    }
    htmlContent = text;
  }
 
  @SimpleProperty
  public String HTMLContent() {
    if (htmlFormat) {
      return htmlContent;
    } else {
      return TextViewUtil.getText(view);
    }
  }
 
 
  @SimpleProperty(
      category = PropertyCategory.APPEARANCE,
      description = "If true, then this label will show html text else it " +
      "will show plain text. Note: Not all HTML is supported.")
  public boolean HTMLFormat() {
    return htmlFormat;
  }
 
  @DesignerProperty(editorType = PropertyTypeConstants.PROPERTY_TYPE_BOOLEAN,
      defaultValue = "False")
  @SimpleProperty(userVisible = false)
  public void HTMLFormat(boolean fmt) {
    htmlFormat = fmt;
    if (htmlFormat) {
      String txt = TextViewUtil.getText(view);
      TextViewUtil.setTextHTML(view, txt);
    } else {
      String txt = TextViewUtil.getText(view);
      TextViewUtil.setText(view, txt);
    }
  }
 
  @SimpleProperty(
      category = PropertyCategory.APPEARANCE)
  @IsColor
  public int TextColor() {
    return textColor;
  }
 
  @DesignerProperty(editorType = PropertyTypeConstants.PROPERTY_TYPE_COLOR,
      defaultValue = Component.DEFAULT_VALUE_COLOR_BLACK)
  @SimpleProperty
  public void TextColor(int argb) {
    textColor = argb;
    if (argb != Component.COLOR_DEFAULT) {
      TextViewUtil.setTextColor(view, argb);
    } else {
      TextViewUtil.setTextColor(view, container.$form().isDarkTheme() ? Component.COLOR_WHITE : Component.COLOR_BLACK);
    }
  }
}