/// <summary> /// A MultiPoint is simple if it has no repeated points. /// </summary> public bool IsSimple(IMultiPoint mp) { if (mp.IsEmpty) return true; Set<ICoordinate> points = new Set<ICoordinate>(); for (int i = 0; i < mp.NumGeometries; i++) { IPoint pt = (IPoint) mp.GetGeometryN(i); ICoordinate p = pt.Coordinate; if (points.Contains(p)) return false; points.Add(p); } return true; }
public void IntersectionTest() { Set<int> a = new Set<int>(); for(int i = 0; i < 16; i += 2) a.Add(i); Set<int> b = new Set<int>(); for(int i = 0; i < 16; i += 3) b.Add(i); Set<int> inter = a.Intersect(b); Assert.AreEqual(3, inter.Count, "A01"); Assert.AreEqual(0, inter[0], "A02"); Assert.AreEqual(6, inter[1], "A03"); Assert.AreEqual(12, inter[2], "A04"); }
public void Init(FdoCache cache, bool enableCancel) { CheckDisposed(); m_cache = cache; m_btnCancel.Visible = enableCancel; Set<int> revIdxWs = new Set<int>(4); foreach (IReversalIndex ri in cache.LangProject.LexDbOA.ReversalIndexesOC) revIdxWs.Add(ri.WritingSystemRAHvo); // Include only the analysis writing systems chosen by the user. See LT-7514 and LT-7239. Set<int> activeWs = new Set<int>(8); foreach (int ws in cache.LangProject.AnalysisWssRC.HvoArray) activeWs.Add(ws); m_cbWritingSystems.Sorted = true; m_cbWritingSystems.DisplayMember = "Name"; NamedWritingSystem nwsSelected = null; foreach (NamedWritingSystem nws in cache.LangProject.GetDbNamedWritingSystems()) { if (revIdxWs.Contains(nws.Hvo)) { AddLanguageForExistingRevIdx(nws.IcuLocale); continue; } if (!activeWs.Contains(nws.Hvo)) continue; m_cbWritingSystems.Items.Add(nws); if (nwsSelected == null && !LanguageMatchesExistingRevIdx(nws.IcuLocale)) nwsSelected = nws; } if (nwsSelected != null) m_cbWritingSystems.SelectedItem = nwsSelected; if (m_cbWritingSystems.Items.Count > 0 && m_cbWritingSystems.SelectedIndex < 0) m_cbWritingSystems.SelectedIndex = 0; if (!enableCancel && m_cbWritingSystems.Items.Count == 0) throw new ApplicationException("Cancel is disabled, but there are none to choose, so the user has no way to get out of this dialog."); }
/// <summary> /// Determines which types are produced by this mapping. /// </summary> private Set<EntityType> FindReachableTypes( DomainConstraintConversionContext<string, ValueCondition> converter, Vertex[] mappingConditions) { // For each entity type, create a candidate function that evaluates to true given // discriminator assignments iff. all of that type's conditions evaluate to true // and its negative conditions evaluate to false. var candidateFunctions = new Vertex[MappedEntityTypes.Count]; for (var i = 0; i < candidateFunctions.Length; i++) { // Seed the candidate function conjunction with 'true'. var candidateFunction = Vertex.One; for (var j = 0; j < NormalizedEntityTypeMappings.Count; j++) { var entityTypeMapping = NormalizedEntityTypeMappings[j]; // Determine if this mapping is a positive or negative case for the current type. if (entityTypeMapping.ImpliedEntityTypes[i]) { candidateFunction = converter.Solver.And(candidateFunction, mappingConditions[j]); } else { candidateFunction = converter.Solver.And(candidateFunction, converter.Solver.Not(mappingConditions[j])); } } candidateFunctions[i] = candidateFunction; } // Make sure that for each type there is an assignment that resolves to only that type. var reachableTypes = new Set<EntityType>(); for (var i = 0; i < candidateFunctions.Length; i++) { // Create a function that evaluates to true iff. the current candidate function is true // and every other candidate function is false. var isExactlyThisTypeCondition = converter.Solver.And( candidateFunctions.Select( (typeCondition, ordinal) => ordinal == i ? typeCondition : converter.Solver.Not(typeCondition))); // If the above conjunction is satisfiable, it means some row configuration exists producing the type. if (!isExactlyThisTypeCondition.IsZero()) { reachableTypes.Add(MappedEntityTypes[i]); } } return reachableTypes; }
static void ConsumeParsingQueue () { int pending = 0; IProgressMonitor monitor = null; try { Set<ProjectDom> dbsToFlush = new Set<ProjectDom> (); do { if (pending > 5 && monitor == null) { monitor = GetParseProgressMonitor (); monitor.BeginTask (GettextCatalog.GetString ("Generating database"), 0); } ParsingJob job = DequeueParseJob (); if (job != null) { try { job.ParseCallback (job.File, monitor); if (job.Database != null) dbsToFlush.Add (job.Database); } catch (Exception ex) { if (monitor == null) monitor = GetParseProgressMonitor (); monitor.ReportError (null, ex); } } pending = PendingJobCount; } while (pending > 0); queueEmptied.Set (); // Flush the parsed databases foreach (ProjectDom db in dbsToFlush) db.Flush (); } finally { if (monitor != null) monitor.Dispose (); } }
/** * returns a set of projects that a combine contains and a set of projects * that are referenced from combine projects but not part of the combine */ void GetAllProjects (SolutionFolder folder, SolutionConfiguration config, out Set<SolutionFolderItem> projects, out Set<SolutionFolderItem> references) { List<SolutionFolderItem> subitems = new List<SolutionFolderItem> (); GetSubItems (subitems, folder); projects = (Set<SolutionFolderItem>) combineProjects [folder]; if (projects != null) { references = (Set<SolutionFolderItem>) combineReferences [folder]; return; } projects = new Set<SolutionFolderItem>(); references = new Set<SolutionFolderItem>(); foreach (SolutionFolderItem item in subitems) { if (item is SolutionItem) { SolutionItem entry = (SolutionItem) item; if (!config.BuildEnabledForItem (entry)) continue; projects.Add (entry); references.Union (entry.GetReferencedItems (config.Selector)); } else if (item is SolutionFolder) { Set<SolutionFolderItem> subProjects; Set<SolutionFolderItem> subReferences; GetAllProjects ((SolutionFolder)item, config, out subProjects, out subReferences); projects.Union (subProjects); references.Union (subReferences); } } references.Without (projects); combineProjects [folder] = projects; combineReferences [folder] = references; }
public void IncludeFileToProject () { Set<IWorkspaceFileObject> projects = new Set<IWorkspaceFileObject> (); var nodesByProject = CurrentNodes.GroupBy (n => n.GetParentDataItem (typeof(Project), true) as Project); foreach (var projectGroup in nodesByProject) { Project project = projectGroup.Key; List<FilePath> newFiles = new List<FilePath> (); foreach (ITreeNavigator node in projectGroup) { SystemFile file = (SystemFile) node.DataItem; if (project != null) { newFiles.Add (file.Path); projects.Add (project); } else { SolutionFolder folder = node.GetParentDataItem (typeof(SolutionFolder), true) as SolutionFolder; if (folder != null) { folder.Files.Add (file.Path); projects.Add (folder.ParentSolution); } else { Solution sol = node.GetParentDataItem (typeof(Solution), true) as Solution; sol.RootFolder.Files.Add (file.Path); projects.Add (sol); } } } if (newFiles.Count > 0) project.AddFiles (newFiles); } IdeApp.ProjectOperations.SaveAsync (projects); }
/// <summary> /// On Refresh, we want to reload the XML configuration files. This greatly facilitates developing /// those files, even though it's not as useful for normal use. It might prove useful whenever we /// get around to allowing user customization (or it might not). /// </summary> /// <param name="sender"></param> /// <returns></returns> public bool OnRefresh(object sender) { CheckDisposed(); Set<string> setDatabases = new Set<string>(); foreach (FwXWindow wnd in m_rgMainWindows) { string sDatabase = wnd.Cache.DatabaseName; if (setDatabases.Contains(sDatabase)) continue; setDatabases.Add(sDatabase); Inventory.GetInventory("layouts", sDatabase).ReloadIfChanges(); Inventory.GetInventory("parts", sDatabase).ReloadIfChanges(); } return false; }
public override void DeleteMultipleItems() { var projects = new Set<SolutionEntityItem> (); var folders = new List<ProjectFolder> (); foreach (ITreeNavigator node in CurrentNodes) folders.Add ((ProjectFolder) node.DataItem); var removeButton = new AlertButton (GettextCatalog.GetString ("_Remove from Project"), Gtk.Stock.Remove); var question = new QuestionMessage () { AllowApplyToAll = folders.Count > 1, SecondaryText = GettextCatalog.GetString ( "The Delete option permanently removes the directory and any files it contains from your hard disk. " + "Click Remove from Project if you only want to remove it from your current solution.") }; question.Buttons.Add (AlertButton.Cancel); question.Buttons.Add (AlertButton.Delete); question.Buttons.Add (removeButton); var deleteOnlyQuestion = new QuestionMessage () { AllowApplyToAll = folders.Count > 1, SecondaryText = GettextCatalog.GetString ("The directory and any files it contains will be permanently removed from your hard disk. ") }; deleteOnlyQuestion.Buttons.Add (AlertButton.Cancel); deleteOnlyQuestion.Buttons.Add (AlertButton.Delete); foreach (var folder in folders) { var project = folder.Project; AlertButton result; if (project == null) { deleteOnlyQuestion.Text = GettextCatalog.GetString ("Are you sure you want to remove directory {0}?", folder.Name); result = MessageService.AskQuestion (deleteOnlyQuestion); if (result == AlertButton.Delete) { DeleteFolder (folder); continue; } else break; } var folderRelativePath = folder.Path.ToRelative (project.BaseDirectory); var files = project.Files.GetFilesInVirtualPath (folderRelativePath).ToList (); var folderPf = project.Files.GetFileWithVirtualPath (folderRelativePath); bool isProjectFolder = files.Count == 0 && folderPf == null; //if the parent directory has already been removed, there may be nothing to do if (isProjectFolder) { deleteOnlyQuestion.Text = GettextCatalog.GetString ("Are you sure you want to remove directory {0}?", folder.Name); result = MessageService.AskQuestion (deleteOnlyQuestion); if (result != AlertButton.Delete) break; } else { question.Text = GettextCatalog.GetString ("Are you sure you want to remove directory {0} from project {1}?", folder.Name, project.Name); result = MessageService.AskQuestion (question); if (result != removeButton && result != AlertButton.Delete) break; projects.Add (project); //remove the files and link files in the directory foreach (var f in files) project.Files.Remove (f); // also remove the folder's own ProjectFile, if it exists // FIXME: it probably was already in the files list if (folderPf != null) project.Files.Remove (folderPf); } if (result == AlertButton.Delete) { DeleteFolder (folder); } else { //explictly remove the node from the tree, since it currently only tracks real folder deletions folder.Remove (); } if (isProjectFolder && folder.Path.ParentDirectory != project.BaseDirectory) { // If it's the last item in the parent folder, make sure we keep a reference to the parent // folder, so it is not deleted from the tree. var inParentFolder = project.Files.GetFilesInVirtualPath (folderRelativePath.ParentDirectory); if (!inParentFolder.Skip (1).Any ()) { project.Files.Add (new ProjectFile (folder.Path.ParentDirectory) { Subtype = Subtype.Directory, }); } } } IdeApp.ProjectOperations.Save (projects); }
static internal bool TryFirstWsInList(SIL.FieldWorks.Common.COMInterfaces.ISilDataAccess sda, int hvo, int flid, int[] wssToTry, ref Set<int> wssTried, out int retWs, out ITsString retTss) { retTss = null; retWs = 0; foreach (int wsLoop in wssToTry) { if (wssTried.Contains(wsLoop)) continue; wssTried.Add(wsLoop); retTss = sda.get_MultiStringAlt(hvo, flid, wsLoop); if (retTss.Length > 0) { retWs = wsLoop; return true; } } return false; }
/// <summary> /// This method is the one to override if you need side effects when DeleteUnderlyingObject /// is called. If other objects should be deleted also, do NOT delete them directly; this /// tends to produce abysmal performance. Rather, add them to objectsToDeleteAlso, and the /// whole lot (including this) will be deleted in one relatively efficient operation. /// You should not modify objectsToDeleteAlso except to add HVOs to it. /// You must not use the FDO object after calling this, it has been put into the deleted state. /// </summary> /// <param name="objectsToDeleteAlso">hashtable of HVOs (value typically just true, it's really a set).</param> /// <param name="state"></param> public override void DeleteObjectSideEffects(Set<int> objectsToDeleteAlso, ProgressState state) { if (Owner.ClassID == PhMetathesisRule.kclsidPhMetathesisRule) { // update the StrucChange field to reflect the removed simple context IPhMetathesisRule rule = Owner as IPhMetathesisRule; int removeCtxt = rule.UpdateStrucChange(rule.GetStrucChangeIndex(Hvo), IndexInOwner, false); if (removeCtxt != 0) objectsToDeleteAlso.Add(removeCtxt); } base.DeleteObjectSideEffects(objectsToDeleteAlso, state); }
/// <summary> /// This method is the one to override if you need side effects when DeleteUnderlyingObject /// is called. If other objects should be deleted also, do NOT delete them directly; this /// tends to produce abysmal performance. Rather, add them to objectsToDeleteAlso, and the /// whole lot (including this) will be deleted in one relatively efficient operation. /// You should not modify objectsToDeleteAlso except to add HVOs to it. /// You must not use the FDO object after calling this, it has been put into the deleted state. /// </summary> /// <param name="objectsToDeleteAlso">hashtable of HVOs (value typically just true, it's really a set).</param> /// <param name="state"></param> public override void DeleteObjectSideEffects(Set<int> objectsToDeleteAlso, ProgressState state) { switch (Owner.ClassID) { case MoAffixProcess.kclsidMoAffixProcess: // if this is owned by a MoAffixProcess we must remove all of the associated output mappings IMoAffixProcess rule = Owner as IMoAffixProcess; foreach (int mappingHvo in rule.OutputOS.HvoArray) { switch (m_cache.GetClassOfObject(mappingHvo)) { case MoCopyFromInput.kclsidMoCopyFromInput: IMoCopyFromInput copy = new MoCopyFromInput(m_cache, mappingHvo); if (copy.ContentRAHvo == Hvo) objectsToDeleteAlso.Add(mappingHvo); break; case MoModifyFromInput.kclsidMoModifyFromInput: IMoModifyFromInput modify = new MoModifyFromInput(m_cache, mappingHvo); if (modify.ContentRAHvo == Hvo) objectsToDeleteAlso.Add(mappingHvo); break; } } break; case PhPhonData.kclsidPhPhonData: List<LinkedObjectInfo> linkedObjs = LinkedObjects; foreach (LinkedObjectInfo loi in linkedObjs) { if (loi.RelObjClass == PhIterationContext.kclsidPhIterationContext && loi.RelObjField == (int)PhIterationContext.PhIterationContextTags.kflidMember) { IPhIterationContext ctxt = new PhIterationContext(m_cache, loi.RelObjId); ctxt.DeleteObjectSideEffects(objectsToDeleteAlso, state); objectsToDeleteAlso.Add(loi.RelObjId); } else if (loi.RelObjClass == PhSequenceContext.kclsidPhSequenceContext && loi.RelObjField == (int)PhSequenceContext.PhSequenceContextTags.kflidMembers && m_cache.GetVectorSize(loi.RelObjId, (int)PhSequenceContext.PhSequenceContextTags.kflidMembers) == 1) { IPhSequenceContext ctxt = new PhSequenceContext(m_cache, loi.RelObjId); ctxt.DeleteObjectSideEffects(objectsToDeleteAlso, state); objectsToDeleteAlso.Add(loi.RelObjId); } } break; } base.DeleteObjectSideEffects(objectsToDeleteAlso, state); }
/// <summary> /// This method is the one to override if you need side effects when DeleteUnderlyingObject /// is called. If other objects should be deleted also, do NOT delete them directly; this /// tends to produce abysmal performance. Rather, add them to objectsToDeleteAlso, and the /// whole lot (including this) will be deleted in one relatively efficient operation. /// You should not modify objectsToDeleteAlso except to add HVOs to it. /// You must not use the FDO object after calling this, it has been put into the deleted state. /// </summary> /// <param name="objectsToDeleteAlso">hashtable of HVOs (value typically just true, it's really a set).</param> /// <param name="state"></param> public override void DeleteObjectSideEffects(Set<int> objectsToDeleteAlso, ProgressState state) { if (MemberRAHvo != 0) objectsToDeleteAlso.Add(MemberRAHvo); base.DeleteObjectSideEffects(objectsToDeleteAlso, state); }
/// <summary> /// Get a set of hvos that are suitable for targets to a reference property. /// Subclasses should override this method to return a sensible list of IDs. /// </summary> /// <param name="flid">The reference property that can store the IDs.</param> /// <returns>A set of hvos.</returns> public override Set<int> ReferenceTargetCandidates(int flid) { Set<int> set = null; switch (flid) { case (int)PartOfSpeech.PartOfSpeechTags.kflidDefaultInflectionClass: set = new Set<int>(); foreach (IMoInflClass ic in AllInflectionClasses) set.Add(ic.Hvo); break; case (int)PartOfSpeech.PartOfSpeechTags.kflidBearableFeatures: set = new Set<int>(); ILangProject lp = m_cache.LangProject; if (lp != null) { IFsFeatStrucType exceps = lp.ExceptionFeatureType; set.AddRange(exceps.FeaturesRS.HvoArray); } break; case (int)PartOfSpeech.PartOfSpeechTags.kflidInflectableFeats: set = new Set<int>(); set.AddRange(m_cache.LangProject.MsFeatureSystemOA.FeaturesOC.HvoArray); break; default: set = base.ReferenceTargetCandidates(flid); break; } return set; }
/// <summary> /// This method is called by the ReversalEntriesText virtual handler when text may have changed in the /// property, in order to update the actual list of reversal entries appropriately. /// </summary> /// <param name="tssVal">The new string.</param> /// <param name="ws">The ws.</param> public void CommitReversalEntriesText(ITsString tssVal, int ws) { LexSenseReversalEntriesTextHandler vh = BaseVirtualHandler.GetInstalledHandler(m_cache, "LexSense", LexSenseReversalEntriesTextHandler.StandardFieldName) as LexSenseReversalEntriesTextHandler; Debug.Assert(vh != null, "The 'LexSenseReversalEntriesTextHandler' virtual handler has to be created at application startup now."); ITsString tssOld = vh.GetValue(m_hvo, ws); // The old and new values could be in another order, and this test won't catch that case. // That condition won't be fatal, however, so don't fret about it. if (tssOld.Equals(tssVal)) return; // no change has occurred string val = tssVal.Text; if (val == null) val = ""; // This will effectively cause any extant entries for the given 'ws' to be removed in the end. StringCollection formsColl = new StringCollection(); foreach (string form in val.Split(';')) { // These strings will be null, if there are two semi-colons together. // Or, it may be just whitespace, if it is '; ;'. if (form == null || form.Trim().Length == 0) continue; formsColl.Add(form.Trim()); } int[] senseEntries = ReversalEntriesRC.HvoArray; int originalSenseEntriesCount = senseEntries.Length; int indexId; DbOps.ReadOneIntFromCommand(m_cache, "SELECT id FROM ReversalIndex WHERE WritingSystem=?", ws, out indexId); ReversalIndex revIndex; if (indexId == 0) { // Create the missing reversal index instead of crashing. See LT-10186. ILgWritingSystem lgws = LgWritingSystem.CreateFromDBObject(m_cache, ws); IReversalIndex newIdx = m_cache.LangProject.LexDbOA.ReversalIndexesOC.Add(new ReversalIndex()); newIdx.WritingSystemRA = lgws; // Copy any and all alternatives from lgws.Name to newIdx.Name foreach (ILgWritingSystem lgwsLoop in m_cache.LanguageEncodings) { string lgsNameAlt = lgws.Name.GetAlternative(lgwsLoop.Hvo); if (lgsNameAlt != null && lgsNameAlt.Length > 0) newIdx.Name.SetAlternative(lgsNameAlt, lgws.Hvo); } revIndex = (ReversalIndex)newIdx; } else { revIndex = (ReversalIndex)CmObject.CreateFromDBObject(m_cache, indexId, false); } // We need the list of ReversalIndexEntries that this sense references, but which belong // to another reversal index. Those hvos, plus any entry hvos from the given 'ws' that are reused, // get put into 'survivingEntries'. Set<int> survivingEntries = new Set<int>(originalSenseEntriesCount + formsColl.Count); // 'entriesNeedingPropChangeBackRef' will hold the hvos of all ReversalIndexEntry objects that need to have // their 'ReferringSenses' virtual property (re)computed. // Any reversal index entry that gains or loses a reference will need this (re)computing. List<int> entriesNeedingPropChangeBackRef = new List<int>(originalSenseEntriesCount + formsColl.Count); foreach (int entryHvo in senseEntries) { // Use 'cheapo' FDO object maker, since it is supposed to all be in the cache already. ReversalIndexEntry rie = (ReversalIndexEntry)CmObject.CreateFromDBObject(m_cache, entryHvo, false); int wsIndex = 0; int hvoIndex = m_cache.GetOwnerOfObjectOfClass(rie.Hvo, ReversalIndex.kclsidReversalIndex); if (hvoIndex != 0) wsIndex = m_cache.GetIntProperty(hvoIndex, (int)ReversalIndex.ReversalIndexTags.kflidWritingSystem); if (wsIndex == ws) { string form = rie.LongName; if (formsColl.Contains(form)) { // Recycling an entry. survivingEntries.Add(rie.Hvo); formsColl.Remove(form); // Don't need to mess with it later on. } else { // It is being removed from the extant reference property, // so needs to recompute its back ref virtual handler. entriesNeedingPropChangeBackRef.Add(rie.Hvo); } } else { // These are all in some other ws, so they certainly must survive (cf. LT-3391). // Any entries that are reused will get added to this array later on. survivingEntries.Add(rie.Hvo); } } // Start Undoable section of code. m_cache.BeginUndoTask(Strings.ksUndoMakeRevEntries, Strings.ksRedoMakeRevEntries); ISilDataAccess sda = m_cache.MainCacheAccessor; IActionHandler acth = sda.GetActionHandler(); try { // add undo actions to reload the virtual handler and send prop changes to update displays if (acth != null) { List<PropChangedInfo> pciList = new List<PropChangedInfo>(); pciList.Add(new PropChangedInfo(m_hvo, vh.Tag, ws, 0, 0)); acth.AddAction(new PropChangedUndoAction(m_cache, true, PropChangeType.kpctNotifyAll, pciList)); acth.AddAction(new ReloadVirtualHandlerUndoAction(m_cache, true, vh, m_hvo, vh.Tag, ws)); } int cOldEntries = revIndex.EntriesOC.Count; foreach (string currentForm in formsColl) { int idRevEntry = revIndex.FindOrCreateReversalEntry(currentForm); entriesNeedingPropChangeBackRef.Add(idRevEntry); survivingEntries.Add(idRevEntry); } // Notify everyone, and his brother, about the changes done here. // PropChanged (1 of 3) Main: Replace main sense property with current set of entries. sda.Replace(m_hvo, (int)LexSense.LexSenseTags.kflidReversalEntries, 0, originalSenseEntriesCount, survivingEntries.ToArray(), survivingEntries.Count); sda.PropChanged(null, (int)PropChangeType.kpctNotifyAll, m_hvo, (int)LexSense.LexSenseTags.kflidReversalEntries, 0, survivingEntries.Count, originalSenseEntriesCount); // remove entries from the index that are no longer valid foreach (int rieHvo in senseEntries) { if (!survivingEntries.Contains(rieHvo)) { // the entry is no longer a reversal entry for this sense ReversalIndexEntry rie = new ReversalIndexEntry(m_cache, rieHvo); if (rie.SenseIds.Count == 0) // the entry is longer a reversal entry for any sense revIndex.EntriesOC.Remove(rie); } } // PropChanged (2 of 3) Affected Entries: (Re)compute // on the virtual property of select reversal index entries. ReversalIndexEntry.ResetReferringSenses(m_cache, entriesNeedingPropChangeBackRef); // PropChanged (3 of 3) Index Entries: Simulate a complete replacement of the entries collection, // BUT only if new entries were added in this method. int cNewEntries = revIndex.EntriesOC.Count; if (cNewEntries > cOldEntries) { sda.PropChanged(null, (int)PropChangeType.kpctNotifyAll, indexId, (int)ReversalIndex.ReversalIndexTags.kflidEntries, 0, cNewEntries, cOldEntries); } // add redo actions to reload the virtual handler and send prop changes to update displays if (acth != null) { acth.AddAction(new ReloadVirtualHandlerUndoAction(m_cache, false, vh, m_hvo, vh.Tag, ws)); List<PropChangedInfo> pciList = new List<PropChangedInfo>(); pciList.Add(new PropChangedInfo(m_hvo, vh.Tag, ws, 0, 0)); acth.AddAction(new PropChangedUndoAction(m_cache, false, PropChangeType.kpctNotifyAll, pciList)); } } finally { if (acth != null && Marshal.IsComObject(acth)) Marshal.ReleaseComObject(acth); } // End undoable section of code. m_cache.EndUndoTask(); }
public void FindCurves(string whereClause = null) { IMap pMap = ArcMap.Document.ActiveView.FocusMap; if (hasOpenJob()) return; IRelationshipClass relationshipClass = null; ISelectionSet relatedSelectionSet = null; myAOProgressor progressor = new myAOProgressor(); try { Finished = false; progressor.setStepProgressorProperties(1, "Initializing"); ICadastralFabricLayer CFLayer = GetFabricLayer(pMap); IFeatureLayer CFLineLayer = CFLayer.get_CadastralSubLayer(esriCadastralFabricRenderer.esriCFRLines); IFeatureLayer CFParcelLayer = CFLayer.get_CadastralSubLayer(esriCadastralFabricRenderer.esriCFRParcels); //for each CF line feature class IFeatureSelection CFLineFeatureSelection = (IFeatureSelection)CFLineLayer; IFeatureSelection CFParcelFeatureSelection = (IFeatureSelection)CFParcelLayer; ISelectionSet selectionSet = null; if (CFParcelFeatureSelection.SelectionSet.Count > 0) { //parcels selected //Create memory relationship class to help with the mapping IMemoryRelationshipClassFactory MemoryRCF = new MemoryRelationshipClassFactoryClass(); relationshipClass = MemoryRCF.Open("Parcel_Layer_Rel", CFParcelLayer.FeatureClass, "ObjectID", CFLineLayer.FeatureClass, "ParcelID", "forward", "backward", esriRelCardinality.esriRelCardinalityOneToMany); //convert selection set to ISet of rows ISet polySet = new Set(); ICursor cursor; CFParcelFeatureSelection.SelectionSet.Search(null, false, out cursor); IRow row = null; while((row = cursor.NextRow()) != null) polySet.Add(row); polySet.Reset(); //use the relationship class to find related rows ISet lineSet = relationshipClass.GetObjectsRelatedToObjectSet(polySet); //convert set back to selection set lineSet.Reset(); //create an empty selection set (there should be a better way to do this.... //will only evaluate the lines related to the parcels that are selected //selectionSet = CFLineLayer.FeatureClass.Select(new QueryFilter() { WhereClause = "1=0" }, esriSelectionType.esriSelectionTypeIDSet, esriSelectionOption.esriSelectionOptionNormal, null); //will union the current line selection and the parcel selection relatedSelectionSet = CFLineFeatureSelection.SelectionSet.Select(null, esriSelectionType.esriSelectionTypeIDSet, esriSelectionOption.esriSelectionOptionNormal, null); while ((row = (IRow)lineSet.Next()) != null) { relatedSelectionSet.Add(row.OID); Marshal.ReleaseComObject(row); } Marshal.ReleaseComObject(lineSet); polySet.Reset(); while ((row = (IRow)polySet.Next()) != null) Marshal.ReleaseComObject(row); Marshal.ReleaseComObject(polySet); selectionSet = relatedSelectionSet; } else if (CFLineFeatureSelection.SelectionSet.Count > 0) { //lines selected selectionSet = CFLineFeatureSelection.SelectionSet; } else { if (DialogResult.OK != messageBox.Show("You are about to run the add-in on the entire feature class, this could take a long time. Proceeed?", "Long Operation", MessageBoxButtons.OKCancel)) return; } FindCurves(CFLineLayer.Name, CFLineLayer.FeatureClass, selectionSet, whereClause, progressor); if (Curves.Count == 0) { messageBox.Show("No inferred curved lines found."); return; } } catch (Exception Exx) { messageBox.Show(Exx.Message); if (relationshipClass != null) Marshal.ReleaseComObject(relationshipClass); if (relatedSelectionSet != null) Marshal.ReleaseComObject(relatedSelectionSet); } finally { progressor.Dispose(); Finished = true; } }
public void IncludeToProject() { Set<SolutionEntityItem> projects = new Set<SolutionEntityItem> (); foreach (ITreeNavigator node in CurrentNodes) { Project project = node.GetParentDataItem (typeof(Project), true) as Project; if (node.HasChildren ()) { List<SystemFile> filesToAdd = new List<SystemFile> (); ITreeNavigator nav = node.Clone (); GetFiles (nav, filesToAdd); foreach (SystemFile file in filesToAdd) project.AddFile (file.Path); projects.Add (project); } else { ProjectFolder pf = node.DataItem as ProjectFolder; if (pf != null) { project.AddDirectory (FileService.AbsoluteToRelativePath (project.BaseDirectory, pf.Path)); projects.Add (project); } } } IdeApp.ProjectOperations.Save (projects); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Adds all of the LgWritingSystems in source to the namedWritingSystems set. /// </summary> /// <param name="namedWritingSystems"></param> /// <param name="source"></param> /// <param name="displayLocale">REVIEW (TimS): Looks like this param is not used (maybe /// used to be used). Is there a plan to use it or can it be removed?</param> /// ------------------------------------------------------------------------------------ private static void AddWsNamedObjsToSet(Set<NamedWritingSystem> namedWritingSystems, IEnumerable source, string displayLocale) { foreach (LgWritingSystem ws in source) { NamedWritingSystem nws = new NamedWritingSystem(ws.ShortName, ws.ICULocale, ws.Hvo); // TE-6958 kept crashing when we tried to get a hashcode for a malformed ws. Instead // of crashing, let's just skip the bum ws. It's still a mystery how we apparently get // a ws without a name since the name will default to the IcuLocale if it is missing. if (nws.Name != null && nws.IcuLocale != null) namedWritingSystems.Add(nws); } }
void PublishDir (Set<FilePath> dirs, FilePath dir, bool rec, IProgressMonitor monitor) { string ndir = (string) dir; while (ndir[ndir.Length - 1] == Path.DirectorySeparatorChar) ndir = ndir.Substring (0, ndir.Length - 1); dir = ndir; if (dirs.Contains (dir)) return; dirs.Add (dir); if (rec) { PublishDir (dirs, dir.ParentDirectory, true, monitor); Add (dir, false, monitor); } }
private static Set<NamedWritingSystem> GetNamedWritingSystemsFromLDFs(ILgWritingSystemFactory wsf, string[] fileList, Set<NamedWritingSystem> namedWritingSystems) { Set<string> names = new Set<string>(); foreach (NamedWritingSystem nws in namedWritingSystems) names.Add(nws.IcuLocale); // Now add the ones from the XML files. foreach (string pathname in fileList) { string[] bits = pathname.Split('\\'); string filename = bits[bits.Length - 1]; bits = filename.Split('.'); string icuLocale = bits[0]; // Name up to first '.'. // The first test excludes names like en.xml1. if (bits[1] == "xml" && !names.Contains(icuLocale.ToLowerInvariant())) { try { // This will get the language name from the XML language def. file. This // should be the same name the user chose to call the language when creating // its writing system. LanguageDefinitionFactory ldf = new LanguageDefinitionFactory(wsf, icuLocale); if (ldf.LanguageDefinition == null) { System.Diagnostics.Debug.WriteLine("The XML file for " + icuLocale + " did not parse properly."); } else { string displayName = ldf.LanguageDefinition.DisplayName; // REVIEW: These two lines are how we used to get the display name. Now we read // it from the language def. file (i.e. the .xml file). Will the name from the // XML file always be in the display locale? //Icu.UErrorCode err; //Icu.GetDisplayName(icuLocale, displayLocale, out displayName, out err); // If it can't find a name, the normal behavior is to return the icuLocale. // If that happens we leave this one out. // If anything worse happens (e.g., that might produce a bad error code), // the other checks we make here should detect it. if (displayName != null && displayName != icuLocale && displayName.Length != 0) namedWritingSystems.Add(new NamedWritingSystem(displayName, icuLocale)); } } catch (FileNotFoundException e) { System.Diagnostics.Debug.WriteLine(e.Message); // LanguageDefinitionFactory can throw this error. Just ignore it. } } } return namedWritingSystems; }
private int ConvertDummiesToReal(int hvoDummy) { List<int> currentEntries = new List<int>(); int countIndices = m_silCache.get_VecSize(m_sense.Hvo, kFlidIndices); int hvoReal = 0; Set<int> writingSystemsModified = new Set<int>(); for (int i = 0; i < countIndices; ++i) { int hvoIndex = m_silCache.get_VecItem(m_sense.Hvo, kFlidIndices, i); ReversalIndex revIndex = ReversalIndex.CreateFromDBObject(m_fdoCache, hvoIndex) as ReversalIndex; writingSystemsModified.Add(revIndex.WritingSystemRAHvo); int countRealEntries = m_silCache.get_VecSize(hvoIndex, kFlidEntries) - 1; // Skip the dummy entry at the end. // Go through it from the far end, since we may be deleting empty items. for (int j = countRealEntries - 1; j >= 0; --j) { int hvoEntry = m_silCache.get_VecItem(hvoIndex, kFlidEntries, j); // If hvoEntry is greater than 0, then it started as a real entry. // If hvoEntry is less than 0, it is clearly a new one. // The text may have changed for a real one, so check to see if is the same. // If it is the same, then just add it to the currentEntries array. // If it is different, or if it is a new one, then we need to // see if it already exists in the index. // If it exists, then add it to the currentEntries array. // If it does not exist, we have to create it, and add it to the currentEntries array. List<string> rgsFromDummy = new List<string>(); if (GetReversalFormsAndCheckExisting(currentEntries, hvoIndex, revIndex.WritingSystemRAHvo, j, hvoEntry, rgsFromDummy)) { continue; } // At this point, we need to find or create one or more entries. int hvo = revIndex.FindOrCreateReversalEntry(rgsFromDummy); currentEntries.Add(hvo); if (hvoEntry == hvoDummy) hvoReal = hvo; } } // Reset the sense's ref. property to all the ids in the currentEntries array. int[] ids = currentEntries.ToArray(); int senseFlid = (int)LexSense.LexSenseTags.kflidReversalEntries; if (!m_fdoCache.IsValidObject(m_sense.Hvo)) return 0; // our object has been deleted while we weren't looking! int countEntries = m_fdoCache.GetVectorSize(m_sense.Hvo, senseFlid); // Check the current state and don't save (or create an Undo stack item) if // nothing has changed. bool fChanged = true; if (countEntries == ids.Length) { fChanged = false; for (int i = 0; i < countEntries; ++i) { int id = m_fdoCache.GetVectorItem(m_sense.Hvo, senseFlid, i); if (id != ids[i]) { fChanged = true; break; } } } if (fChanged) { m_fdoCache.BeginUndoTask(LexEdStrings.ksUndoSetRevEntries, LexEdStrings.ksRedoSetRevEntries); m_fdoCache.ReplaceReferenceProperty(m_sense.Hvo, senseFlid, 0, countEntries, ref ids); m_fdoCache.EndUndoTask(); // Also recompute and issue a PropChanged for the virtual property which may be displaying these // senses as a string in bulk edit. IVwVirtualHandler vh = m_fdoCache.VwCacheDaAccessor.GetVirtualHandlerName("LexSense", LexSenseReversalEntriesTextHandler.StandardFieldName); if (vh != null) { foreach (int ws in writingSystemsModified) { vh.Load(m_sense.Hvo, vh.Tag, ws, m_fdoCache.VwCacheDaAccessor); m_fdoCache.PropChanged(m_sense.Hvo, vh.Tag, ws, 0, 0); } } } return hvoReal; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Returns a set of NamedWritingSystem objects for the current pronunciation /// writing systems. If that set is empty, writing systems from the vernacular set /// with ICULocale variants of IPA or EMC are added to the current pronunciation writing /// systems. If the pronunciation set is still empty, the first vernacular writing /// system is added to it. /// </summary> /// <returns> /// Set of current pronunciation writing systems as NamedWritingSystem objects /// </returns> /// ------------------------------------------------------------------------------------ public Set<NamedWritingSystem> GetPronunciationWritingSystems() { InitializePronunciationWritingSystems(); string displayLocale = m_cache.LanguageWritingSystemFactoryAccessor.GetStrFromWs(m_cache.DefaultUserWs); Set<NamedWritingSystem> writingSystems = GetDbNamedWritingSystems(); ILgWritingSystem wsVern = CurVernWssRS[0]; string sVern = wsVern.ICULocale; int idx = sVern.IndexOf("_"); if (idx > 0) sVern = sVern.Substring(0, idx + 1).ToLowerInvariant(); else sVern = sVern.ToLower() + "_"; Set<NamedWritingSystem> pronunciationWritingSystems = new Set<NamedWritingSystem>(CurPronunWssRS.Count + 1); AddWsNamedObjsToSet(pronunciationWritingSystems, CurPronunWssRS, displayLocale); foreach (NamedWritingSystem nws in writingSystems) { if (nws.IcuLocale == wsVern.ICULocale || nws.IcuLocale.IndexOf(sVern) == 0) pronunciationWritingSystems.Add(nws); } return pronunciationWritingSystems; }
// utility function for finding the correct order to process directories List<SolutionFolderItem> CalculateSubDirOrder (AutotoolsContext ctx, SolutionFolder folder, SolutionConfiguration config) { List<SolutionFolderItem> resultOrder = new List<SolutionFolderItem>(); Set<SolutionFolderItem> dependenciesMet = new Set<SolutionFolderItem>(); Set<SolutionFolderItem> inResult = new Set<SolutionFolderItem>(); // We don't have to worry about projects built in parent combines dependenciesMet.Union (ctx.GetBuiltProjects ()); bool added; string notMet; do { added = false; notMet = null; List<SolutionFolderItem> items = new List<SolutionFolderItem> (); GetSubItems (items, folder); foreach (SolutionFolderItem item in items) { Set<SolutionFolderItem> references, provides; if (inResult.Contains (item)) continue; if (item is SolutionItem) { SolutionItem entry = (SolutionItem) item; if (!config.BuildEnabledForItem (entry)) continue; references = new Set<SolutionFolderItem> (); provides = new Set<SolutionFolderItem>(); references.Union (entry.GetReferencedItems (config.Selector)); provides.Add (entry); } else if (item is SolutionFolder) { GetAllProjects ((SolutionFolder) item, config, out provides, out references); } else continue; if (dependenciesMet.ContainsSet (references) ) { resultOrder.Add (item); dependenciesMet.Union(provides); inResult.Add(item); added = true; } else notMet = item.Name; } } while (added); if (notMet != null) throw new Exception("Impossible to find a solution order that satisfies project references for '" + notMet + "'"); return resultOrder; }
/// <summary> /// Get a Set of zero or more actual writing system IDs for the given ws identifier. /// </summary> /// <param name="sWs">One of our magic strings that signifies one or more writing systems</param> /// <param name="cache"></param> /// <param name="currentWS"></param> /// <param name="hvo">object to use in determining 'best' names</param> /// <param name="flid">flid to use in determining 'best' names</param> /// <returns></returns> public static Set<int> GetAllWritingSystems(string sWs, FdoCache cache, IWritingSystem currentWS, int hvo, int flid) { Set<int> allWsIds = new Set<int>(); if (sWs != null) { switch (sWs) { case "all analysis": allWsIds.AddRange(cache.LangProject.CurAnalysisWssRS.HvoArray); break; case "all vernacular": allWsIds.AddRange(cache.LangProject.CurVernWssRS.HvoArray); break; case "analysis vernacular": allWsIds.AddRange(cache.LangProject.CurAnalysisWssRS.HvoArray); allWsIds.AddRange(cache.LangProject.CurVernWssRS.HvoArray); break; case "vernacular analysis": allWsIds.AddRange(cache.LangProject.CurVernWssRS.HvoArray); allWsIds.AddRange(cache.LangProject.CurAnalysisWssRS.HvoArray); break; case "all pronunciation": cache.LangProject.InitializePronunciationWritingSystems(); allWsIds.AddRange(cache.LangProject.CurPronunWssRS.HvoArray); //if (allWsIds.Count == 0) // allWsIds.Add(cache.LangProject.DefaultPronunciationWritingSystem); break; default: sWs = GetWsSpecWithoutPrefix(sWs); string[] rgsWs = sWs.Split(new char[] { ',' }); for (int i = 0; i < rgsWs.Length; ++i) { int ws = InterpretWsLabel(cache, rgsWs[i], 0, hvo, flid, currentWS); if (ws != 0) allWsIds.Add(ws); } break; } } return allWsIds; }
static void CheckModifiedFiles () { // Check databases following a bottom-up strategy in the dependency // tree. This will help resolving parsed classes. Set<ProjectDom> list = new Set<ProjectDom> (); lock (databases) { // There may be several uris for the same db foreach (ProjectDom ob in databases.Values) list.Add (ob); } Set<ProjectDom> done = new Set<ProjectDom> (); while (list.Count > 0) { ProjectDom readydb = null; ProjectDom bestdb = null; int bestRefCount = int.MaxValue; // Look for a db with all references resolved foreach (ProjectDom db in list) { bool allDone = true; foreach (ProjectDom refdb in db.References) { if (!done.Contains (refdb)) { allDone = false; break; } } if (allDone) { readydb = db; break; } else if (db.References.Count < bestRefCount) { bestdb = db; bestRefCount = db.References.Count; break; } } // It may not find any db without resolved references if there // are circular dependencies. In this case, take the one with // less references if (readydb == null) readydb = bestdb; readydb.CheckModifiedFiles (); list.Remove (readydb); done.Add (readydb); } }
/// <summary> /// Return the possible writing systems that we might want to preload for the given fragment. /// Note that currently this is for optimization and preloading; it is not (yet) guaranteed to /// return EVERY writing system that might be displayed by the given fragment. /// </summary> /// <param name="frag"></param> /// <param name="cache"></param> /// <returns></returns> public static Set<int> GetWritingSystems(XmlNode frag, FdoCache cache) { string wsSpec = null; XmlAttribute xa = frag.Attributes["ws"]; if (xa == null) return new Set<int>(0); wsSpec = GetWsSpecWithoutPrefix(xa.Value); Set<int> result = new Set<int>(); switch (wsSpec) { case "vernacular": result.Add(cache.DefaultVernWs); break; case "analysis": result.Add(cache.DefaultAnalWs); break; case "pronunciation": case "all pronunciation": result.Add(cache.LangProject.DefaultPronunciationWritingSystem); break; case "current": break; case "reversal": // Enhance JohnT: make this (currently for optimization preloading) routine work // better for reversal views //actualWS = GetReversalIndexEntryWritingSystem(cache, hvoObj, wsDefault); break; case "best analorvern": case "best vernoranal": return cache.LangProject.CurrentAnalysisAndVernWss; // Enhance JohnT: make this (currently for optimization preloading) routine work // better for the above two cases: possibly add all current analysis and vernacular writing systems case "analysis vernacular": case "av": case "vernacular analysis": case "va": result.Add(cache.DefaultVernWs); result.Add(cache.DefaultAnalWs); break; case "user": result.Add(cache.DefaultUserWs); break; case "best analysis": case "all analysis": result.AddRange(cache.LangProject.CurAnalysisWssRS.HvoArray); break; case "best vernacular": case "all vernacular": result.AddRange(cache.LangProject.CurVernWssRS.HvoArray); break; default: // See if we can get anywhere by treating it as an ICU locale. // Note that it is important to do this in a way that won't create a new writing system for // an invalid locale name, for example, if 'all analysis' is mistakenly passed to this routine. // Note however that the behavior of recognizing an ICU locale name for an existing writing system // definitely IS needed, e.g., when the user configures a Browse view to show an explicit writing system. int wsT = cache.LanguageWritingSystemFactoryAccessor.GetWsFromStr(wsSpec); if (wsT != 0) result.Add(wsT); break; } return result; }
public override void DeleteMultipleItems () { Set<IWorkspaceFileObject> items = new Set<IWorkspaceFileObject> (); foreach (ITreeNavigator node in CurrentNodes) { Solution solution = node.DataItem as Solution; Workspace parent = node.GetParentDataItem (typeof(Workspace), false) as Workspace; if (parent == null) return; if (MessageService.Confirm (GettextCatalog.GetString ("Do you really want to remove solution {0} from workspace {1}?", solution.Name, parent.Name), AlertButton.Remove)) { if (IdeApp.Workspace.RequestItemUnload (solution)) { parent.Items.Remove (solution); solution.Dispose (); items.Add (parent); } } } IdeApp.ProjectOperations.Save (items); }
/// <summary> /// Try to get an actual writing system id from some ws string specification. /// If it does not recognize the ws spec string, it returns 0. /// </summary> /// <param name="cache"></param> /// <param name="wsSpec"></param> /// <param name="wsDefault"></param> /// <param name="hvoObj"></param> /// <param name="flid"></param> /// <param name="currentWS"></param> /// <returns>A Set of writing system ids, or an empty Set, if it can't recognize the wsSpec parameter.</returns> internal static Set<int> GetWritingSystemIdsFromLabel(FdoCache cache, string wsSpec, int wsDefault, int hvoObj, int flid, IWritingSystem currentWS) { Set<int> writingSystemIds = new Set<int>(); switch (wsSpec.Trim().ToLowerInvariant()) { case "all analysis": { writingSystemIds.AddRange(cache.LangProject.CurAnalysisWssRS.HvoArray); break; } case "all vernacular": { writingSystemIds.AddRange(cache.LangProject.CurVernWssRS.HvoArray); break; } case "analysis vernacular": { writingSystemIds.AddRange(cache.LangProject.CurAnalysisWssRS.HvoArray); writingSystemIds.AddRange(cache.LangProject.CurVernWssRS.HvoArray); break; } case "vernacular analysis": { writingSystemIds.AddRange(cache.LangProject.CurVernWssRS.HvoArray); writingSystemIds.AddRange(cache.LangProject.CurAnalysisWssRS.HvoArray); break; } default: writingSystemIds.Add(InterpretWsLabel(cache, wsSpec, wsDefault, hvoObj, flid, currentWS)); break; } return writingSystemIds; }
/// <summary> /// Determines which types are produced by this mapping. /// </summary> private Set<EntityType> FindUnambiguouslyReachableTypes( DomainConstraintConversionContext<string, ValueCondition> converter, Vertex[] mappingConditions) { // For each entity type, create a candidate function that evaluates to true given // discriminator assignments iff. all of that type's conditions evaluate to true. var candidateFunctions = new Vertex[MappedEntityTypes.Count]; for (var i = 0; i < candidateFunctions.Length; i++) { // Seed the candidate function conjunction with 'true'. var candidateFunction = Vertex.One; for (var j = 0; j < NormalizedEntityTypeMappings.Count; j++) { var entityTypeMapping = NormalizedEntityTypeMappings[j]; // Determine if this mapping is a positive or negative case for the current type. if (entityTypeMapping.ImpliedEntityTypes[i]) { candidateFunction = converter.Solver.And(candidateFunction, mappingConditions[j]); } } candidateFunctions[i] = candidateFunction; } // Make sure that for each type with satisfiable candidateFunction all assignments for the type resolve to only that type. var unambigouslyReachableMap = new BitArray(candidateFunctions.Length, true); for (var i = 0; i < candidateFunctions.Length; ++i) { if (candidateFunctions[i].IsZero()) { // The i-th type is unreachable regardless of other types. unambigouslyReachableMap[i] = false; } else { for (var j = i + 1; j < candidateFunctions.Length; ++j) { if (!converter.Solver.And(candidateFunctions[i], candidateFunctions[j]).IsZero()) { // The i-th and j-th types have common assignments, hence they aren't unambiguously reachable. unambigouslyReachableMap[i] = false; unambigouslyReachableMap[j] = false; } } } } var reachableTypes = new Set<EntityType>(); for (var i = 0; i < candidateFunctions.Length; ++i) { if (unambigouslyReachableMap[i]) { reachableTypes.Add(MappedEntityTypes[i]); } } return reachableTypes; }
public override void OnMultipleNodeDrop (object[] dataObjects, DragOperation operation) { Set<IWorkspaceFileObject> toSave = new Set<IWorkspaceFileObject> (); foreach (object dataObject in dataObjects) { Workspace ws = (Workspace) CurrentNode.DataItem; WorkspaceItem it = (WorkspaceItem) dataObject; if (!MessageService.Confirm (GettextCatalog.GetString ("Are you sure you want to move the item '{0}' to the workspace '{1}'?", it.Name, ws.Name), AlertButton.Move)) return; if (it.ParentWorkspace != null) { it.ParentWorkspace.Items.Remove (it); ws.Items.Add (it); toSave.Add (it.ParentWorkspace); toSave.Add (ws); } else { IdeApp.Workspace.Items.Remove (it); ws.Items.Add (it); toSave.Add (ws); } } IdeApp.ProjectOperations.Save (toSave); }