text: /**
   * @class Ext.fx.target.Sprite
  
   This class represents an animation target for a {@link Ext.draw.Sprite}. In general this class will not be
   created directly, the {@link Ext.draw.Sprite} will be passed to the animation and
   and the appropriate target will be created.
  
   * @markdown
   */
  
  Ext.define('Ext.fx.target.Sprite', {
  
      /* Begin Definitions */
  
      extend: 'Ext.fx.target.Target',
  
      /* End Definitions */
  
      type: 'draw',
  
      getFromPrim: function (sprite, attr) {
          var obj;
          switch (attr) {
              case 'rotate':
              case 'rotation':
                  obj = sprite.attr.rotation;
                  return {
                      x: obj.x || 0,
                      y: obj.y || 0,
                      degrees: obj.degrees || 0
                  };
              case 'scale':
              case 'scaling':
                  obj = sprite.attr.scaling;
                  return {
                      x: obj.x || 1,
                      y: obj.y || 1,
                      cx: obj.cx || 0,
                      cy: obj.cy || 0
                  };
              case 'translate':
              case 'translation':
                  obj = sprite.attr.translation;
                  return {
                      x: obj.x || 0,
                      y: obj.y || 0
                  };
              default:
                  return sprite.attr[attr];
          }
      },
  
      getAttr: function (attr, val) {
          return [
              [this.target, val != undefined ? val : this.getFromPrim(this.target, attr)]
          ];
      },
  
      setAttr: function (targetData) {
          var ln = targetData.length,
              spriteArr = [],
              attrsConf, attr, attrArr, attrs, sprite, idx, value, i, j, x, y, ln2;
          for (i = 0; i < ln; i++) {
              attrsConf = targetData[i].attrs;
              for (attr in attrsConf) {
                  attrArr = attrsConf[attr];
                  ln2 = attrArr.length;
                  for (j = 0; j < ln2; j++) {
                      sprite = attrArr[j][0];
                      attrs = attrArr[j][1];
                      if (attr === 'translate' || attr === 'translation') {
                          value = {
                              x: attrs.x,
                              y: attrs.y
                          };
                      }
                      else if (attr === 'rotate' || attr === 'rotation') {
                          x = attrs.x;
                          if (isNaN(x)) {
                              x = null;
                          }
                          y = attrs.y;
                          if (isNaN(y)) {
                              y = null;
                          }
                          value = {
                              degrees: attrs.degrees,
                              x: x,
                              y: y
                          };
                      } else if (attr === 'scale' || attr === 'scaling') {
                          x = attrs.x;
                          if (isNaN(x)) {
                              x = null;
                          }
                          y = attrs.y;
                          if (isNaN(y)) {
                              y = null;
                          }
                          value = {
                              x: x,
                              y: y,
                              cx: attrs.cx,
                              cy: attrs.cy
                          };
                      }
                      else if (attr === 'width' || attr === 'height' || attr === 'x' || attr === 'y') {
                          value = parseFloat(attrs);
                      }
                      else {
                          value = attrs;
                      }
                      idx = Ext.Array.indexOf(spriteArr, sprite);
                      if (idx == -1) {
                          spriteArr.push([sprite, {}]);
                          idx = spriteArr.length - 1;
                      }
                      spriteArr[idx][1][attr] = value;
                  }
              }
          }
          ln = spriteArr.length;
          for (i = 0; i < ln; i++) {
              spriteArr[i][0].setAttributes(spriteArr[i][1]);
          }
          this.target.redraw();
      }
  });
  