Mobile native Wearable native

EDJE Data Collection Reference

A typical Edje file starts with the following definitions:

images {}
fonts {}
color_classes {}
styles {}
collections 
{
   sounds 
   {
      tone: "tone-1" 2300;
      tone: "tone-2" 2300;
      sample 
      {
         name: "sound1" RAW;
         source: "sound_file1.wav";
      }
   }
   group {}
   group {}
}
Note
This reference is based on original work from Andres Blanc (dresb) andresblanc@gmail.com, and it has been heavily expanded and edited since then.

The following list shows the details of the top-level blocks.

  • images block: 
    images 
{
   image: "filename1.ext" COMP;
   image: "filename2.ext" LOSSY 99;
   set {}
   set {}
}

    The images block is used to list the image files used in the theme. The used compression methods are also defined here. In addition to the top-level, the images blocks can be included inside other blocks, usually collections, group, and part. Using the images block on the top-level makes file list maintenance easier, when the theme is split among multiple files.

    • image [image file] [compression method] (compression level)

      This property is included for each image file. The full path to the directory holding the image can be defined later with the edje_cc tool's -id option. The available compression methods are:

      • RAW: Uncompressed
      • COMP: Lossless compression
      • LOSSY [0-100]: JPEG lossy compression with quality from 0 to 100
      • USER: Not embedded in the file, refer to an external file instead
    • images.set block 
      set 
{
   name: "image_name_used";
   image {}
   image {}
}

      The set block is used to define an image with different content depending on its size. In addition to the top-level, the set blocks can be included inside other blocks, normally collections, group, and part. Using the set block on the top-level makes file list maintenance easier, when the theme is split among multiple files.

      • name [image name]

        Sets the name of this image description.

      • images.set.image block 
        image 
{
   image: "filename4.ext" COMP;
   size: 51 51 200 200;
   border: 0 0 0 0;
   border_scale_by: 0.0;
}

        The image block defines the characteristics of an image. Every block describes one image and the size rule to use it. For full details, see Image.

        • image [image file] [compression method] (compression level)

          This property is included for each image file. The full path to the directory holding the image can be defined later with the edje_cc tool's -id option.

        • size [minw] [minh] [maxw] [maxh]

          Sets the minimum and maximum size that selects a specific image.

        • border [left] [right] [top] [bottom]

          If set, the width (in pixels) of each side of the image is displayed as a fixed size border, from the side inwards, preventing the corners from being changed on a resize.

        • border_scale_by [value]

          If border scaling is enabled, normally the output border sizes scale accordingly. For example, if 3 pixels on the left edge are set as a border, then normally at scale 1.0, those 3 columns are always the exact 3 columns of output, or at scale 2.0 they are 6 columns, or 0.33 they merge into a single column. This property multiplies the input scale factor by this multiplier, allowing the creation of supersampled borders to enable higher resolution outputs by always using the highest resolution artwork and then at runtime scaling it down. Valid values are: 0.0 or bigger (0.0 or 1.0 to switch it off).

  • fonts block 
    fonts
{
   font: "filename1.ext" "fontname";
   font: "filename2.ext" "otherfontname";
}

    The fonts block is used to list each font file with an alias used later in the theme. As with the images block, additional fonts blocks can be included inside other blocks.

    • font [font filename] [font alias]

      This property is included for each font, and it defines the font file and alias. The full path to the directory containing the font files can be defined later with the edje_cc tool's -fd option.

  • data block 
    data 
{
   item: "key" "value";
   file: "otherkey" "filename.ext";
}

    The data block behaves in the same way as the data block inside the parts block, but the usage is different: this block is useful for data that covers the whole theme, such as license information, version, and authors.

  • color_classes block 
    color_classes 
{
   color_class 
   {
      name: "colorclassname";
      color: [0-255] [0-255] [0-255] [0-255];
      color2: [0-255] [0-255] [0-255] [0-255];
      color3: [0-255] [0-255] [0-255] [0-255];
   }
}

    The color_classes block contains one or more color_class blocks. Each color_class block allows you to name an arbitrary group of colors to be used in the theme. The application can use that name to alter the color values at runtime.

    • name [color class name]

      Sets the name for the color class, and is used as a reference by both the theme and the application.

    • color [red] [green] [blue] [alpha]

      Sets the main color.

    • color2 [red] [green] [blue] [alpha]

      Used as an outline in text and textblock parts.

    • color3 [red] [green] [blue] [alpha]

      Used as a shadow in text and textblock parts.

  • styles block 
    styles 
{
   style 
   {
      name: "stylename";
      base: "..default style properties..";
      tag: "tagname" "..style properties..";
   }
}

    The styles block contains one or more style blocks. A style block is used to create style <tags> for advanced textblock formatting.

    • name [style name]

      Sets the name of the style to be used as a reference later in the theme.

    • base [style properties string]

      Sets the default style properties applied to the complete text. The following tags can be used in the style property:

      • font
      • font_size
        Note
        The font size is a point size, and the size of the rendered text is affected by the ppi information. The system basic ppi is 96, and you can change it in the Emulator menu.
      • color
      • color_class
      • text_class
      • ellipsis
      • wrap
      • style
      • valign
      • align
    • tag [tag name] [style properties string]

      Sets the style to be applied only to text between style <tags>..</tags>. When creating paired tags, like <bold></bold>, a '+' sign must be added at the start of the style properties of the first part (<bold>). If the second part (</bold>) is also defined, a '-' sign must be added to its style properties. This applies only to paired tags; single tags, like <tab>, must not have a starting '+'.

      • br
      • tab
      • b
      • match

      The following code is the style sample for the text style:

      style 
{ 
   name: "list_text_main";
   base: "font=Tizen:style=Regular font_size=30 color=#ffffff ellipsis=1.0";
   tag: "br" "\n";\
   tag: "ps" "ps";\
   tag: "tab" "\t";\
   tag: "b" "+ font_weight=Bold";
}
  • collections block 
    collections 
{
   base_scale: 1.8;
   sounds 
   {
      tone: "tone-1" 2300;
      tone: "tone-2" 440;
      sample 
      {
         name: "sound_file1" RAW;
         source: "sound_file1.wav";
      }
   }
   group 
   {
      name: "groupname";
      alias: "anothername;"
      min: width height;
      max: width height;
      parts {}
      scripts {}
      limits {}
      data {}
      programs {}
   }
}

    The collections block is used to list the groups that compose the theme. Additional collections blocks do not prevent overriding group names.

    • base_scale: [scale factor]

      Sets information about the scale factor in the EDC file.

      Object scaling must be defined in the config.xml file of the application to show the application in a proper size in other devices. However, the scaling must be based on the scale 1.0. If the application is based on another scale, this scale must be defined in the config.xml file. This predefined scale is called the base scale.

      The size of a scalable object is multiplied with the device scale value. If the scalable object with the size 10 is created in a device with the scale 1.0, the size of the object is 20 in a device with the scale 2.0, and 40 in a device with the scale 4.0.

      For more information about supporting multiple screens in one EDC, see the Multiple Screen Support guide.

    • sounds block

      The sounds block contains one or more sound sample and tone items.

      • tone [tone name] [frequency]

        Sets the sound of the given frequency.

      • sounds.sample block

        The sample block defines the sound sample.

        • name [sample name] [compression type] (quality)

          Used to include each sound file. The full path to the directory holding the sounds can be defined later with the edje_cc tool's -sd option. The valid compression types are:

          • RAW: Uncompressed
          • COMP: Lossless compression
          • LOSSY [-0.1 - 1.0]: Lossy compression with quality from 0.0 to 1.0
          • AS_IS: No compression or encoding, write the file information as it is
        • source [file name]

          Sets the sound source file name (mono or stereo WAV file; only files with the 44.1 KHz sample rate are supported for now).

    • group block

      The group block defines Edje Objects.

