public void EssentiallyEquals_ThisTagZeroLength() { Guid newGuid = Guid.NewGuid(); FwLinkArgs args1 = new FwLinkArgs("myTool", newGuid, string.Empty); Assert.IsTrue(args1.EssentiallyEquals(new FwLinkArgs("myTool", newGuid, "myTag"))); }
public void Equals_NullParameter() { Guid newGuid = Guid.NewGuid(); FwLinkArgs args1 = new FwLinkArgs("myTool", newGuid, "myTag"); Assert.IsFalse(args1.Equals(null)); }
public void Equals_ExactlyTheSame() { Guid newGuid = Guid.NewGuid(); FwLinkArgs args1 = new FwLinkArgs("myTool", newGuid, "myTag"); Assert.IsTrue(args1.Equals(new FwLinkArgs("myTool", newGuid, "myTag"))); }
public void Equals_SameObject() { Guid newGuid = Guid.NewGuid(); FwLinkArgs args1 = new FwLinkArgs("myTool", newGuid, "myTag"); Assert.IsTrue(args1.Equals(args1)); }
public void Equals_DifferByToolName() { Guid newGuid = Guid.NewGuid(); FwLinkArgs args1 = new FwLinkArgs("myTool", newGuid, "myTag"); Assert.IsFalse(args1.Equals(new FwLinkArgs("myOtherTool", newGuid, "myTag"))); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Copy the link-related information to a new FwLinkArgs. Currently this does NOT /// yield an FwAppArgs even if the recipient is one. /// </summary> /// ------------------------------------------------------------------------------------ public FwLinkArgs CopyLinkArgs() { FwLinkArgs result = new FwLinkArgs(m_toolName, TargetGuid, m_tag); result.m_propertyTableEntries.AddRange(m_propertyTableEntries); return(result); }
public void Equals_TagOfArgumentZeroLength() { Guid newGuid = Guid.NewGuid(); FwLinkArgs args1 = new FwLinkArgs("myTool", newGuid, "myTag"); Assert.IsFalse(args1.Equals(new FwLinkArgs("myTool", newGuid, string.Empty))); }
public void Equals_ToolNameDiffersByCase() { Guid newGuid = Guid.NewGuid(); FwLinkArgs args1 = new FwLinkArgs("MyTool", newGuid, "myTag"); Assert.IsFalse(args1.Equals(new FwLinkArgs("mytool", newGuid, "myTag"))); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Some comparisons don't care about the content of the property table, so we provide a /// method similar to Equals but not quite as demanding. /// </summary> /// <param name="lnk">The link to compare.</param> /// ------------------------------------------------------------------------------------ public override bool EssentiallyEquals(FwLinkArgs lnk) { FwAppArgs appArgs = lnk as FwAppArgs; if (appArgs == null || !base.EssentiallyEquals(lnk)) { return(false); } return(appArgs.Database == Database); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Determines whether the specified <see cref="T:System.Object"/> is equal to this instance. /// </summary> /// <param name="obj">The <see cref="T:System.Object"/> to compare with this instance.</param> /// <returns> /// <c>true</c> if the specified <see cref="T:System.Object"/> is equal to this instance; otherwise, <c>false</c>. /// </returns> /// <exception cref="T:System.NullReferenceException"> /// The <paramref name="obj"/> parameter is null. /// </exception> /// ------------------------------------------------------------------------------------ public override bool Equals(object obj) { FwLinkArgs link = obj as FwLinkArgs; if (link == null) { return(false); } if (link == this) { return(true); } //just compare the URLs return(ToString() == link.ToString()); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Some comparisons don't care about the content of the property table, so we provide a /// method similar to Equals but not quite as demanding. /// </summary> /// <param name="lnk">The link to compare.</param> /// ------------------------------------------------------------------------------------ public virtual bool EssentiallyEquals(FwLinkArgs lnk) { if (lnk == null) { return(false); } if (lnk == this) { return(true); } if (lnk.ToolName != ToolName) { return(false); } if (lnk.TargetGuid != TargetGuid) { return(false); } // tag is optional, but if a tool uses it with content, it should consistently provide content. // therefore if one of these links does not have content, and the other does then // we'll assume they refer to the same link // (one link simply comes from a control with more knowledge then the other one) return(lnk.Tag.Length == 0 || Tag.Length == 0 || lnk.Tag == Tag); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Applications should override this method to handle incoming links. This method is /// called from FieldWorks when a link is requested. It is guaranteed to be on the /// correct thread (the thread this application is on) so invoking should not be needed. /// Overridden in FwXApp. /// See the class comment on FwLinkArgs for details on how all the parts of hyperlinking work. /// </summary> /// <param name="link">The link to handle.</param> /// ------------------------------------------------------------------------------------ public virtual void HandleIncomingLink(FwLinkArgs link) { throw new NotImplementedException(); }
private static void ListNewPossibilities(StreamWriter writer, string sMsg, List<ICmPossibility> list, string tool) { if (list.Count > 0) { tool = null; // FIXME when FwLink starts working again... writer.WriteLine("<h3>{0}</h3>", String.Format(sMsg, list.Count)); writer.WriteLine("<ul>"); foreach (ICmPossibility poss in list) { if (String.IsNullOrEmpty(tool)) { writer.WriteLine("<li>{0}</li>", poss.AbbrAndName); } else { FwLinkArgs link = new FwLinkArgs(tool, poss.Guid); string href = link.ToString(); writer.WriteLine("<li><a href=\"{0}\">{1}</a></li>", href, poss.AbbrAndName); } } writer.WriteLine("</ul>"); } }
public void Equals_ExactlyTheSame() { Guid newGuid = Guid.NewGuid(); FwLinkArgs args1 = new FwLinkArgs("myTool", newGuid, "myTag"); Assert.IsTrue(args1.Equals(new FwLinkArgs("myTool", newGuid, "myTag"))); }
public void EssentiallyEquals_DiffereByGuid() { FwLinkArgs args1 = new FwLinkArgs("myTool", Guid.NewGuid(), "myTag"); Assert.IsFalse(args1.EssentiallyEquals(new FwLinkArgs("myTool", Guid.NewGuid(), "myTag"))); }
/// <summary> /// Executes in two distinct scenarios. /// /// 1. If disposing is true, the method has been called directly /// or indirectly by a user's code via the Dispose method. /// Both managed and unmanaged resources can be disposed. /// /// 2. If disposing is false, the method has been called by the /// runtime from inside the finalizer and you should not reference (access) /// other managed objects, as they already have been garbage collected. /// Only unmanaged resources can be disposed. /// </summary> /// <param name="disposing"></param> /// <remarks> /// If any exceptions are thrown, that is fine. /// If the method is being done in a finalizer, it will be ignored. /// If it is thrown by client code calling Dispose, /// it needs to be handled by fixing the bug. /// /// If subclasses override this method, they should call the base implementation. /// </remarks> protected virtual void Dispose(bool disposing) { System.Diagnostics.Debug.WriteLineIf(!disposing, "****** Missing Dispose() call for " + GetType().Name + ". ****** "); // Must not be run more than once. if (m_isDisposed) return; if (disposing) { // Dispose managed resources here. if (m_mediator != null) { m_mediator.RemoveColleague(this); m_mediator.PropertyTable.SetProperty("LinkListener", null, false); m_mediator.PropertyTable.SetPropertyPersistence("LinkListener", false); } if (m_backStack != null) m_backStack.Clear(); if (m_forwardStack != null) m_forwardStack.Clear(); } // Dispose unmanaged resources here, whether disposing is true or false. m_mediator = null; m_currentContext = null; m_backStack = null; m_forwardStack = null; m_isDisposed = true; }
/// ----------------------------------------------------------------------------------- /// <summary> /// Initializes a new instance of the <see cref="LinkListener"/> class. /// </summary> /// ----------------------------------------------------------------------------------- public LinkListener() { m_backStack = new LinkedList<FwLinkArgs>(); m_forwardStack = new LinkedList<FwLinkArgs>(); m_currentContext = null; }
public void Equals_SameObject() { Guid newGuid = Guid.NewGuid(); FwLinkArgs args1 = new FwLinkArgs("myTool", newGuid, "myTag"); Assert.IsTrue(args1.Equals(args1)); }
/// <summary> /// /// </summary> /// <returns></returns> public bool OnHistoryBack(object unused) { CheckDisposed(); if (m_backStack.Count > 0) { if (m_currentContext!= null) { Push(m_forwardStack, m_currentContext); } m_fUsingHistory = true; m_lnkActive = Pop(m_backStack); FollowActiveLink(); } return true; }
public void Equals_DifferByToolName() { Guid newGuid = Guid.NewGuid(); FwLinkArgs args1 = new FwLinkArgs("myTool", newGuid, "myTag"); Assert.IsFalse(args1.Equals(new FwLinkArgs("myOtherTool", newGuid, "myTag"))); }
public void Equals_NullParameter() { Guid newGuid = Guid.NewGuid(); FwLinkArgs args1 = new FwLinkArgs("myTool", newGuid, "myTag"); Assert.IsFalse(args1.Equals(null)); }
public void Equals_ToolNameDiffersByCase() { Guid newGuid = Guid.NewGuid(); FwLinkArgs args1 = new FwLinkArgs("MyTool", newGuid, "myTag"); Assert.IsFalse(args1.Equals(new FwLinkArgs("mytool", newGuid, "myTag"))); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Copy the link-related information to a new FwLinkArgs. Currently this does NOT /// yield an FwAppArgs even if the recipient is one. /// </summary> /// ------------------------------------------------------------------------------------ public FwLinkArgs CopyLinkArgs() { FwLinkArgs result = new FwLinkArgs(m_toolName, TargetGuid, m_tag); result.m_propertyTableEntries.AddRange(m_propertyTableEntries); return result; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Some comparisons don't care about the content of the property table, so we provide a /// method similar to Equals but not quite as demanding. /// </summary> /// <param name="lnk">The link to compare.</param> /// ------------------------------------------------------------------------------------ public virtual bool EssentiallyEquals(FwLinkArgs lnk) { if (lnk == null) return false; if (lnk == this) return true; if (lnk.ToolName != ToolName) return false; if (lnk.TargetGuid != TargetGuid) return false; // tag is optional, but if a tool uses it with content, it should consistently provide content. // therefore if one of these links does not have content, and the other does then // we'll assume they refer to the same link // (one link simply comes from a control with more knowledge then the other one) return lnk.Tag.Length == 0 || Tag.Length == 0 || lnk.Tag == Tag; }
/// <summary> /// /// </summary> /// <returns></returns> public bool OnAddContextToHistory(object _link) { CheckDisposed(); //Debug.WriteLineIf(RuntimeSwitches.linkListenerSwitch.TraceInfo, "OnAddContextToHistory(" + m_currentContext + ")", RuntimeSwitches.linkListenerSwitch.DisplayName); FwLinkArgs lnk = (FwLinkArgs)_link; if (lnk.EssentiallyEquals(m_currentContext)) { //Debug.WriteLineIf(RuntimeSwitches.linkListenerSwitch.TraceInfo, " Link equals current context.", RuntimeSwitches.linkListenerSwitch.DisplayName); return true; } if (m_currentContext != null && //not where we just came from via a "Back" call ((m_forwardStack.Count == 0) || (m_currentContext != m_forwardStack.Last.Value))) { //Debug.WriteLineIf(RuntimeSwitches.linkListenerSwitch.TraceInfo, " Pushing current to back: " + m_currentContext, RuntimeSwitches.linkListenerSwitch.DisplayName); Push(m_backStack, m_currentContext); } // Try to omit intermediate targets which are added to the stack when switching // tools. This doesn't work in OnFollowLink() because the behavior of following // the link is not synchronous even when SendMessage is used at the first two // levels of handling. if (m_fFollowingLink && lnk.EssentiallyEquals(m_lnkActive)) { int howManyAdded = m_backStack.Count - m_cBackStackOrig; for( ; howManyAdded > 1; --howManyAdded) { m_backStack.RemoveLast(); } m_fFollowingLink = false; m_cBackStackOrig = 0; m_lnkActive = null; } // The forward stack should be cleared by jump operations that are NOT spawned by // a Back or Forward (ie, history) operation. This is the standard behavior in // browsers, for example (as far as I know). if (m_fUsingHistory) { if (lnk.EssentiallyEquals(m_lnkActive)) { m_fUsingHistory = false; m_lnkActive = null; } } else { m_forwardStack.Clear(); } m_currentContext = lnk; return true; }
protected override void HandleChooser() { VectorReferenceLauncher vrl = null; using (FeatureSystemInflectionFeatureListDlg dlg = new FeatureSystemInflectionFeatureListDlg()) { IFsFeatStruc originalFs = m_obj as IFsFeatStruc; Slice parentSlice = Slice; if (originalFs == null) { int owningFlid; ILexEntryInflType leit = parentSlice.Object as ILexEntryInflType; owningFlid = (parentSlice as FeatureSystemInflectionFeatureListDlgLauncherSlice).Flid; dlg.SetDlgInfo(m_cache, m_mediator, leit, owningFlid); } else { dlg.SetDlgInfo(m_cache, m_mediator, originalFs, (parentSlice as FeatureSystemInflectionFeatureListDlgLauncherSlice).Flid); } const string ksPath = "/group[@id='Linguistics']/group[@id='Morphology']/group[@id='FeatureChooser']/"; dlg.Text = m_mediator.StringTbl.GetStringWithXPath("InflectionFeatureTitle", ksPath); dlg.Prompt = m_mediator.StringTbl.GetStringWithXPath("InflectionFeaturesPrompt", ksPath); dlg.LinkText = m_mediator.StringTbl.GetStringWithXPath("InflectionFeaturesLink", ksPath); DialogResult result = dlg.ShowDialog(parentSlice.FindForm()); if (result == DialogResult.OK) { if (dlg.FS != null) m_obj = dlg.FS; m_msaInflectionFeatureListDlgLauncherView.Init(m_mediator, dlg.FS); } else if (result == DialogResult.Yes) { /* // Get the VectorReferenceLauncher for the Inflection Features slice. // Since we're not changing tools, we want to change the chooser dialog. // See LT-5913 for motivation. Control ctl = this.Parent; while (ctl != null && !(ctl is Slice)) ctl = ctl.Parent; Slice slice = ctl as Slice; if (slice != null) { DataTree dt = slice.ContainingDataTree; for (int i = 0; i < dt.Slices.Count; ++i) { Slice sliceT = dt.FieldOrDummyAt(i); vrl = sliceT.Control as VectorReferenceLauncher; if (vrl != null) { if (vrl.Flid == PartOfSpeechTags.kflidInflectableFeats) break; vrl = null; } } } if (vrl == null) { // We do, too, need to change tools! Sometimes this slice shows up in a different context, // such as the main data entry view. See LT-7167. // go to m_highestPOS in editor // TODO: this should be reviewed by someone who knows how these links should be done // I'm just guessing. // Also, is there some way to know the application name and tool name without hard coding them? */ var linkJump = new FwLinkArgs("featuresAdvancedEdit", m_cache.LanguageProject.MsFeatureSystemOA.Guid); m_mediator.PostMessage("FollowLink", linkJump); /*} else { vrl.HandleExternalChooser(); }*/ } } }
/// <summary> /// NOTE: This will not handle link requests for other databases/applications. To handle other /// databases or applications, pass a FwAppArgs to the IFieldWorksManager.HandleLinkRequest method. /// </summary> /// <returns></returns> public bool OnFollowLink(object lnk) { CheckDisposed(); m_fFollowingLink = true; m_cBackStackOrig = m_backStack.Count; m_lnkActive = lnk as FwLinkArgs; return FollowActiveLink(); }
private void btnAdd_Click(object sender, EventArgs e) { // Get the checked occurrences; List<int> occurrences = m_rbv.CheckedItems; if (occurrences == null || occurrences.Count == 0) { // do nothing. return; } List<int> uniqueSegments = (from fake in occurrences select m_clerk.VirtualListPublisher.get_ObjectProp(fake, ConcDecorator.kflidSegment)).Distinct().ToList (); int insertIndex = m_owningSense.ExamplesOS.Count; // by default, insert at the end. if (m_les != null) { // we were given a LexExampleSentence, so set our insertion index after the given one. insertIndex = m_owningSense.ExamplesOS.IndexOf(m_les) + 1; } UndoableUnitOfWorkHelper.Do(LexEdStrings.ksUndoAddExamples, LexEdStrings.ksRedoAddExamples, m_cache.ActionHandlerAccessor, () => { int cNewExamples = 0; ILexExampleSentence newLexExample = null; foreach (int segHvo in uniqueSegments) { var seg = m_cache.ServiceLocator.GetObject(segHvo) as ISegment; if (cNewExamples == 0 && m_les != null && m_les.Example.BestVernacularAlternative.Text == "***" && (m_les.TranslationsOC == null || m_les.TranslationsOC.Count == 0) && m_les.Reference.Length == 0) { // we were given an empty LexExampleSentence, so use this one for our first new Example. newLexExample = m_les; } else { // create a new example sentence. newLexExample = m_cache.ServiceLocator.GetInstance<ILexExampleSentenceFactory>().Create(); m_owningSense.ExamplesOS.Insert(insertIndex + cNewExamples, newLexExample); cNewExamples++; } // copy the segment string into the new LexExampleSentence // Enhance: bold the relevant occurrence(s). newLexExample.Example.VernacularDefaultWritingSystem = seg.BaselineText; if (seg.FreeTranslation.AvailableWritingSystemIds.Length > 0) { var trans = m_cache.ServiceLocator.GetInstance<ICmTranslationFactory>().Create(newLexExample, m_cache.ServiceLocator.GetInstance<ICmPossibilityRepository>().GetObject( CmPossibilityTags.kguidTranFreeTranslation)); trans.Translation.CopyAlternatives(seg.FreeTranslation); } if (seg.LiteralTranslation.AvailableWritingSystemIds.Length > 0) { var trans = m_cache.ServiceLocator.GetInstance<ICmTranslationFactory>().Create(newLexExample, m_cache.ServiceLocator.GetInstance<ICmPossibilityRepository>().GetObject( CmPossibilityTags.kguidTranLiteralTranslation)); trans.Translation.CopyAlternatives(seg.LiteralTranslation); } // copy the reference. ITsString tssRef = seg.Paragraph.Reference(seg, seg.BeginOffset); // convert the plain reference string into a link. ITsStrBldr tsb = tssRef.GetBldr(); FwLinkArgs fwl = new FwLinkArgs("interlinearEdit", seg.Owner.Owner.Guid); // It's not clear how to focus in on something smaller than the text when following // a link. //fwl.PropertyTableEntries.Add(new Property("LinkSegmentGuid", seg.Guid.ToString())); tsb.SetStrPropValue(0, tsb.Length, (int)FwTextPropType.ktptObjData, (char)FwObjDataTypes.kodtExternalPathName + fwl.ToString()); tsb.SetStrPropValue(0, tsb.Length, (int)FwTextPropType.ktptNamedStyle, "Hyperlink"); newLexExample.Reference = tsb.GetString(); } }); }
/// <summary> /// /// </summary> /// <returns></returns> public bool OnHistoryForward(object unused) { CheckDisposed(); if (m_forwardStack.Count > 0) { m_fUsingHistory = true; m_lnkActive = Pop(m_forwardStack); FollowActiveLink(); } return true; }
public void EssentiallyEquals_ThisTagZeroLength() { Guid newGuid = Guid.NewGuid(); FwLinkArgs args1 = new FwLinkArgs("myTool", newGuid, string.Empty); Assert.IsTrue(args1.EssentiallyEquals(new FwLinkArgs("myTool", newGuid, "myTag"))); }
private bool FollowActiveLink() { try { //Debug.Assert(!(m_lnkActive is FwAppArgs), "Beware: This will not handle link requests for other databases/applications." + // " To handle other databases or applications, pass the FwAppArgs to the IFieldWorksManager.HandleLinkRequest method."); if (m_lnkActive.ToolName == "default") { // Need some smarts here. The link creator was not sure what tool to use. // The object may also be a child we don't know how to jump to directly. var cache = (FdoCache)m_mediator.PropertyTable.GetValue("cache"); ICmObject target; if (!cache.ServiceLocator.ObjectRepository.TryGetObject(m_lnkActive.TargetGuid, out target)) return false; // or message? var realTarget = GetObjectToShowInTool(target); string realTool; var majorObject = realTarget.Owner ?? realTarget; var app = FwUtils.ksFlexAbbrev; switch (majorObject.ClassID) { case ReversalIndexTags.kClassId: realTool = "reversalToolEditComplete"; break; case TextTags.kClassId: realTool = "interlinearEdit"; break; case LexEntryTags.kClassId: realTool = "lexiconEdit"; break; case ScriptureTags.kClassId: ShowCantJumpMessage(xWorksStrings.ksCantJumpToScripture); return false; // Todo: don't know how to handle this yet. //app = FwUtils.ksTeAbbrev; //realTool = "reversalToolEditComplete"; //break; case CmPossibilityListTags.kClassId: // The area listener knows about the possible list tools. // Unfortunately AreaListener is in an assembly we can't reference. // But there may be custom ones, so just listing them all here does not seem to be an option, // and anyway it would be hard to maintain. // Thus we've created this method (on AreaListener) which we call awkwardly throught the mediator. var parameters = new object[2]; parameters[0] = majorObject; m_mediator.SendMessage("GetToolForList", parameters); realTool = (string)parameters[1]; break; case RnResearchNbkTags.kClassId: realTool = "notebookEdit"; break; case DsConstChartTags.kClassId: realTarget = ((IDsConstChart) majorObject).BasedOnRA; realTool = "interlinearEdit"; // Enhance JohnT: do something to make it switch to Discourse tab break; case LexDbTags.kClassId: // other things owned by this?? case LangProjectTags.kClassId: ShowCantJumpMessage(xWorksStrings.ksCantJumpToLangProj); return false; default: var msg = string.Format(xWorksStrings.ksCantJumpToObject, cache.MetaDataCacheAccessor.GetClassName(majorObject.ClassID)); ShowCantJumpMessage(msg); return false; // can't jump to it. } m_lnkActive = new FwLinkArgs(realTool, realTarget.Guid); // Todo JohnT: need to do something special here if we c } // It's important to do this AFTER we set the real tool name if it is "default". Otherwise, the code that // handles the jump never realizes we have reached the desired tool (as indicated by the value of // SuspendLoadingRecordUntilOnJumpToRecord) and we stop recording context history and various similar problems. if (m_lnkActive.TargetGuid != Guid.Empty) { // allow tools to skip loading a record if we're planning to jump to one. // interested tools will need to reset this "JumpToRecord" property after handling OnJumpToRecord. m_mediator.PropertyTable.SetProperty("SuspendLoadingRecordUntilOnJumpToRecord", m_lnkActive.ToolName + "," + m_lnkActive.TargetGuid.ToString(), PropertyTable.SettingsGroup.LocalSettings); m_mediator.PropertyTable.SetPropertyPersistence("SuspendLoadingRecordUntilOnJumpToRecord", false); } m_mediator.SendMessage("SetToolFromName", m_lnkActive.ToolName); // Note: It can be Guid.Empty in cases where it was never set, // or more likely, when the HVO was set to -1. if (m_lnkActive.TargetGuid != Guid.Empty) { FdoCache cache = (FdoCache)m_mediator.PropertyTable.GetValue("cache"); ICmObject obj = cache.ServiceLocator.GetInstance<ICmObjectRepository>().GetObject(m_lnkActive.TargetGuid); if (obj is IReversalIndexEntry && m_lnkActive.ToolName == "reversalToolEditComplete") { // For the reversal index tool, just getting the tool right isn't enough. We // also need to be showing the proper index. (See FWR-1105.) var guid = ReversalIndexEntryUi.GetObjectGuidIfValid(m_mediator, "ReversalIndexGuid"); if (!guid.Equals(obj.Owner.Guid)) m_mediator.PropertyTable.SetProperty("ReversalIndexGuid", obj.Owner.Guid.ToString()); } // Allow this to happen after the processing of the tool change above by using the Broadcast // method on the mediator, the SendMessage would process it before the above msg and it would // use the wrong RecordList. (LT-3260) m_mediator.BroadcastMessageUntilHandled("JumpToRecord", obj.Hvo); } foreach (Property property in m_lnkActive.PropertyTableEntries) { m_mediator.PropertyTable.SetProperty(property.name, property.value); //TODO: I can't think at the moment of what to do about setting //the persistence or ownership of the property...at the moment the only values we're putting //in there are strings or bools } m_mediator.BroadcastMessageUntilHandled("LinkFollowed", m_lnkActive); } catch(Exception err) { string s; if (err.InnerException != null && !string.IsNullOrEmpty(err.InnerException.Message)) s = String.Format(xWorksStrings.UnableToFollowLink0, err.InnerException.Message); else s = xWorksStrings.UnableToFollowLink; MessageBox.Show(s, xWorksStrings.FailedJump, System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Exclamation); return false; } return true; //we handled this. }
/// ------------------------------------------------------------------------------------ /// <summary> /// Attempt to show the most appropriate passage for the object indicated in the link. /// </summary> /// <param name="link"></param> /// ------------------------------------------------------------------------------------ public override void HandleIncomingLink(FwLinkArgs link) { ICmObject target; if (!Cache.ServiceLocator.ObjectRepository.TryGetObject(link.TargetGuid, out target)) return; // can't even get the target object! var targetRef = GetTargetRef(target); if (targetRef == null) return; // don't know how to go there yet. var mainWnd = this.ActiveMainWindow as TeMainWnd; if (mainWnd == null) { throw new Exception("life stinks"); } mainWnd.GotoVerse(targetRef); }
private void Push(LinkedList<FwLinkArgs> stack, FwLinkArgs context) { stack.AddLast(context); while (stack.Count > kmaxDepth) stack.RemoveFirst(); }
internal string LinkRef(int hvo) { ICmObjectRepository repo = m_cache.ServiceLocator.GetInstance<ICmObjectRepository>(); if (!repo.IsValidObjectId(hvo)) return null; Guid guid = repo.GetObject(hvo).Guid; FwLinkArgs link = new FwLinkArgs("lexiconEdit", guid); return link.ToString(); }
private void linkLabel1_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e) { Guid guid = m_cache.LangProject.PhFeatureSystemOA.Guid; m_link = new FwLinkArgs("phonologicalFeaturesAdvancedEdit", guid); m_btnCancel.PerformClick(); DialogResult = DialogResult.Ignore; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Some comparisons don't care about the content of the property table, so we provide a /// method similar to Equals but not quite as demanding. /// </summary> /// <param name="lnk">The link to compare.</param> /// ------------------------------------------------------------------------------------ public override bool EssentiallyEquals(FwLinkArgs lnk) { FwAppArgs appArgs = lnk as FwAppArgs; if (appArgs == null || !base.EssentiallyEquals(lnk)) return false; return (appArgs.AppAbbrev == AppAbbrev && appArgs.Database == Database && appArgs.Server == Server); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Construct a new form /// </summary> /// <param name="app">The app.</param> /// <param name="wndCopyFrom">Source window to copy from</param> /// <param name="iconStream">The icon stream.</param> /// <param name="configFile">The config file.</param> /// <param name="startupLink">The link to follow once the window is initialized.</param> /// <param name="inAutomatedTest">if set to <c>true</c>, (well behaved) code will avoid /// bringing up dialogs that we cannot respond to (like confirmation and error dialogs) /// and it should cause the system to avoid saving the settings to a file (or at least /// saving them in some special way so as not to mess up the user.)</param> /// ------------------------------------------------------------------------------------ public FwXWindow(FwApp app, Form wndCopyFrom, Stream iconStream, string configFile, FwLinkArgs startupLink, bool inAutomatedTest) { BasicInit(app); m_startupLink = startupLink; Debug.Assert(File.Exists(configFile)); m_app = app; m_configFile = configFile; Init(iconStream, wndCopyFrom, app.Cache); if(inAutomatedTest) { Mediator.PropertyTable.SetProperty("DoingAutomatedTest", true); Mediator.PropertyTable.SetPropertyPersistence("DoingAutomatedTest", false); } // The order of the next two lines has been changed because the loading of the UI // properly depends on m_viewHelper being initialized. Why this was not so with DNB // I do not know. // Here is the orginal order (along with a comment between them that seemed to imply this // new order could be a problem, but no obvious ones have appeared in my testing. /* * LoadUI(configFile); * // Reload additional property settings that depend on knowing the database name. * m_viewHelper = new ActiveViewHelper(this); */ m_viewHelper = new ActiveViewHelper(this); LoadUI(configFile); m_viewHelper.ActiveViewChanged += new EventHandler<EventArgs>(ActiveViewChanged); }
/// ----------------------------------------------------------------------------------- /// <summary> /// Initializes a new instance of the TeMainWnd class /// </summary> /// <param name="app"></param> /// <param name="wndCopyFrom"></param> /// <param name="startupLink">Optional link to jump to in OnFinishedInit</param> /// ----------------------------------------------------------------------------------- public TeMainWnd(FwApp app, Form wndCopyFrom, FwLinkArgs startupLink) : base(app, wndCopyFrom) { m_startupLink = startupLink; Init(); }
/// <summary> /// Handle launching of the MSA editor. /// </summary> protected override void HandleChooser() { VectorReferenceLauncher vrl = null; using (MsaInflectionFeatureListDlg dlg = new MsaInflectionFeatureListDlg()) { IFsFeatStruc originalFs = m_obj as IFsFeatStruc; Slice parentSlice = Slice; if (originalFs == null) { int owningFlid; int parentSliceClass = (int)parentSlice.Object.ClassID; switch (parentSliceClass) { case MoAffixAllomorphTags.kClassId: IMoAffixAllomorph allo = parentSlice.Object as IMoAffixAllomorph; owningFlid = (parentSlice as MsaInflectionFeatureListDlgLauncherSlice).Flid; dlg.SetDlgInfo(m_cache, m_mediator, allo, owningFlid); break; /*case LexEntryInflTypeTags.kClassId: ILexEntryInflType leit = parentSlice.Object as ILexEntryInflType; owningFlid = (parentSlice as MsaInflectionFeatureListDlgLauncherSlice).Flid; dlg.SetDlgInfo(m_cache, m_mediator, leit, owningFlid); break;*/ default: IMoMorphSynAnalysis msa = parentSlice.Object as IMoMorphSynAnalysis; owningFlid = (parentSlice as MsaInflectionFeatureListDlgLauncherSlice).Flid; dlg.SetDlgInfo(m_cache, m_mediator, msa, owningFlid); break; } } else { dlg.SetDlgInfo(m_cache, m_mediator, originalFs, (parentSlice as MsaInflectionFeatureListDlgLauncherSlice).Flid); } const string ksPath = "/group[@id='Linguistics']/group[@id='Morphology']/group[@id='FeatureChooser']/"; dlg.Text = m_mediator.StringTbl.GetStringWithXPath("InflectionFeatureTitle", ksPath); dlg.Prompt = m_mediator.StringTbl.GetStringWithXPath("InflectionFeaturePrompt", ksPath); dlg.LinkText = m_mediator.StringTbl.GetStringWithXPath("InflectionFeatureLink", ksPath); DialogResult result = dlg.ShowDialog(parentSlice.FindForm()); if (result == DialogResult.OK) { // Note that this may set m_obj to null. dlg.FS will be null if all inflection features have been // removed. That is a valid state for this slice; m_obj deleted is not. m_obj = dlg.FS; m_msaInflectionFeatureListDlgLauncherView.Init(m_mediator, dlg.FS); } else if (result == DialogResult.Yes) { // Get the VectorReferenceLauncher for the Inflection Features slice. // Since we're not changing tools, we want to change the chooser dialog. // See LT-5913 for motivation. Control ctl = this.Parent; while (ctl != null && !(ctl is Slice)) ctl = ctl.Parent; Slice slice = ctl as Slice; if (slice != null) { DataTree dt = slice.ContainingDataTree; for (int i = 0; i < dt.Slices.Count; ++i) { Slice sliceT = dt.FieldOrDummyAt(i); vrl = sliceT.Control as VectorReferenceLauncher; if (vrl != null) { if (vrl.Flid == PartOfSpeechTags.kflidInflectableFeats) break; vrl = null; } } } if (vrl == null) { // We do, too, need to change tools! Sometimes this slice shows up in a different context, // such as the main data entry view. See LT-7167. // go to m_highestPOS in editor // TODO: this should be reviewed by someone who knows how these links should be done // I'm just guessing. // Also, is there some way to know the application name and tool name without hard coding them? var linkJump = new FwLinkArgs("posEdit", dlg.HighestPOS.Guid); m_mediator.PostMessage("FollowLink", linkJump); } else { vrl.HandleExternalChooser(); } } } }
public virtual bool OnJumpToTool(object commandObject) { XCore.Command cmd = (XCore.Command)commandObject; string tool = SIL.Utils.XmlUtils.GetManditoryAttributeValue(cmd.Parameters[0], "tool"); string className = SIL.Utils.XmlUtils.GetManditoryAttributeValue(cmd.Parameters[0], "className"); string concordOn = SIL.Utils.XmlUtils.GetOptionalAttributeValue(cmd.Parameters[0], "concordOn", ""); if (CurrentAnalysisTree.Analysis != null) { // If the user selects a concordance on gloss or analysis, we want the current one, // not what we started with. We would save anyway as we switched views, so do it now. var parent = Controller; if (parent != null) parent.UpdateRealFromSandbox(null, false, null); // This leaves the parent in a bad state, but maybe it would be good if all this is // happening in some other parent, such as the words analysis view? //m_hvoAnalysisGuess = GetRealAnalysis(false); int hvo = GetHvoForJumpToToolClass(className); if (hvo != 0) { FdoCache cache = m_caches.MainCache; ICmObject co = cache.ServiceLocator.GetInstance<ICmObjectRepository>().GetObject(hvo); var fwLink = new FwLinkArgs(tool, co.Guid); List<Property> additionalProps = fwLink.PropertyTableEntries; if (!String.IsNullOrEmpty(concordOn)) additionalProps.Add(new Property("ConcordOn", concordOn)); m_mediator.PostMessage("FollowLink", fwLink); return true; } } return false; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Handles the incoming link, after the right window of the right application on the right /// project has been activated. /// See the class comment on FwLinkArgs for details on how all the parts of hyperlinking work. /// </summary> /// <param name="link">The link.</param> /// ------------------------------------------------------------------------------------ public override void HandleIncomingLink(FwLinkArgs link) { CheckDisposed(); // Get window that uses the given DB. FwXWindow fwxwnd = m_rgMainWindows.Count > 0 ? (FwXWindow)m_rgMainWindows[0] : null; if (fwxwnd != null) { fwxwnd.Mediator.SendMessage("FollowLink", link); bool topmost = fwxwnd.TopMost; fwxwnd.TopMost = true; fwxwnd.TopMost = topmost; fwxwnd.Activate(); } }
public void EssentiallyEquals_DiffereByGuid() { FwLinkArgs args1 = new FwLinkArgs("myTool", Guid.NewGuid(), "myTag"); Assert.IsFalse(args1.EssentiallyEquals(new FwLinkArgs("myTool", Guid.NewGuid(), "myTag"))); }