void RemoveFromFilteredAndGroup(object item) { if (RemoveFromFiltered(item) || true) { RootGroup.RemoveInSubtree(item); } }
/// <summary> /// Find a list of entries with a defined property, such as OTP Url /// The customized properties are stored in CustomData per PxDefs, such as PxCustomDataOtpUrl /// </summary> /// <param name="name">The property name. Must not be <c>null</c>.</param> /// <returns>a list of entries</returns> public IEnumerable <PwEntry> GetEntryListByProperty(string name) { if (name == null) { Debug.Assert(false); throw new ArgumentNullException("name"); } List <PwEntry> resultsList = new List <PwEntry>(); LinkedList <PwGroup> flatGroupList = RootGroup.GetFlatGroupList(); foreach (PwEntry entry in RootGroup.Entries) { if (entry.CustomData != null && entry.CustomData.Exists(name)) { if (!string.IsNullOrWhiteSpace(entry.CustomData.Get(name))) { resultsList.Add(entry); } } } foreach (PwEntry entry in PwGroup.GetFlatEntryList(flatGroupList)) { if (entry.CustomData != null && entry.CustomData.Exists(name)) { if (!string.IsNullOrWhiteSpace(entry.CustomData.Get(name))) { resultsList.Add(entry); } } } return(resultsList); }
void HandleSourceCollectionChanged(object sender, NotifyCollectionChangedEventArgs e) { // Firstly if we are copying the source collection into our filtered list, update // the copy with the new changes and compute the actual index of our item in the // sorted/grouped/filtered list. int actualOldIndex = -1; int actualNewIndex = -1; bool originalList = ActiveList == SourceCollection; if (!originalList) { switch (e.Action) { case NotifyCollectionChangedAction.Add: foreach (object o in e.NewItems) { AddToFilteredAndGroupSorted(o); } break; case NotifyCollectionChangedAction.Remove: actualOldIndex = IndexOf(e.OldItems [0]); foreach (object o in e.OldItems) { RemoveFromFilteredAndGroup(o); } break; case NotifyCollectionChangedAction.Replace: foreach (object o in e.OldItems) { RemoveFromFilteredAndGroup(o); } foreach (object o in e.NewItems) { AddToFilteredAndGroupSorted(o); } break; case NotifyCollectionChangedAction.Reset: filteredList.Clear(); RootGroup.ClearSubtree(); foreach (var o in SourceCollection) { AddToFilteredAndGroup(o); } break; } } else { // Raise the collection changed event RaiseCollectionChanged(e); } IsEmpty = ActiveList.Count == 0; IsCurrentAfterLast = CurrentPosition == ActiveList.Count || ActiveList.Count == 0; IsCurrentBeforeFirst = CurrentPosition == -1 || ActiveList.Count == 0; }
public override string ToString() { StringBuilder RetVal = new StringBuilder(); RetVal.AppendFormat("ConfigDocument {0}", Name); RootGroup.ToString().Split('\n').ToList().ForEach(l => RetVal.AppendFormat(" {0}\n", l)); return(RetVal.ToString()); }
public XElement ToXml() { XElement RetVal = new XElement("config"); RetVal.SetAttributeValue("name", Name); RetVal.SetAttributeValue("datafolderpath", DataFolderPath); RetVal.Add(RootGroup.ToXml()); return(RetVal); }
void AddToFilteredAndGroupSorted(object item) { // If we're adding an item because of a call to the 'AddNew' method, we // if (AddToFiltered(item, true) && Grouping && CurrentAddItem == null) { RootGroup.AddInSubtree(item, Culture, GroupDescriptions); } }
public override void Refresh() { if (IsAddingNew || IsEditingItem) { throw new InvalidOperationException("Cannot refresh while adding or editing an item"); } if (DeferLevel != 0) { return; } Groups = null; RootGroup.ClearItems(); if (ActiveList != SourceCollection) { try { IgnoreFilteredListChanges = true; filteredList.Clear(); foreach (var item in SourceCollection) { AddToFiltered(item, false); } if (SortDescriptions.Count > 0) { filteredList.Sort(new PropertyComparer(SortDescriptions)); } } finally { IgnoreFilteredListChanges = false; } if (GroupDescriptions.Count > 0 && filteredList.Count > 0) { foreach (var item in filteredList) { RootGroup.AddInSubtree(item, Culture, GroupDescriptions, false); } Groups = RootGroup.Items; } } IsEmpty = ActiveList.Count == 0; IsCurrentAfterLast = CurrentPosition == ActiveList.Count || ActiveList.Count == 0; IsCurrentBeforeFirst = CurrentPosition == -1 || ActiveList.Count == 0; int index = IndexOf(CurrentItem); if (index < 0 && CurrentPosition != -1 && !IsEmpty) { index = 0; } RaiseCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset), false); MoveCurrentTo(index, true, false); }
/// <summary> /// Delete an entry. /// </summary> /// <param name="pe">The entry to be deleted. Must not be <c>null</c>.</param> /// <param name="permanent">Permanent delete or move to recycle bin</param> public void DeleteEntry(PwEntry pe, bool permanent = false) { if (pe == null) { throw new ArgumentNullException("pe"); } PwGroup pgRecycleBin = RootGroup.FindGroup(RecycleBinUuid, true); PwGroup pgParent = pe.ParentGroup; if (pgParent == null) { return; // Can't remove } pgParent.Entries.Remove(pe); bool bPermanent = false; if (RecycleBinEnabled == false) { bPermanent = true; } else if (permanent) { bPermanent = true; } else if (pgRecycleBin == null) { } // if we cannot find it, we will create it later else if (pgParent == pgRecycleBin) { bPermanent = true; } else if (pgParent.IsContainedIn(pgRecycleBin)) { bPermanent = true; } DateTime dtNow = DateTime.UtcNow; if (bPermanent) { PwDeletedObject pdo = new PwDeletedObject(pe.Uuid, dtNow); DeletedObjects.Add(pdo); } else // Recycle { EnsureRecycleBin(ref pgRecycleBin); pgRecycleBin.AddEntry(pe, true, true); pe.Touch(false); } }
public void TestHashCode() { var item = new RootGroup { ID = 1, Name = "1" }; var item2 = new RootGroup { ID = 1, Name = "1" }; Assert.Equal(item.GetHashCode(), item2.GetHashCode()); }
int IndexOf(object item) { if (Grouping) { return(RootGroup.IndexOfSubtree(item)); } else { return(ActiveList.IndexOf(item)); } }
public void CreateDownLoad(string path, Action callback) { Action <WWW, int> load = (www, udata) => { if (www.error != null || www.text == null) { Log_Debug.LogError("www download error"); return; } string info = www.text; string[] splited = info.Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries); if (splited.Length <= 1)//数据错误 { DownLoadManager.Instance.ShowLoadingErrTips("服务器下载数据错误"); return; } for (int i = 0; i < splited.Length; i++) { if (i == 0) { string[] first = splited[0].Split(new string[] { "ver:", "|FileCount:" }, StringSplitOptions.RemoveEmptyEntries); int ver = int.Parse(first[0]); int filecount = int.Parse(first[1]); string hash = Convert.ToBase64String(DownLoadManager.Instance.sha1.ComputeHash(www.bytes)); if (RemoteVersion.Version != ver) { RemoteVersion.Version = ver; } if (this.filecount != filecount) { this.filecount = filecount; } if (this.hash != hash) { this.hash = hash; } } else { string[] first = splited[i].Split(new string[] { "|", "@" }, StringSplitOptions.RemoveEmptyEntries); RootGroup root = new RootGroup(first[0], first[1], int.Parse(first[2])); rootlist[first[0]] = root; } } if (callback != null) { callback(); } }; DownLoadManager.Instance.AddDownLoadTask(path, load); }
public bool Equals(RootGroup other) { if (ReferenceEquals(null, other)) { return(false); } if (ReferenceEquals(this, other)) { return(true); } return(Equals(other.Name, Name)); }
public void Unload() { RootGroup.Unload(); foreach (var bound in RootBoundingBoxes) { UnityEngine.Object.Destroy(bound.gameObject); } GlobalVariableDataStore.Instance.Unload(); RootBoundingBoxes.Clear(); }
public void TestEqualWithSelfAndWithNull() { var item = new RootGroup { ID = 1, Name = "1" }; var item2 = new RootGroup { ID = 1, Name = "1" }; Assert.True(item.Equals(item)); Assert.False(item.Equals(null)); Assert.True(item.Equals(item2)); }
public override void CommitNew() { if (IsEditingItem) { throw new InvalidOperationException("Cannot CommitNew while editing an item"); } if (IsAddingNew) { if (CurrentAddItem is IEditableObject) { ((IEditableObject)CurrentAddItem).EndEdit(); } RootGroup.RemoveInSubtree(CurrentAddItem); if (Filter != null && !Filter(CurrentAddItem)) { RemoveFromSourceCollection(SourceCollection.IndexOf(CurrentAddItem)); } else { // When adding a new item, we initially put it in the root group. Once it's committed // we need to place it in the correct subtree group. if (Grouping) { RootGroup.AddInSubtree(CurrentAddItem, Culture, GroupDescriptions); } // The item was not filtered out of the tree. Do we need to resort it? if (SortDescriptions.Count > 0) { // The newly added item is at the end of the array. If we're sorting, we may have to move it. // Use a binary search to figure out where the item should be in the list and put it in there. int actualIndex = filteredList.IndexOf(CurrentAddItem); int sortedIndex = filteredList.BinarySearch(0, filteredList.Count - 1, CurrentAddItem, new PropertyComparer(SortDescriptions)); if (sortedIndex < 0) { sortedIndex = ~sortedIndex; } if (actualIndex != sortedIndex) { MoveAndSelectFromSorted(actualIndex, sortedIndex, CurrentItem); } } } CurrentAddItem = null; IsAddingNew = false; UpdateCanAddNewAndRemove(); } }
public void CreateParentChildGroups() { var connection = new ConnectionSettingProvider(); var metadataElastic = new ElasticClient( connection.Get() .DefaultIndex("es.info.metadata")); var attachmentProcessor = new AttachmentProcessor(); var metadataRepo = new MetadataRepository(metadataElastic); var metadataInfo = new InformationRepository(metadataElastic, attachmentProcessor, new ItemMetadataProvider(metadataRepo)); var childGroup1 = new ChildGroup { SortOrder = 1, Title = "child 1" }; var childGroup2 = new ChildGroup { SortOrder = 2, Title = "child 2" }; var grandChild = new ChildGroup { SortOrder = 1, Title = "grandchild" }; var rootGroup = new RootGroup { Title = "root" }; attachmentProcessor.Attach(childGroup1, rootGroup); attachmentProcessor.Attach(childGroup2, rootGroup); attachmentProcessor.Attach(grandChild, childGroup1); attachmentProcessor.Attach(grandChild, rootGroup); attachmentProcessor.Attach(childGroup1, rootGroup); attachmentProcessor.Attach(childGroup2, rootGroup); metadataInfo.Save(rootGroup); metadataInfo.Save(childGroup1); metadataInfo.Save(childGroup2); metadataInfo.Save(grandChild); }
public void TestEqualWithObject() { var item = new RootGroup { ID = 1, Name = "1" }; var item2 = new RootGroup { ID = 1, Name = "1" }; var itemGroup = new ItemGroup(); Assert.False(item.Equals((object)null)); Assert.True(item.Equals((object)item)); Assert.False(item.Equals((object)itemGroup)); Assert.True(item.Equals(item2)); }
public override object AddNew() { ThrowIfDeferred(); if (ItemConstructor == null) { throw new InvalidOperationException("The underlying collection does not support adding new items"); } if (SourceCollection.IsFixedSize) { throw new InvalidOperationException("The source collection is of fixed size"); } // If there's an existing AddNew or Edit, we commit it. Commit the edit first because // we're not allowed CommitNew if we're in the middle of an edit. if (IsEditingItem) { CommitEdit(); } if (IsAddingNew) { CommitNew(); } var newObject = ItemConstructor.Invoke(null); // FIXME: I need to check the ordering on the events when the source is INCC CurrentAddItem = newObject; IsAddingNew = true; if (Grouping) { RootGroup.AddItem(newObject, false, SourceCollection); HandleRootGroupCollectionChanged(RootGroup, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, newObject, RootGroup.IndexOfSubtree(newObject))); } AddToSourceCollection(newObject); MoveCurrentTo(newObject); if (newObject is IEditableObject) { ((IEditableObject)newObject).BeginEdit(); } UpdateCanAddNewAndRemove(); return(newObject); }
public void Write(Stream stream) { EnsureState(); XmlDocument doc = new XmlDocument(); XmlElement root = doc.CreateElement("package"); PackageItem.AddAttribute(root, "id", Id); PackageItem.AddAttribute(root, "name", Name); if (Condition != null) { PackageItem.AddAttribute(root, "condition", Condition.ToString()); } PackageItem.AddAttribute(root, "version", Version.ToString()); PackageItem.AddAttribute(root, "attribution", Attribution); if (Website != null) { PackageItem.AddAttribute(root, "website", Website.ToString()); } if (UpdateUri != null) { PackageItem.AddAttribute(root, "updateUri", UpdateUri.ToString()); } if (FeedbackUri != null) { PackageItem.AddAttribute(root, "feedbackUri", FeedbackUri.ToString()); } doc.AppendChild(root); RootGroup.Write(root); XmlWriterSettings settings = new XmlWriterSettings(); settings.ConformanceLevel = ConformanceLevel.Document; settings.Encoding = Encoding.UTF8; settings.Indent = true; settings.IndentChars = "\t"; XmlWriter wtr = XmlWriter.Create(stream, settings); doc.WriteTo(wtr); wtr.Flush(); }
void DownloadOk(RootGroup g) { lock (NeedDownLoadFiles) { NeedDownLoadFiles.Remove(g); if (NeedDownLoadFiles.Count == 0) { LocalVersion.SaveGroupToLocal("allver.ver.txt"); SetSliderProgress(1.0f); ResManager.AssetBundleInit(); ResManager.LoadAssetBundleInMemory((str) => { if (str.Equals("Root/config.assetbundle"))//解析配置文件 { ConfigManager.Instance.Parse(ParseConfigOver); } }); } } }
public override void CancelNew() { if (IsEditingItem) { throw new InvalidOperationException("Cannot CancelNew while editing an item"); } if (IsAddingNew) { if (CurrentAddItem is IEditableObject) { ((IEditableObject)CurrentAddItem).CancelEdit(); } if (Grouping) { RootGroup.RemoveItem(CurrentAddItem); } RemoveFromSourceCollection(SourceCollection.IndexOf(CurrentAddItem)); CurrentAddItem = null; IsAddingNew = false; UpdateCanAddNewAndRemove(); } }
async void Search(object sender, EventArgs e) { CardDataStore.CardsQuery query = RootGroup.GetQuery(); await Navigation.PushAsync(new CardsListPage(query.ToDataStore())); }
/// <summary> /// Delete a group. /// </summary> /// <param name="pg">Group to be added. Must not be <c>null</c>.</param> /// <param name="permanent">Permanent delete or move to recycle bin</param> public void DeleteGroup(PwGroup pg, bool permanent = false) { if (pg == null) { throw new ArgumentNullException("pg"); } PwGroup pgParent = pg.ParentGroup; if (pgParent == null) { throw new ArgumentNullException("pgParent"); // Can't remove virtual or root group } PwGroup pgRecycleBin = RootGroup.FindGroup(RecycleBinUuid, true); bool bPermanent = false; if (RecycleBinEnabled == false) { bPermanent = true; } else if (permanent) { bPermanent = true; } else if (pgRecycleBin == null) { } // if we cannot find it, we will create it later else if (pg == pgRecycleBin) { bPermanent = true; } else if (pg.IsContainedIn(pgRecycleBin)) { bPermanent = true; } else if (pgRecycleBin.IsContainedIn(pg)) { bPermanent = true; } pgParent.Groups.Remove(pg); if (bPermanent) { pg.DeleteAllObjects(this); PwDeletedObject pdo = new PwDeletedObject(pg.Uuid, DateTime.UtcNow); DeletedObjects.Add(pdo); } else // Recycle { EnsureRecycleBin(ref pgRecycleBin); try { pgRecycleBin.AddGroup(pg, true, true); } catch (Exception) { if (pgRecycleBin.Groups.IndexOf(pg) < 0) { pgParent.AddGroup(pg, true, true); // Undo removal } } pg.Touch(false); } }
public void Execute(PackageExecutionSettings settings) { /////////////////////////////////// // Prepare EnsureState(); if (IsBusy) { throw new InvalidOperationException("Cannot execute another package whilst executing a package."); } IsBusy = true; if (settings.LiteMode) { FactoryOptions.Populate(); FactoryOptions.Instance[Anolis.Core.Data.DirectoryResourceDataFactory.IconSizeLimit] = 128; } /////////////////////////////////// // Create Backup Details Group backupGroup = null; if (settings.BackupDirectory != null) { if (settings.BackupDirectory.Exists) { settings.BackupDirectory = new DirectoryInfo(PackageUtility.GetUnusedDirectoryName(settings.BackupDirectory.FullName)); } settings.BackupDirectory.Create(); settings.BackupDirectory.Refresh(); Package backupPackage = new Package(settings.BackupDirectory); backupPackage.Version = this.Version; backupPackage.Name = this.Name + " Uninstallation Package"; backupPackage.Attribution = "Anolis Installer"; backupPackage.FeedbackUri = this.FeedbackUri; backupGroup = backupPackage.RootGroup; } ExecutionInfo = new PackageExecutionSettingsInfo(this, settings.ExecutionMode, settings.CreateSystemRestorePoint, settings.LiteMode, backupGroup, settings.I386Directory); /////////////////////////////////// // Flatten Log.Add(LogSeverity.Info, "Beginning package execution: " + this.Name + ", with mode " + ExecutionInfo.ExecutionMode.ToString()); OnProgressEvent(new PackageProgressEventArgs(0, "Flattening Package Tree")); List <Operation> operations = new List <Operation>(); RootGroup.Flatten(operations); List <Operation> obsoleteOperations = new List <Operation>(); Dictionary <String, Operation> uniques = new Dictionary <String, Operation>(); foreach (Operation op in operations) { if (!op.IsEnabled) { obsoleteOperations.Add(op); continue; } Operation originalOperation; if (uniques.TryGetValue(op.Key, out originalOperation)) { if (originalOperation.Merge(op)) { obsoleteOperations.Add(op); } } else { uniques.Add(op.Key, op); } } operations.RemoveAll(op => obsoleteOperations.Contains(op)); /////////////////////////////////// // Prepare if (ExecutionInfo.ExecutionMode == PackageExecutionMode.Regular) { PackageUtility.AllowProtectedRenames(); } Int64 restorePointSequenceNumber = -2; /////////////////////////////////// // System Restore, Part 1 if (ExecutionInfo.ExecutionMode == PackageExecutionMode.Regular && ExecutionInfo.CreateSystemRestorePoint) { if (SystemRestore.IsSystemRestoreAvailable()) { OnProgressEvent(new PackageProgressEventArgs(-1, "Creating System Restore Point")); String pointName = "Installed Anolis Package \"" + this.Name + '"'; restorePointSequenceNumber = SystemRestore.CreateRestorePoint(pointName, SystemRestoreType.ApplicationInstall); if (restorePointSequenceNumber < 0) { Log.Add(LogSeverity.Error, "Failed to create System Restore point"); } } else { Log.Add(LogSeverity.Error, "System Restore not supported"); } } /////////////////////////////////// // Install (Backup and Execute; backups are the responisiblity of each Operation) try { float i = 0, cnt = operations.Count; foreach (Operation op in operations) { OnProgressEvent(new PackageProgressEventArgs((int)(100 * i++ / cnt), op.ToString())); if (!op.SupportsCDImage && ExecutionInfo.ExecutionMode == PackageExecutionMode.CDImage) { continue; } try { if (op.CustomEvaluation) { op.Execute(); } else { EvaluationResult result = op.Evaluate(); switch (result) { case EvaluationResult.False: Log.Add(LogSeverity.Info, "Evaluation False - " + op.Key); break; case EvaluationResult.FalseParent: Log.Add(LogSeverity.Info, "Evaluation ParentFalse - " + op.Key); break; case EvaluationResult.Error: Log.Add(LogSeverity.Error, "Evaluation Error - " + op.Key); break; case EvaluationResult.True: op.Execute(); break; } } } catch (Exception ex) { Log.Add(new LogItem(LogSeverity.Error, ex, op.Name + " failed: \"" + ex.Message + "\"")); continue; } #if !DEBUG // don't add "Info - Done {op}" in debug mode because it's too verbose and clutters up the logfile PathOperation pathOp = op as PathOperation; if (pathOp != null) { Log.Add(LogSeverity.Info, "Done " + op.Name + ": " + pathOp.Path); } else { Log.Add(LogSeverity.Info, "Done " + op.Name); } #endif } //foreach OnProgressEvent(new PackageProgressEventArgs(100, "Complete")); } finally { /////////////////////////////////// // System Restore, Part 2 if (restorePointSequenceNumber >= 0) { OnProgressEvent(new PackageProgressEventArgs(-1, "Finishing System Restore Point")); SystemRestore.EndRestorePoint(restorePointSequenceNumber); } /////////////////////////////////// // Backup, Part 2 if (ExecutionInfo.BackupGroup != null) { String backupFileName = Path.Combine(ExecutionInfo.BackupDirectory.FullName, "Package.xml"); ExecutionInfo.BackupPackage.Write(backupFileName); } /////////////////////////////////// // Dump the log to disk Log.Save(Path.Combine(this.RootDirectory.FullName, "Anolis.Installer.log")); IsBusy = false; } //try/finally }
public void AcceptChanges() { RootGroup.AcceptChanges(); }
//called by Groups manager public IEnumerator CheckGroupLoadStates() { if (!mInitialized) { yield break; } if (RootGroup == null || RootGroup.IsDestroyed) { Debug.Log("ROOT GROUP was null or destroyed in unloader, we're finished"); yield break; } //we may have to backtrack if new groups were added if (NotPreparedToUnload.Count > 0) { LoadState = WIGroupLoadState.Loaded; } else if (PreparingToUnload.Count > 0) { LoadState = WIGroupLoadState.PreparingToUnload; } else if (Unloading.Count > 0) { LoadState = WIGroupLoadState.Unloading; } switch (LoadState) { case WIGroupLoadState.Loaded: //tell everyone in the Loaded list to prepare to unload //then move them all into preparing to unload //---TRANSITION TO PREPARED TO UNLOAD---// for (int i = NotPreparedToUnload.LastIndex(); i >= 0; i--) { if (NotPreparedToUnload [i].PrepareToUnload()) { PreparingToUnload.Add(NotPreparedToUnload [i]); NotPreparedToUnload.RemoveAt(i); } yield return(null); } if (NotPreparedToUnload.Count == 0 && RootGroup.PrepareToUnload()) { LoadState = WIGroupLoadState.PreparingToUnload; //RootGroup.LoadState = WIGroupLoadState.PreparingToUnload; } yield return(null); break; case WIGroupLoadState.PreparingToUnload: //go through each child group and ask if it's ready to unload //this will force the group to ask each of its child items //if it's prepared we move it to the prepared to unload group for (int i = PreparingToUnload.LastIndex(); i >= 0; i--) { WIGroup loadedGroup = PreparingToUnload [i]; if (loadedGroup.ReadyToUnload) { PreparingToUnload.RemoveAt(i); ReadyToUnload.Add(loadedGroup); } yield return(null); //yield return null; } //---TRANSITION TO UNLOADING---// //if all are ready to unload and there are no more not prepared to unload //then begin unload - there's no turning back at this point! if (PreparingToUnload.Count == 0 && RootGroup.ReadyToUnload) { Unloading.AddRange(ReadyToUnload); ReadyToUnload.Clear(); for (int i = 0; i < Unloading.Count; i++) { Unloading [i].BeginUnload(); } RootGroup.BeginUnload(); LoadState = WIGroupLoadState.Unloading; //RootGroup.LoadState = WIGroupLoadState.Unloading; } yield return(null); break; case WIGroupLoadState.Unloading: if (Unloading.Count > 0) { for (int i = Unloading.LastIndex(); i >= 0; i--) { if (Unloading [i].FinishedUnloading) { FinishedUnloading.Add(Unloading [i]); Unloading.RemoveAt(i); //this generates a huge amount of garbage yield break; } #if UNITY_EDITOR else { LastHoldout = Unloading [i].FileName + " " + Unloading [i].HoldoutChildItem; } #endif yield return(null); } } else { if (FinishedUnloading.Count > 0) { for (int i = FinishedUnloading.LastIndex(); i >= 0; i--) { if (FinishedUnloading [i] == null || FinishedUnloading [i].IsDestroyed) { FinishedUnloading.RemoveAt(i); } else { //we see if it's ready to actually be destroyed //no groups greater than [x] depth that have not been destroyed #if UNITY_EDITOR LastHoldout = FinishedUnloading [i].FileName + " " + FinishedUnloading [i].HoldoutChildItem; #endif if (!FinishedUnloading [i].HasChildGroups) { ReadyToDestroy.Add(FinishedUnloading [i]); FinishedUnloading.RemoveAt(i); } } yield return(null); } } else { } } yield return(null); //---TRANSITION TO UNLOADED---// //if we have more than just the root group then we wait until the root group is finished unloading to kill everything if (FinishedUnloading.Count == 0 && ReadyToDestroy.Count == 0) { if (!RootGroup.FinishedUnloading) { //now it will be detsroyed by WIGroups #if UNITY_EDITOR LastHoldout = RootGroup.FileName + " " + RootGroup.HoldoutChildItem; #endif if (RootGroup.PrepareToUnload()) { RootGroup.BeginUnload(); } } else { LoadState = WIGroupLoadState.Unloaded; } } break; case WIGroupLoadState.Unloaded: //nothing left to do break; default: Debug.Log("Weird load state in WIGroupUnloader: " + LoadState.ToString()); break; } yield break; }
public override string ToStringWithoutDelim() { return(RootGroup.ToStringWithoutDelim()); }
public override void CommitEdit() { if (IsAddingNew) { throw new InvalidOperationException("Cannot cancel edit while adding new"); } if (IsEditingItem) { var editItem = CurrentEditItem; CurrentEditItem = null; IsEditingItem = false; if (CanCancelEdit) { ((IEditableObject)editItem).EndEdit(); CanCancelEdit = false; } UpdateCanAddNewAndRemove(); int originalIndex = IndexOf(editItem); int newIndex; // If we're filtering the item out just nuke it if (Filter != null && !Filter(editItem)) { RemoveFromFilteredAndGroup(editItem); if (CurrentItem == editItem) { MoveCurrentTo(CurrentPosition); } return; } // We could also have changed the property which sorts it if (SortDescriptions.Count > 0) { // We can't just remove the item and binary search for the correct place as that will change the // order of elements which compare as equal and breaks more tests than it fixes. We need to first // check to see if the editItem is >= than the previous one and <= the next one. If that is true // we need to do nothing. Otherwise we need to binary search either the upper or lower half and // find the new index where the editItem should be placed. if (originalIndex > 0 && Comparer.Compare(filteredList [originalIndex - 1], editItem) > 0) { newIndex = filteredList.BinarySearch(0, originalIndex, editItem, Comparer); } else if (originalIndex < (filteredList.Count - 1) && Comparer.Compare(filteredList [originalIndex + 1], editItem) < 0) { newIndex = filteredList.BinarySearch(originalIndex + 1, filteredList.Count - (originalIndex + 1), editItem, Comparer); } else { // We're already in the right place. newIndex = originalIndex; } } else { // No sorting == no index change newIndex = originalIndex; } var currentSelection = CurrentItem; if (newIndex != originalIndex) { if (newIndex < 0) { newIndex = ~newIndex; } // When we remove the element from the original index, our newIndex will be off by 1 as everything // gets shuffled down so decrement it here. if (newIndex > originalIndex) { newIndex--; } DeferCurrentChanged = true; filteredList.RemoveAt(originalIndex); filteredList.Insert(newIndex, editItem); DeferCurrentChanged = false; } // We may have edited the property which controls which group the item is in // so re-seat it if (Grouping) { DeferCurrentChanged = true; RootGroup.RemoveInSubtree(editItem); RootGroup.AddInSubtree(editItem, Culture, GroupDescriptions); DeferCurrentChanged = false; MoveCurrentTo(IndexOf(currentSelection) + 1); } else if (originalIndex != newIndex) { MoveCurrentTo(IndexOf(currentSelection)); } } }
public override string ToStringTree() { return(RootGroup.ToStringTree()); }
public void BeginDownLoad(string path, Action callback) { Action CompareDiff = () => { foreach (KeyValuePair <string, VerGroup> index in RemoteVersion.RemoteVerGroup) { if (LocalVersion.LocalVerGroup.ContainsKey(index.Key))//比较hash,size { VerGroup local = LocalVersion.LocalVerGroup[index.Key]; //if (local.hash != index.Value.hash || local.filecount != index.Value.filecount) //{ // LocalVersion.LocalVerGroup[index.Key] = index.Value; //} foreach (KeyValuePair <string, RootGroup> KV in index.Value.rootlist) { if (local.rootlist.ContainsKey(KV.Key)) { RootGroup group = local.rootlist[KV.Key]; if (group.hash != KV.Value.hash || group.filesize != KV.Value.filesize) { local.rootlist[KV.Key] = KV.Value; local.rootlist[KV.Key].needdownload = true; } } else { RootGroup g = new RootGroup(KV.Value.FileName, KV.Value.hash, KV.Value.filesize); g.needdownload = true; local.rootlist[KV.Key] = g; } } } else { VerGroup newgroup = new VerGroup(index.Value.RootName, index.Value.hash, index.Value.filecount); index.Value.SetAllFilesNeedDownLoad(); newgroup.rootlist = index.Value.rootlist; LocalVersion.LocalVerGroup[index.Key] = newgroup; } } //LocalVersion.SaveGroupToLocal("allver.ver.txt"); //TODO::与本地解析比较,找出需要下载的 if (callback != null) { callback(); } }; Action <WWW, int> AllVerCallBack = (www, udata) => { if (www.error != null || www.text == null) { Log_Debug.LogError("www download error"); return; } string info = www.text; string[] splited = info.Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries); if (splited.Length <= 1)//数据错误 { ShowLoadingErrTips("服务器下载数据错误"); return; } for (int i = 0; i < splited.Length; i++) { if (i == 0) { string[] first = splited[0].Split(new string[] { ":" }, StringSplitOptions.None); int.TryParse(first[1], out RemoteVersion.Version); } else { string[] first = splited[i].Split(new string[] { "|" }, StringSplitOptions.None); VerGroup ver = new VerGroup(first[0], first[1], int.Parse(first[2])); RemoteVersion.RemoteVerGroup[first[0]] = ver; } } Debug.Log(RootHashDiff()); if (RemoteVersion.Version > LocalVersion.Version || RootHashDiff())// { LocalVersion.Version = RemoteVersion.Version; foreach (KeyValuePair <string, VerGroup> group in RemoteVersion.RemoteVerGroup) { StringBuilder str = new StringBuilder(); str.Append(RemoteVersion.remoteurl).Append("/" + group.Key + ".ver.txt"); group.Value.CreateDownLoad(str.ToString(), CompareDiff); } } else { if (callback != null) { callback(); } } }; Action MergeLocal = () => { RemoteVersion.AddDownLoadTask(path, AllVerCallBack); }; if (DataManager.Instance.IsFirstEnterGame)//首次进入游戏 { LocalVersion.ClearLocalCache(); RemoteVersion.AddDownLoadTask(path, AllVerCallBack); } else { LocalVersion.ReadLocalAllVer(path, MergeLocal); } }
public bool Equals(RootGroup other) { if (ReferenceEquals(null, other)) return false; if (ReferenceEquals(this, other)) return true; return Equals(other.Name, Name); }