private void DoOpen(AssetList assets, bool alreadyOpen)
 {
   if (alreadyOpen)
   {
     using (List<Asset>.Enumerator enumerator = assets.GetEnumerator())
     {
       while (enumerator.MoveNext())
       {
         Asset current = enumerator.Current;
         bool flag = false;
         int count = this.assetList.Count;
         for (int index = 0; index < count; ++index)
         {
           if (this.assetList[index].path == current.path)
           {
             flag = true;
             this.assetList[index] = current;
             break;
           }
         }
         if (!flag)
           this.assetList.Add(current);
       }
     }
   }
   else
     this.assetList.AddRange((IEnumerable<Asset>) assets);
   this.RefreshList();
 }

		public static void Open(AssetList assets)
		{
			Task task = Provider.Status(assets);
			task.Wait();
			WindowResolve window = WindowResolve.GetWindow();
			window.DoOpen(task.assetList);
		}

 private void DoOpen(AssetList assets, bool alreadyOpen)
 {
     if (alreadyOpen)
     {
         foreach (Asset asset in assets)
         {
             bool flag = false;
             int count = this.assetList.Count;
             for (int i = 0; i < count; i++)
             {
                 if (this.assetList[i].path == asset.path)
                 {
                     flag = true;
                     this.assetList[i] = asset;
                     break;
                 }
             }
             if (!flag)
             {
                 this.assetList.Add(asset);
             }
         }
     }
     else
     {
         this.assetList.AddRange(assets);
     }
     this.RefreshList();
 }

        public void WriteAssetList(AssetList assets, int total, int pagesize, int pagestart)
        {
            writer.WriteStartElement("Assets");

            if (total > -1)
            {
                writer.WriteAttributeString("total", total.ToString());
            }

            if (pagesize > -1)
            {
                writer.WriteAttributeString("pageSize", pagesize.ToString());
            }

            if (pagestart > -1)
            {
                writer.WriteAttributeString("pageStart", pagestart.ToString());
            }

            foreach (var asset in assets)
            {
                WriteAsset(asset);
            }

            writer.WriteEndElement();
        }

 public static void Open(AssetList assets)
 {
     Task task = Provider.Status(assets);
     task.Wait();
     AssetList revert = task.assetList.Filter(true, new Asset.States[] { Asset.States.CheckedOutLocal });
     GetWindow().DoOpen(revert);
 }

 private void DoOpen(AssetList resolve)
 {
     bool includeFolder = true;
     Asset.States[] states = new Asset.States[] { Asset.States.Conflicted };
     this.assetList = resolve.Filter(includeFolder, states);
     this.RefreshList();
 }

 public static void Open(AssetList assets)
 {
     Task task = Provider.Status(assets);
     task.Wait();
     Asset.States[] states = new Asset.States[] { Asset.States.CheckedOutLocal, Asset.States.DeletedLocal, Asset.States.AddedLocal, Asset.States.Missing };
     AssetList revert = task.assetList.Filter(true, states);
     GetWindow().DoOpen(revert);
 }

 private static void UpdateFilesInVCIfNeeded()
 {
     if (Provider.enabled)
     {
         string[] strArray = Directory.GetFiles("Temp/ScriptUpdater/", "*.*", SearchOption.AllDirectories);
         AssetList assets = new AssetList();
         foreach (string str in strArray)
         {
             assets.Add(Provider.GetAssetByPath(str.Replace("Temp/ScriptUpdater/", string.Empty)));
         }
         Task task = Provider.Checkout(assets, CheckoutMode.Exact);
         task.Wait();
         if (<>f__am$cache0 == null)
         {

        public override void Export(AssetList asset, string path)
        {
            var materials = (asset as MaterialList);
            var mat = new MAT();

            foreach (Material material in materials.Entries)
            {
                mat.Materials.Add(
                    new MATMaterial(
                        material.Name,
                        material.Texture.Name
                    )
                );
            }

            mat.Save(path);
        }

 private void DoOpen(ChangeSet change, AssetList assets)
 {
     this.taskSubmit = null;
     this.submitResultCode = 0x100;
     this.submitErrorMessage = null;
     this.changeSet = change;
     this.description = (change != null) ? this.SanitizeDescription(change.description) : "";
     this.assetList = null;
     if (change == null)
     {
         this.taskStatus = Provider.Status(assets);
     }
     else
     {
         this.taskDesc = Provider.ChangeSetDescription(change);
         this.taskStat = Provider.ChangeSetStatus(change);
     }
 }

		private void DoOpen(ChangeSet change, AssetList assets)
		{
			this.taskSubmit = null;
			this.submitResultCode = 256;
			this.submitErrorMessage = null;
			this.changeSet = change;
			this.description = string.Empty;
			this.assetList = null;
			if (change == null)
			{
				this.taskStatus = Provider.Status(assets);
			}
			else
			{
				this.taskDesc = Provider.ChangeSetDescription(change);
				this.taskStat = Provider.ChangeSetStatus(change);
			}
		}

 public void LoadAssetsAsync(AssetList list, FloatRef progress)
 {
     List<Asset> assets = new List<Asset>();
     foreach (string path in datapaths)
     {
         try
         {
             if (!Directory.Exists(path))
             {
                 continue;
             }
             foreach (string s in Directory.GetFiles(path, "*.*", SearchOption.AllDirectories))
             {
                 try
                 {
                     FileInfo f = new FileInfo(s);
                     if (f.Name.Equals("thumbs.db", StringComparison.InvariantCultureIgnoreCase))
                     {
                         continue;
                     }
                     Asset a = new Asset();
                     a.data = File.ReadAllBytes(s);
                     a.dataLength = a.data.Length;
                     a.name = f.Name.ToLowerInvariant();
                     a.md5 = Md5(a.data);
                     assets.Add(a);
                 }
                 catch
                 {
                 }
             }
         }
         catch
         {
         }
     }
     progress.value = 1;
     list.count = assets.Count;
     list.items = new Asset[2048];
     for (int i = 0; i < assets.Count; i++)
     {
         list.items[i] = assets[i];
     }
 }

		private static void UpdateFilesInVCIfNeeded()
		{
			if (!Provider.enabled)
			{
				return;
			}
			string[] files = Directory.GetFiles("Temp/ScriptUpdater/", "*.*", SearchOption.AllDirectories);
			AssetList assetList = new AssetList();
			string[] array = files;
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i];
				assetList.Add(Provider.GetAssetByPath(text.Replace("Temp/ScriptUpdater/", string.Empty)));
			}
			Task task = Provider.Checkout(assetList, CheckoutMode.Both);
			task.Wait();
			IEnumerable<Asset> source = 
				from a in task.assetList
				where (a.state & Asset.States.ReadOnly) == Asset.States.ReadOnly
				select a;
			if (!task.success || source.Any<Asset>())
			{
				string arg_103_0 = "[API Updater] Files cannot be updated (failed to checkout): {0}";
				object[] expr_BA = new object[1];
				expr_BA[0] = (
					from a in source
					select string.Concat(new object[]
					{
						a.fullName,
						" (",
						a.state,
						")"
					})).Aggregate((string acc, string curr) => acc + Environment.NewLine + "\t" + curr);
				Debug.LogErrorFormat(arg_103_0, expr_BA);
				ScriptUpdatingManager.ReportExpectedUpdateFailure();
				return;
			}
			FileUtil.CopyDirectoryRecursive("Temp/ScriptUpdater/", ".", true);
			FileUtil.DeleteFileOrDirectory("Temp/ScriptUpdater/");
		}

 private static void UpdateFilesInVCIfNeeded()
 {
   if (!Provider.enabled)
     return;
   string[] files = Directory.GetFiles("Temp/ScriptUpdater/", "*.*", SearchOption.AllDirectories);
   AssetList assets = new AssetList();
   foreach (string str in files)
     assets.Add(Provider.GetAssetByPath(str.Replace("Temp/ScriptUpdater/", string.Empty)));
   Task task = Provider.Checkout(assets, CheckoutMode.Exact);
   task.Wait();
   IEnumerable<Asset> source = task.assetList.Where<Asset>((Func<Asset, bool>) (a => (a.state & Asset.States.ReadOnly) == Asset.States.ReadOnly));
   if (!task.success || source.Any<Asset>())
   {
     Debug.LogErrorFormat("[API Updater] Files cannot be updated (failed to check out): {0}", (object) source.Select<Asset, string>((Func<Asset, string>) (a => a.fullName + " (" + (object) a.state + ")")).Aggregate<string>((Func<string, string, string>) ((acc, curr) => acc + Environment.NewLine + "\t" + curr)));
     ScriptUpdatingManager.ReportExpectedUpdateFailure();
   }
   else
   {
     FileUtil.CopyDirectoryRecursive("Temp/ScriptUpdater/", ".", true);
     FileUtil.DeleteFileOrDirectory("Temp/ScriptUpdater/");
   }
 }

 public static void OpenIfCheckoutFailed(AssetList assets)
 {
   Object[] objectsOfTypeAll = Resources.FindObjectsOfTypeAll(typeof (WindowCheckoutFailure));
   bool alreadyOpen = (objectsOfTypeAll.Length <= 0 ? (Object) null : (Object) (objectsOfTypeAll[0] as WindowCheckoutFailure)) != (Object) null;
   bool flag = alreadyOpen;
   if (!flag)
   {
     using (List<Asset>.Enumerator enumerator = assets.GetEnumerator())
     {
       while (enumerator.MoveNext())
       {
         if (!enumerator.Current.IsState(Asset.States.CheckedOutLocal))
         {
           flag = true;
           break;
         }
       }
     }
   }
   if (!flag)
     return;
   WindowCheckoutFailure.GetWindow().DoOpen(assets, alreadyOpen);
 }

 public MainMenu()
 {
     one = 1;
     textures = new DictionaryStringInt1024();
     textTextures = new TextTexture[256];
     textTexturesCount = 0;
     screen = new ScreenMain();
     screen.menu = this;
     loginClient = new LoginClientCi();
     assets = new AssetList();
     assetsLoadProgress = new FloatRef();
 }

		public void CreateWorkitem()
		{
			const string type = "Story";
			const string title = "Story Name";
			const string description = "Story description";
			const string projectToken = "Scope:0";
			const string externalFieldName = "FieldName";
			const string externalId = "externalId";
			const string externalSystemName = "External System Name";
			const string priorityId = "Priority:12";
			const string owners = "Onwer_1,Owners_2";

			var memberAssetType = new TestAssetType("Member");
			var projectAssetType = new TestAssetType("Project");
			var priorityAssetType = new TestAssetType("Priority");

			var storyAttributes = new Dictionary<string, IAttributeDefinition> {
                {"Owners", new TestAttributeDefinition(memberAssetType, true, false, false)},
            };
			var storyAssetType = new TestAssetType("Story", storyAttributes);

			var source = TestValueId.Create(externalSystemName, "Source", 333);
			var sources = new PropertyValues(new List<ValueId> { source });
			var assetStory = new Asset(storyAssetType);
			var ownersAssets = new AssetList {
                new Asset(new TestOid(new TestAssetType("Member"), 1, null)),
                new Asset(new TestOid(new TestAssetType("Member"), 2, null)),
            };
			var queryResult = new QueryResult(ownersAssets, 2, null);

			Expect.Call(_mockMetaModel.GetAssetType("Scope")).Return(projectAssetType);
			Expect.Call(_mockQueryBuilder.QueryPropertyValues(VersionOneProcessor.WorkitemSourceType)).Return(sources);
			Expect.Call(_mockMetaModel.GetAssetType("Story")).Return(storyAssetType);
			Expect.Call(_mockServices.New(storyAssetType, Oid.Null)).Return(assetStory);
			Expect.Call(_mockMetaModel.GetAssetType("Member")).Return(memberAssetType);
			Expect.Call(_mockServices.Retrieve(null)).IgnoreArguments().Return(queryResult);
			Expect.Call(_mockMetaModel.GetAssetType("Priority")).Return(priorityAssetType);
			Expect.Call(() => _mockServices.Save(assetStory));

			Expect.Call(_mockMetaModel.GetAssetType("Story")).Return(storyAssetType);
			Expect.Call(_mockQueryBuilder.Query("Story", new FilterTerm(null))).IgnoreArguments().Return(new AssetList { assetStory });
			Expect.Call(_mockQueryBuilder.ListPropertyValues).Return(null);
			Expect.Call(_mockQueryBuilder.TypeResolver).Return(null);

			_repository.ReplayAll();

			_processor.CreateWorkitem(type, title, description, projectToken,
				externalFieldName, externalId, externalSystemName,
				priorityId, owners);
			_repository.VerifyAll();
		}

        public void WriteHistoricalAttribute(AssetList assets, IAttributeDefinition attribdef, int total, int pagesize, int pagestart) {
            writer.WriteStartElement("History");

            if(total > -1) {
                writer.WriteAttributeString("total", total.ToString());
            }

            if(pagesize > -1) {
                writer.WriteAttributeString("pageSize", pagesize.ToString());
            }

            if(pagestart > -1) {
                writer.WriteAttributeString("pageStart", pagestart.ToString());
            }

            foreach(var asset in assets) {
                WriteAttribute(asset.GetAttribute(attribdef));
            }

            writer.WriteEndElement();
        }

 public void WriteHistoricalAsset(AssetList assets, int total, int pagesize, int pagestart) {
     WriteHistoricalAssetList(assets, total, pagesize, pagestart);
 }

 public void Save(AssetList assetList)
 {
     OnBeforeSave(assetList);
     _wrapped.Save(assetList);
 }