Group Block

group
{
   name: "nameusedbytheapplication";
   alias: "anothername";
   min: width height;
   max: width height;
   parts 
   {
      <definitions of parts>
   }
   script 
   {
      <embryo script>
   }
   limits 
   {
      vertical: "limit_name" height_barrier;
      horizontal: "limit_name" width_barrier;
   }
   data 
   {
      items: "key" "value";
      file: "key" "file";
   }
   programs {}
}

The group block contains a list of parts and programs that compose a given Edje Object.

  • name [group name]

    Sets the name used by the application to load the resulting Edje object and to identify the group to swallow in a group part. If a group with the same name exists already, it is completely overridden by the new group.

  • inherit_only [1 or 0]

    Flags the group as being used only for inheriting, which inhibits the edje_cc tool from resolving programs and parts that do not exist in this group, but are located in the group which is inheriting this group.

  • inherit [parent group name]

    Sets the parent group name for inheritance. The inherit property is used to inherit any predefined group and change some properties which belong to a part, description, items, or program. The child group has the same properties as its parent group. If you specify the type again in an inherited part, it causes an error.

    Note
    When inheriting any parts, descriptions without state names are not allowed.
  • script_recursion [1/0]

    Determines whether to error on unsafe calls when recursively running Embryo programs. For example, running an Embryo script which calls EDC that has a script{} block is unsafe, and the outer-most (first) Embryo stack is corrupted. It is strongly unadvisable to use this flag.

  • alias [additional group name]

    Sets the additional name to be used as an identifier. Defining multiple aliases is supported.

  • min [width] [height]

    Sets the minimum size for the container defined by the composition of the parts. It is not enforced.

  • max [width] [height]

    Sets the maximum size for the container defined by the totality of the parts. It is not enforced.

  • broadcast_signal [on/off]

    Determines whether a signal gets automatically broadcasted to all sub group parts. The default value is on.

  • orientation [AUTO/LTR/RTL]

    Sets the group orientation. It is useful if you want to match the interface orientation with language.

    • AUTO: Follow system defaults
    • LTR: Used in the Left To Right Languages (Latin)
    • RTL: Used in the Right To Left Languages (Hebrew, Arabic)
  • mouse_events [1 or 0]

    Changes the default value of mouse_events for every part in this group. The default value is 1, to maintain compatibility.

  • program_source [source name]

    Changes the default value of the source in the current group for every program which is declared after this value is set. The value defaults to an unset value to maintain compatibility. The name of the source can be set on every program, but if the name can be defined in the group level, it reduces the effort to indicate it in every program.

  • group.parts block 
    parts 
{
   part {}
   part {}
   part {}
}

    The parts block contains one or more part. Each part describes a visual element and has a type, such as text, image, or table.

  • group.script block 
    group 
{
   script 
   {
      <embryo script>
   }
   program 
   {
      script 
      {
         <embryo script>
      }
   }
}

    The script block is used to inject embryo scripts to a given Edje theme. It functions in two modalities: when it is included inside a program block, the script is executed every time the program is run, and when included directly into a group, part, or description block, it is executed once at the load time, in the load order.

  • group.limits block 
    limits 
{
   vertical: "limit_name" height_barrier;
   horizontal: "limit_name" width_barrier;
}

    The limits block is used to trigger signals when the Edje object is resized.

    • vertical [name] [height barrier]

      Sends a limit,name,over signal when the object is resized and passes the limit by growing over it. When the object's size is reduced below the limit, the limit,name,below signal is sent. This limit is applied on the Y axis and is given in pixels.

    • horizontal [name] [width barrier]

      Sends a limit,name,over signal when the object is resized and passes the limit by growing over it. When the object's size is reduced below the limit, the limit,name,below signal is sent. This limit is applied on the X axis and is given in pixels.

  • group.data block 
    data 
{
   item: "key" "value";
   file: "key2" "somefile";
}

    The data block is used to pass arbitrary parameters from the theme to the application. Unlike the images and fonts blocks, additional data blocks can only be included inside the group block.

    • items: "key" "value";

      Sets a new parameter, the value is the string specified next to it.

    • file: "key" "file";

      Sets a new parameter, the value is the content of the specified file formatted as a single string of text. This property only works with plain text files.

    Note
    For genlist item styles, keys must be texts and icons, respectively for text parts and swallow parts; values must the names of the parts, separated with spaces.
  • group.programs block 
    programs 
{
   program {}
   program {}
   program {}
}

    The programs group contain one or more program. Each program contains code related to the interaction and animation of the visual elements.

Part Block

