protected void btnSave_Click(object sender, EventArgs e)
    {

        InventoryManager iManager = new InventoryManager(this);
        Inventory inventory = new Inventory();

        inventory.ProductId = Convert.ToInt32(cboProducts.SelectedValue);
        inventory.DepositId = Convert.ToInt32(cboDeposit.SelectedValue);
        inventory.CompanyId = Company.CompanyId;

        try
        {
            iManager.InventoryDrop(inventory, ucCurrFieldQuantity.IntValue, (int)DropType.Transfer, null);
        }
        catch (InvalidOperationException ex)
        {

            ShowError(Resources.Exception.InvalidStockQuantity);
            return;

        }

        ClientScript.RegisterClientScriptBlock(this.GetType(), "", "alert('Baixa no Estoque efetuada com sucesso!');", true);

    }

        /// <summary>
        /// </summary>
        /// <param name="manager"></param>
        /// <param name="ii"></param>
        internal InventoryNotecard(InventoryManager manager, InventoryItem ii)
			: base( manager, ii._Name, ii._Description, ii._FolderID, ii._InvType, ii._Type, ii._CreatorID)
		{
            if ((ii.InvType != 7) || (ii.Type != (sbyte)Asset.AssetType.Notecard))
			{
				throw new Exception("The InventoryItem cannot be converted to a Notecard, wrong InvType/Type.");
			}

			this.iManager = manager;
            this._ItemID = ii._ItemID;
			this._Asset = ii._Asset;
			this._AssetID = ii._AssetID;
			this._BaseMask = ii._BaseMask;
			this._CRC = ii._CRC;
			this._CreationDate = ii._CreationDate;
			this._EveryoneMask = ii._EveryoneMask;
			this._Flags = ii._Flags;
			this._GroupID = ii._GroupID;
			this._GroupMask = ii._GroupMask;
			this._GroupOwned = ii._GroupOwned;
			this._InvType = ii._InvType;
			this._NextOwnerMask = ii._NextOwnerMask;
			this._OwnerID = ii._OwnerID;
			this._OwnerMask = ii._OwnerMask;
			this._SalePrice = ii._SalePrice;
			this._SaleType = ii._SaleType;
			this._Type = ii._Type;
		}

        internal InventoryItem(InventoryManager manager, InventoryDescendentsPacket.ItemDataBlock itemData)
            : base(manager)
        {
            _Name = System.Text.Encoding.UTF8.GetString(itemData.Name).Trim().Replace("\0", "");
            _Description = System.Text.Encoding.UTF8.GetString(itemData.Description).Trim().Replace("\0", "");
            _CreationDate = itemData.CreationDate;

            _InvType = itemData.InvType;
            _Type = itemData.Type;

            _AssetID = itemData.AssetID;
            _FolderID = itemData.FolderID;

            _GroupOwned = itemData.GroupOwned;
            _GroupID = itemData.GroupID;
            _GroupMask = itemData.GroupMask;

            _CreatorID = itemData.CreatorID;
            _OwnerID = itemData.OwnerID;
            _OwnerMask = itemData.OwnerMask;

            _Flags = itemData.Flags;
            _BaseMask = itemData.BaseMask;
            _EveryoneMask = itemData.EveryoneMask;
            _NextOwnerMask = itemData.NextOwnerMask;

            _SaleType = itemData.SaleType;
            _SalePrice = itemData.SalePrice;

            _CRC = itemData.CRC;
        }

        internal InventoryImage( InventoryManager manager, InventoryItem ii )
            : base(manager, ii._Name, ii._Description, ii._FolderID, ii._InvType, ii._Type, ii._CreatorID)
        {
            if( (ii.InvType != 0) || (ii.Type != Asset.ASSET_TYPE_IMAGE) )
            {
                throw new Exception("The InventoryItem cannot be converted to a Image/Texture, wrong InvType/Type.");
            }

            this.iManager = manager;
            this._Asset = ii._Asset;
            this._AssetID = ii._AssetID;
            this._BaseMask = ii._BaseMask;
            this._CRC = ii._CRC;
            this._CreationDate = ii._CreationDate;
            this._EveryoneMask = ii._EveryoneMask;
            this._Flags = ii._Flags;
            this._GroupID = ii._GroupID;
            this._GroupMask = ii._GroupMask;
            this._GroupOwned = ii._GroupOwned;
            this._InvType = ii._InvType;
            this._NextOwnerMask = ii._NextOwnerMask;
            this._OwnerID = ii._OwnerID;
            this._OwnerMask = ii._OwnerMask;
            this._SalePrice = ii._SalePrice;
            this._SaleType = ii._SaleType;
            this._Type = ii._Type;
        }

 // Use this for initialization
 void Start()
 {
     DeactivateTooltip();
     CanvasRectTransform = Canvas.GetComponent<RectTransform>();
     RectTransform = TooltipPanel.GetComponent<RectTransform>();
     InventoryManager = GameObject.FindGameObjectWithTag("InventoryManager").GetComponent<InventoryManager>();
 }

 public ComposeManager(InventoryManager inventoryManager)
 {
     m_inventoryManager = inventoryManager;
     AddListener();
     m_versionID = inventoryManager.m_versionId;
     Instance = this;
 }

 internal InventoryFolder(InventoryManager manager, String name, LLUUID folderID, LLUUID parentID, sbyte Type)
     : base(manager)
 {
     this._Name = name;
     this._FolderID = folderID;
     this._ParentID = parentID;
     this._Type = Type;
 }

 /// <summary>
 /// </summary>
 /// <param name="manager"></param>
 internal InventoryBase(InventoryManager manager)
 {
     if( manager == null )
     {
         throw new Exception( "Inventory Manager cannot be null" );
     }
     iManager = manager;
 }

 internal InventoryFolder(InventoryManager manager, Dictionary<string, string> htData)
     : base(manager)
 {
     this._Name = htData["name"];
     this._FolderID = new LLUUID(htData["folder_id"]);
     this._ParentID = new LLUUID(htData["parent_id"]);
     this._Type = sbyte.Parse(htData["type_default"].ToString());
 }

    public DecomposeManager(Dictionary<int, ItemParent> _equipmentDic, InventoryManager _inventory)
    {
        Instance = this;
        m_inventory = _inventory;
        m_equipmentDic = _equipmentDic;
        m_versionID = m_inventory.m_versionId;
        AddListener();

    }

	void Awake() {
		Player = GetComponent<PlayerManager>();
		Inventory = GetComponent<InventoryManager>();

		_startSequence = new List<IGameManager>();
		_startSequence.Add(Player);
		_startSequence.Add(Inventory);

		StartCoroutine(StartupManager());
	}

	public virtual void Start() {
		inventory = FindObjectOfType<InventoryManager>();
		
		SetSelectable();
		
		baseColors = new Color[parts.Length];
		baseMaterials = new Material[parts.Length];
		for (int i = 0; i < parts.Length; i++) {
			baseColors[i] = parts[i].renderer.material.color;
			baseMaterials[i] = parts[i].renderer.material;
		}		
	}

        public CharacterEntity(Game mGame, int mX, int mY, int mZ, string mName, bool mHostile)
            : base(mGame, mX, mY, mZ, mName)
        {
            _statusManager = new StatusManager();
            _inventoryManager = new InventoryManager();
            behaviors = new List<Behavior>();
            visibleThisTurn = new List<Entity>();
            perceptionRange = 20;
            hostile = mHostile;

            Game.LogAdd("#" + UID + ": new 'CharacterEntity' named '" + Name + "' - (" + X + ";" + Y + ")", true);
        }

	void OnEnable()
	{
		GlobalEvents.AddListener<AddItemToMixerEvent>(AddItemToMix);
		if (interactableScript == null)
		{
			interactableScript = GetComponent<ItemMixer>();
		}
		if (null == inventory)
		{
			inventory = GameObject.FindGameObjectWithTag("Inventory").GetComponent<InventoryManager>();
		}
	}

    protected void grdReceive_RowDeleting(object sender, GridViewDeleteEventArgs e)
    {
        InventoryManager invManager = new InventoryManager(this);
        InventoryMoviment movement = new InventoryMoviment();

        int movementId = Convert.ToInt16(grdReceive.DataKeys[e.RowIndex]["InventoryMovementId"]);
        int destinationCompanyId = Convert.ToInt16(grdReceive.DataKeys[e.RowIndex]["CompanyDestinationId"]);

        invManager.RefuseMovement(movementId);

        grdReceive.DataBind();
        e.Cancel = true;
    }

        public void GetCar()
        {
            Car existingCar = new Car() { CarId = 1 };

            Mock<IDataRepositoryFactory> mockDataRepositoryFactory = new Mock<IDataRepositoryFactory>();
            mockDataRepositoryFactory.Setup(mock => mock.GetDataRepository<ICarRepository>().Get(1)).Returns(existingCar);

            InventoryManager manager = new InventoryManager(mockDataRepositoryFactory.Object);

            Car retrievedCar = manager.GetCar(1);

            Assert.IsTrue(retrievedCar == existingCar);
        }

        public void UpdateCar_UpdateExisting()
        {
            Car existingCar = new Car() { CarId = 1 };
            Car updatedCar = new Car() { CarId = 1 };

            Mock<IDataRepositoryFactory> mockDataRepositoryFactory = new Mock<IDataRepositoryFactory>();
            mockDataRepositoryFactory.Setup(mock => mock.GetDataRepository<ICarRepository>().Update(existingCar)).Returns(updatedCar);

            InventoryManager manager = new InventoryManager(mockDataRepositoryFactory.Object);

            Car updateCarResults = manager.UpdateCar(existingCar);

            Assert.IsTrue(updateCarResults == updatedCar);
        }

        public void UpdateCar_AddNew()
        {
            Car newCar = new Car();
            Car addedCar = new Car() { CarId = 1 };

            Mock<IDataRepositoryFactory> mockDataRepositoryFactory = new Mock<IDataRepositoryFactory>();
            mockDataRepositoryFactory.Setup(mock => mock.GetDataRepository<ICarRepository>().Add(newCar)).Returns(addedCar);

            InventoryManager manager = new InventoryManager(mockDataRepositoryFactory.Object);

            Car updateCarResults = manager.UpdateCar(newCar);

            Assert.IsTrue(updateCarResults == addedCar);
        }

        public void UpdateCar_update_existing()
        {
            Car existingCar = new Car() { CarId = 1 };
            Car updatedCar = new Car() { CarId = 1 };

            var mockRepositoryFactory = new Mock<IDataRepositoryFactory>();
            mockRepositoryFactory.Setup(obj => obj.GetDataRepository<ICarRepository>().Update(existingCar)).Returns(updatedCar);

            var manager = new InventoryManager(mockRepositoryFactory.Object);

            var results = manager.UpdateCar(existingCar);

            Assert.IsTrue(results == updatedCar);
        }

        public void UpdateCar_add_new()
        {
            var newCar = new Car();
            var addedCar = new Car() { CarId = 1 };

            var mockRepositoryFactory = new Mock<IDataRepositoryFactory>();
            mockRepositoryFactory.Setup(obj => obj.GetDataRepository<ICarRepository>().Add(newCar)).Returns(addedCar);

            var manager = new InventoryManager(mockRepositoryFactory.Object);

            var results = manager.UpdateCar(newCar);

            Assert.IsTrue(results == addedCar);
        }