/// <summary>
/// Receives the broadcast message "PropertyChanged"
/// </summary>
public override void OnPropertyChanged(string name)
{
CheckDisposed();
switch (name)
{
default:
base.OnPropertyChanged(name);
break;
case "ReversalIndexHvo":
ChangeOwningObjectIfPossible();
break;
case "ActiveClerk":
RecordClerk activeClerk = (RecordClerk)m_mediator.PropertyTable.GetValue("ActiveClerk");
if (activeClerk == this)
{
ChangeOwningObjectIfPossible();
}
else
{
base.OnPropertyChanged(name);
}
break;
}
}
/// <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 override void Dispose(bool disposing)
{
//Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************");
// Must not be run more than once.
if (IsDisposed)
{
return;
}
base.Dispose(disposing);
if (disposing)
{
// Dispose managed resources here.
if (m_vc != null)
{
m_vc.Dispose();
}
}
// Dispose unmanaged resources here, whether disposing is true or false.
m_clerk = null;
m_vc = null;
m_configurationParameters = null;
}
public void Init(Mediator mediator, PropertyTable propertyTable, XmlNode configurationParameters)
{
CheckDisposed();
_mediator = mediator; //allows the Cache property to function
_propertyTable = propertyTable;
_cache = _propertyTable.GetValue <LcmCache>("cache");
string name = XmlUtils.GetAttributeValue(configurationParameters, "clerk");
var clerk = RecordClerk.FindClerk(_propertyTable, name);
m_clerk = (clerk == null || clerk is TemporaryRecordClerk) ?
(InterlinearTextsRecordClerk)RecordClerkFactory.CreateClerk(mediator, _propertyTable, configurationParameters, true) :
(InterlinearTextsRecordClerk)clerk;
// There's no record bar for it to control, but it should control the staus bar (e.g., it should update if we change
// the set of selected texts).
m_clerk.ActivateUI(true);
_areaName = XmlUtils.GetOptionalAttributeValue(configurationParameters, "area", "unknown");
RebuildStatisticsTable();
//add ourselves so that we can receive messages (related to the text selection currently misnamed AddTexts)
mediator.AddColleague(this);
//add our current state to the history system
string toolName = _propertyTable.GetStringProperty("currentContentControl", "");
mediator.SendMessage("AddContextToHistory", new FwLinkArgs(toolName, Guid.Empty), false);
}
public InfoPane(FdoCache cache, Mediator mediator, RecordClerk clerk)
{
// This call is required by the Windows.Forms Form Designer.
InitializeComponent();
Initialize(cache, mediator, clerk);
}
public static ClerkActivator ActivateClerkMatchingExportType(string exportType, Mediator mediator)
{
var isDictionary = exportType == DictionaryType;
const string area = "lexicon";
var tool = isDictionary ? "lexiconDictionary" : "reversalToolEditComplete";
var collector = new XmlNode[1];
var parameter = new Tuple <string, string, XmlNode[]>(area, tool, collector);
mediator.SendMessage("GetContentControlParameters", parameter);
var parameters = collector[0].SelectSingleNode(".//parameters[@clerk]");
var currentClerk = mediator.PropertyTable.GetValue("ActiveClerk", null) as RecordClerk;
if (DoesClerkMatchParams(currentClerk, parameters))
{
return(null); // No need to juggle clerks if the one we want is already active
}
var tempClerk = isDictionary ? s_dictionaryClerk : s_reversalIndexClerk;
if (tempClerk == null || tempClerk.IsDisposed)
{
tempClerk = RecordClerk.FindClerk(mediator, isDictionary ? "entries" : "AllReversalEntries");
if (tempClerk == null || tempClerk.IsDisposed)
{
tempClerk = RecordClerkFactory.CreateClerk(mediator, parameters, true);
}
CacheClerk(exportType, tempClerk);
}
tempClerk.ActivateUI(true, false);
tempClerk.UpdateList(true, true);
return(new ClerkActivator(currentClerk)); // ensure the current active clerk is reactivated after we use the temporary clerk.
}
public bool OnDisplayExport(object commandObject,
ref UIItemDisplayProperties display)
{
CheckDisposed();
// In order for this menu to be visible and enabled it has to be in the correct area (lexicon)
// and the right tool(s).
// Tools that allow this menu, as far as I (RickM) can tell, as of 10 Aug 2007:
// (areaChoice == "lexicon" or "words" or "grammar" or "lists"
RecordClerk clerk = Clerk;
string areaChoice = m_mediator.PropertyTable.GetStringProperty("areaChoice", null);
//uncomment the following line if we need to turn on or off the Export menu item
//for specific tools in the various areas of the application.
//string toolChoice = m_mediator.PropertyTable.GetStringProperty("ToolForAreaNamed_lexicon", null);
string toolChoice = m_mediator.PropertyTable.GetStringProperty("grammarSketch_grammar", null);
bool inFriendlyTerritory = (areaChoice == "lexicon" ||
areaChoice == "notebook" ||
clerk.Id == "concordanceWords" ||
areaChoice == "grammar" ||
areaChoice == "lists");
if (inFriendlyTerritory)
{
display.Enabled = display.Visible = true;
}
else
{
display.Enabled = display.Visible = false;
}
return(true);
}
private void InitializeInfoView(RecordClerk clerk)
{
if (m_mediator == null)
{
return;
}
XmlNode xnWindow = (XmlNode)m_mediator.PropertyTable.GetValue("WindowConfiguration");
if (xnWindow == null)
{
return;
}
XmlNode xnControl = xnWindow.SelectSingleNode(
"controls/parameters/guicontrol[@id=\"TextInformationPane\"]/control/parameters");
if (xnControl == null)
{
return;
}
m_xrev = new InterlinearTextsRecordEditView();
m_xrev.Clerk = clerk;
m_xrev.Init(m_mediator, xnControl);
m_xrev.Dock = DockStyle.Fill;
this.Controls.Add(m_xrev);
}
private void InitializeInfoView(RecordClerk clerk)
{
if (m_mediator == null)
{
return;
}
if (m_propertyTable == null)
{
return;
}
var xnWindow = m_propertyTable.GetValue <XmlNode>("WindowConfiguration");
if (xnWindow == null)
{
return;
}
XmlNode xnControl = xnWindow.SelectSingleNode(
"controls/parameters/guicontrol[@id=\"TextInformationPane\"]/control/parameters");
if (xnControl == null)
{
return;
}
var activeClerk = m_propertyTable.GetValue <RecordClerk>("ActiveClerk");
var toolChoice = m_propertyTable.GetStringProperty("currentContentControl", null);
if (m_xrev != null)
{
//when re-using the infoview we want to remove and dispose of the old recordeditview and
//associated datatree. (LT-13216)
Controls.Remove(m_xrev);
m_xrev.Dispose();
}
m_xrev = new InterlinearTextsRecordEditView(this);
if (clerk.GetType().Name == "InterlinearTextsRecordClerk")
{
m_xrev.Clerk = clerk;
}
else
{
//We want to make sure that the following initialization line will initialize this
//clerk if we haven't already set it. Without this assignment to null, the InfoPane
//misbehaves in the Concordance view (it uses the filter from the InterlinearTexts view)
m_xrev.Clerk = null;
}
m_xrev.Init(m_mediator, m_propertyTable, xnControl); // <-- This call will change the ActiveClerk
DisplayCurrentRoot();
m_xrev.Dock = DockStyle.Fill;
Controls.Add(m_xrev);
// There are times when moving to the InfoPane causes the wrong ActiveClerk to be set.
// See FWR-3390 (and InterlinearTextsRecordClerk.OnDisplayInsertInterlinText).
var activeClerkNew = m_propertyTable.GetValue <RecordClerk>("ActiveClerk");
if (toolChoice != "interlinearEdit" && activeClerk != null && activeClerk != activeClerkNew)
{
m_propertyTable.SetProperty("ActiveClerk", activeClerk, true);
activeClerk.ActivateUI(true);
}
}
public override void FixtureSetup()
{
base.FixtureSetup();
FwRegistrySettings.Init();
m_application = new MockFwXApp(new MockFwManager {
Cache = Cache
}, null, null);
var configFilePath = Path.Combine(FwDirectoryFinder.CodeDirectory, m_application.DefaultConfigurationPathname);
m_window = new MockFwXWindow(m_application, configFilePath);
((MockFwXWindow)m_window).Init(Cache); // initializes Mediator values
m_mediator = m_window.Mediator;
m_mediator.AddColleague(new StubContentControlProvider());
m_window.LoadUI(configFilePath);
// set up clerk to allow DictionaryPublicationDecorator to be created during the UploadToWebonaryController driven export
const string reversalIndexClerk = @"<?xml version='1.0' encoding='UTF-8'?>
<root>
<clerks>
<clerk id='entries'>
<recordList owner='LexDb' property='Entries'/>
</clerk>
</clerks>
<tools>
<tool label='Dictionary' value='lexiconDictionary' icon='DocumentView'>
<control>
<dynamicloaderinfo assemblyPath='xWorks.dll' class='SIL.FieldWorks.XWorks.XhtmlDocView'/>
<parameters area='lexicon' clerk='entries' layout='Bartholomew' layoutProperty='DictionaryPublicationLayout' editable='false' configureObjectName='Dictionary'/>
</control>
</tool>
</tools>
</root>" ;
var doc = new XmlDocument();
doc.LoadXml(reversalIndexClerk);
XmlNode clerkNode = doc.SelectSingleNode("//tools/tool[@label='Dictionary']//parameters[@area='lexicon']");
m_Clerk = RecordClerkFactory.CreateClerk(m_mediator, clerkNode, false);
m_mediator.PropertyTable.SetProperty("ActiveClerk", m_Clerk);
m_mediator.PropertyTable.SetProperty("ToolForAreaNamed_lexicon", "lexiconDictionary");
Cache.ProjectId.Path = Path.Combine(FwDirectoryFinder.SourceDirectory, "xWorks/xWorksTests/TestData/");
// setup style sheet and style to allow the css to generate during the UploadToWebonaryController driven export
m_styleSheet = FontHeightAdjuster.StyleSheetFromMediator(m_mediator);
m_owningTable = new StyleInfoTable("AbbySomebody", (IWritingSystemManager)Cache.WritingSystemFactory);
var fontInfo = new FontInfo();
var letHeadStyle = new TestStyle(fontInfo, Cache)
{
Name = CssGenerator.LetterHeadingStyleName, IsParagraphStyle = false
};
var dictNormStyle = new TestStyle(fontInfo, Cache)
{
Name = CssGenerator.DictionaryNormal, IsParagraphStyle = true
};
m_styleSheet.Styles.Add(letHeadStyle);
m_styleSheet.Styles.Add(dictNormStyle);
m_owningTable.Add(CssGenerator.LetterHeadingStyleName, letHeadStyle);
m_owningTable.Add(CssGenerator.DictionaryNormal, dictNormStyle);
}
/// <summary>
/// Save the configuration parameters in case we want to use them locally.
/// </summary>
/// <param name="mediator"></param>
/// <param name="configurationParameters"></param>
public override void Init(Mediator mediator, System.Xml.XmlNode configurationParameters)
{
CheckDisposed();
base.Init(mediator, configurationParameters);
m_configurationParameters = configurationParameters;
m_clerk = ToolConfiguration.FindClerk(m_mediator, m_configurationParameters);
}
/// <summary>
/// Save the configuration parameters in case we want to use them locally.
/// </summary>
/// <param name="mediator"></param>
/// <param name="propertyTable"></param>
/// <param name="configurationParameters"></param>
public override void Init(Mediator mediator, PropertyTable propertyTable, XmlNode configurationParameters)
{
CheckDisposed();
base.Init(mediator, propertyTable, configurationParameters);
m_configurationParameters = configurationParameters;
m_clerk = ToolConfiguration.FindClerk(m_propertyTable, m_configurationParameters);
m_styleSheet = FontHeightAdjuster.StyleSheetFromPropertyTable(m_propertyTable);
}
public InfoPane(FdoCache cache, Mediator mediator, RecordClerk clerk)
{
// This call is required by the Windows.Forms Form Designer.
InitializeComponent();
m_cache = cache;
m_mediator = mediator;
InitializeInfoView(clerk);
}
/// <summary>
/// Save the configuration parameters in case we want to use them locally.
/// </summary>
/// <param name="mediator"></param>
/// <param name="configurationParameters"></param>
public override void Init(Mediator mediator, System.Xml.XmlNode configurationParameters)
{
CheckDisposed();
base.Init(mediator, configurationParameters);
m_configurationParameters = configurationParameters;
m_clerk = ToolConfiguration.FindClerk(m_mediator, m_configurationParameters);
m_styleSheet = FontHeightAdjuster.StyleSheetFromMediator(m_mediator);
}
public bool IsSortingOnAlphaHeaders()
{
var clerk = m_propertyTable.GetValue <RecordClerk>("ActiveClerk", null);
int[] entriesToSave;
var publicationDecorator =
ConfiguredXHTMLGenerator.GetPublicationDecoratorAndEntries(m_propertyTable, out entriesToSave, "Dictionary");
return(RecordClerk.IsClerkSortingByHeadword(clerk));
}
/// <summary>
/// Record browse view implements ShowRecord by scrolling to show the current record. However,
/// that may well not be all the response to selecting that record in the Clerk: for example,
/// another pane may show a more detailed view of the selected record. Therefore, RecordBrowseView
/// never claims to have 'handled' this event.
/// </summary>
/// <param name="argument"></param>
/// <returns>
/// false; we didn't fully handle it, even though we may have done something.
/// </returns>
public override bool OnRecordNavigation(object argument)
{
CheckDisposed();
// Can't do anything if it isn't fully initialized,
// and we don't want to do anything, if we are told not to.
if (!m_fullyInitialized || m_suppressRecordNavigation)
{
return(false);
}
Debug.Assert(m_browseViewer != null, "RecordBrowseView.SetupDataContext() has to be called before RecordBrowseView.OnRecordNavigation().");
if (m_browseViewer == null || m_browseViewer.BrowseView == null || m_browseViewer.BrowseView.RootBox == null)
{
return(false); // can't do anything useful without a root box to select in.
}
var rni = (RecordNavigationInfo)argument;
m_suppressShowRecord = rni.SkipShowRecord;
m_suppressRecordNavigation = rni.SuppressSaveOnChangeRecord;
bool bvEnabled = m_browseViewer.Enabled;
if (rni.SuppressFocusChange && bvEnabled)
{
m_browseViewer.Enabled = false;
}
try
{
RecordClerk clerk = Clerk;
RecordClerk sendingClerk = RecordNavigationInfo.GetSendingClerk(argument);
// NOTE: If the clerk's current index is less than zero,
// or greater than the number of objects in the vector,
// SelectedIndex will assert in a debug build,
// and throw an exception in a release build.
if (clerk != null && sendingClerk == clerk && clerk.IsActiveInGui)
{
m_browseViewer.SelectedIndex = clerk.CurrentIndex;
// go ahead and SetInfoBarText even if we didn't change indices
// we may have changed objects or root object classes (from Entries to Senses)
SetInfoBarText();
}
//base.OnRecordNavigation(argument);
}
finally
{
m_suppressShowRecord = false;
m_suppressRecordNavigation = false;
if (rni.SuppressFocusChange && bvEnabled)
{
m_browseViewer.Enabled = true;
}
}
return(false);
}
/// <summary>
/// Have the utility do what it does.
/// </summary>
public void Process()
{
Debug.Assert(m_dlg != null);
FdoCache cache = (FdoCache)m_dlg.Mediator.PropertyTable.GetValue("cache");
List <int> wordformIds = DbOps.ReadIntsFromCommand(
cache,
"SELECT Id FROM WfiWordform",
null);
int curObjId = 0;
if (m_dlg.Mediator != null)
{
Mediator mediator = m_dlg.Mediator;
RecordClerk activeClerk = (RecordClerk)mediator.PropertyTable.GetValue("ActiveClerk");
if (activeClerk != null && activeClerk.Id == "concordanceWords" && activeClerk.CurrentObject != null)
{
curObjId = activeClerk.CurrentObject.Hvo;
}
}
// Set up progress bar.
m_dlg.ProgressBar.Minimum = 0;
m_dlg.ProgressBar.Maximum = wordformIds.Count;
m_dlg.ProgressBar.Step = 1;
// stop parser if it's running.
m_dlg.Mediator.SendMessage("StopParser", null);
if (wordformIds.Count > 0)
{
if (cache.DatabaseAccessor.IsTransactionOpen())
{
cache.DatabaseAccessor.CommitTrans();
}
foreach (int wfId in wordformIds)
{
cache.DatabaseAccessor.BeginTrans();
DbOps.ExecuteStoredProc(
cache,
string.Format("EXEC RemoveParserApprovedAnalyses$ {0}", wfId),
null);
cache.DatabaseAccessor.CommitTrans();
using (WfiWordformUi wfui = new WfiWordformUi(WfiWordform.CreateFromDBObject(cache, wfId)))
{
wfui.UpdateWordsToolDisplay(curObjId, false, false, true, true);
}
m_dlg.ProgressBar.PerformStep();
}
}
else
{
m_dlg.ProgressBar.PerformStep();
}
}
public virtual void Init(Mediator mediator, XmlNode configurationParameters)
{
CheckDisposed();
m_mediator = mediator;
m_helpTopicProvider = m_mediator.HelpTopicProvider;
m_configurationParameters = configurationParameters;
m_cache = (FdoCache)mediator.PropertyTable.GetValue("cache");
string name = RecordClerk.GetCorrespondingPropertyName(XmlUtils.GetAttributeValue(configurationParameters, "clerk"));
m_clerk = (OccurrencesOfSelectedUnit)m_mediator.PropertyTable.GetValue(name) ?? (OccurrencesOfSelectedUnit)RecordClerkFactory.CreateClerk(m_mediator, m_configurationParameters, true);
m_clerk.ConcordanceControl = this;
}
protected override void SetupDataContext()
{
TriggerMessageBoxIfAppropriate();
System.Windows.Forms.Cursor.Current = System.Windows.Forms.Cursors.WaitCursor;
//m_flid = RecordClerk.GetFlidOfVectorFromName(m_vectorName, Cache, out m_owningObject);
RecordClerk clerk = Clerk;
clerk.ActivateUI(false);
m_fakeFlid = clerk.VirtualFlid;
// retrieve persisted clerk index and set it.
int idx = m_mediator.PropertyTable.GetIntProperty(clerk.PersistedIndexProperty, -1, PropertyTable.SettingsGroup.LocalSettings);
if (idx >= 0 && !clerk.HasEmptyList)
{
int idxOld = clerk.CurrentIndex;
try
{
clerk.JumpToIndex(idx);
}
catch
{
clerk.JumpToIndex(idxOld >= 0 ? idxOld : 0);
}
}
clerk.SelectedRecordChanged();
m_hvoOwner = clerk.OwningObject.Hvo;
clerk.IsDefaultSort = false;
// Create the main view
// Review JohnT: should it be m_configurationParameters or .FirstChild?
m_mainView = new XmlSeqView(m_hvoOwner, m_fakeFlid, m_configurationParameters);
m_mainView.Init(m_mediator, m_configurationParameters); // Required call to xCore.Colleague.
m_mainView.Dock = System.Windows.Forms.DockStyle.Fill;
m_mainView.Cache = Cache;
m_mainView.SelectionChangedEvent +=
new FwSelectionChangedEventHandler(OnSelectionChanged);
m_mainView.ShowRangeSelAfterLostFocus = true; // This makes selections visible.
// If the rootsite doesn't have a rootbox, we can't display the record!
// Calling ShowRecord() from InitBase() sets the state to appear that we have
// displayed (and scrolled), even though we haven't. See LT-7588 for the effect.
m_mainView.MakeRoot();
SetupStylesheet();
Controls.Add(m_mainView);
if (Controls.Count == 2)
{
Controls.SetChildIndex(m_mainView, 1);
m_mainView.BringToFront();
}
m_fullyInitialized = true; // Review JohnT: was this really the crucial last step?
}
private static void CacheClerk(string clerkType, RecordClerk clerk)
{
switch (clerkType)
{
case DictionaryType:
s_dictionaryClerk = clerk;
break;
case ReversalType:
s_reversalIndexClerk = clerk;
break;
}
}
private static bool DoesClerkMatchParams(RecordClerk clerk, XmlNode parameters)
{
if (clerk == null)
{
return(false);
}
var atts = parameters.Attributes;
if (atts == null)
{
return(false);
}
var id = atts["clerk"].Value;
return(id == clerk.Id);
}
/// <summary>
/// Receives the broadcast message "PropertyChanged"
/// </summary>
public override void OnPropertyChanged(string name)
{
CheckDisposed();
var window = m_propertyTable.GetValue <FwXWindow>("window");
if (window != null)
{
window.ClearInvalidatedStoredData();
}
switch (name)
{
default:
base.OnPropertyChanged(name);
break;
case "ReversalIndexGuid":
ChangeOwningObjectIfPossible();
break;
case "ToolForAreaNamed_lexicon":
int rootIndex = GetRootIndex(m_list.CurrentIndex);
JumpToIndex(rootIndex);
base.OnPropertyChanged(name);
break;
case "ActiveClerk":
RecordClerk activeClerk = m_propertyTable.GetValue <RecordClerk>("ActiveClerk");
if (activeClerk == this)
{
ChangeOwningObjectIfPossible();
}
else
{
base.OnPropertyChanged(name);
}
break;
case "ReversalIndexPublicationLayout":
// When the user chooses a different reversal index configuration from the drop-down menu,
// set the list of associated reversal index entries.
DictionaryConfigurationUtils.SetReversalIndexGuidBasedOnReversalIndexConfiguration(m_propertyTable, Cache);
break;
}
}
/// <summary>
///
/// </summary>
/// <param name="argument"></param>
/// <returns>
/// true; we fully handled it.
/// </returns>
public bool OnRecordNavigation(object argument)
{
RecordNavigationInfo rni = argument as RecordNavigationInfo;
RecordClerk clerk = rni.Clerk;
string clerkId = clerk.Id;
string myClerkId = m_configurationNode.SelectSingleNode("parameters").Attributes["clerk"].Value;
if (clerk.Id == myClerkId)
{
MainControl.SelectedFinder = rni.Clerk.CurrentObject;
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Initialize this as an IxCoreColleague
/// </summary>
/// <remarks> subclasses must call this from their Init.
/// This was done, rather than providing an Init() here in the normal way,
/// to drive home the point that the subclass must set m_fullyInitialized
/// to true when it is fully initialized.</remarks>
/// <param name="mediator"></param>
/// <param name="configurationParameters"></param>
protected void InitBase(Mediator mediator, XmlNode configurationParameters)
{
Debug.Assert(m_fullyInitialized == false, "No way we are fully initialized yet!");
m_mediator = mediator;
m_configurationParameters = configurationParameters;
ReadParameters();
RecordClerk clerk = ExistingClerk;
if (clerk == null)
{
// NOTE: new clerks do not typically complete ReloadList()
// until Clerk.ActivateUI() is set (eg. here in SetupDataContext()).
// however, we should further delay loading the list
// if the subclass is initializing sorters/filters.
// so we use ListUpdateHelper below to delay reloading the list.
clerk = Clerk;
Debug.Assert(clerk != null);
}
// suspend any loading of the Clerk's list items until after a
// subclass (possibly) initializes sorters/filters
// in SetupDataContext()
using (RecordClerk.ListUpdateHelper luh = new RecordClerk.ListUpdateHelper(clerk))
{
luh.ClearBrowseListUntilReload = true;
clerk.UpdateOwningObjectIfNeeded();
SetTreebarAvailability();
AddPaneBar();
// NB: It is critical that we get added *after* our RecordClerk,
// so that it will get messages, for example about a change of cache, before we do.
mediator.AddColleague(this);
SetupDataContext();
}
// In case it hasn't yet been loaded, load it! See LT-10185.
if (!Clerk.ListLoadingSuppressed && Clerk.RequestedLoadWhileSuppressed)
{
Clerk.UpdateList(true, true);
}
ShowRecord();
}
public bool OnMoveReversalindexEntry(object cmd)
{
using (var dlg = new ReversalEntryGoDlg())
{
Slice slice = m_dataEntryForm.CurrentSlice;
Debug.Assert(slice != null, "No slice was current");
var currentEntry = (IReversalIndexEntry)slice.Object;
dlg.ReversalIndex = currentEntry.ReversalIndex;
dlg.FilteredReversalEntries.Add(currentEntry);
IReversalIndexEntry owningEntry = currentEntry.OwningEntry;
if (owningEntry != null)
{
dlg.FilteredReversalEntries.Add(owningEntry);
}
dlg.SetHelpTopic("khtpMoveReversalEntry");
var wp = new WindowParams {
m_btnText = LexEdStrings.ks_MoveEntry, m_title = LexEdStrings.ksMoveRevEntry
};
var cache = (FdoCache)m_mediator.PropertyTable.GetValue("cache");
dlg.SetDlgInfo(cache, wp, m_mediator);
if (dlg.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
var newOwner = (IReversalIndexEntry)dlg.SelectedObject;
UndoableUnitOfWorkHelper.Do(LexEdStrings.ksUndoMoveRevEntry,
LexEdStrings.ksRedoMoveRevEntry, Cache.ActionHandlerAccessor,
() =>
{
newOwner.MoveIfNeeded(currentEntry);
newOwner.SubentriesOC.Add(currentEntry);
});
RecordClerk clerk = m_mediator.PropertyTable.GetValue("ActiveClerk") as RecordClerk;
if (clerk != null)
{
clerk.RemoveItemsFor(currentEntry.Hvo);
}
// Note: PropChanged should happen on the old owner and the new while completing the unit of work.
// Have to jump to a main entry, as RecordClerk doesn't know anything about subentries.
m_mediator.BroadcastMessageUntilHandled("JumpToRecord", newOwner.MainEntry.Hvo);
}
}
return(true);
}
public bool OnMoveReversalindexEntry(object cmd)
{
using (ReversalEntryGoDlg dlg = new ReversalEntryGoDlg())
{
Slice slice = m_dataEntryForm.CurrentSlice;
Debug.Assert(slice != null, "No slice was current");
IReversalIndexEntry currentEntry = (IReversalIndexEntry)slice.Object;
List <IReversalIndexEntry> filteredEntries = new List <IReversalIndexEntry>();
filteredEntries.Add(currentEntry);
IReversalIndexEntry owningEntry = currentEntry.OwningEntry;
if (owningEntry != null)
{
filteredEntries.Add(owningEntry);
}
WindowParams wp = new WindowParams();
wp.m_btnText = LexEdStrings.ks_MoveEntry;
wp.m_label = LexEdStrings.ks_Find_;
wp.m_title = LexEdStrings.ksMoveRevEntry;
dlg.SetDlgInfo(m_mediator, wp, filteredEntries); // , true
if (dlg.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
FdoCache cache = (FdoCache)m_mediator.PropertyTable.GetValue("cache");
IReversalIndexEntry newOwner = ReversalIndexEntry.CreateFromDBObject(cache, dlg.SelectedID);
cache.BeginUndoTask(LexEdStrings.ksUndoMoveRevEntry,
LexEdStrings.ksRedoMoveRevEntry);
ICmObject newOwningObj = newOwner.MoveIfNeeded(currentEntry);
newOwner.SubentriesOC.Add(currentEntry);
cache.EndUndoTask();
RecordClerk clerk = m_mediator.PropertyTable.GetValue("ActiveClerk") as RecordClerk;
if (clerk != null)
{
clerk.RemoveItemsFor(currentEntry.Hvo);
}
// Note: PropChanged should happen on the old owner and the new in the 'Add" method call.
// Have to jump to a main entry, as RecordClerk doesn't know anything about subentries.
m_mediator.BroadcastMessageUntilHandled("JumpToRecord", newOwner.MainEntry.Hvo);
}
}
return(true);
}
protected override void OnFinishButton()
{
base.OnFinishButton();
SaveSettings();
if (string.IsNullOrEmpty(m_fileListBox.Text))
{
return;
}
using (var dlg = new ProgressDialogWithTask(this, m_cache.ThreadHelper))
{
dlg.AllowCancel = false;
dlg.Minimum = 0;
// Allow 100 units of progress for each file for now. This allows for plenty of resolution for the LL importer
dlg.Maximum = m_fileListBox.Text.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Count() * 100;
try
{
dlg.RunTask(true, DoConversion);
}
catch (WorkerThreadException ex) // any exception on the worker thread is converted to this
{
// JohnT: I hate to just report and otherwise ignore all exceptions, but have not been able to find any doc of which ones,
// if any, EncConverters may throw.
System.Diagnostics.Debug.WriteLine("Error: " + ex.InnerException.Message);
MessageBox.Show(this, String.Format(ITextStrings.ksSfmImportProblem, ex.InnerException.Message),
ITextStrings.ksUnhandledError,
MessageBoxButtons.OK, MessageBoxIcon.Error);
DialogResult = DialogResult.Cancel;
Close();
}
}
m_mediator.SendMessage("MasterRefresh", ActiveForm);
if (m_firstNewText != null)
{
// try to select it.
var clerk = RecordClerk.FindClerk(m_mediator, "interlinearTexts");
if (clerk != null)
{
clerk.JumpToRecord(m_firstNewText.ContentsOA.Hvo);
}
}
}
/// <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 override void Dispose(bool disposing)
{
// Must not be run more than once.
if (IsDisposed)
{
return;
}
base.Dispose(disposing);
if (disposing)
{
// Dispose managed resources here.
}
// Dispose unmanaged resources here, whether disposing is true or false.
m_clerk = null;
m_vc = null;
m_configurationParameters = null;
}
internal void LoadList(SplitterPanel parent, ICmObject mainObject)
{
parent.FindForm().UseWaitCursor = true;
parent.SuspendLayout();
m_mediator.RemoveColleague(this);
if (m_currentControl != null)
{
m_currentControl.SuspendLayout();
m_currentControl.Parent.Controls.Remove(m_currentControl);
m_currentControl.Dispose();
m_currentControl = null;
}
// Add the new browse view, if available in the config node.
if (m_configurationNode.HasChildNodes)
{
XmlNode parms = m_configurationNode.SelectSingleNode("parameters");
if (mainObject != null)
{
RecordClerk clerk = (RecordClerk)m_mediator.PropertyTable.GetValue("RecordClerk-" + parms.Attributes["clerk"].Value);
if (clerk == null)
{
clerk = RecordClerkFactory.CreateClerk(m_mediator, parms);
}
clerk.OwningObject = mainObject;
}
RecordBrowseView browseView = new RecordBrowseView();
browseView.SuspendLayout();
browseView.Dock = DockStyle.Fill;
m_currentControl = browseView;
parent.Controls.Add(browseView);
browseView.Init(m_mediator, parms);
m_mediator.RemoveColleague(browseView);
browseView.BringToFront();
browseView.ResumeLayout();
m_mediator.AddColleague(this);
}
parent.ResumeLayout();
parent.FindForm().UseWaitCursor = false;
}
private void AddConfigurableControls()
{
// Load the controls.
// 1. Initialize the preview pane (lower pane)
m_previewPane = new XmlView(0, "publicationNew", false);
m_previewPane.Cache = m_cache;
m_previewPane.StyleSheet = FontHeightAdjuster.StyleSheetFromPropertyTable(m_propertyTable);
BasicPaneBarContainer pbc = new BasicPaneBarContainer();
pbc.Init(m_mediator, m_propertyTable, m_previewPane);
pbc.Dock = DockStyle.Fill;
pbc.PaneBar.Text = LexEdStrings.ksFindExampleSentenceDlgPreviewPaneTitle;
panel2.Controls.Add(pbc);
if (m_previewPane.RootBox == null)
{
m_previewPane.MakeRoot();
}
// 2. load the browse view. (upper pane)
XmlNode xnBrowseViewControlParameters = this.BrowseViewControlParameters;
// First create our Clerk, since we can't set it's OwningObject via the configuration/mediator/PropertyTable info.
m_clerk = RecordClerkFactory.CreateClerk(m_mediator, m_propertyTable, xnBrowseViewControlParameters, true);
m_clerk.OwningObject = m_owningSense;
m_rbv = DynamicLoader.CreateObject(xnBrowseViewControlParameters.ParentNode.SelectSingleNode("dynamicloaderinfo")) as ConcOccurrenceBrowseView;
m_rbv.Init(m_mediator, m_propertyTable, xnBrowseViewControlParameters, m_previewPane, m_clerk.VirtualListPublisher);
m_rbv.CheckBoxChanged += m_rbv_CheckBoxChanged;
// add it to our controls.
BasicPaneBarContainer pbc1 = new BasicPaneBarContainer();
pbc1.Init(m_mediator, m_propertyTable, m_rbv);
pbc1.BorderStyle = BorderStyle.FixedSingle;
pbc1.Dock = DockStyle.Fill;
pbc1.PaneBar.Text = LexEdStrings.ksFindExampleSentenceDlgBrowseViewPaneTitle;
panel1.Controls.Add(pbc1);
CheckAddBtnEnabling();
}
/// <summary>
/// Clean up any resources being used.
/// </summary>
protected override void Dispose(bool disposing)
{
if (IsDisposed)
{
return;
}
if (disposing)
{
if (components != null)
{
components.Dispose();
}
ClearResetTimer();
}
m_cache = null;
m_cacheSearch = null;
m_clerk = null;
base.Dispose(disposing);
}
private void AddConfigurableControls()
{
// Load the controls.
// 1. Initialize the preview pane (lower pane)
m_previewPane = new XmlView(0, "publicationNew", null, false);
m_previewPane.Cache = m_cache;
m_previewPane.StyleSheet = FontHeightAdjuster.StyleSheetFromMediator(m_mediator);
BasicPaneBarContainer pbc = new BasicPaneBarContainer();
pbc.Init(m_mediator, m_previewPane);
pbc.Dock = DockStyle.Fill;
pbc.PaneBar.Text = LexEdStrings.ksFindExampleSentenceDlgPreviewPaneTitle;
panel2.Controls.Add(pbc);
if (m_previewPane.RootBox == null)
m_previewPane.MakeRoot();
// 2. load the browse view. (upper pane)
XmlNode xnBrowseViewControlParameters = this.BrowseViewControlParameters;
// First create our Clerk, since we can't set it's OwningObject via the configuration/mediator/PropertyTable info.
m_clerk = RecordClerkFactory.CreateClerk(m_mediator, xnBrowseViewControlParameters, true);
m_clerk.OwningObject = m_owningSense;
m_rbv = DynamicLoader.CreateObject(xnBrowseViewControlParameters.ParentNode.SelectSingleNode("dynamicloaderinfo")) as ConcOccurrenceBrowseView;
m_rbv.Init(m_mediator, xnBrowseViewControlParameters, m_previewPane, m_clerk.VirtualListPublisher);
m_rbv.CheckBoxChanged += new CheckBoxChangedEventHandler(m_rbv_CheckBoxChanged);
// add it to our controls.
BasicPaneBarContainer pbc1 = new BasicPaneBarContainer();
pbc1.Init(m_mediator, m_rbv);
pbc1.BorderStyle = BorderStyle.FixedSingle;
pbc1.Dock = DockStyle.Fill;
pbc1.PaneBar.Text = LexEdStrings.ksFindExampleSentenceDlgBrowseViewPaneTitle;
panel1.Controls.Add(pbc1);
CheckAddBtnEnabling();
}
private bool SetDlgInfoPrivate(Mediator mediator, XmlNode configurationParameters)
{
using (new WaitCursor(this))
{
m_mediator = mediator;
m_btnRefresh.Image = ResourceHelper.RefreshIcon;
m_rbDiscardAnalyses.Checked = m_mediator.PropertyTable.GetBoolProperty("RemoveAnalyses", true);
m_rbKeepAnalyses.Checked = !m_rbDiscardAnalyses.Checked;
m_rbDiscardAnalyses.Click += m_rbDiscardAnalyses_Click;
m_rbKeepAnalyses.Click += m_rbDiscardAnalyses_Click;
m_cbUpdateLexicon.Checked = m_mediator.PropertyTable.GetBoolProperty("UpdateLexiconIfPossible", true);
m_cbCopyAnalyses.Checked = m_mediator.PropertyTable.GetBoolProperty("CopyAnalysesToNewSpelling", true);
m_cbCopyAnalyses.Click += m_cbCopyAnalyses_Click;
m_cbMaintainCase.Checked = m_mediator.PropertyTable.GetBoolProperty("MaintainCaseOnChangeSpelling", true);
m_cbMaintainCase.Click += m_cbMaintainCase_Click;
m_cache = (FdoCache)m_mediator.PropertyTable.GetValue("cache");
// We need to use the 'best vern' ws,
// since that is what is showing in the Words-Analyses detail edit control.
// Access to this respeller dlg is currently (Jan. 2008) only via a context menu in the detail edit pane.
// The user may be showing multiple wordform WSes in the left hand browse view,
// but we have no way of knowing if the user thinks one of those alternatives is wrong without asking.
m_vernWs = WritingSystemServices.ActualWs(m_cache,
WritingSystemServices.kwsFirstVern,
m_srcwfiWordform.Hvo,
WfiWordformTags.kflidForm);
// Bail out if no vernacular writing system was found (see LT-8892).
Debug.Assert(m_vernWs != 0);
if (m_vernWs == 0)
return false;
// Bail out, rather than run into a null reference exception.
// (Should fix LT-7666.)
var vernForm = m_srcwfiWordform.Form.get_String(m_vernWs);
if (vernForm == null || vernForm.Length == 0)
return false;
m_cbNewSpelling.WritingSystemFactory = m_cache.LanguageWritingSystemFactoryAccessor;
m_cbNewSpelling.WritingSystemCode = m_vernWs;
m_cbNewSpelling.StyleSheet = FontHeightAdjuster.StyleSheetFromMediator(m_mediator);
Debug.Assert(m_cbNewSpelling.StyleSheet != null); // if it is we get a HUGE default font (and can't get the correct size)
if (m_cbNewSpelling.WritingSystemFactory.get_EngineOrNull(m_vernWs).RightToLeftScript)
{
m_cbNewSpelling.RightToLeft = RightToLeft.Yes;
}
m_cbNewSpelling.Tss = vernForm;
m_cbNewSpelling.AdjustForStyleSheet(this, null, m_cbNewSpelling.StyleSheet);
if (!Application.RenderWithVisualStyles)
m_cbNewSpelling.Padding = new Padding(1, 2, 1, 1);
SetSuggestions();
m_btnApply.Enabled = false;
m_cbNewSpelling.TextChanged += m_dstWordform_TextChanged;
// Setup source browse view.
var toolNode = configurationParameters.SelectSingleNode("controls/control[@id='srcSentences']/parameters");
m_srcClerk = RecordClerkFactory.CreateClerk(m_mediator, toolNode, true);
m_srcClerk.OwningObject = m_srcwfiWordform;
m_sourceSentences.Init(m_mediator, toolNode);
m_sourceSentences.CheckBoxChanged += sentences_CheckBoxChanged;
m_specialSda = m_sourceSentences.BrowseViewer.SpecialCache;
m_moreMinSize = Size;
m_moreMinSize.Height -= m_sourceSentences.Height / 2;
m_lessMinSize = m_moreMinSize;
m_lessMinSize.Height -= m_optionsPanel.Height;
AdjustHeightAndMinSize(Height - m_optionsPanel.Height, m_lessMinSize);
m_optionsPanel.Visible = false;
m_btnMore.Image = ResourceHelper.MoreButtonDoubleArrowIcon;
m_btnMore.Click += btnMore_Click;
m_sMoreButtonText = m_btnMore.Text;
m_optionsPanel.Paint += m_optionsPanel_Paint;
m_btnPreviewClear.Click += m_btnPreviewClear_Click;
var specialMdc = m_specialSda.MetaDataCache;
int fakeFlid = specialMdc.GetFieldId2(WfiWordformTags.kClassId, "Occurrences", false);
int[] concordanceItems = m_specialSda.VecProp(m_srcwfiWordform.Hvo, fakeFlid);
// (Re)set selected state in cache, so default behavior of checked is used.
foreach (var concId in concordanceItems)
{
m_specialSda.SetInt(concId, m_sourceSentences.BrowseViewer.PreviewEnabledTag, 1);
m_specialSda.SetInt(concId, XMLViewsDataCache.ktagItemSelected, 1);
}
// We initially check everything.
var segmentRepos = m_cache.ServiceLocator.GetInstance<ISegmentRepository>();
foreach (var hvo in m_sourceSentences.BrowseViewer.AllItems)
m_enabledItems.Add(hvo);
// no good...code in MakeRoot of XmlBrowseView happens later and overrides. Control with
// selectionType attr in Xml configuration.
//m_sourceSentences.BrowseViewer.SelectedRowHighlighting = XmlBrowseViewBase.SelectionHighlighting.none;
m_lblExplainText = m_lblExplainDisabled.Text;
// We only reload the list when refresh is pressed.
m_srcClerk.ListLoadingSuppressed = true;
CheckForOtherOccurrences();
SetEnabledState();
}
return true;
}
internal bool SetDlgInfo(Mediator mediator, XmlNode configurationParameters)
{
m_wfClerk = (RecordClerk)mediator.PropertyTable.GetValue("RecordClerk-concordanceWords");
m_wfClerk.SuppressSaveOnChangeRecord = true; // various things trigger change record and would prevent Undo
//We need to re-parse the interesting texts so that the rows in the dialog show all the occurrences (make sure it is up to date)
if(m_wfClerk is InterlinearTextsRecordClerk)
{
//Unsuppress to allow for the list to be reloaded during ParseInterstingTextsIfNeeded()
//(this clerk and its list are not visible in this dialog, so there will be no future reload)
m_wfClerk.ListLoadingSuppressed = false;
(m_wfClerk as InterlinearTextsRecordClerk).ParseInterstingTextsIfNeeded(); //Trigger the parsing
}
m_srcwfiWordform = (IWfiWordform)m_wfClerk.CurrentObject;
if (m_fDisposeMediator && m_mediator != null)
m_mediator.Dispose();
m_fDisposeMediator = false;
return SetDlgInfoPrivate(mediator, configurationParameters);
}