part
{
   // Inherit all the fields of another part
   inherit: "partname";
   // Name the part
   name: "partname";
   // Set the part type
   type: IMAGE;
   // Enable mouse events on the part
   mouse_events: 0/1;
   // Repeat the mouse events to the parts below the current one
   repeat_events: 0/1;
   ignore_flags: NONE;
   // Set whether the part sizes scale with the edje scaling factor
   scale: 0/1;
   // Set whether fully-transparent pixels are taken into account for collision detection
   precise_is_inside: 0/1;
   // Only render the area of the part that coincides with the given part
   clip_to: "anotherpart";
   // For group/textblock parts: swallow the given group (for textblock: goes below text)
   source: "groupname";
   // Same as the source but goes on top of text
   source2: "groupname";
   // For textblock parts: swallow the given group below the mouse cursor when it hovers over the part
   source3: "groupname";
   // Same as source3 but goes on top of the cursor
   source4: "groupname";
   // For textblock parts: swallow the given group below text anchors (<a>...</a>)
   source5: "groupname";
   // Same as source5 but goes on to top of the anchor
   source6: "groupname";
   // Add a shadow effect to the part
   effect: SOFT_SHADOW (BOTTOM_RIGHT);
   // For textblock parts: makes the text editable, possibly with a specific behavior
   entry_mode: PASSWORD;
   // For textblock parts: change how the text selection is triggered
   select_mode: EXPLICIT;
   // For editable textblock parts: where to draw the (blinking) cursor
   cursor_mode: UNDER;
   // For editable textblock parts: allow multiple lines
   multiline: 0/1;
   // For textblock parts: accessibility features are used
   access: 0/1;
   // No-one uses that
   pointer_mode: AUTOGRAB;
   use_alternate_font_metrics: 0/1;
   // Remove the given program; useful when it was inherited
   program_remove: "programname";
   // Remove the given part; useful when it was inherited
   part_remove: "partname";
   // Insert the current part below the given part, as if it were declared before
   insert_before: "partname";
   // Insert the current part above the given part, as if it were declared after
   insert_after: "partname";
   // Define a new part inside this one
   part 
   {
      <part definition>
   }
   draggable
   {
      // Confine the current part to the given part
      confine: "another part";
      // Only start drag when it has moved enough to be outside the given part
      threshold: "another part";
      // Forward the drag events to the given part instead of handling them
      events: "another draggable part";
      // Enable the horizontal drag of the part with step_size steps or with steps_count steps
      x: 0/1 <step_size> <steps_count>;
      // Same as x but vertical
      y: 1 0 100;
   }
   // For box or table parts
   box/table 
   {
      // List of items
      items 
      {
         item 
         {
            // Define the item type, can only be GROUP
            type: GROUP;
            // Name the item
            name: "name";
            // Set the source for this item, or its content
            source: "groupname";
            // Set the minimum horizontal and vertical item sizes (-1 for expand)
            min: -1 -1;
            // Set the maximum horizontal and vertical item sizes (-1 for ignore)
            max: 100 100;
            // Set the item padding in pixels
            padding: 2 2 2 2;
            spread: 1 1;
            // Set the item alignment
            align: 0.5 0.5;
            // Set a weight hint in the box for the given object
            weight: 1 1;
            // Set the aspect ratio hint
            aspect: 1 1;
            aspect_mode: BOTH;
            // Set the number of columns and rows the item takes
            span: 1 1;
         }
      }
   }
   description 
   {
      // Inherit another description
      inherit: "default" 1.0;
      // Name the current description
      state: "default" 1.0;
      // Use another part as content of the current proxy part 
      // This description only works in the proxy part and the current part mirrors the rendering content of the source part
      source: "partname";
      // Make the part (in)visible (invisible parts emit no signals)
      visible: 0/1;
      // Emit a signal when the given dimension becomes zero or stops being zero
      limit: WIDTH;
      // Set the horizontal and vertical alignment of the part inside its parent
      align: 0.5 0.5;
      // Set that the part does not change size
      fixed: 0/1 0/1;
      // Set the minimum size for the part
      min: 200 200;
      // Forcibly multiply the minimum sizes by the given factors
      minmul: 1.2 1.2;
      // Set the maximum size for the part
      max: 400 400;
      // Make vertical and horizontal resizes happen in steps
      step: 0 0;
      // Force the aspect ratio to be kept between min and max between resizes
      aspect: 0.8 1.2;
      // Set the dimension to which the aspect ratio applies
      aspect_preference: BOTH;
      // Use the given color class which can be used to factor font colors
      color_class: "colorclassname";
      // Set the text color
      color: 255 0 0 255;
      // Set the color of the text shadow
      color2: 0 255 0 255;
      // Set the color of the text outline
      color3: 0 0 255 255;
      // Define the positions of the top-left (rel1) and bottom-right (rel2) corners
      rel1/rel2 
      {
         // Make relative and offset use the given part for their positioning
         to: "partname";
         // Position the corner relative to the part given through to (0.0 being axis beginning, 1.0 being its end)
         relative: 0.1 0.1;
         // Add an absolute offset (in pixels) along each axis
         offset: 10 10;
         // Same as to but only for the X axis
         to_x: "partname";
         // Same as to but only for the Y axis
         to_y: "partname";
      }
      // Settings specific to parts of the image type
      image 
      {
         // Set the name (not path) of the regular image
         normal: "imagename";
         // Set the image to use while transitioning to the normal image; use several times to create animations
         tween: "imagename2";
         // Set the number of pixels that make up each border of the image, and are not resized with the image
         border: 4 4 4 4;
         // Hide, strip from its alpha, or show (default) the non-border part of the image
         middle: DEFAULT;
         border_scale_by: 1.0;
         // Set whether to scale the border
         border_scale: 0/1;
         scale_hint: STATIC;
         // Set how the image is going to fill its part
         fill: 
         {
            // Set whether to smooth the image when scaling it
            smooth: 0/1;
            spread: ??;
            // Set whether to scale or tile to fit when resizing the image is needed
            type: SCALE/TILE;
            // Only display the part of the image that is below and to the right of the given point
            origin 
            {
               // Specify top-left point as relative coordinates
               relative: 0.1 0.1;
               // Specify top-left point as a pixel offset
               offset: 10 10;
            }
            // Specify bottom-right point as relative coordinates
            size 
            {
               // Specify bottom-right point as relative coordinates
               relative: 0.1 0.1;
               // Specify bottom-right point as a pixel offset
               offset: 10 10;
            }
         }
      }
      // Settings specific to parts of the text and textblock type 
      text 
      {
         // Set the part text
         text: "some text";
         // Set the text font
         font: "Tizen Sans";
         // Set the text size
         size: 14;
         // Set the text's class which can be used to factor font and font-size settings
         text_class: "classname";
         // Set the styles defined in stylename
         style: "stylename";
         // For textblocks in the password mode, replace characters to hide with this string
         repch: "*";
         // Set the min and max font sizes allowed when resizing (default is 0 0, or unrestricted)
         size_range: 6 18;
         // Increase the font size as much as possible while still remaining in the container for both axes
         fit: 0/1 0/1;
         // Make the min size of the container equal to the min size of the current text (0 0 by default)
         min: 0/1 0/1;
         // Make the max size of the container equal to the max size of the current text (0 0 by default)
         max: 0/1 0/1;
         // Set the vertical and horizontal alignments of the text
         align: 0.5 0.5;
         // Reuse the text of another part
         text_source: "partname";
         // When the text is too long to fit, set the relative position at which to cut the text and put an ellipsis ("...")
         ellipsis: 0.9;
      }
      // Settings specific to parts of the box type
      box 
      {
         // Set how children are arranged in the box
         layout: horizontal_homogeneous;
         // Set the vertical and horizontal alignments of the box
         align: 0.5 0.5;
         // Set the padding between items of the box
         padding: 1 1;
         // Make the box's min size the min size of its elements (make it shrinkable as much as its items)
         min: 0 1;
      }
      table 
      {
         // Make items homogeneous
         homogeneous: NONE;
         // Set the vertical and horizontal alignments of the table
         align: 0.5 0.5;
         // Set the padding between items of the table
         padding: 1 1;
         // Make the table's min size the min size of its elements (make it shrinkable as much as its items)
         min: 0 1;
      }
      map 
      {
         perspective: "partname";
         light: "partname";
         on: 0/1;
         smooth: 0/1;
         alpha: 0/1;
         backface_cull: 0/1;
         perspective_on: 0/1;
         color: 0/1;
         rotation 
         {
            center: "partname";
            x: 45;
            y: 120;
            z: 90;
         }
         perspective 
         {
            zplane: 0/1;
            focal: 20;
         }
         // Simpler syntax to create transitions to the current part
         link 
         {
            base: "edje,signal" "edje";
         }
      }
   }
}

