/**
 * Project  : AMDA-NG4
 * Name     : ext-override.js
 * @file     ext-override.js

 * @brief   patches for extjs
 * @author  elena (sencha support)
 * @version $Id: ext-override.js 2345 2014-05-13 09:06:43Z elena $
 *******************************************************************************
 *    FT Id     :   Date   : Name - Description
 *******************************************************************************
 *  :           :16/06/2011 : elena  -  creation
 *
 */

Ext.onReady(function () {

  // Fix for #7096
  Ext.override(Ext.dd.DragTracker, {
    constrainModes: {
      point: function (me, xy) {
        var dr = me.dragRegion,
        constrainTo = me.getConstrainRegion();

        if (!constrainTo) {
          return xy;
        }
        dr.x = dr.left = dr[0] = dr.right = xy[0];
        dr.y = dr.top = dr[1] = dr.bottom = xy[1];
        if (!me.gridBugFix)
          dr.constrainTo(constrainTo);

        return [dr.left, dr.top];
      },
      // Constrain the dragTarget to within the constrain region. Return the passed xy adjusted by the same delta.
      dragTarget: function(me, xy) {
        var s = me.startXY,
          dr = me.startRegion.copy(),
          constrainTo = me.getConstrainRegion(),
          adjust;
          // No constraint
          if (!constrainTo) {
            return xy;
          }
          // See where the passed XY would put the dragTarget if translated by the unconstrained offset.
          // If it overflows, we constrain the passed XY to bring the potential
          // region back within the boundary.
          dr.translateBy(xy[0] - s[0], xy[1] - s[1]);
          // Constrain the X coordinate by however much the dragTarget overflows
          if (dr.right > constrainTo.right) {
            xy[0] += adjust = (constrainTo.right - dr.right);
            // overflowed the right
            dr.left += adjust;
          }
          if (dr.left < constrainTo.left) {
            xy[0] += (constrainTo.left - dr.left);
          }
          // overflowed the left
          // Constrain the Y coordinate by however much the dragTarget overflows
          if (dr.bottom > constrainTo.bottom) {
            xy[1] += adjust = (constrainTo.bottom - dr.bottom);
            // overflowed the bottom
            dr.top += adjust;
          }
          if (dr.top < constrainTo.top) {
            xy[1] += (constrainTo.top - dr.top);
          }
          // overflowed the top
          return xy;
        }
    }
  });

// for version 4.1.3 - corrected in 4.2.2
  /*Ext.override(Ext.grid.RowNumberer, {
     renderer: function(value, metaData, record, rowIdx, colIdx, store) {
        var rowspan = this.rowspan;
        if (rowspan){
            metaData.tdAttr = 'rowspan="' + rowspan + '"';
        }

        metaData.tdCls = Ext.baseCSSPrefix + 'grid-cell-special';

        return store.indexOf(record) + 1;
    }
  });*/

//TODO check if needed for  version 4.1.3,  4.2.2
    /*Ext.override(Ext.view.Table, {
      onUpdate : function(store, record, operation, changedFieldNames) {
        var me = this,
            index,
            newRow, oldRow,
            oldCells, newCells, len, i,
            columns, overItemCls,
            isHovered, row;

        if (me.rendered) {
            index = me.store.indexOf(record);
            columns = me.headerCt.getGridColumns();
            overItemCls = me.overItemCls;

            // If we have columns which may *need* updating (think lockable grid child with all columns either locked or unlocked)
            // and the changed record is within our view, then update the view

            if (columns.length && index > -1) {
                newRow = me.bufferRender([record], index)[0];
                oldRow = me.all.item(index);
		if (oldRow){
                isHovered = oldRow.hasCls(overItemCls);
                oldRow.dom.className = newRow.className;
                if(isHovered) {
                    oldRow.addCls(overItemCls);
                }

                // Replace changed cells in the existing row structure with the new version from the rendered row.
                oldCells = oldRow.query(this.cellSelector);
                newCells = Ext.fly(newRow).query(this.cellSelector);
                len = newCells.length;
                // row is the element that contains the cells.  This will be a different element from oldRow when using a rowwrap feature
                row = oldCells[0].parentNode;
                for (i = 0; i < len; i++) {
                    // If the field at this column index was changed, replace the cell.
                    if (me.shouldUpdateCell(columns[i], changedFieldNames)) {
                        row.insertBefore(newCells[i], oldCells[i]);
                        row.removeChild(oldCells[i]);
                    }
                }
		}
                // Maintain selection after update
                // TODO: Move to approriate event handler.
                me.selModel.refresh();
                me.doStripeRows(index, index);
                me.fireEvent('itemupdate', record, index, newRow);
            }
        }
       }
      });*/

//TODO check if needed for  version 4.1.3,  4.2.2
   /*Ext.override(Ext.ZIndexManager, {
      tempHidden: [],
      show: function() {
	var comp, x, y;

	while (comp = this.tempHidden.shift()) {
	  x = comp.x;
	  y = comp.y;

	  comp.show();
	  comp.setPosition(x,y);
      }
    }
    });

    Ext.override(Ext.selection.TreeModel, {

	onRowClick: function (view, record, item, index, e) {
		// Record index will be -1 if the clicked record is a metadata record and not selectable
  		if (index !== -1) {
			if (!this.allowRightMouseSelection(e)) {
				return ;
			}

			//Don't process if it's a right-click over a previously selected record.
			// if (!(e.type === 'contextmenu' && this.isSelected(record))) {
				this.processSelection(view, record, item, index, e);
			// }
		}
	}
    });
	Ext.override(Ext.selection.Model, {
		storeHasSelected: function(record) {
			var store = this.store,
				records,
				len, id, i;

			if (record.hasId() && store.getById(record.getId())) {
				return true;
			} else {
				if (store.buffered) {//on buffered stores the map holds the data items
	                records = [];
	                for (m in store.data.map) {
	                    records = records.concat(store.data.map[m].value);
	                }
	            } else {
	                records = store.data.items;
	            }
				len = records.length;
				id = record.internalId;

				for (i = 0; i < len; ++i) {
					if (id === records[i].internalId) {
						return true;
					}
				}
			}
			return false;
		}
	});*/
});