/// <summary>
/// Gets the thumb nail.
/// </summary>
/// <param name="theMediaModel">
/// The media ViewModel.
/// </param>
/// <returns>
/// </returns>
private static async Task <Image> GetThumbNail(HLinkMediaModel theHLinkMediaModel)
{
var webImage = new Image {
Aspect = Aspect.AspectFit
};
webImage.Source = ImageSource.FromFile(theHLinkMediaModel.DeRef.MediaStorageFile.FullPath);
return(webImage);
// return await DispatcherHelper.ExecuteOnUIThreadAsync(async () => { Image resultValue =
// new Image(1, 1);
// string newFile = ThumbNailGetFileName(theHLinkMediaModel);
// StorageFile bitMapFile = await DataStore.DS.CurrentThumbNailFolder.GetFileAsync(newFile);
// BasicProperties ttt = await bitMapFile.GetBasicPropertiesAsync();
// ulong tttt = ttt.Size;
// if (tttt > 0) { using (IRandomAccessStream stream = await
// bitMapFile.OpenAsync(FileAccessMode.Read)) { stream.Seek(0);
// await resultValue.SetSourceAsync(stream); } }
// // TODO Handle zero size if (resultValue.PixelHeight == 0 || resultValue.PixelWidth ==
// 0) { DataStore.CN.NotifyError("Result bitmap is zero for file " +
// bitMapFile.DisplayName); }
// return resultValue;
//});
// return resultValue; return new Image();
}
/// <summary>
/// Thumbs the name of the nail get file.
/// </summary>
/// <param name="theHLinkMediaModel">
/// The h link media model.
/// </param>
/// <returns>
/// </returns>
public static string ThumbNailGetFileName(HLinkMediaModel theHLinkMediaModel)
{
switch (theHLinkMediaModel.HomeImageType)
{
case CommonConstants.HomeImageTypeClippedBitmap:
{
return(theHLinkMediaModel.HLinkKey + "-" + theHLinkMediaModel.GCorner1X + theHLinkMediaModel.GCorner1Y + theHLinkMediaModel.GCorner2X + theHLinkMediaModel.GCorner2Y + ".bmp");
}
case CommonConstants.HomeImageTypeSymbol:
{
return(null); // TODO show error
}
case CommonConstants.HomeImageTypeThumbNail:
{
return(theHLinkMediaModel.HLinkKey + ".bmp");
}
default:
break;
}
return(null); // TODO Should never get here
}
/// <summary>
/// Populates the view ViewModel.
/// </summary>
/// <returns>
/// </returns>
public override void PopulateViewModel()
{
BaseCL.LogRoutineEntry("AddressDetailViewModel");
AddressObject = DV.AddressDV.GetModelFromHLink(BaseNavParamsHLink);
if (AddressObject.Valid)
{
// Trigger refresh of View fields via INotifyPropertyChanged
RaisePropertyChanged(string.Empty);
BaseTitle = AddressObject.GetDefaultText;
// Get media image
MediaCard = AddressObject.HomeImageHLink.ConvertToHLinkMediaModel;
// Get Header Details
//CardGroup headerCardGroup = new CardGroup { };
// Get the Name Details
CardListLineCollection nameDetails = new CardListLineCollection
{
new CardListLine("Card Type:", "Address Detail"),
new CardListLine("Street:", AddressObject.GStreet),
new CardListLine("City:", AddressObject.GCity),
new CardListLine("Locality:", AddressObject.GLocality),
new CardListLine("County:", AddressObject.GCounty),
new CardListLine("State:", AddressObject.GState),
new CardListLine("Country:", AddressObject.GCountry),
new CardListLine("Date:", AddressObject.GDate.ShortDate),
new CardListLine("Postal:", AddressObject.GPostal),
new CardListLine("Phone:", AddressObject.GPhone),
};
// Get date card
BaseDetail.Add(AddressObject.GDate.AsCardListLine());
BaseDetail.Add(nameDetails);
// Add Standard details
BaseDetail.Add(DV.PersonDV.GetModelInfoFormatted(AddressObject));
// Add map card
BaseDetail.Add(TurnAddressToURLModel());
// Add header
//BaseDetail.Add(headerCardGroup);
BaseDetail.Add(AddressObject.GCitationRefCollection.GetCardGroup());
BaseDetail.Add(AddressObject.GNoteRefCollection.GetCardGroup());
}
return;
}
/// <summary>
/// Populate the Hub View.
/// </summary>
public override async Task <bool> PopulateViewModelAsync()
{
// Get Header CardLarge
HLinkHeaderModel HeaderCard = DV.HeaderDV.HeaderDataModel.HLink;
HeaderCard.CardType = DisplayFormat.HeaderCardLarge;
BaseDetail.Add(HeaderCard);
HLinkMediaModel HeroImage = DV.MediaDV.GetRandomFromCollection(null);
HeroImage.CardType = DisplayFormat.MediaCardLarge;
BaseDetail.Add(HeroImage);
if (HeroImage == null)
{
DataStore.CN.NotifyAlert("No images found in this data. Consider adding some.");
}
// Setup ToDo list
ObservableCollection <NoteModel> t = DV.NoteDV.GetAllOfType(NoteModel.GTypeToDo);
CardGroup temp = new CardGroup();
foreach (NoteModel item in t)
{
temp.Add(item.HLink);
}
temp.Title = "ToDo list";
BaseDetail.Add(temp);
// Setup Latest Changes list
// TODO fix this LatestChanges.Add(DV.BookMarkDV.GetLatestChanges());
BaseDetail.Add(DV.CitationDV.GetLatestChanges());
BaseDetail.Add(DV.EventDV.GetLatestChanges());
BaseDetail.Add(DV.FamilyDV.GetLatestChanges());
BaseDetail.Add(DV.MediaDV.GetLatestChanges());
BaseDetail.Add(DV.NoteDV.GetLatestChanges());
BaseDetail.Add(DV.PersonDV.GetLatestChanges());
BaseDetail.Add(DV.PlaceDV.GetLatestChanges());
BaseDetail.Add(DV.SourceDV.GetLatestChanges());
BaseDetail.Add(DV.TagDV.GetLatestChanges());
return(true);
}
/// <summary>
/// Gets the object collection.
/// </summary>
/// <param name="xmlData">
/// The XML data.
/// </param>
/// <returns>
/// </returns>
private async Task <HLinkMediaModelCollection> GetObjectCollection(XElement xmlData)
{
HLinkMediaModelCollection t = new HLinkMediaModelCollection();
var theORElement = from _ORElementEl in xmlData.Elements(ns + "objref")
select _ORElementEl;
if (theORElement.Any())
{
// load media object references
foreach (XElement theLoadORElement in theORElement)
{
// save the MediaObject reference
HLinkMediaModel t2 = new HLinkMediaModel
{
HLinkKey = GetAttribute(theLoadORElement.Attribute("hlink")),
};
// Get region
XElement regionDetails = theLoadORElement.Element(ns + "region");
if (regionDetails != null)
{
HLinkLoadImageModel t3 = new HLinkLoadImageModel
{
HLinkKey = t2.HLinkKey,
HomeImageType = CommonEnums.HomeImageType.ThumbNail,
GCorner1X = (int)regionDetails.Attribute("corner1_x"),
GCorner1Y = (int)regionDetails.Attribute("corner1_y"),
GCorner2X = (int)regionDetails.Attribute("corner2_x"),
GCorner2Y = (int)regionDetails.Attribute("corner2_y"),
};
t2 = await CreateClippedMediaModel(t3).ConfigureAwait(false);
}
// Get remaining fields
t2.GAttributeRefCollection = GetAttributeCollection(theLoadORElement);
t2.GCitationRefCollection = GetCitationCollection(theLoadORElement);
t2.GNoteRefCollection = GetNoteCollection(theLoadORElement);
// TODO !ELEMENT objref (region?, attribute*, citationref*, noteref*)>
// !ATTLIST objref hlink IDREF #REQUIRED priv (0|1) #IMPLIED
t.Add(t2);
}
}
// Return sorted by the default text
t.SortAndSetFirst();
return(t);
}
/// <summary>
/// Gets the cache item.
/// </summary>
/// <param name="theMediaModel">
/// The media model.
/// </param>
/// <returns>
/// Bitmaps of the Cache item.
/// </returns>
public static async Task <Image> GetCacheItem(HLinkMediaModel theMediaModel)
{
bool result = await CacheItemExistsAsync(theMediaModel);
if (!result)
{
await SaveThumbNailAsync(theMediaModel);
}
Image t = await GetThumbNail(theMediaModel);
return(t);
}
/// <summary>
/// Gets the object collection.
/// </summary>
/// <param name="xmlData">
/// The XML data.
/// </param>
/// <returns>
/// </returns>
private async Task <HLinkMediaModelCollection> GetObjectCollection(XElement xmlData)
{
HLinkMediaModelCollection t = new HLinkMediaModelCollection
{
Title = "Media Collection"
};
IEnumerable <XElement> theORElement = from _ORElementEl in xmlData.Elements(ns + "objref")
select _ORElementEl;
if (theORElement.Any())
{
// load media object references
foreach (XElement theLoadORElement in theORElement)
{
// save the MediaObject reference
HLinkMediaModel outHLMediaModel = new HLinkMediaModel
{
HLinkKey = GetHLinkKey(theLoadORElement),
Priv = GetPrivateObject(theLoadORElement),
};
if (outHLMediaModel.HLinkKey.Value == "_ea97612787a7a61ff4c3177b8b0")
{
}
// Get region
XElement regionDetails = theLoadORElement.Element(ns + "region");
if (regionDetails != null)
{
outHLMediaModel.HLinkGlyphItem.ImageType = CommonEnums.HLinkGlyphType.Image;
outHLMediaModel.GCorner1X = (int)regionDetails.Attribute("corner1_x");
outHLMediaModel.GCorner1Y = (int)regionDetails.Attribute("corner1_y");
outHLMediaModel.GCorner2X = (int)regionDetails.Attribute("corner2_x");
outHLMediaModel.GCorner2Y = (int)regionDetails.Attribute("corner2_y");
outHLMediaModel = await CreateClippedMediaModel(outHLMediaModel).ConfigureAwait(false);
}
// Get remaining fields
outHLMediaModel.GAttributeRefCollection = GetAttributeCollection(theLoadORElement);
outHLMediaModel.GCitationRefCollection = GetCitationCollection(theLoadORElement);
outHLMediaModel.GNoteRefCollection = GetNoteCollection(theLoadORElement);
t.Add(outHLMediaModel);
}
}
return(t);
}
/// <summary>
/// Tests the date null age.
/// </summary>
//[Fact]
public void TestCreateHLinkCollection()
{
// Setup Collection
HLinkBaseCollection <HLinkMediaModel> imageModelCollection = new HLinkBaseCollection <HLinkMediaModel>
{
//FirstImageHLink = new HLinkMediaModel(),
};
// Setup test hlink
HLinkMediaModel testHLink = new HLinkMediaModel
{
//BackgroundColour = Microsoft.Toolkit.Uwp.Helpers.ColorHelper.ToColor("White"),
};
// Test FirstImageHLink is correct
//Assert.True(imageModelCollection.FirstImageHLink.CompareTo(testHLink) == 0);
}
/// <summary>
/// Organises the media repository.
/// </summary>
private static async Task <bool> OrganiseMediaRepository()
{
await DataStore.CN.MajorStatusAdd("Organising Media data").ConfigureAwait(false);
try
{
foreach (MediaModel theMediaObject in DV.MediaDV.DataViewData)
{
HLinkMediaModel t = theMediaObject.HLink;
//if (theMediaObject.Id == "O0032")
//{
//}
// Back Reference Citation HLinks
foreach (HLinkCitationModel citationRef in theMediaObject.GCitationRefCollection)
{
DataStore.DS.CitationData[citationRef.HLinkKey].BackHLinkReferenceCollection.Add(new HLinkBackLink(t));
}
// Back Reference Note HLinks
foreach (HLinkNoteModel noteRef in theMediaObject.GNoteRefCollection)
{
DataStore.DS.NoteData[noteRef.HLinkKey].BackHLinkReferenceCollection.Add(new HLinkBackLink(t));
}
// Back Reference Tag HLinks
foreach (HLinkTagModel tagRef in theMediaObject.GTagRefCollection)
{
DataStore.DS.TagData[tagRef.HLinkKey].BackHLinkReferenceCollection.Add(new HLinkBackLink(t));
}
}
}
catch (Exception ex)
{
DataStore.CN.NotifyException("Exception in OrganiseMediaRepository", ex);
throw;
}
return(true);
}
private void MediaImageFull_BindingContextChanged(object sender, EventArgs e)
{
Contract.Assert(sender != null);
MediaImageFull mifModel = (sender as MediaImageFull);
// Hide if not valid
if ((!(mifModel.BindingContext is HLinkMediaModel argHLinkMediaModel)) || (!argHLinkMediaModel.Valid))
{
mifModel.IsVisible = false;
return;
}
if (argHLinkMediaModel == mifModel.CurrentHLinkMediaModel)
{
return;
}
IMediaModel t = argHLinkMediaModel.DeRef;
if ((t.IsMediaStorageFileValid) && (t.IsImage))
{
try
{
mifModel.daImage.Source = t.MediaStorageFilePath;
mifModel.IsVisible = true;
CurrentHLinkMediaModel = argHLinkMediaModel;
return;
}
catch (Exception ex)
{
App.Current.Services.GetService <IErrorNotifications>().NotifyException("Exception in MediaImageFull control", ex);
throw;
}
}
// Nothing to display so hide
mifModel.IsVisible = false;
}
///// <summary>
///// Saves the media object thumb nail.
///// </summary>
///// <param name="theHlinkMediaModel">
///// HLink to the media model.
///// </param>
///// <returns>
///// Nothing.
///// </returns>
// public static async Task SaveThumbNailAsync(HLinkMediaModel theHlinkMediaModel) {
// StorageFolder tt = DataStore.DS.CurrentThumbNailFolder; Stream pixelStream = new MemoryStream();
// if (tt != null) { string newFile = ThumbNailGetFileName(theHlinkMediaModel);
// try { bool fileFound = await StoreFileUtility.StorageItemExists(tt, newFile);
// if (fileFound == false) { StorageFile t = await tt.CreateFileAsync(newFile, CreationCollisionOption.FailIfExists);
// if (!theHlinkMediaModel.DeRef.IsThumbnailValid) { // Get the thumbnail var
// storageItemThumbnail = await
// theHlinkMediaModel.DeRef.MediaStorageFile.GetScaledImageAsThumbnailAsync(ThumbnailMode.SingleItem, 100);
// StorageItemThumbnail tempThumb = storageItemThumbnail;
// if (tempThumb != null) { Image image = new Image(100, 100); image.SetSource(tempThumb);
// pixelStream = image.PixelBuffer.AsStream(); } else { // TODO Handle failure
// DataStore.CN.NotifyError("Thumbnail not valid for " +
// theHlinkMediaModel.DeRef.MediaStorageFile.DisplayName); } } else { pixelStream =
// theHlinkMediaModel.DeRef.ImageThumbNail.PixelBuffer.AsStream(); }
// // Save the file using (IRandomAccessStream stream = await
// t.OpenAsync(FileAccessMode.ReadWrite)) { BitmapEncoder encoder = await
// BitmapEncoder.CreateAsync(BitmapEncoder.BmpEncoderId, stream);
// byte[] pixels = new byte[pixelStream.Length]; await pixelStream.ReadAsync(pixels, 0,
// pixels.Length); encoder.SetPixelData( BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore,
// (uint)theHlinkMediaModel.DeRef.ImageThumbNail.PixelWidth,
// (uint)theHlinkMediaModel.DeRef.ImageThumbNail.PixelHeight, 96.0, 96.0, pixels); await
// encoder.FlushAsync(); } } } catch (Exception ex) { // TODO Fix this
// DataStore.CN.NotifyException(ex.Message + newFile, ex); } } }
/// <summary>
/// Saves the media object thumb nail.
/// </summary>
/// <param name="theHlinkMediaModel">
/// HLink to the media model.
/// </param>
/// <returns>
/// Nothing.
/// </returns>
public static async Task SaveThumbNailAsync(HLinkMediaModel theHlinkMediaModel)
{
//StorageFolder tt = DataStore.DS.CurrentThumbNailFolder;
//Stream pixelStream = new MemoryStream();
//await DispatcherHelper.ExecuteOnUIThreadAsync(async () =>
// {
// Image t = new Image(100, 100);
// if (tt != null) { string newFile = ThumbNailGetFileName(theHlinkMediaModel);
// StorageFile newFileSF = await tt.CreateFileAsync(newFile, CreationCollisionOption.FailIfExists);
// try { switch (theHlinkMediaModel.HomeImageType) { case
// CommonConstants.HomeImageTypeClippedBitmap: { t = await
// Common.CommonCropBitmap.GetClippedBitMapAsync(theHlinkMediaModel); break; }
// case CommonConstants.HomeImageTypeSymbol: { break; }
// case CommonConstants.HomeImageTypeThumbNail: { t = await
// Common.CommonCropBitmap.GetThumbNailAsync(theHlinkMediaModel); break; }
// default: break; }
// pixelStream = t.PixelBuffer.AsStream();
// // Save the file using (IRandomAccessStream stream = await
// newFileSF.OpenAsync(FileAccessMode.ReadWrite)) { BitmapEncoder encoder = await
// BitmapEncoder.CreateAsync(BitmapEncoder.BmpEncoderId, stream);
// byte[] pixels = new byte[4 * t.PixelHeight * t.PixelWidth];
// await pixelStream.ReadAsync(pixels, 0, pixels.Length);
// encoder.SetPixelData( BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore,
// (uint)t.PixelWidth, (uint)t.PixelHeight, 96.0, 96.0, pixels);
// await encoder.FlushAsync(); } } catch (Exception ex) { // TODO Fix this
// DataStore.CN.NotifyException(ex.Message + newFile, ex); } } } );
}
/// <summary>
/// Check if the item exists in the cache.
/// </summary>
/// <param name="theMediaModel">
/// HLink media model.
/// </param>
/// <returns>
/// True or False if the Cache Item exists.
/// </returns>
public static async Task <bool> CacheItemExistsAsync(HLinkMediaModel theMediaModel)
{
return(await DataStore.DS.CurrentThumbNailFolder.FileExists(ThumbNailGetFileName(theMediaModel)));
}
public HLinkBackLink SetBookMarkTarget(string argGTarget, string argGHlink)
{
switch (argGTarget)
{
case "person":
{
HLinkPersonModel p1 = new HLinkPersonModel
{
HLinkKey = argGHlink
};
return(new HLinkBackLink(p1));
}
case "family":
{
HLinkFamilyModel p1 = new HLinkFamilyModel
{
HLinkKey = argGHlink
};
return(new HLinkBackLink(p1));
}
case "event":
{
HLinkEventModel p1 = new HLinkEventModel
{
HLinkKey = argGHlink
};
return(new HLinkBackLink(p1));
}
case "source":
{
HLinkSourceModel p1 = new HLinkSourceModel
{
HLinkKey = argGHlink
};
return(new HLinkBackLink(p1));
}
case "citation":
{
HLinkCitationModel p1 = new HLinkCitationModel
{
HLinkKey = argGHlink
};
return(new HLinkBackLink(p1));
}
case "place":
{
HLinkPlaceModel p1 = new HLinkPlaceModel
{
HLinkKey = argGHlink
};
return(new HLinkBackLink(p1));
}
case "media":
{
HLinkMediaModel p1 = new HLinkMediaModel
{
HLinkKey = argGHlink
};
return(new HLinkBackLink(p1));
}
case "repository":
{
HLinkRepositoryModel p1 = new HLinkRepositoryModel
{
HLinkKey = argGHlink
};
return(new HLinkBackLink(p1));
}
case "note":
{
HLinkNoteModel p1 = new HLinkNoteModel
{
HLinkKey = argGHlink
};
return(new HLinkBackLink(p1));
}
}
return(new HLinkBackLink());
}
private async Task <HLinkMediaModel> CreateClippedMediaModel(HLinkMediaModel argHLinkLoadImageModel)
{
if (argHLinkLoadImageModel is null)
{
throw new ArgumentNullException(nameof(argHLinkLoadImageModel));
}
if (!argHLinkLoadImageModel.DeRef.Valid)
{
throw new ArgumentException("CreateClippedMediaModel argument is invalid", nameof(argHLinkLoadImageModel));
}
IMediaModel returnMediaModel = await MainThread.InvokeOnMainThreadAsync(() =>
{
// TODO cleanup code. Multiple copies of things in use
IMediaModel theMediaModel = argHLinkLoadImageModel.DeRef;
SKBitmap resourceBitmap = new SKBitmap();
IMediaModel newMediaModel = new MediaModel();
HLinkKey newHLinkKey = new HLinkKey($"{argHLinkLoadImageModel.HLinkKey.Value}-{argHLinkLoadImageModel.GCorner1X}{argHLinkLoadImageModel.GCorner1Y}{argHLinkLoadImageModel.GCorner2X}{argHLinkLoadImageModel.GCorner2Y}");
string outFileName = $"{newHLinkKey.Value}{"~crop"}.png";
if (newHLinkKey.Value == "_c5132553a185c9c51d8-35415065")
{
}
Debug.WriteLine(newHLinkKey.Value);
string outFilePath = Path.Combine(DataStore.Instance.AD.CurrentImageAssetsFolder.Path, outFileName);
Debug.WriteLine(argHLinkLoadImageModel.DeRef.MediaStorageFilePath);
// Check if already exists
IMediaModel fileExists = DV.MediaDV.GetModelFromHLinkKey(newHLinkKey);
if ((!fileExists.Valid) && theMediaModel.IsMediaStorageFileValid)
{
// Needs clipping
using (StreamReader stream = new StreamReader(theMediaModel.MediaStorageFilePath))
{
//resourceBitmap = SKBitmap.Decode(stream.BaseStream);
// TODO See https://github.com/mono/SkiaSharp/issues/1621
SKImage img = SKImage.FromEncodedData(stream.BaseStream);
resourceBitmap = SKBitmap.FromImage(img);
}
// Check for too large a bitmap
//Debug.WriteLine("Image ResourceBitmap size: " + resourceBitmap.ByteCount);
if (resourceBitmap.ByteCount > int.MaxValue - 1000)
{
// TODO Handle this better. Perhaps resize? Delete for now
resourceBitmap = new SKBitmap();
}
float crleft = (float)(argHLinkLoadImageModel.GCorner1X / 100d * theMediaModel.MetaDataWidth);
float crright = (float)(argHLinkLoadImageModel.GCorner2X / 100d * theMediaModel.MetaDataWidth);
float crtop = (float)(argHLinkLoadImageModel.GCorner1Y / 100d * theMediaModel.MetaDataHeight);
float crbottom = (float)(argHLinkLoadImageModel.GCorner2Y / 100d * theMediaModel.MetaDataHeight);
SKRect cropRect = new SKRect(crleft, crtop, crright, crbottom);
SKBitmap croppedBitmap = new SKBitmap(
(int)cropRect.Width,
(int)cropRect.Height
);
SKRect dest = new SKRect(
0,
0,
cropRect.Width,
cropRect.Height
);
SKRect source = new SKRect(
cropRect.Left,
cropRect.Top,
cropRect.Right,
cropRect.Bottom);
using (SKCanvas canvas = new SKCanvas(croppedBitmap))
{
canvas.DrawBitmap(resourceBitmap, source, dest);
}
// create an image COPY
SKImage image = SKImage.FromBitmap(croppedBitmap);
// encode the image (defaults to PNG)
SKData encoded = image.Encode();
// get a stream over the encoded data
using (Stream stream = File.Open(outFilePath, FileMode.OpenOrCreate, FileAccess.Write, FileShare.ReadWrite))
{
encoded.SaveTo(stream);
}
croppedBitmap.Dispose();
// ------------ Save new MediaObject
newMediaModel = theMediaModel.Clone();
newMediaModel.HLinkKey = newHLinkKey;
newMediaModel.OriginalFilePath = outFilePath;
newMediaModel.MediaStorageFile = new FileInfoEx(argFileName: outFilePath);
newMediaModel.IsInternalMediaFile = true;
newMediaModel.InternalMediaFileOriginalHLink = theMediaModel.HLinkKey;
newMediaModel.MetaDataHeight = cropRect.Height;
newMediaModel.MetaDataWidth = cropRect.Width;
// newMediaModel = SetHomeImage(newMediaModel);
DataStore.Instance.DS.MediaData.Add((MediaModel)newMediaModel);
}
else
{
ErrorInfo t = new ErrorInfo("File not found when Region specified in ClipMedia")
{
{ "Original ID", theMediaModel.Id },
{ "Original File", theMediaModel.MediaStorageFilePath },
{ "Clipped Id", argHLinkLoadImageModel.DeRef.Id }
};
_iocCommonNotifications.NotifyError(t);
}
resourceBitmap.Dispose();
return(newMediaModel);
}).ConfigureAwait(false);
return(returnMediaModel.HLink);
}
/// <summary>
/// Populates the view ViewModel.
/// </summary>
/// <returns>
/// </returns>
public override void PopulateViewModel()
{
BaseCL.LogRoutineEntry("PersonDetailViewModel");
PersonObject = DV.PersonDV.GetModelFromHLink(BaseNavParamsHLink);
if (!(PersonObject is null))
{
BaseTitle = PersonObject.GPersonNamesCollection.GetPrimaryName.DeRef.GetDefaultText;
// Get media image
HLinkMediaModel personImage = PersonObject.HomeImageHLink.ConvertToHLinkMediaModel();
Contract.Assert(PersonObject.HomeImageHLink != null, PersonObject.Id);
personImage.CardType = DisplayFormat.MediaCardLarge;
BaseDetail.Add(personImage);
// Get Header Details
CardGroup headerCardGroup = new CardGroup {
Title = "Header Details"
};
// Get the Person Details
CardListLineCollection nameDetails = new CardListLineCollection
{
new CardListLine("Card Type:", "Person Detail"),
};
headerCardGroup.Add(nameDetails);
// Get the Name Details
headerCardGroup.Add(PersonObject.GPersonNamesCollection.GetPrimaryName);
// Get details on persons age etc
headerCardGroup.Add(GetExtraPersonDetails());
// Get parent details
headerCardGroup.Add(
new ParentLinkModel
{
Parents = PersonObject.GChildOf.DeRef,
});
// Add Standard details
headerCardGroup.Add(DV.PersonDV.GetModelInfoFormatted(PersonObject));
BaseDetail.Add(headerCardGroup);
// Get Bio
HLinkNoteModel bioCard = PersonObject.GNoteRefCollection.GetBio;
bioCard.CardType = DisplayFormat.NoteCardFull;
BaseDetail.Add(bioCard);
// Add PersonRefDetails
if (BaseNavParamsHLink is HLinkPersonRefModel)
{
HLinkPersonRefModel personRef = (BaseNavParamsHLink as HLinkPersonRefModel);
Contract.Assert(personRef != null);
BaseDetail.Add(personRef.GCitationCollection.GetCardGroup("PersonRef Citations"));
BaseDetail.Add(personRef.GNoteCollection.GetCardGroup("PersonRef Notes"));
}
// Add details
BaseDetail.Add(PersonObject.GPersonNamesCollection.GetCardGroup());
BaseDetail.Add(PersonObject.GParentInRefCollection.GetCardGroup());
BaseDetail.Add(EventsIncFamily());
BaseDetail.Add(PersonObject.GCitationRefCollection.GetCardGroup());
BaseDetail.Add(PersonObject.GNoteRefCollection.GetCardGroupWithoutBio());
BaseDetail.Add(PersonObject.GMediaRefCollection.GetCardGroup());
BaseDetail.Add(PersonObject.GAttributeCollection);
BaseDetail.Add(PersonObject.GAddress.GetCardGroup());
BaseDetail.Add(PersonObject.GTagRefCollection.GetCardGroup());
BaseDetail.Add(PersonObject.GURLCollection);
BaseDetail.Add(PersonObject.GLDSCollection);
BaseDetail.Add(PersonObject.GPersonRefCollection.GetCardGroup());
BaseDetail.Add(PersonObject.BackHLinkReferenceCollection.GetCardGroup());
_PlatformSpecific.ActivityTimeLineAdd(PersonObject);
}
return;
}
public static HLinkBackLink SetBookMarkTarget(string argGTarget, HLinkKey argHLinkKey)
{
switch (argGTarget)
{
case "person":
{
HLinkPersonModel p1 = DV.PersonDV.GetModelFromHLinkKey(argHLinkKey).HLink;
return(new HLinkBackLink(p1));
}
case "family":
{
HLinkFamilyModel p1 = DV.FamilyDV.GetModelFromHLinkKey(argHLinkKey).HLink;
return(new HLinkBackLink(p1));
}
case "event":
{
HLinkEventModel p1 = DV.EventDV.GetModelFromHLinkKey(argHLinkKey).HLink;
return(new HLinkBackLink(p1));
}
case "source":
{
HLinkSourceModel p1 = DV.SourceDV.GetModelFromHLinkKey(argHLinkKey).HLink;
return(new HLinkBackLink(p1));
}
case "citation":
{
HLinkCitationModel p1 = DV.CitationDV.GetModelFromHLinkKey(argHLinkKey).HLink;
return(new HLinkBackLink(p1));
}
case "place":
{
HLinkPlaceModel p1 = DV.PlaceDV.GetModelFromHLinkKey(argHLinkKey).HLink;
return(new HLinkBackLink(p1));
}
case "media":
{
HLinkMediaModel p1 = DV.MediaDV.GetModelFromHLinkKey(argHLinkKey).HLink;
return(new HLinkBackLink(p1));
}
case "repository":
{
HLinkRepositoryModel p1 = DV.RepositoryDV.GetModelFromHLinkKey(argHLinkKey).HLink;
return(new HLinkBackLink(p1));
}
case "note":
{
HLinkNoteModel p1 = DV.NoteDV.GetModelFromHLinkKey(argHLinkKey).HLink;
return(new HLinkBackLink(p1));
}
}
return(new HLinkBackLink());
}
