public static bool TitlePropertyHasImplicitImplementation(object documentContentOrDocumentViewModel)
{
IDocumentContent documentContent = documentContentOrDocumentViewModel as IDocumentContent;
#if !NETFX_CORE
if (documentContent != null)
{
return(ExpressionHelper.PropertyHasImplicitImplementation(documentContent, i => i.Title));
}
#pragma warning disable 612, 618
IDocumentViewModel documentViewModel = documentContentOrDocumentViewModel as IDocumentViewModel;
if (documentViewModel != null)
{
return(ExpressionHelper.PropertyHasImplicitImplementation(documentViewModel, i => i.Title));
}
#pragma warning restore 612, 618
#else
if (documentContent != null)
{
InterfaceMapping mapping = documentContent.GetType().GetTypeInfo().GetRuntimeInterfaceMap(typeof(IDocumentContent));
return(mapping.TargetMethods.FirstOrDefault(mi => mi.Name == "set_Title" && mi.IsPrivate) != null);
}
#endif
throw new ArgumentException("", "documentContentOrDocumentViewModel");
}
/// <summary>
/// Saves a document and resets the dirty flag.
/// </summary>
/// <param name="fileToSave"></param>
/// <param name="saveAsFlag"></param>
public void Save(IDocumentViewModel fileToSave, bool saveAsFlag = false)
{
if (fileToSave.FilePath == null || saveAsFlag)
{
var dlg = new SaveFileDialog();
if (fileToSave.FilePath != null)
{
dlg.FileName = Path.GetFileName(fileToSave.FilePath);
}
else
{
dlg.FileName = Path.GetFileName(fileToSave.ContentId);
}
//dlg.RestoreDirectory = true;
dlg.InitialDirectory = Path.GetDirectoryName(fileToSave.FilePath);
if (dlg.ShowDialog().GetValueOrDefault())
{
fileToSave.FilePath = dlg.SafeFileName;
ActiveDocument.SaveAsCommand.SafeExecute();
}
}
else
{
ActiveDocument.SaveCommand.SafeExecute();
}
}
int Compare(int sortColumnIndex, IDocumentViewModel objX, IDocumentViewModel objY)
{
var objSortColumn = default(DocumentsSortColumnInfo);
int intResult = 0;
if (sortColumnIndex >= mobjSortColumns.Count)
{
return(0);
}
objSortColumn = (DocumentsSortColumnInfo)mobjSortColumns [sortColumnIndex];
if (objSortColumn.Direction == SortDirection.Ascending)
{
intResult = CompareValues(objSortColumn.ColumnName, objX, objY);
}
else
{
intResult = CompareValues(objSortColumn.ColumnName, objY, objX);
}
// Difference not found, sort by next sort column
if (intResult == 0)
{
return(Compare(sortColumnIndex + 1, objX, objY));
}
return(intResult);
}
public DocumentView(IDocumentViewModel viewModel)
{
Helpers.NullCheck(viewModel);
this.DataContext = viewModel;
InitializeComponent();
}
public void Update(DependencyObject target, IDocumentViewModel documentViewModel) {
object title = documentViewModel.Title;
#if !SILVERLIGHT
if(convertToString)
title = title == null ? string.Empty : title.ToString();
#endif
target.SetValue(targetProperty, title);
}
/// <summary>
/// Compares two documents and returns a value indicating whether one is less than,
/// equal to, or greater than the other. This method is of Comparison<T> delegate type
/// </summary>
/// <param name="x">First document.</param>
/// <param name="y">Second document.</param>
public int Compare(IDocumentViewModel x, IDocumentViewModel y)
{
if (mobjSortColumns.Count == 0)
{
return(0);
}
return(Compare(0, x, y));
}
/// <summary>
/// Determines the matching view for a specific given type of viewmodel.
/// </summary>
/// <param name="item">Identifies the viewmodel object for which we require an associated view.</param>
/// <param name="container">Identifies the container's instance that wants to resolve this association.</param>
public override System.Windows.DataTemplate SelectTemplate(object item,
System.Windows.DependencyObject container)
{
return(item switch
{
IDocumentViewModel _ => FileViewTemplate,
LogViewModel _ => LogViewTemplate,
ProjectExplorerViewModel _ => ProjectExplorerTemplate,
_ => base.SelectTemplate(item, container)
});
public bool CouldDeleteDocument(IDocumentViewModel documentViewModel)
{
if (documentViewModel != null)
{
if (documentViewModel.IsDeletable == false)
{
return(false);
}
}
return(true);
}
public bool EvaluateCondition()
{
if (fixture.DemoBaseTesting.CurrentDemoModule == null)
{
return(true);
}
DocumentPreviewControl viewer = BaseTestingFixture.HelperActions.FindElementByType <DocumentPreviewControl>(fixture.DemoBaseTesting.CurrentDemoModule);
IDocumentViewModel model = viewer.Document;
bool documentBuilt = model == null ? false : !model.IsCreating && model.Pages.Count > 0;
return(documentBuilt);
}
/// <summary>
/// called only when oldValue or newVlaue is me
/// </summary>
/// <param name="oldValue"></param>
/// <param name="newValue"></param>
internal protected virtual void OnActiveDocumentChanged(IDocumentViewModel oldValue, IDocumentViewModel newValue)
{
//using Object.ReferenceEquals to compare
if (object.ReferenceEquals(newValue, this))
{
ContextualUI.Show(this);
}
else if (object.ReferenceEquals(oldValue, this))
{
ContextualUI.Hide(this);
}
}
public TitleUpdater(bool convertToString, IDocumentViewModel documentViewModel, DependencyObject target, DependencyProperty targetProperty) {
TitleUpdater oldUpdater = (TitleUpdater)target.GetValue(TitleUpdaterInternalProperty);
if(oldUpdater != null)
oldUpdater.Dispose();
this.convertToString = convertToString;
target.SetValue(TitleUpdaterInternalProperty, this);
this.targetProperty = targetProperty;
this.updateHandler = new PropertyChangedWeakEventHandler<DependencyObject>(target, OnDocumentViewModelPropertyChanged);
INotifyPropertyChanged notify = documentViewModel as INotifyPropertyChanged;
DocumentViewModel = notify;
if(notify != null)
notify.PropertyChanged += this.updateHandler.Handler;
}
public void OpenDocument(IDocumentViewModel viewModel)
{
Argument.IsNotNull("viewModel", viewModel);
var docViewModel = (viewModel as DocumentBaseViewModel);
docViewModel.OnBeforeOpen();
//see comments up.not using Collection.Contains because it using Equals to compare
if (!Documents.Contains_CompareByReference <IDocumentViewModel>(viewModel))
{
Documents.Add(viewModel);
}
docViewModel.IsAliveClosed = false;
viewModel.IsSelected = true;
}
public static object GetTitle(object documentContentOrDocumentViewModel)
{
IDocumentContent documentContent = documentContentOrDocumentViewModel as IDocumentContent;
if (documentContent != null)
{
return(documentContent.Title);
}
#pragma warning disable 612, 618
IDocumentViewModel documentViewModel = documentContentOrDocumentViewModel as IDocumentViewModel;
if (documentViewModel != null)
{
return(documentViewModel.Title);
}
#pragma warning restore 612, 618
throw new ArgumentException("", "documentContentOrDocumentViewModel");
}
public static bool TitlePropertyHasImplicitImplementation(object documentContentOrDocumentViewModel)
{
IDocumentContent documentContent = documentContentOrDocumentViewModel as IDocumentContent;
if (documentContent != null)
{
return(ExpressionHelper.PropertyHasImplicitImplementation(documentContent, i => i.Title));
}
#pragma warning disable 612, 618
IDocumentViewModel documentViewModel = documentContentOrDocumentViewModel as IDocumentViewModel;
if (documentViewModel != null)
{
return(ExpressionHelper.PropertyHasImplicitImplementation(documentViewModel, i => i.Title));
}
#pragma warning restore 612, 618
throw new ArgumentException("", "documentContentOrDocumentViewModel");
}
public static void OnClose(object documentContentOrDocumentViewModel, CancelEventArgs e)
{
IDocumentContent documentContent = documentContentOrDocumentViewModel as IDocumentContent;
if (documentContent != null)
{
documentContent.OnClose(e);
return;
}
#pragma warning disable 612, 618
IDocumentViewModel documentViewModel = documentContentOrDocumentViewModel as IDocumentViewModel;
#pragma warning restore 612, 618
if (documentViewModel != null)
{
e.Cancel = !documentViewModel.Close();
return;
}
}
int CompareValues(string columnName, IDocumentViewModel x, IDocumentViewModel y)
{
switch (columnName)
{
case DocumentsDisplayColumnInfo.COLUMN_SORTORDER:
return(x.SortOrderIndex.CompareTo(y.SortOrderIndex));
case DocumentsDisplayColumnInfo.COLUMN_CATEGORY:
return(x.Category.CompareTo(y.Category));
case DocumentsDisplayColumnInfo.COLUMN_CREATEDBY:
return(x.CreatedByUser.CompareTo(y.CreatedByUser));
case DocumentsDisplayColumnInfo.COLUMN_CREATEDDATE:
return(x.CreatedDate.CompareTo(y.CreatedDate));
case DocumentsDisplayColumnInfo.COLUMN_PUBLISHEDONDATE:
return(x.PublishedOnDate.CompareTo(y.PublishedOnDate));
case DocumentsDisplayColumnInfo.COLUMN_DESCRIPTION:
return(x.Description.CompareTo(y.Description));
case DocumentsDisplayColumnInfo.COLUMN_MODIFIEDBY:
return(x.ModifiedByUser.CompareTo(y.ModifiedByUser));
case DocumentsDisplayColumnInfo.COLUMN_MODIFIEDDATE:
return(x.ModifiedDate.CompareTo(y.ModifiedDate));
case DocumentsDisplayColumnInfo.COLUMN_OWNEDBY:
return(x.OwnedByUser.CompareTo(y.OwnedByUser));
case DocumentsDisplayColumnInfo.COLUMN_SIZE:
return(x.Size.CompareTo(y.Size));
case DocumentsDisplayColumnInfo.COLUMN_TITLE:
return(x.Title.CompareTo(y.Title));
case DocumentsDisplayColumnInfo.COLUMN_CLICKS:
return(x.Clicks.CompareTo(y.Clicks));
}
return(0);
}
public void SavePage(IDocumentViewModel documentViewModel)
{
if (documentViewModel == null)
{
return;
}
var dialogService = new DialogService();
var filename = dialogService.GetFileSavePath(SAVE_TITLE, SAVE_DEFAULT_EXT, SAVE_FILTER);
if (string.IsNullOrEmpty(filename))
{
return;
}
var markdown = documentViewModel.MarkdownContent;
var html = _documentParser.ParseClean(markdown);
File.WriteAllText(filename, html);
}
void DocumentClosedEventHandler(DocumentClosedEvent documentClosedEvent)
{
IDocumentViewModel documentClosed = documentClosedEvent.Data;
}
public void ActivateDocument(IDocumentViewModel documentViewModel)
{
ActiveDocument = documentViewModel;
}
//public event Action<IDocumentViewModel> DocumentClosed;
public bool CloseDocument(IDocumentViewModel documentViewModel)
{
if ((!documentViewModel.CanClose) && !IsClearing)
{
this.Messager.MessageBox.ShowInformation(Metaseed.ShellBase.Properties.Resources.ClosingThisDocumentIsNotAlowed);
return(false);
}
if (documentViewModel.IsDataDirty)
{
documentViewModel.SaveViewModel();
Log.Info(documentViewModel.NameText + "-" + Metaseed.ShellBase.Properties.Resources.Saved);
}
if (!documentViewModel.KeepAliveWhenClose)
{
documentViewModel.CloseViewModel(true);
var viewModel = documentViewModel as DocumentBaseViewModel;
if (viewModel != null)
{
viewModel.IsAliveClosed = false;
}
}
else
{
var viewModel = documentViewModel as DocumentBaseViewModel;
if (viewModel != null)
{
viewModel.IsAliveClosed = true;
}
}
if (Application.Current == null || Application.Current.Dispatcher == null)
{
return(false);
}
if (!Application.Current.Dispatcher.CheckAccess())
{
Application.Current.Dispatcher.Invoke(new Action(() => { Documents.Remove(documentViewModel); }),
DispatcherPriority.Normal);
}
else
{
Documents.Remove(documentViewModel);
}
if (!IsClearing && (documentViewModel.ContentId != null))
{
var docUnopen = new DocumentUnopenBase()
{
ContentId = documentViewModel.ContentId, NameText = documentViewModel.Title, Description = documentViewModel.Description, KeepAliveWhenClose = documentViewModel.KeepAliveWhenClose
};
if (documentViewModel.KeepAliveWhenClose)
{
docUnopen.DocClosedButAlive = documentViewModel;
}
DocumentsUnopen.Add(docUnopen);
var model = documentViewModel as DocumentBaseViewModel;
if (model != null)
{
model.OnAfterClose();
}
}
DocumentClosedEvent.SendWith(documentViewModel);
return(true);
}
public CloseDocumentMessage(IDocumentViewModel model)
{
Document = model;
}
public void SavePage(IDocumentViewModel documentViewModel)
{
if (documentViewModel == null) return;
var dialogService = new DialogService();
var fileName = dialogService.GetFileSavePath(SAVE_TITLE, SAVE_DEFAULT_EXT, SAVE_FILTER);
if (string.IsNullOrEmpty(fileName)) return;
var markdown = documentViewModel.MarkdownContent;
var html = _documentParser.ParseClean(markdown);
File.WriteAllText(fileName, html);
}
public override void ActivateDocument(IDocumentViewModel documentViewModel)
{
Manager.ActiveContent = documentViewModel;
}
void OpenPackage(string packageFilePath)
{
if (!File.Exists(packageFilePath))
{
Log.Error("File Not Exist!");
return;
}
_oderOpenDocumentItemList.Clear();
int oderOpenDocumentItemNum = 0;
var shellService = ((ShellService)(ShellService));
using (Package package = Package.Open(packageFilePath, FileMode.Open, FileAccess.Read, FileShare.Read))
{
//_EventAggregator.GetEvent<PackageBeforeOpenEvent>().Publish(package);
PackageBeforeOpenEvent.SendWith(package);
//load documents unopen
var packageRelationShipDocumentsUnopen = package.GetRelationship(Package_DocumentsUnopen_ID);
var layoutPartDocumentsUnopen = package.GetPart(packageRelationShipDocumentsUnopen.TargetUri);
var xmlSerilalizer = new System.Xml.Serialization.XmlSerializer(typeof(ObservableCollection <DocumentUnopen>));
var unopenDocs = xmlSerilalizer.Deserialize(layoutPartDocumentsUnopen.GetStream()) as ObservableCollection <DocumentUnopen>;
if (unopenDocs != null)
{
foreach (var item in unopenDocs)
{
shellService.DocumentsUnopen.Add(item);
if (item.KeepAliveWhenClose)
{
_oderOpenDocumentItemList.Add(new OderOpenDocumentItem()
{
IsUnopenDoc = true,
UnopenDocContentId = item.ContentId,
DocUnopen = item
});
}
}
}
//load avalondock panel layout
var layoutRelationShip = package.GetRelationship(Package_PanelLayoutPart_ID);
var layoutPart = package.GetPart(layoutRelationShip.TargetUri);
var packageManger = this.GetDependencyResolver().Resolve <DockingManager>();
var layoutSerializer = new XmlLayoutSerializer(packageManger);
layoutSerializer.LayoutSerializationCallback += (s, e) =>
{
//Get LayoutContentViewModel From Package
if (e.Model is LayoutAnchorable)
{
var layoutAnchorable = e.Model as LayoutAnchorable;
Debug.Assert(package != null, "package != null");
var contentViewModel = OpenPackageContent(package, e.Model.ContentId);
var toolViewModel = contentViewModel as IToolViewModel;
System.Diagnostics.Debug.Assert(toolViewModel != null);
e.Content = contentViewModel;
if (!ShellService.Tools.Contains_CompareByReference(toolViewModel))
{
ShellService.Tools.Add(toolViewModel);
}
toolViewModel.IsSelected = layoutAnchorable.IsSelected;
toolViewModel.IsActive = layoutAnchorable.IsActive;
toolViewModel.IsVisible = layoutAnchorable.IsVisible;
System.Diagnostics.Debug.Assert(ShellService.Documents.Count == 0);//the code of the avalondock behave in this kind of behavior, and the whole application assume the tools are loaded first.
return;
}
else if (e.Model is LayoutDocument)
{
var layoutDocument = e.Model as LayoutDocument;
//var contentViewModel = Services.ShellService.OpenPackageContent(package, e.Model.ContentId) as IDocumentViewModel;
//e.Content = contentViewModel;
//if (!ShellService.Documents.Contains_CompareByReference(contentViewModel))
//{
// ShellService.Documents.Add(contentViewModel);
//}
//contentViewModel.IsSelected = layoutDocument.IsSelected;
//contentViewModel.IsActive = layoutDocument.IsActive;
_oderOpenDocumentItemList.Add(new OderOpenDocumentItem()
{
Num = oderOpenDocumentItemNum, LayoutContent = layoutDocument
});
oderOpenDocumentItemNum++;
e.Cancel = true;
return;
}
else
{
return;
}
};
layoutSerializer.Deserialize(layoutPart.GetStream());
foreach (var item in _oderOpenDocumentItemList)
{
if (!item.IsUnopenDoc)
{
//bug fix for avalondock start form 2.1.0, because the close() methord work like 2.0.0
//in 2.0.0 close(){
//ILayoutRoot root = base.Root;
//ILayoutContainer parentAsContainer = base.Parent;
//parentAsContainer.RemoveChild(this);
//if (root != null)
//{
// root.CollectGarbage();
//}}
//if (item.LayoutContent.Parent != null)
//{
item.LayoutContent.Parent.RemoveChild(item.LayoutContent);
//}
}
}
//Order Open Document;
_oderOpenDocumentItemList.Sort((item) =>
{
string packagePartId;
string contentId = null;
contentId = item.IsUnopenDoc ? item.UnopenDocContentId : item.LayoutContent.ContentId;
Type packagePartType = ContentID_ToTypeAndPackagePartID(contentId, out packagePartId);
return(packagePartType.GetAttributeValue((DocumentOpenOrderAttribute a) => a.Value));
});
IDocumentViewModel lastActiveDocument = null;
foreach (var doc in _oderOpenDocumentItemList)
{
if (doc.IsUnopenDoc)
{
var contentViewModel = OpenPackageContent(package, doc.UnopenDocContentId);
var documentViewModel = contentViewModel as IDocumentViewModel;
System.Diagnostics.Debug.Assert(documentViewModel != null);
doc.DocUnopen.DocClosedButAlive = documentViewModel;
doc.DocUnopen = null;
}
else
{
var contentViewModel = OpenPackageContent(package, doc.LayoutContent.ContentId);
var documentViewModel = contentViewModel as IDocumentViewModel;
System.Diagnostics.Debug.Assert(documentViewModel != null);
doc.LayoutContentViewModel = documentViewModel;
ShellService.OpenDocument(documentViewModel);
if (doc.LayoutContent.IsLastFocusedDocument)
{
lastActiveDocument = doc.LayoutContentViewModel;
}
}
}
_oderOpenDocumentItemList.RemoveAll(x => x.IsUnopenDoc);
_oderOpenDocumentItemList.Sort((item) => item.Num);
for (int i = 0; i < _oderOpenDocumentItemList.Count; i++)
{
int indexInShellDocuments = ShellService.Documents.IndexOf(_oderOpenDocumentItemList[i].LayoutContentViewModel);
if (i != indexInShellDocuments)
{
ShellService.Documents.Move(indexInShellDocuments, i);
}
_oderOpenDocumentItemList[i].LayoutContentViewModel = null;
}
if (lastActiveDocument != null)
{
ShellService.ActivateDocument(lastActiveDocument);
}
PackageAfterOpenEvent.SendWith(package);
_oderOpenDocumentItemList.Clear();
}
}
/// <summary>
/// Class constructor
/// </summary>
public GenericAppViewModel(IDocumentViewModel demoAooViewModel)
: this()
{
_demo = demoAooViewModel;
}
