private void ButtonMoreMenus_Click(object sender, RoutedEventArgs e)
{
PDFDocument pdf_document = GetPDFDocument();
ASSERT.Test(pdf_document != null);
if (pdf_document != null)
{
LibraryCatalogPopup popup = new LibraryCatalogPopup(new List <PDFDocument> {
pdf_document
});
popup.Open();
}
e.Handled = true;
}
private void OnDrop_PDFDocumentList(object drop_object, Point mouse_current_virtual)
{
List <PDFDocument> pdf_documents = (List <PDFDocument>)drop_object;
ASSERT.Test(pdf_documents != null);
List <object> node_contents = new List <object>();
foreach (PDFDocument pdf_document in pdf_documents)
{
PDFDocumentNodeContent document_node_content = new PDFDocumentNodeContent(pdf_document.Fingerprint, pdf_document.LibraryRef.Id);
node_contents.Add(document_node_content);
}
DragDropManager?.SceneRenderingControl?.AddNewNodeControls(node_contents, mouse_current_virtual.X, mouse_current_virtual.Y);
}
public void Test_PDF_metadata_extraction_via_multipurp_chunk0030(string filepath)
{
string pdf_filename = MiscTestHelpers.GetNormalizedPathToAnyTestDataTestFile($"fixtures/PDF/{ filepath.Replace("./", "") }");
ASSERT.FileExists(pdf_filename);
PDFDocumentMuPDFMetaInfo info = MuPDFRenderer.GetDocumentMetaInfo(pdf_filename, null, ProcessPriorityClass.Normal);
string json_text = ProduceJSONtext4Comparison(info);
// Perform comparison via ApprovalTests->BeyondCompare (that's what I use for *decades* now)
//ApprovalTests.Approvals.VerifyJson(json_out); --> becomes the code below:
ApprovalTests.Approvals.Verify(
new QiqqaApprover(json_text, pdf_filename),
ApprovalTests.Approvals.GetReporter()
);
}
public string GetDescriptionForTopic(int topic, bool include_topic_number = true, string separator = "; ", bool stop_at_word_probability_jump = true)
{
StringBuilder sb = new StringBuilder();
if (include_topic_number)
{
sb.Append(String.Format("{0}. ", topic + 1));
}
LDAAnalysis lda = LDAAnalysis;
WordProbability[] lda_wordprobs = lda.DensityOfWordsInTopicsSorted[topic];
ASSERT.Test(lda_wordprobs != null);
double last_term_prob = 0;
for (int t = 0; t < 5 && t < lda.NUM_WORDS; ++t)
{
WordProbability lda_node = lda_wordprobs[t];
ASSERT.Test(lda_node != null);
if (last_term_prob / lda_node.prob > 10)
{
if (stop_at_word_probability_jump)
{
break;
}
else
{
sb.Append(" // ");
}
}
last_term_prob = lda_node.prob;
sb.Append(String.Format("{0}", words[lda_node.word]));
sb.Append(separator);
}
string description = sb.ToString();
if (description.EndsWith(separator))
{
description = description.Substring(0, description.Length - separator.Length);
}
return(description);
}
// ----------------------------------------------------------------------------------------------------------------------------------
public static WebLibraryDetail PickWebLibrary(string message = null)
{
List <WebLibraryDetail> wlds = WebLibraryManager.Instance.WebLibraryDetails_WorkingWebLibraries;
ASSERT.Test(wlds.Count > 0);
switch (wlds.Count)
{
case 1:
// If we have only one library, use that...
return(wlds[0]);
default:
// Otherwise fall back on the GUI
return(PickWebLibrary_GUI(message));
}
}
private void ButtonInCite_Snippet_Click(object sender, RoutedEventArgs e)
{
ButtonInCitePopup.Close();
FeatureTrackingManager.Instance.UseFeature(Features.InCite_AddNewCitationSnippet_FromDocument);
PDFDocument pdf_document = GetPDFDocument();
ASSERT.Test(pdf_document != null);
if (pdf_document != null)
{
PDFDocumentCitingTools.CiteSnippetPDFDocument(false, pdf_document);
}
e.Handled = true;
}
public void Test_Conversion_To_And_From_BibTeX_Text(string filepath)
{
string path = GetNormalizedPathToAnyTestDataTestFile(filepath);
ASSERT.FileExists(path);
string data_in = GetTestFileContent(path);
string s1 = data_in;
string s2 = BibTexCharacterMap.ASCIIToBibTex(s1);
string s3 = BibTexCharacterMap.BibTexToASCII(s2);
//ASSERT.AreEqual(s1, s3);
ApprovalTests.Approvals.Verify(
new QiqqaApprover(s3, filepath),
ApprovalTests.Approvals.GetReporter()
);
}
private static void ExpandThemes(PDFDocument doc, NodeControl node_control)
{
WPFDoEvents.AssertThisCodeIs_NOT_RunningInTheUIThread();
ASSERT.Test(doc != null);
FeatureTrackingManager.Instance.UseFeature(Features.Brainstorm_ExploreLibrary_Document_Themes);
if (doc != null)
{
ASSERT.Test(doc.LibraryRef.Xlibrary != null);
bool added_at_least_one_theme = false;
ExpeditionDataSource eds = doc.LibraryRef.Xlibrary?.ExpeditionManager?.ExpeditionDataSource;
if (null != eds)
{
if (eds.docs_index.ContainsKey(doc.Fingerprint))
{
int doc_id = eds.docs_index[doc.Fingerprint];
TopicProbability[] topics = eds.LDAAnalysis.DensityOfTopicsInDocsSorted[doc_id];
WPFDoEvents.InvokeInUIThread(() =>
{
for (int t = 0; t < Math.Min(topics.Length, 5); ++t)
{
string topic_name = eds.GetDescriptionForTopic(topics[t].topic, include_topic_number: false, "\n");
ThemeNodeContent tnc = new ThemeNodeContent(topic_name, doc.LibraryRef.Id);
NodeControlAddingByKeyboard.AddChildToNodeControl(node_control, tnc, false);
added_at_least_one_theme = true;
}
});
}
else
{
Logging.Warn("Expedition has not been run for library '{0}'.", doc.LibraryRef.Title);
}
}
if (!added_at_least_one_theme)
{
MessageBoxes.Warn("There were no themes available for this document. Please run Expedition against your library.");
}
}
}
internal static Attribute GetCustomAttribute(Type type)
{
if (!IsDefined(type))
{
return(null);
}
int pack = 0, size = 0;
LayoutKind layoutKind = LayoutKind.Auto;
switch (type.Attributes & TypeAttributes.LayoutMask)
{
case TypeAttributes.ExplicitLayout: layoutKind = LayoutKind.Explicit; break;
case TypeAttributes.AutoLayout: layoutKind = LayoutKind.Auto; break;
case TypeAttributes.SequentialLayout: layoutKind = LayoutKind.Sequential; break;
default: ASSERT.UNREACHABLE(); break;
}
CharSet charSet = CharSet.None;
switch (type.Attributes & TypeAttributes.StringFormatMask)
{
case TypeAttributes.AnsiClass: charSet = CharSet.Ansi; break;
case TypeAttributes.AutoClass: charSet = CharSet.Auto; break;
case TypeAttributes.UnicodeClass: charSet = CharSet.Unicode; break;
default: ASSERT.UNREACHABLE(); break;
}
type.Module.MetadataImport.GetClassLayout(type.MetadataToken, out pack, out size);
// Metadata parameter checking should not have allowed 0 for packing size.
// The runtime later converts a packing size of 0 to 8 so do the same here
// because it's more useful from a user perspective.
if (pack == 0)
{
pack = DEFAULT_PACKING_SIZE;
}
return(new StructLayoutAttribute(layoutKind, pack, size, charSet));
}
public static void SaveSafely(string filename, object animal_to_save)
{
if (!ShutdownableManager.Instance.IsShuttingDown)
{
ASSERT.Test(animal_to_save != null);
}
if (animal_to_save != null)
{
try
{
SaveRedundant(filename, animal_to_save);
}
catch (Exception ex)
{
Logging.Warn(ex, $"Error saving '{filename}'");
}
}
}
public static PDFDocument CreateFromVanillaReference(WebLibraryDetail web_library_detail)
{
PDFDocument pdf_document = new PDFDocument(web_library_detail);
// Store the most important information
//
// thread-UNSAFE access is permitted as the PDF has just been created so there's no thread-safety risk yet.
pdf_document.FileType = Constants.VanillaReferenceFileType;
pdf_document.Fingerprint = VanillaReferenceCreating.CreateVanillaReferenceFingerprint();
pdf_document.DateAddedToDatabase = DateTime.UtcNow;
pdf_document.DateLastModified = DateTime.UtcNow;
Directory.CreateDirectory(pdf_document.DocumentBasePath);
List <LibraryDB.LibraryItem> library_items = web_library_detail.Xlibrary.LibraryDB.GetLibraryItems(PDFDocumentFileLocations.METADATA, new List <string>()
{
pdf_document.Fingerprint
});
ASSERT.Test(library_items.Count < 2);
if (0 == library_items.Count)
{
pdf_document.QueueToStorage();
}
else
{
LibraryDB.LibraryItem library_item = null;
try
{
library_item = library_items[0];
pdf_document = LoadFromMetaData(web_library_detail, pdf_document.Fingerprint, library_item.data);
}
catch (Exception ex)
{
Logging.Error(ex, "There was a problem reloading an existing PDF from existing metadata, so overwriting it! (document fingerprint: {0}, data: {1})", pdf_document.Fingerprint, library_item?.MetadataAsString() ?? "???");
// TODO: WARNING: overwriting old (possibly corrupted) records like this can loose you old/corrupted/unsupported metadata content!
pdf_document.QueueToStorage();
}
}
return(pdf_document);
}
public static void InvokeAsyncInUIThread(Action action, DispatcherPriority priority = DispatcherPriority.Normal)
{
if (Application.Current != null)
{
Application.Current.Dispatcher.BeginInvoke(action, priority);
}
else
{
ASSERT.Test(ShutdownableManager.Instance.IsShuttingDown);
try
{
throw new Exception("Ignoring async UI invocation during shutdown.");
}
catch (Exception ex)
{
Logging.Warn(ex);
}
}
}
public void Test_Live_Scholar_Search()
{
//GoogleScholarScraper gs_scraper = new GoogleScholarScraper("latent dirichlet allocation", 100, true);
string url = GenerateQueryUrl("dirichlet", 100);
List <GoogleScholarScrapePaper> gssps = ScrapeUrl(url);
ASSERT.IsGreaterOrEqual(gssps.Count, 1);
foreach (var gs_paper in gssps)
{
#if false
bool have_a_match = false;
bool have_a_close_match = false;
foreach (ACLPaperMetadata metadata in ACLPaperMetadatas.GetACLPaperMetadatas().Values)
{
string acl_title = metadata.title.ToLower();
string gs_title = gs_paper.title.ToLower();
double max_length = Math.Max(acl_title.Length, gs_title.Length);
int lewenstein = StringTools.LewensteinDistance(acl_title, gs_title);
if (lewenstein / max_length < 0.2)
{
have_a_close_match = true;
}
if (acl_title.Contains(gs_title) || gs_title.Contains(acl_title))
{
have_a_match = true;
}
}
Logging.Info((have_a_match ? "X" : ".") + (have_a_close_match ? "X" : "."));
if (have_a_match != have_a_close_match)
{
int aaaaaaaaa = 3;
}
#endif
Logging.Info(gs_paper.ToString());
}
}
private void ButtonInCite_BibTeXKey_Click(object sender, RoutedEventArgs e)
{
ButtonInCitePopup.Close();
PDFDocument pdf_document = GetPDFDocument();
ASSERT.Test(pdf_document != null);
if (pdf_document != null)
{
if (!String.IsNullOrEmpty(pdf_document.BibTexKey))
{
string result = @"\cite{" + pdf_document.BibTexKey + @"}";
ClipboardTools.SetText(result);
StatusManager.Instance.UpdateStatus("CopyBibTeXKey", String.Format("Copied '{0}' to clipboard.", result));
}
}
e.Handled = true;
}
internal static void ReadFromDisk(PDFDocument pdf_document)
{
WPFDoEvents.AssertThisCodeIs_NOT_RunningInTheUIThread();
byte[] annotations_data = null;
// Try to load the annotations from file if they exist
var items = pdf_document.LibraryRef.Xlibrary.LibraryDB.GetLibraryItems(PDFDocumentFileLocations.ANNOTATIONS, new List <string>()
{
pdf_document.Fingerprint
});
ASSERT.Test(items.Count < 2);
if (0 < items.Count)
{
annotations_data = items[0].data;
}
// If we actually have some annotations, load them
if (null != annotations_data)
{
List <DictionaryBasedObject> annotation_dictionaries = null;
try
{
annotation_dictionaries = ReadFromStream_JSON(annotations_data);
}
catch (Exception)
{
annotation_dictionaries = ReadFromStream_BINARY(annotations_data);
}
if (null != annotation_dictionaries)
{
foreach (DictionaryBasedObject annotation_dictionary in annotation_dictionaries)
{
PDFAnnotation pdf_annotation = new PDFAnnotation(annotation_dictionary, false);
pdf_document.AddUpdatedAnnotation(pdf_annotation);
}
}
}
}
public void TestCallAsyncFireAndForget_ImmediateThrow()
{
try
{
// output "hello world" as method returns early
ASSERT.AreEqual(ExampleFireAndForgetFunc(), "hello world");
}
catch
{
// Exception is NOT caught here
ASSERT.Fail("exception should not be caught here");
}
//ASSERT.IsNull(caught_ex);
Thread.Sleep(500);
ASSERT.IsNotNull(caught_ex);
ASSERT.IsTrue(faulted, "faulted");
ASSERT.IsTrue(completed, "completed");
ASSERT.IsFalse(canceled, "cancelled");
}
internal void ExecuteSearchQuick(string query)
{
ASSERT.Test(query != null);
SearchQuick.Text = query;
if (!String.IsNullOrEmpty(query))
{
FeatureTrackingManager.Instance.UseFeature(Features.Library_KeywordFilter);
List <IndexResult> index_results = LibrarySearcher.FindAllFingerprintsMatchingQuery(library_filter_control.web_library_detail, query);
library_filter_control.search_quick_query = query;
library_filter_control.search_quick_scores = new Dictionary <string, double>();
library_filter_control.search_quick_fingerprints = new HashSet <string>();
foreach (var index_result in index_results)
{
library_filter_control.search_quick_fingerprints.Add(index_result.fingerprint);
library_filter_control.search_quick_scores[index_result.fingerprint] = index_result.score;
}
}
else
{
library_filter_control.search_quick_query = null;
library_filter_control.search_quick_fingerprints = null;
library_filter_control.search_quick_scores = null;
}
// Create the feedback
library_filter_control.search_quick_fingerprints_span = new Span();
Bold bold = new Bold();
bold.Inlines.Add("Search");
library_filter_control.search_quick_fingerprints_span.Inlines.Add(bold);
library_filter_control.search_quick_fingerprints_span.Inlines.Add(" (click search score for details)");
library_filter_control.search_quick_fingerprints_span.Inlines.Add(": ");
library_filter_control.search_quick_fingerprints_span.Inlines.Add("'");
library_filter_control.search_quick_fingerprints_span.Inlines.Add(query);
library_filter_control.search_quick_fingerprints_span.Inlines.Add("'");
library_filter_control.search_quick_fingerprints_span.Inlines.Add(LibraryFilterHelpers.GetClearImageInline("Clear this filter.", hyperlink_search_quick_fingerprints_span_OnClick));
}
private void MoveGuestPreviewPDFDocument(WebLibraryDetail web_library_detail)
{
PDFDocument pdf_document = GetPDFDocument();
ASSERT.Test(pdf_document != null);
if (pdf_document != null)
{
PDFDocument source_pdf_document = pdf_document;
SafeThreadPool.QueueUserWorkItem(o =>
{
PDFDocument cloned_pdf_document = ImportingIntoLibrary.ClonePDFDocumentsFromOtherLibrary_SYNCHRONOUS(source_pdf_document, web_library_detail);
ASSERT.Test(cloned_pdf_document != null);
WPFDoEvents.InvokeInUIThread(() =>
{
// Open the new
if (null != cloned_pdf_document)
{
MainWindowServiceDispatcher.Instance.OpenDocument(cloned_pdf_document);
}
else
{
MessageBoxes.Warn("There was a problem moving this document to another library.");
}
// Close the old
MainWindowServiceDispatcher.Instance.ClosePDFReadingControl(this);
// Delete the old
if (cloned_pdf_document != null && cloned_pdf_document != source_pdf_document)
{
source_pdf_document.Deleted = true;
source_pdf_document.Bindable.NotifyPropertyChanged(nameof(source_pdf_document.Deleted));
}
});
});
}
}
public void ReflectLibrary(WebLibraryDetail web_library_detail)
{
// Reset
RegionNoLibrary.Visibility = Visibility.Collapsed;
RegionNoExpedition.Visibility = Visibility.Collapsed;
RegionStaleExpedition.Visibility = Visibility.Collapsed;
RegionExpeditionTooSmall.Visibility = Visibility.Collapsed;
// Reflect
if (null == web_library_detail)
{
RegionNoLibrary.Visibility = Visibility.Visible;
}
else
{
ExpeditionDataSource eds = web_library_detail.Xlibrary?.ExpeditionManager?.ExpeditionDataSource;
if (null != eds)
{
RegionNoExpedition.Visibility = Visibility.Visible;
}
else
{
ASSERT.Test(eds.words != null);
ASSERT.Test(eds.docs != null);
// Is this expedition getting old?
if (web_library_detail.Xlibrary.ExpeditionManager.IsStale)
{
RegionStaleExpedition.Visibility = Visibility.Visible;
}
// Is this expedition too small?
if (eds.docs.Count < 20 || eds.words.Count < 5)
{
RegionExpeditionTooSmall.Visibility = Visibility.Visible;
}
}
}
}
public void Basic_Test(string sample_filepath)
{
string path = GetNormalizedPathToAnyTestDataTestFile(sample_filepath);
ASSERT.FileExists(path);
string sample_text = GetTestFileContent(path);
// extract URL from sample file:
string url = null;
string docHtml = null;
Match match = Regex.Match(sample_text, @"<!--(.*?)-->(.*)", RegexOptions.Singleline); // counter-intuitive flag: https://stackoverflow.com/questions/159118/how-do-i-match-any-character-across-multiple-lines-in-a-regular-expression
if (Match.Empty != match)
{
url = match.Groups[1].Value.Trim();
docHtml = match.Groups[2].Value;
}
List <GoogleScholarScrapePaper> gssps = new List <GoogleScholarScrapePaper>();
HtmlDocument doc = new HtmlDocument();
doc.LoadHtml(docHtml);
//doc.Load(ms, System.Text.Encoding.UTF8, detectEncodingFromByteOrderMarks: false);
ScrapeDoc(doc, url, ref gssps);
ASSERT.IsGreaterOrEqual(gssps.Count, 1);
// Serialize the result to JSON for easier comparison via ApprovalTests->BeyondCompare (that's what I use for *decades* now)
string json_out = JsonConvert.SerializeObject(gssps, Newtonsoft.Json.Formatting.Indented).Replace("\r\n", "\n");
//ApprovalTests.Approvals.VerifyJson(json_out); --> becomes the code below:
ApprovalTests.Approvals.Verify(
new QiqqaApprover(json_out, sample_filepath),
ApprovalTests.Approvals.GetReporter()
);
}
private void GetCombinedWordsList(List <string> words, List <int> page_word_offsets)
{
PDFDocument pdf_document = GetPDFDocument();
ASSERT.Test(pdf_document != null);
if (null != pdf_document)
{
for (int page = 1; page <= pdf_document.PageCount; ++page)
{
WordList words_on_page = pdf_document.GetOCRText(page);
page_word_offsets.Add(words.Count);
if (null != words_on_page)
{
foreach (Word word in words_on_page)
{
words.Add(word.Text);
}
}
}
}
}
public void GetFirstWord_Test(string data_filepath)
{
string path = GetNormalizedPathToAnyTestDataTestFile(data_filepath);
ASSERT.FileExists(path);
string data_text = GetTestFileContent(path);
Result rv = new Result();
rv.input = data_text;
rv.result = StringTools.GetFirstWord(data_text);
// Serialize the result to JSON for easier comparison via ApprovalTests->BeyondCompare (that's what I use for *decades* now)
string json_out = JsonConvert.SerializeObject(rv, Newtonsoft.Json.Formatting.Indented).Replace("\r\n", "\n");
//ApprovalTests.Approvals.VerifyJson(json_out); --> becomes the code below:
ApprovalTests.Approvals.Verify(
new QiqqaApprover(json_out, data_filepath),
ApprovalTests.Approvals.GetReporter()
);
}
internal static Attribute GetCustomAttribute(int token, Module scope)
{
UnmanagedType unmanagedType, arraySubType;
VarEnum safeArraySubType;
int sizeParamIndex = 0, sizeConst = 0;
string marshalTypeName = null, marshalCookie = null, safeArrayUserDefinedTypeName = null;
int iidParamIndex = 0;
ConstArray nativeType = scope.ModuleHandle.GetMetadataImport().GetFieldMarshal(token);
if (nativeType.Length == 0)
{
return(null);
}
MetadataImport.GetMarshalAs(nativeType,
out unmanagedType, out safeArraySubType, out safeArrayUserDefinedTypeName, out arraySubType, out sizeParamIndex,
out sizeConst, out marshalTypeName, out marshalCookie, out iidParamIndex);
Type safeArrayUserDefinedType = safeArrayUserDefinedTypeName == null || safeArrayUserDefinedTypeName.Length == 0 ? null :
RuntimeTypeHandle.GetTypeByNameUsingCARules(safeArrayUserDefinedTypeName, scope);
Type marshalTypeRef = null;
try
{
marshalTypeRef = marshalTypeName == null ? null : RuntimeTypeHandle.GetTypeByNameUsingCARules(marshalTypeName, scope);
}
catch (System.TypeLoadException)
{
// The user may have supplied a bad type name string causing this TypeLoadException
// Regardless, we return the bad type name
ASSERT.CONSISTENCY_CHECK(marshalTypeName != null);
}
return(new MarshalAsAttribute(
unmanagedType, safeArraySubType, safeArrayUserDefinedType, arraySubType,
(short)sizeParamIndex, sizeConst, marshalTypeName, marshalTypeRef, marshalCookie, iidParamIndex));
}
private void SetSearchKeywords_EXECUTE(string search_string)
{
// Check if we are repeating the search or not...
if (previous_search_string != search_string)
{
FeatureTrackingManager.Instance.UseFeature(Features.Document_Search);
previous_search_string = search_string;
PDFDocument pdf_document = GetPDFDocument();
ASSERT.Test(pdf_document != null);
if (pdf_document != null)
{
previous_search_result_set = PDFSearcher.Search(pdf_document, search_string);
}
}
else
{
FeatureTrackingManager.Instance.UseFeature(Features.Document_SearchAgain);
}
PDFSearchResultSet search_result_set = previous_search_result_set;
// Set the PDF viewer search results
pdf_renderer_control.SetSearchKeywords(search_result_set);
// Set the bottom list box search results
if (null != search_result_set && search_result_set.Count > 0)
{
GridBOTTOM.Visibility = Visibility.Visible;
}
else
{
GridBOTTOM.Visibility = Visibility.Collapsed;
}
ListSearchDetails.DataContext = search_result_set.AsList();
}
private static void ExpandRelevants(PDFDocument doc, NodeControl node_control)
{
WPFDoEvents.AssertThisCodeIs_NOT_RunningInTheUIThread();
ASSERT.Test(doc != null);
FeatureTrackingManager.Instance.UseFeature(Features.Brainstorm_ExploreLibrary_Document_Similars);
if (doc != null)
{
List <ExpeditionPaperSuggestions.Result> results = ExpeditionPaperSuggestions.GetRelevantOthers(doc, 10);
WPFDoEvents.InvokeInUIThread(() =>
{
WPFDoEvents.AssertThisCodeIsRunningInTheUIThread();
foreach (ExpeditionPaperSuggestions.Result result in results)
{
PDFDocumentNodeContent content = new PDFDocumentNodeContent(result.pdf_document.Fingerprint, result.pdf_document.LibraryRef.Id);
NodeControlAddingByKeyboard.AddChildToNodeControl(node_control, content, false);
}
});
}
}
public void Basic_Import_Test(string pubmed_filepath)
{
// See http://www.nlm.nih.gov/bsd/licensee/elements_descriptions.html for the low-down
string path = GetNormalizedPathToPubMedXMLTestFile(pubmed_filepath);
ASSERT.FileExists(path);
string pubmed_xml = GetTestFileContent(path);
Result rv = new Result();
rv.success = PubMedXMLToBibTex.TryConvert(pubmed_xml, out rv.bibtex, out rv.messages);
// Serialize the result to JSON for easier comparison via ApprovalTests->BeyondCompare (that's what I use for *decades* now)
string json_out = JsonConvert.SerializeObject(rv, Newtonsoft.Json.Formatting.Indented).Replace("\r\n", "\n");
//ApprovalTests.Approvals.VerifyJson(json_out); --> becomes the code below:
ApprovalTests.Approvals.Verify(
new QiqqaApprover(json_out, pubmed_filepath),
ApprovalTests.Approvals.GetReporter()
);
}
private static void ExpandTags(PDFDocument doc, NodeControl node_control)
{
WPFDoEvents.AssertThisCodeIs_NOT_RunningInTheUIThread();
ASSERT.Test(doc != null);
FeatureTrackingManager.Instance.UseFeature(Features.Brainstorm_ExploreLibrary_Document_Tags);
if (doc != null)
{
var tags = TagTools.ConvertTagBundleToTags(doc.Tags);
WPFDoEvents.InvokeInUIThread(() =>
{
WPFDoEvents.AssertThisCodeIsRunningInTheUIThread();
foreach (string tag in tags)
{
PDFTagNodeContent pdf_tag = new PDFTagNodeContent(doc.LibraryRef.Id, tag);
NodeControlAddingByKeyboard.AddChildToNodeControl(node_control, pdf_tag, false);
}
});
}
}
private static void ExpandAutoTags(PDFDocument doc, NodeControl node_control)
{
WPFDoEvents.AssertThisCodeIs_NOT_RunningInTheUIThread();
ASSERT.Test(doc != null);
FeatureTrackingManager.Instance.UseFeature(Features.Brainstorm_ExploreLibrary_Document_AutoTags);
if (doc != null)
{
HashSet <string> tags = doc.LibraryRef.Xlibrary.AITagManager.AITags.GetTagsWithDocument(doc.Fingerprint);
WPFDoEvents.InvokeInUIThread(() =>
{
WPFDoEvents.AssertThisCodeIsRunningInTheUIThread();
foreach (string tag in tags)
{
PDFAutoTagNodeContent pdf_auto_tag = new PDFAutoTagNodeContent(doc.LibraryRef.Id, tag);
NodeControlAddingByKeyboard.AddChildToNodeControl(node_control, pdf_auto_tag, false);
}
});
}
}
public static void SaveDesktop()
{
List <string> restore_settings = new List <string>();
// Get the remembrances
List <FrameworkElement> framework_elements = MainWindowServiceDispatcher.Instance.MainWindow.DockingManager.GetAllFrameworkElements();
foreach (FrameworkElement framework_element in framework_elements)
{
{
LibraryControl library_control = framework_element as LibraryControl;
if (null != library_control)
{
Logging.Info("Remembering a library control {0}", library_control.LibraryRef.Id);
restore_settings.Add(String.Format("PDF_LIBRARY,{0}", library_control.LibraryRef.Id));
}
}
{
PDFReadingControl pdf_reading_control = framework_element as PDFReadingControl;
if (null != pdf_reading_control)
{
PDFDocument pdf_document = pdf_reading_control.GetPDFDocument();
ASSERT.Test(pdf_document != null);
if (pdf_document != null)
{
Logging.Info("Remembering a PDF reader {0}", pdf_document.Fingerprint);
restore_settings.Add(String.Format("PDF_DOCUMENT,{0},{1}", pdf_document.LibraryRef.Id, pdf_document.Fingerprint));
}
}
}
}
// Store the remembrances
File.WriteAllLines(Filename, restore_settings);
}
protected virtual void Dispose(bool disposing)
{
Logging.Debug("PDFReadingControl::Dispose({0}) @{1}", disposing, dispose_count);
WPFDoEvents.InvokeInUIThread(() =>
{
WPFDoEvents.SafeExec(() =>
{
if (dispose_count == 0)
{
// GetPDFDocument() depends on a valid pdf_renderer_control reference, so we do this one first!
PDFDocument pdf_document = GetPDFDocument();
ASSERT.Test(pdf_document != null);
pdf_document?.FlushCachedPageRenderings();
}
});
WPFDoEvents.SafeExec(() =>
{
if (dispose_count == 0)
{
// Get rid of managed resources
PDFRendererControlArea.Children.Clear();
pdf_renderer_control?.Dispose();
}
});
WPFDoEvents.SafeExec(() =>
{
pdf_renderer_control = null;
});
++dispose_count;
});
}