The part block is used to represent the most basic design elements of the theme, for example, a part can represent a line in a border or a label on a button.

  • inherit [part name]

    Copies all properties except part name from the referenced part into the current part. All existing properties, except part name, are overwritten.

    Note
    When inheriting any parts, descriptions without state names are not allowed.
  • program_remove [program name] (program name) (program name) ...

    Removes the listed programs from an inherited group. Removing non-existing programs is not allowed.

    Note
    This breaks program sequences if a program in the middle of the sequence is removed.
  • part_remove [part name] (part name) (part name) ...

    Removes the listed parts from an inherited group. Removing non-existing parts is not allowed.

  • name [part name]

    Sets the part name is used as a reference in the theme's relative positioning system, by programs and in some cases by the application. The part name must be unique within the group.

  • type [TYPE]

    Sets the type (IMAGE by default). The valid types are:

    • RECT: Rectangle object in the screen
    • TEXT: Simple text
    • IMAGE: Image area
    • SWALLOW: Area where you can add an object
    • TEXTBLOCK: Complex text with, for example, multiple lines or mark-up elements
    • GROUP: Part which can include other groups in the same group
    • BOX: Container object as a container. It has a row or a column.
    • TABLE: Container object as a container. It has a row and column.
    • PROXY: Clone of another part in the same group. It shares the memory of the source part.
    • SPACER: Rectangle object, but invisible. Recommended for padding, because it does not allocate any memory.
  • part [part declaration]

    Sets a nested part that adds hierarchy to Edje. A nested part inherits its location relative to the parent part. To declare a nested part, create a new part within the current part declaration. Define the parent part name before adding nested parts.

    part 
{
   name: "parent_rect";
   type: RECT;
   description {}
   part 
   {
      name: "nested_rect";
      type: RECT;
      description {}
   }
}
  • insert_before [another part's name]

    Sets the part's name which this part is inserted before. One part cannot have both insert_before and insert_after. One part cannot refer to more than one part name by insert_before.

  • insert_after [another part's name]

    Sets the part's name which this part is inserted after. One part cannot have both insert_before and insert_after. One part cannot refer to more than one part name by insert_after.

  • mouse_events [1 or 0]

    Determines whether the part emits signals, although it is named mouse_events. Disabling (0) prevents the part from emitting a signal. The default value is 1, or the value set to mouse_events at the group level.

  • repeat_events [1 or 0]

    Determines whether a part echoes a mouse event to other parts below the pointer (1). The default value is 0.

  • ignore_flags [FLAG] ...

    Determines whether events with the given flags are ignored, or do not emit signals to the parts. Multiple flags must be separated by spaces, the effect is ignoring all events with one of the flags specified. Possible flags are:

    • NONE: Event is handled properly (default value)
    • ON_HOLD: Event is not handled or passed in this part
  • scale [1 or 0]

    Determines whether the part scales its size with an Edje scaling factor. This is used to scale properties, such as font size or min/max size of the part, and it can also be used to scale based on DPI of the target device. The reason to be selective is that some parts are scaled well, others are not, so choose what works best. By default the scaling is off (0) and the default scale factor is 1.0, which means no scaling.

  • pointer_mode [MODE]

    Sets the mouse pointer behavior for a given part. The default value is AUTOGRAB. The available modes are:

    • AUTOGRAB: When the part is clicked and the button remains pressed, the part is the source of all future mouse signals emitted, even outside the object, until the button is released
    • NOGRAB: Effect is limited to the part's container
  • precise_is_inside [1 or 0]

    Enables precise point collision detection for the part, which is more resource-intensive. This setting is disabled by default.

  • use_alternate_font_metrics [1 or 0]

    Determines whether Edje uses different size measurement functions. This setting only affects text and textblock parts, and is disabled by default.

  • clip_to [another part's name]

    Renders only the area of the part that coincides with another part's container. Overflowing content is not displayed. Note that the part being clipped to can only be a rectangle part.

  • source [another group's name]

    Swallows the specified group into the part's container if the source is a group. If the source is a textblock, it is used for the group to be loaded and used for selection display under the selected text. source2 is used on top of the selected text, if source2 is specified.

    Only available to group or textblock parts.

  • source2 [another group's name]

    Used for the group to be loaded and used for selection display over the selected text. source is used under the selected text, if source is specified.

    Only available to textblock parts.

  • source3 [another group's name]

    Used for the group to be loaded and used for cursor display under the cursor position. source4 is used over the cursor text, if source4 is specified.

    Only available to textblock parts.

  • source4 [another group's name]

    Used for the group to be loaded and used for cursor display over the cursor position. source3 is used under the cursor text, if source3 is specified.

    Only available to textblock parts.

  • source5 [another group's name]

    Used for the group to be loaded and used for anchors display under the anchor position. source6 is used over the anchor text, if source6 is specified.

    Only available to textblock parts.

  • source6 [another group's name]

    Used for the group to be loaded and used for anchor display over the anchor position. source5 is used under the anchor text, if source5 is specified.

    Only available to textblock parts.

  • effect [effect] (shadow direction)

    Applies the selected outline, shadow, or glow effect to a textblock. Note that this effect only works for the textblock. The available effects are:

    • PLAIN
    • OUTLINE
    • SOFT_OUTLINE
    • SHADOW
    • SOFT_SHADOW
    • OUTLINE_SHADOW
    • OUTLINE_SOFT_SHADOW
    • FAR_SHADOW
    • FAR_SOFT_SHADOW
    • GLOW

    The available shadow direction definitions are:

    • BOTTOM_RIGHT (default)
    • BOTTOM
    • BOTTOM_LEFT
    • LEFT
    • TOP_LEFT
    • TOP
    • TOP_RIGHT
    • RIGHT
  • entry_mode [mode]

    Sets the edit mode for a textblock part. The available modes are:

    • NONE: Textblock is non-editable
    • PLAIN: Textblock is non-editable, but selectable
    • EDITABLE: Textblock is editable
    • PASSWORD: Textblock is editable if the Edje object has the keyboard focus and the part has the Edje focus (or selectable always regardless of focus). In case of the password mode, the textblock is not selectable and all text characters are replaced with * characters, but they remain editable and pastable.
  • select_mode [mode]

    Sets the selection mode for a textblock part. The available modes are:

    • DEFAULT: Selection mode is what you would expect on any desktop. Press mouse, drag, and release to end.
    • EXPLICIT: Mode requires the application controlling the Edje object to explicitly begin and end selection modes, and the selection itself is draggable at both ends
  • cursor_mode [mode]

    Sets the cursor mode for a textblock part. The available modes are:

    • UNDER: Cursor draws below the character pointed at. This is the default setting.
    • BEFORE: Cursor is drawn as a vertical line before the current character, just like many other GUI toolkits handle it
  • multiline [1 or 0]

    Enables multiple lines for editing in an editable a textblock.

  • access [1 or 0]

    Determines whether the part uses the accessibility feature (1). The default value is 0.

  • draggable block 
    draggable 
{
   confine: "another part";
   threshold: "another part";
   events:  "another draggable part";
   x: 0 0 0;
   y: 0 0 0;
}

    The draggable block enables the part to be dragged around the interface. Do not confuse this feature with external drag and drop. By default, Edje (and most applications) attempts to use the smallest possible size for a draggable part. If the min property is not set in the description, the part is (most likely) set to 0px width and 0px height, thus invisible.

    • x [enable/disable] [step] [count]

      Sets up dragging events for the X axis. The first parameter is used to enable (1 or -1) and disable (0) dragging along the axis. When enabled, 1 sets the starting point at 0.0 and -1 at 1.0. The second parameter takes any integer and limits the movement to values divisible by it, causing the part to jump from position to position. If the step is set to 0, it is calculated as the width of the confine part divided by count.

    • y [enable/disable] [step] [count]

      Sets up dragging events for the Y axis. The first parameter is used to enable (1 or -1) and disable (0) dragging along the axis. When enabled, 1 sets the starting point at 0.0 and -1 at 1.0. The second parameter takes any integer and limits the movement to values divisible by it, causing the part to jump from position to position. If the step is set to 0, it is calculated as the height of the confine part divided by count.

    • confine [another part's name]

      Limits the movement of the dragged part to another part's container. Set a min size for the part, or the dragged object does not show up.

    • threshold [another part's name]

      Allows (when set) the movement of the dragged part start only when it gets moved outside the threshold part.

    • events [another draggable part's name]

      Causes the part to forward the drag events to another part, thus ignoring the drag events for itself.

  • box or table block
    • box.items or table.items block 
      box/table 
{
   items 
   {
      item 
      {
         type: GROUP;
         source: "some source";
         min: -1 -1;
         max: 100 100;
         padding: 1 1 2 2;
      }
      item 
      {
         type: GROUP;
         source: "some other source";
         name: "some name";
         align: 1.0 0.5;
      }
   }
}

      On a box part, the items block is used to set other groups as elements of the box. These elements can be mixed with external objects set by the application through the edje_object_part_box*() functions.

      • box.items.item or table.items.item block

        The item block defines an element within the box or table.

        • type [item type]

          Sets the type of the object this item holds. The supported type is:

          • GROUP (default)
        • name [name for the object]

          Sets the name of the object using the evas_object_name_set() function.

        • source [another group's name]

          Sets the group this object is made of.

        • min [width] [height]

          Sets the minimum size hints for this object.

          Note
          The minimum size hint must be -1 to get the expand behavior.
        • spread [width] [height]

          Replicates the item in a rectangle of size (width x height) box starting from the defined position of this item. The default value is 1 1.

        • prefer [width] [height]

          Sets the preferred size hints for this object.

        • max [width] [height]

          Sets the maximum size hints for this object.

        • padding [left] [right] [top] [bottom]

          Sets the padding hints for this object.

        • align [x] [y]

          Sets the alignment hints for this object.

        • weight [x] [y]

          Sets the weight hints for this object.

        • aspect [w] [h]

          Sets the aspect width and height hints for this object.

        • aspect_mode [mode]

          Sets the aspect control hints for this object. The available hints are:

          • NONE
          • NEITHER
          • HORIZONTAL
          • VERTICAL
          • BOTH
        • options [extra options]

          Sets extra options for the object.

        • position [col] [row]

          Sets the position this item has in the table. This is required for the table type parts only.

        • span [col] [row]

          Sets how many columns and rows this item uses. The default value is 1 1.

  • description block 
    description 
{
   inherit: "another_description" INDEX;
   state: "description_name" INDEX;
   visible: 1;
   min: 0 0;
   max: -1 -1;
   align: 0.5 0.5;
   fixed: 0 0;
   step: 0 0;
   aspect: 1 1;

   rel1 
   {
      ...
   }

   rel2 
   {
      ...
   }
}

    The description block is used to define the style and layout properties of a part in a given state. Every part can have one or more description blocks.

    • inherit [another description's name] [another description's index]

      Sets the description from which all the properties are inherited. The properties defined in this part override the inherited properties, reducing the amount of necessary code for simple state changes. Note that inheritance in Edje is single level only.

    • source [another part's name]

      Causes the part to use another part's content as the content of this part. This works only with a proxy part.

    • state [name for the description] [index]

      Sets the name used to identify a description inside a given part. Multiple descriptions are used to declare different states of the same part, like clicked or invisible. All state declarations are also coupled with an index number between 0.0 and 1.0. All parts must have at least one description named default 0.0.

    • visible [0 or 1]

      Determines whether a part is visible (1). Non-visible parts do not emit signals. The default value is 1.

    • limit [mode]

      Emits a signal when the part size changes from zero or to zero (limit,width,over, limit,width,zero). By default, no signal is emitted. The valid values are:

      • NONE
      • WIDTH
      • HEIGHT
      • BOTH
    • align [X axis] [Y axis]

      When the displayed object's size is smaller or bigger than its container, this property moves it relatively along both axes inside its container. 0.0 means left/top edges of the object touching container's respective ones, and 1.0 stands for right/bottom edges of the object (on horizontal/vertical axis, respectively). The default value is 0.5 0.5. For a more detailed explanation, see Align size hint.

    • fixed [width, 0 or 1] [height, 0 or 1]

      Sets the minimum size calculation. See the edje_object_size_min_calc() and edje_object_size_min_restricted_calc() functions of the Edje Object Geometry API (in mobile and wearable applications). The value tells the min size calculation routine where this part does not change size in width or height (1 for it does not, 0 for it does), so the routine does not try to expand or contract the part.

    • min [width] [height] or SOURCE

      Sets the minimum size of the state. When the property is set to SOURCE, it looks at the original image size and enforces its minimal size to match at least the original one. The part must be an image or a group part.

    • minmul [width multiplier] [height multiplier]

      Sets the multiplier forcibly applied to whatever minimum size is only during minimum size calculation.

    • max [width] [height] or SOURCE

      Sets the maximum size of the state. A size of -1.0 means that it is ignored in one direction. When the property is set to SOURCE, Edje enforces the part to be not more than the original image size. The part must be an image part.

    • step [width] [height]

      Restricts resizing of each dimension to values divisible by its value. This causes the part to jump from value to value while resizing. The default value is 0 0, which disables stepping.

    • aspect [min] [max]

      Forces the width to height ratio to be kept between the minimum and maximum set. For example, 1.0 1.0 increases the width a pixel for every pixel added to height. The default value is 0.0 0.0, which disables aspect. For a more detailed explanation, see Minimum size hint. Normally the width and height can be resized to any values independently.

    • aspect_preference [DIMENSION]

      Sets the dimensions to which the aspect property applies. The available options are:

      • BOTH
      • VERTICAL
      • HORIZONTAL
      • SOURCE
      • NONE

      For a more detailed explanation, see Minimum size hint.

    • color_class [color class name]

      Sets the part to use the color values of the named color_class. These values can be overridden by the color, color2, and color3 properties.

    • color [red] [green] [blue] [alpha]

      Sets the main color to the specified values (between 0 and 255).

      Note
      The textblock part is not affected by the color description. Set the color in the text style.
    • color2 [red] [green] [blue] [alpha]

      Sets the text shadow color to the specified values (0 to 255).

    • color3 [red] [green] [blue] [alpha]

      Sets the text outline color to the specified values (0 to 255).

    • description.rel1 or description.rel2 block 
      description 
{
   rel1 
   {
      relative: 0.0 0.0;
      offset:     0   0;
   }
   rel2 
   {
      relative: 1.0 1.0;
      offset:    -1  -1;
   }
}

      The rel1 and rel2 blocks are used to define the position of each corner of the part's container. rel1 refers to the left-top corner and rel2 to the right-down corner.

      • relative [X axis] [Y axis]

        Moves the corner to a relative position inside the container of the relative to part. Values from 0.0 (0%, beginning) to 1.0 (100%, end) on each axis.

      • offset [X axis] [Y axis]

        Affects the corner position a fixed number of pixels along each axis.

      • to [another part's name]

        Positions the corner relative to another part's container. Setting to "" resets this value for inherited parts.

      • to_x [another part's name]

        Positions the corner relative to the X axis of another part's container. This affects the first parameter of the relative property. Setting to "" resets this value for inherited parts.

      • to_y [another part's name]

        Positions the corner relative to the Y axis of another part's container. This affects the second parameter of the relative property. Setting to "" resets this value for inherited parts.

    • description.image block 
      description 
{
   image 
   {
      normal: "filename.ext";
      tween:  "filename2.ext";
      tween:  "filenameN.ext";
      border:  left right top bottom;
      middle:  0/1/NONE/DEFAULT/SOLID;
      fill {}
   }
}

      The image block defines the settings for an image used in a visual element.

      • normal [image's filename]

        Sets the name of the image to be used as previously declared in the images block. In an animation, this is the first and last image displayed. The file name is required in all image parts.

      • tween [image's filename]

        Sets the name of an image to be used in an animation loop. An image block can have none, one, or multiple tween declarations. Images are displayed in the order they are listed, during the transition to the state they are declared in; the normal image is the final state.

      • border [left] [right] [top] [bottom]

        Sets the width (in pixels) of each side of the image displayed as a fixed size border, from the side inwards, preventing the corners from being changed on a resize.

      • middle [mode]

        If a border is set, this value tells Edje whether the rest of the image (not covered by the defined border) is displayed or assumed to be solid (without alpha). The default value is 1/DEFAULT. The available values are:

        • 0 or NONE
        • 1 or DEFAULT
        • SOLID (strip alpha from the image over the middle zone)
      • border_scale_by [value]

        If border scaling is enabled, normally the output border sizes scale accordingly. For example, if 3 pixels on the left edge are set as a border, then normally at scale 1.0, those 3 columns are always exactly 3 columns of output, or at scale 2.0 they are 6 columns, or 0.33 they merge into a single column. This property multiplies the input scale factor by this multiplier, allowing the creation of supersampled borders to make higher resolution outputs possible by always using the highest resolution artwork and then at runtime scaling it down. The value can be: 0.0 or bigger (0.0 or 1.0 to switch it off)

      • border_scale [0/1]

        Tells Edje whether the border is scaled by the object or global Edje scale factors.

      • scale_hint [mode]

        Sets the Evas image scale hint letting the engine more effectively save cached copies of the scaled image, if it makes sense. The valid values are:

        • 0 or NONE
        • DYNAMIC
        • STATIC
      • description.image.fill block 
        image 
{
   fill 
   {
      type: SCALE;
      smooth: 0-1;
      origin {}
      size {}
   }
}

        The fill block is an optional block that defines the way an image part is going to be displayed inside its container. It can be used for tiling (repeating the image) or displaying only part of an image. For more information, see the evas_object_image_fill_set() function of the Image Object Functions API (in mobile and wearable applications).

        • smooth [0 or 1]

          Determines whether the image is smoothed on scaling (1). The default value is 1.

        • spread
        • type [fill type]

          Sets the image fill type. The min part property must be set, it is the size of the tiled image. If the max property is set, the tiled area has the size according to the max value. The valid values are:

          • SCALE: Image is scaled according to the value of the relative and offset properties from the origin and size blocks. This is the default value.
          • TILE: Image is tiled according to the value of the relative and offset properties from the origin and size blocks
        • image.fill.origin block 
          image 
{
   fill 
   {
      origin 
      {
         relative: 0.0 0.0;
         offset: 0 0;
      }
   }
}

          The origin block is used to place the starting point inside the displayed element that is used to render the tile. By default, the origin is set at the element's left-top corner.

          • relative [X axis] [Y axis]

            Sets the starting point relative to the displayed element's content.

          • offset [X axis] [Y axis]

            Affects the starting point a fixed number of pixels along each axis.

        • image.fill.size block 
          image 
{
   fill 
   {
      size 
      {
         relative: 1.0 1.0;
         offset: -1 -1;
      }
   }
}

          The size block defines the tile size of the content that is displayed.

          • relative [width] [height]

            Takes a pair of decimal values that represent the percentage of the original size of the element. For example, 0.5 0.5 represents half the size, while 2.0 2.0 represents double. The default value is 1.0 1.0.

          • offset [X axis] [Y axis]

            Affects the size of the tile a fixed number of pixels along each axis.

    • description.text block 
      text 
{
   text: "some string of text to display";
   font: "font_name";
   size: SIZE;
   text_class: "class_name";
   fit: horizontal vertical;
   min: horizontal vertical;
   max: horizontal vertical;
   align: X-axis Y-axis;
   source: "part_name";
   text_source: "text_part_name";
   style: "stylename";
}

      The text block defines a text part element.

      • text [a string of text, or nothing]

        Sets the default content of a text part, normally the application is the one changing its value.

      • text_class [text class name]

        Sets the name used by the application to alter the font family and size at runtime (similar to color_class).

      • font [font alias]

        Sets the font family to one of the aliases set up in the fonts block. This can be overridden by the application settings.

      • style [the style name]

        Causes the part to use the default style and tags defined in the style block with the specified name.

      • repch [the replacement character string]

        In the password mode, this string is used to replace every character to hide the details of the entry. Normally * is used, but you can use any character you like.

      • size [font size in points (pt)]

        Sets the default font size for the text part. This can be overridden by the application settings.

      • size_range [font min size in points (pt)] [font max size in points (pt)]

        Sets the allowed font size for the text part. Setting min and max to 0 means that sizing is not restricted. This is also the default value.

      • fit [horizontal] [vertical]

        When any of the parameters is set to 1, Edje resizes the text for it to fit in its container. Both are disabled by default.

      • min [horizontal] [vertical]

        When any of the parameters is enabled (1), it forces the minimum size of the container to be equal to the minimum size of the text. The default value is 0 0.

      • max [horizontal] [vertical]

        When any of the parameters is enabled (1), it forces the maximum size of the container to be equal to the maximum size of the text. The default value is 0 0.

      • align [horizontal] [vertical]

        Changes the position of the point of balance inside the container. The default value is 0.5 0.5.

      • source [another TEXT part's name]

        Causes the part to use the text properties (like font and size) of another part and update them as they change.

      • text_source [another TEXT part's name]

        Causes the part to display the text content of another part and update them as they change.

      • ellipsis [point of balance]

        Balances the text in a relative point from 0.0 to 1.0. This point is the last section of the string to be cut out in case of a resize to a smaller size than the text itself. The default value is 0.0.

    • description.box block 
      box 
{
   layout: "vertical";
   padding: 0 2;
   align: 0.5 0.5;
   min: 0 0;
}

      The box block can contain other objects and display them in different layouts, any of the predefined set, or a custom one, set by the application.

      • layout [primary layout] (fallback layout)

        Sets the layout for the box:

        • horizontal (default)
        • vertical
        • horizontal_homogeneous
        • vertical_homogeneous
        • horizontal_max (homogeneous to the max sized child)
        • vertical_max
        • horizontal_flow
        • vertical_flow
        • stack
        • some_other_custom_layout_set_by_the_application

          Set a custom layout as a fallback. For more information, see the edje_box_layout_register() function in the Edje Box Part API (in mobile and wearable applications). If an unregistered layout is used, it defaults to horizontal.

      • align [horizontal] [vertical]

        Changes the position of the point of balance inside the container. The default value is 0.5 0.5.

      • padding [horizontal] [vertical]

        Sets the space between cells in pixels. The default value is 0 0.

      • min [horizontal] [vertical]

        When any of the parameters is enabled (1), it forces the minimum size of the box to be equal to the minimum size of the items. The default value is 0 0.

    • description.table block 
      table 
{
   homogeneous: TABLE;
   padding: 0 2;
   align: 0.5 0.5;
   min: 0 0;
}

      The table block can contain other objects packed in multiple columns and rows, and each item can span across more than one column or row.

      • homogeneous [homogeneous mode]

        Sets the homogeneous mode for the table:

        • NONE: Default
        • TABLE: Available space is evenly divided between children (the space overflows onto other children if too little space is available)
        • ITEM: Size of each item is the largest minimum size of all the items
      • align [horizontal] [vertical]

        Changes the position of the point of balance inside the container. The default value is 0.5 0.5.

      • padding [horizontal] [vertical]

        Sets the space between cells in pixels. The default value is 0 0.

      • min [horizontal] [vertical]

        When any of the parameters is enabled (1), it forces the minimum size of the table to be equal to the minimum size of the items. The default value is 0 0.

    • description.map block 
      map 
{
   perspective: "name";
   light: "name";
   on: 1;
   smooth: 1;
   perspective_on: 1;
   backface_cull: 1;
   alpha: 1;

   rotation 
   {
      ...
   }
}
      • perspective [another part's name]

        Sets the part that is used as the perspective point for giving a part a 3D look. The perspective point must have a perspective section that provides zplane and focal properties. The center of this part is used as the focal point, thus size, color, and visibility are not relevant, just the center point, zplane, and focal are used. This also implicitly enables perspective transforms.

      • light [another part's name]

        Sets the part that is used as the light for calculating the brightness (based on how directly the part's surface is facing the light source point). Like the perspective point part, the center point is used and zplane is used for the z position (0 being the zero-plane where all 2D objects normally live) and positive values being further away into the distance. The light part color property is used as the light color (alpha not used for light color). The color2 property is used for the ambient lighting when calculating brightness (alpha also not used).

      • on [1 or 0]

        Enables mapping for the part. The default value is 0.

      • smooth [1 or 0]

        Enables smooth map rendering. This can be linear interpolation, anisotropic filtering, or anything the engine decides is smooth. This is a best-effort hint and it may not produce precisely the same results in all engines and situations. The default value is 1.

      • alpha [1 or 0]

        Enables the alpha channel when map rendering. The default value is 1.

      • backface_cull [1 or 0]

        Enables backface culling (when the rotated part that normally faces the camera is facing away after being rotated). This means that the object is hidden when the backface is culled.

      • perspective_on [1 or 0]

        Enables perspective when rotating even without a perspective point object. This uses a perspective set for the object itself or for the canvas as a whole as the global perspective with the edje_perspective_set() and edje_perspective_global_set() functions of the Edje Perspective API (in mobile and wearable applications).

      • color [point] [red] [green] [blue] [alpha]

        Sets the color of a vertex in the map. The colors are linearly interpolated between vertex points through the map. The default color of a vertex in a map is white solid (255, 255, 255, 255), which means it has no affect on modifying the part pixels. Currently only 4 points are supported:

        • 0: Left-top point of a part
        • 1: Right-top point of a part
        • 2: Left-bottom point of a part
        • 3: Right-bottom point of a part
      • map.rotation block 
        rotation 
{
   center: "name";
   x: 45.0;
   y: 45.0;
   z: 45.0;
}

        The rotation block rotates the part, optionally with the center on another part.

        • center [another part's name]

          Sets the part that is used as the center of rotation when rotating the part with this description. The part's center point is used as the rotation center when applying rotation around the X, Y and Z axes. If no center is given, the part's original center itself is used for the rotation center.

        • x [X degrees]

          Sets the rotation around the X axis of the part considering the center set. The value is given in degrees.

        • y [Y degrees]

          Sets the rotation around the Y axis of the part considering the center set. The value is given in degrees.

        • z [Z degrees]

          Sets the rotation around the Z axis of the part considering the center set. The value is given in degrees.

      • map.perspective block 
        perspective 
{
   zplane: 0;
   focal: 1000;
}

        The perspective block adds focal and plane perspective to the part. Active if the perspective_on property is true. This must be provided, if the part is being used by another part as its perspective target.

        • zplane [unscaled Z value]

          Sets the Z value that is not scaled. Normally this is 0 as that is the Z distance.

        • focal [distance]

          Sets the distance from the focal Z plane (zplane) and the camera, for example, equating to focal length of the camera.

Program Block

program
{
   // Set the name of the program
   name: "programname";
   // Set the signals which trigger the program
   signal: "signalname";
   // Filter incoming signals depending on the sender name
   source: "partname";
   // Filter incoming signals depending on the part's state
   filter: "partname" "statename";
   // Delay the program by X seconds plus a random time between 0 and Y
   in: 0.3 0.0;
   // Set the action to perform
   action: STATE_SET "statename" state_value;
   // If the action is STATE_SET, define a transition from the current to the target state
   transition: LINEAR 0.5;
   // If the action is SIGNAL_EMIT, set the name of the part which receives the signal
   target: "partname";
   // Run another program after the current one is done
   after: "programname";
   after: "anotherprogram";
}

The program block defines how your interface reacts to events. Programs can change the part state or trigger other events.

  • name [program name]

    Sets the symbolic name of the program as a unique identifier.

  • signal [signal name]

    Sets the signals that cause the program to run. The signal received must match the specified source to run. There can be several signals, but only one signal keyword per program can be used. Also, there are some predefined signals for touch event handling. The predefined signals are:

    • hold,on: Holding on the mouse event matching the source that starts the program
    • hold,off: Holding off the mouse event matching the source that starts the program
    • focus,part,in: Focusing in the matching source that starts the program
    • focus,part,out: Focusing out of the matching source that starts the program
    • mouse,in: Moving the mouse into the matching source that starts the program
    • mouse,out: Moving the mouse out of the matching source that starts the program
    • mouse,move: Moving the mouse in the matching source that starts the program
    • mouse,down,*: Pressing the mouse button in the matching source that starts the program
    • mouse,up,*: Releasing the mouse button in the matching source that starts the program
    • mouse,clicked,*: Clicking any mouse button in the matching source that starts the program
    • mouse,wheel,0,*: Moving the mouse wheel in the matching source that starts the program. A positive number moves up and a negative number moves down.
    • drag,start: Starting a drag of the mouse in the matching source that starts the program. This signal works only in the draggable part.
    • drag,stop: Stopping a drag of the mouse in the matching source that starts the program. This signal works only in the draggable part.
    • drag: Dragging the mouse in the matching source that starts the program. This signal works only in the draggable part.
  • source [source name]

    Sets the source of an accepted signal. There can be several signals, but only one source keyword per program can be used. For example, source: button-* means that signals from any part or program named button-* are accepted.

  • filter [part] [state]

    Filters the signals to be only accepted if the part is in the [state] state. Only 1 filter per program can be used. If the [state] parameter is not given, the source of the event is used instead.

  • in [from] [range]

    Waits [from] seconds before executing the program and add a random number of seconds (from 0 to [range]) to the total waiting time.

  • action [type] (param1) (param2) (param3) (param4)

    Sets the action to be performed by the program. The valid actions (only 1 can be specified) are:

    • STATE_SET: Set the target part state as target state
    • ACTION_STOP: Stop the ongoing transition
    • SIGNAL_EMIT: Emit a signal to the application level. The application can register a callback for handling actions based on the EDC state.
    • DRAG_VAL_SET: Set a value for the draggable part (x, y values)
    • DRAG_VAL_STEP: Set a step for the draggable part (x, y values)
    • DRAG_VAL_PAGE: Set a page for the draggable part (x, y values)
    • FOCUS_SET: Set the focus to the target group
    • PLAY_SAMPLE "sample name" speed (channel): Play a music sample clip

      PLAY_SAMPLE's (optional) channel can be one of:

      • EFFECT/FX
      • BACKGROUND/BG
      • MUSIC/MUS
      • FOREGROUND/FG
      • INTERFACE/UI
      • INPUT
      • ALERT
    • PLAY_TONE "tone name" duration_in_seconds (Range 0.1 to 10.0): Play a predefined tone of a specific duration
    • PLAY_VIBRATION "sample name" repeat (repeat count)
  • transition [type] [length] (interp val 1) (interp val 2) (option)

    Determines how transitions occur using the STATE_SET action. The [type] parameter is the style of the transition and the [length] parameter is a double specifying the number of seconds in which to perform the transition. The valid types are:

    • LIN or LINEAR
    • SIN or SINUSOIDAL
    • ACCEL or ACCELERATE
    • DECEL or DECELERATE
    • ACCEL_FAC or ACCELERATE_FACTOR
    • DECEL_FAC or DECELERATE_FACTOR
    • SIN_FAC or SINUSOIDAL_FACTOR
    • DIVIS or DIVISOR_INTERP
    • BOUNCE
    • SPRING

    The types have the following requirements:

    • ACCEL_FAC, DECEL_FAC, and SIN_FAC need the extra optional interp val 1 to determine the factor of curviness. 1.0 is the same as their non-factor counterparts and 0.0 is equal to linear. Numbers higher than 1.0 make the curve angles steeper with a more pronounced curve point.
    • DIVIS, BOUNCE, and SPRING also require interp val 2 in addition to interp val 1.
    • DIVIS uses [val 1] as the initial gradient start (for example, 0.0 is horizontal, 1.0 is diagonal (linear), and 2.0 is twice the gradient of linear). [val 2] is interpreted as an integer factor defining how much the value swings outside the gradient before going back to the final resting spot at the end. 0.0 for [val 2] is equivalent to a linear interpolation. Note that DIVIS can exceed 1.0.
    • BOUNCE uses [val 2] as the number of bounces (so it is rounded down to the nearest integer value), with [val 1] determining how much the bounce decays; 0.0 gives a linear decay per bounce and higher values give much more decay.
    • SPRING is similar to bounce; [val 2] specifies the number of spring swings and [val 1] specifies the decay, but it can exceed 1.0 on the outer swings.
    • The valid options are:
      • CURRENT: Causes the object to move from its current position. Can be used as the last parameter of any transition type.
  • target [target]

    Sets the program or part on which the specified action acts.

  • after [after]

    Determines the program that is run after the current program completes. The source and signal parameters of a program run as an after are ignored. Multiple after statements can be specified per program.

Note
Except as noted, this content is licensed under LGPLv2.1+.
Go to top