public void Should_Save_Options_Successfully()
{
RunActionInTransaction(session =>
{
var unitOfWork = new DefaultUnitOfWork(session);
var repository = new DefaultRepository(unitOfWork);
var cmsConfiguration = new Mock <ICmsConfiguration>();
var optionService = new DefaultOptionService(repository, new HttpRuntimeCacheService(), cmsConfiguration.Object);
// Create layout with options
var layout = TestDataProvider.CreateNewLayout();
layout.LayoutOptions = new List <LayoutOption>();
var option1 = TestDataProvider.CreateNewLayoutOption(layout);
option1.Type = OptionType.Text;
layout.LayoutOptions.Add(option1);
var option2 = TestDataProvider.CreateNewLayoutOption(layout);
option2.Type = OptionType.Text;
layout.LayoutOptions.Add(option2);
var option3 = TestDataProvider.CreateNewLayoutOption(layout);
option3.Type = OptionType.Text;
layout.LayoutOptions.Add(option3);
session.SaveOrUpdate(layout);
session.Flush();
session.Clear();
// Create fake options:
// 1 should be kept
// 2 should be updated
// 3 should be inserted
// option2 should be deleted
var newOption1 = new LayoutOption {
Key = option1.Key, Type = option1.Type, DefaultValue = option1.DefaultValue
};
var newOption2 = new LayoutOption {
Key = option2.Key, Type = option2.Type, DefaultValue = TestDataProvider.ProvideRandomString(100)
};
var newOption3 = new LayoutOption {
Key = TestDataProvider.ProvideRandomString(100), Type = OptionType.Text, DefaultValue = TestDataProvider.ProvideRandomString(100)
};
var newOptions = new List <IOptionEntity> {
newOption1, newOption2, newOption3
};
optionService.SetOptions <LayoutOption, Layout>(layout, newOptions);
unitOfWork.Commit();
// Load all options
var options = repository.AsQueryable <LayoutOption>(lo => lo.Layout == layout).ToList();
Assert.AreEqual(options.Count, 3);
Assert.IsTrue(options.Any(o => o.Key == option1.Key && o.DefaultValue == option1.DefaultValue && o.Type == option1.Type));
Assert.IsTrue(options.Any(o => o.Key == option2.Key && o.DefaultValue == newOption2.DefaultValue && o.Type == option2.Type));
Assert.IsTrue(options.Any(o => o.Key == newOption3.Key && o.DefaultValue == newOption3.DefaultValue && o.Type == newOption3.Type));
});
}
public override void Reset()
{
text = "";
image = null;
tooltip = "";
style = "Box";
layoutOptions = new LayoutOption[0];
}
public void SetLayout(LayoutOption value)
{
while (currentLayout != value)
{
AdvanceIndexCyclic();
}
OnLayoutChange.Invoke(currentLayout);
}
public override void Reset()
{
text = "";
image = null;
tooltip = "";
style = "Box";
layoutOptions = new LayoutOption[0];
}
public static void MediaList(XmlNodeList listMedia, MediaOption _options, LayoutOption _layoutOption)
{
//Read Media list one by one
foreach (XmlNode mediaNode in listMedia)
{
XmlAttributeCollection nodeAttributes = mediaNode.Attributes;
ParseOptionsForMediaNode(mediaNode, nodeAttributes, _options, _layoutOption);
}
}
public void Update()
{
if (_memoizedLayout != _layout)
{
layout = _layout;
}
checkForArchType();
}
public OverlayControl(string LayoutPath, LayoutOption _ovelay)
{
InitializeComponent();
this._layoutPath = LayoutPath;
_ovelays = _ovelay;
Loaded += OverlayControl_Loaded;
Unloaded += OverlayControl_Unloaded;
}
public PanelControl(string index, LayoutOption layoutOption, FinishRegionCallback _callbackMethod)
{
InitializeComponent();
this.RegionId = index;
this._callbackMethod = _callbackMethod;
this._layoutOption = layoutOption;
Loaded += PanelControl_Loaded;
Window window = Window.GetWindow(this);
Unloaded += PanelControl_Unloaded;
}
public void Should_Save_Options_Successfully()
{
RunActionInTransaction(session =>
{
var unitOfWork = new DefaultUnitOfWork(session);
var repository = new DefaultRepository(unitOfWork);
var cmsConfiguration = new Mock<ICmsConfiguration>();
var optionService = new DefaultOptionService(repository, new HttpRuntimeCacheService(), cmsConfiguration.Object);
// Create layout with options
var layout = TestDataProvider.CreateNewLayout();
layout.LayoutOptions = new List<LayoutOption>();
var option1 = TestDataProvider.CreateNewLayoutOption(layout);
option1.Type = OptionType.Text;
layout.LayoutOptions.Add(option1);
var option2 = TestDataProvider.CreateNewLayoutOption(layout);
option2.Type = OptionType.Text;
layout.LayoutOptions.Add(option2);
var option3 = TestDataProvider.CreateNewLayoutOption(layout);
option3.Type = OptionType.Text;
layout.LayoutOptions.Add(option3);
session.SaveOrUpdate(layout);
session.Flush();
session.Clear();
// Create fake options:
// 1 should be kept
// 2 should be updated
// 3 should be inserted
// option2 should be deleted
var newOption1 = new LayoutOption { Key = option1.Key, Type = option1.Type, DefaultValue = option1.DefaultValue };
var newOption2 = new LayoutOption { Key = option2.Key, Type = option2.Type, DefaultValue = TestDataProvider.ProvideRandomString(100) };
var newOption3 = new LayoutOption { Key = TestDataProvider.ProvideRandomString(100), Type = OptionType.Text, DefaultValue = TestDataProvider.ProvideRandomString(100) };
var newOptions = new List<IOptionEntity> { newOption1, newOption2, newOption3 };
optionService.SetOptions<LayoutOption, Layout>(layout, newOptions);
unitOfWork.Commit();
// Load all options
var options = repository.AsQueryable<LayoutOption>(lo => lo.Layout == layout).ToList();
Assert.AreEqual(options.Count, 3);
Assert.IsTrue(options.Any(o => o.Key == option1.Key && o.DefaultValue == option1.DefaultValue && o.Type == option1.Type));
Assert.IsTrue(options.Any(o => o.Key == option2.Key && o.DefaultValue == newOption2.DefaultValue && o.Type == option2.Type));
Assert.IsTrue(options.Any(o => o.Key == newOption3.Key && o.DefaultValue == newOption3.DefaultValue && o.Type == newOption3.Type));
});
}
public LayoutOption CreateNewLayoutOption(Layout layout = null)
{
var entity = new LayoutOption();
PopulateBaseFields(entity);
entity.Key = ProvideRandomString(MaxLength.Name);
entity.Layout = layout ?? CreateNewLayout();
entity.Type = ProvideRandomEnumValue <OptionType>();
entity.DefaultValue = ProvideRandomString(100);
return(entity);
}
public static void AdjustSize(ref Size s, LayoutOption o)
{
if (o == LayoutOption.FixHeight)
{
s.Width += 50;
}
else if (o == LayoutOption.FixWidth)
{
s.Height += 50;
}
else
{
s.Width *= 1.2;
s.Height *= 1.2;
}
}
// GameObject
public void Start()
{
practiceEndButton = GameObject.FindWithTag("PracticeEndButtonTag");
liveDropDownMenu = GameObject.FindWithTag("LiveDropDownTag");
challengeTypeIndicatorText = GameObject.FindWithTag("ChallengeTypeIndicatorTag");
dropdown.ClearOptions();
dropdown.AddOptions(new List <string>(Enum.GetNames(typeof(LayoutOption))));
dropdown.value = (int)layout;
_memoizedLayout = _layout;
ActivateLayout();
//practiceTransForm = new Vector3(practiceEndButton.transform.position.x, 6.5498f, practiceEndButton.transform.position.z);
//liveDropTransForm = new Vector3(liveDropDownMenu.transform.position.x, 6.5498f, liveDropDownMenu.transform.position.z);
// challengeTypeIndicatorTransForm = new Vector3(challengeTypeIndicatorText.transform.position.x, 6.5498f, challengeTypeIndicatorText.transform.position.z);
}
public AbstractLayout fromOption(LayoutOption option)
{
switch (option)
{
case LayoutOption.SliderOnly:
return(linearABCDE);
case LayoutOption.ArcType:
return(stylusBinnedABCDE);
case LayoutOption.TiltType:
return(twoRotationABCDE);
case LayoutOption.Raycast:
return(raycastQWERTY);
}
throw new ArgumentException($"unknown layout option: {option.ToString()} in fromOption");
}
private void SetOptions(Root.Models.Layout template, IList <OptionViewModel> options)
{
// Delete old ones
if (template.LayoutOptions != null)
{
foreach (var option in template.LayoutOptions.Distinct())
{
if (options == null || options.All(o => o.OptionKey != option.Key))
{
Repository.Delete(option);
}
}
}
// Add new ones
if (options != null)
{
foreach (var requestLayoutOption in options)
{
LayoutOption option = null;
if (template.LayoutOptions != null)
{
option = template.LayoutOptions.FirstOrDefault(o => o.Key == requestLayoutOption.OptionKey);
}
if (option == null)
{
option = new LayoutOption();
if (template.LayoutOptions == null)
{
template.LayoutOptions = new List <LayoutOption>();
}
template.LayoutOptions.Add(option);
}
option.Key = requestLayoutOption.OptionKey;
option.DefaultValue = requestLayoutOption.OptionDefaultValue;
option.Type = requestLayoutOption.Type;
option.Layout = template;
OptionService.ValidateOptionValue(option);
}
}
}
/// <summary>
/// Prepare Layout(Get all Details in Layout)
/// </summary>
/// <param name="layoutId"></param>
public static void PrepareLayout(string layoutId, LayoutOption _layoutOption)
{
try
{
string _layoutPath = PlayerSettings.libraryPath + layoutId + ".xlf";
//string _layoutPath = layoutId;
XmlDocument layoutXml = new XmlDocument();
if (!string.IsNullOrEmpty(_layoutPath))
{
using (FileStream fs = File.Open(_layoutPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
using (XmlReader reader = XmlReader.Create(fs))
{
layoutXml.Load(reader);
reader.Close();
}
fs.Close();
}
}
_layoutOption.layoutId = int.Parse(layoutId);
// Attributes of the main layout node
XmlNode layoutNode = layoutXml.SelectSingleNode("/layout");
XmlAttributeCollection layoutAttributes = layoutNode.Attributes;
_layoutOption.layoutWidth = int.Parse(layoutAttributes["width"].Value);
_layoutOption.layoutHeight = int.Parse(layoutAttributes["height"].Value);
//Layout Background Color
if (layoutAttributes["bgcolor"] != null && layoutAttributes["bgcolor"].Value != "")
{
_layoutOption.backgroundColor = layoutAttributes["bgcolor"].Value;
}
else
{
_layoutOption.backgroundColor = "#000000";
}
//Layout Background Color Image
if (layoutAttributes["background"] != null && layoutAttributes["background"].Value != "")
{
_layoutOption.backgroundImage = PlayerSettings.libraryPath + @"\" + layoutAttributes["background"].Value;
}
else
{
_layoutOption.backgroundImage = "";
}
// Get the regions
XmlNodeList listRegions = layoutXml.SelectNodes("/layout/region");
//get region details
foreach (XmlNode region in listRegions)
{
try
{
RenderRegion.RenderRegionDetails(region, _layoutOption);
}
catch (Exception ex)
{
PlayerSettings.ErrorLog(ex);
}
}
}
catch (Exception e)
{
PlayerSettings.ErrorLog(e);
}
}
// used in editor!
public void DropdownValueSelected(int index)
{
layout = (LayoutOption)index;
dropdown.value = index;
}
/// <summary>
/// Get Media options
/// </summary>
/// <param name="mediaNode"></param>
/// <param name="nodeAttributes"></param>
/// <param name="_options"></param>
private static void ParseOptionsForMediaNode(XmlNode mediaNode, XmlAttributeCollection nodeAttributes, MediaOption _options, LayoutOption _layoutOption)
{
//Media Id
_options.mediaId = int.Parse(nodeAttributes["id"].Value);
// Type and Duration will always be on the media node
_options.type = nodeAttributes["type"].Value;
// Render as
if (nodeAttributes["render"] != null)
{
_options.render = nodeAttributes["render"].Value;
}
//TODO: Check the type of node we have, and make sure it is supported.
if (nodeAttributes["duration"].Value != "")
{
_options.duration = int.Parse(nodeAttributes["duration"].Value);
}
else
{
_options.duration = 60;
}
// We cannot have a 0 duration here... not sure why we would... but
if (_options.duration == 0 && _options.type != "video" && _options.type != "localvideo")
{
//int emptyLayoutDuration = int.Parse(ApplicationSettings.Default.EmptyLayoutDuration.ToString());
//_options.duration = (emptyLayoutDuration == 0) ? 10 : emptyLayoutDuration;
}
// There will be some stuff on option nodes
XmlNode optionNode = mediaNode.SelectSingleNode("options");
foreach (XmlNode option in optionNode.ChildNodes)
{
if (option.Name == "direction")
{
_options.direction = option.InnerText;
}
else if (option.Name == "uri")
{
_options.uri = option.InnerText;
}
else if (option.Name == "loop")
{
_options.loop = int.Parse(option.InnerText);
}
else if (option.Name == "mute")
{
_options.mute = int.Parse(option.InnerText);
}
else if (option.Name == "copyright")
{
_options.copyrightNotice = option.InnerText;
}
else if (option.Name == "scrollSpeed")
{
if (option.InnerText != null && option.InnerText != "")
{
_options.scrollSpeed = int.Parse(option.InnerText);
}
else
{
System.Diagnostics.Trace.WriteLine("Non integer scrollSpeed in XLF", "Region - SetNextMediaNode");
}
}
else if (option.Name == "updateInterval")
{
//updateIntervalProvided = true;
if (option.InnerText != null && option.InnerText != "")
{
_options.updateInterval = int.Parse(option.InnerText);
}
else
{
// Update interval not defined, so assume a high value
_options.updateInterval = 3600;
}
}
else if (option.Name == "modeid")
{
//updateIntervalProvided = true;
if (option.InnerText != null && option.InnerText != "")
{
_options.modeid = option.InnerText;
}
else
{
// Update interval not defined, so assume a high value
_options.modeid = "";
}
}
//Transition details
else if (option.Name == "transIn")
{
_options.transIn = option.InnerText;
}
else if (option.Name == "transInDirection")
{
_options.transInDirection = option.InnerText;
}
else if (option.Name == "transInDuration")
{
_options.transInDuration = double.Parse(option.InnerText);
}
else if (option.Name == "transOut")
{
_options.transOut = option.InnerText;
}
else if (option.Name == "transOutDirection")
{
_options.transOutDirection = option.InnerText;
}
else if (option.Name == "transOutDuration")
{
_options.transOutDuration = double.Parse(option.InnerText);
}
//Shell Command Details
else if (option.Name == "launchThroughCmd")
{
_options.launchThroughCmd = option.InnerText;
}
else if (option.Name == "name")
{
_options.scName = option.InnerText;
}
else if (option.Name == "terminateCommand")
{
_options.terminateCommand = option.InnerText;
}
else if (option.Name == "useTaskkill")
{
_options.useTaskkill = option.InnerText;
}
else if (option.Name == "windowsCommand")
{
_options.windowsCommand = option.InnerText;
}
}
// And some stuff on Raw nodes
XmlNode rawNode = mediaNode.SelectSingleNode("raw");
if (rawNode != null)
{
foreach (XmlNode raw in rawNode.ChildNodes)
{
if (raw.Name == "text")
{
_options.text = raw.InnerText;
}
else if (raw.Name == "template")
{
_options.documentTemplate = raw.InnerText;
}
else if (raw.Name == "embedHtml")
{
_options.text = raw.InnerText;
}
else if (raw.Name == "embedScript")
{
_options.javaScript = raw.InnerText;
}
}
}
// Audio Nodes?
XmlNodeList audio = mediaNode.SelectNodes("audio");
if (audio != null && audio.Count > 0)
{
AudioOption _audio = new AudioOption();
foreach (XmlNode audioNode in audio)
{
if (audioNode.HasChildNodes)
{
_audio.audioUrl = PlayerSettings.libraryPath + audioNode.InnerText;
if (audioNode.Attributes["loop"] != null)
{
_audio.loop = int.Parse(audioNode.Attributes["loop"].Value);
}
if (audioNode.Attributes["volume"] != null)
{
_audio.volume = int.Parse(audioNode.Attributes["volume"].Value);
}
_layoutOption.AudioNodeList.Add(
new AudioOption(
_options.mediaId,
_audio.volume,
_audio.loop,
_audio.audioUrl,
_options.regionId
)
);
}
_options.audio = true;
}
}
CreateNextMediaNode(_options, _layoutOption);
}
/// <summary>
/// Add Media Details in to MedaiList
/// </summary>
/// <param name="options"></param>
private static void CreateNextMediaNode(MediaOption options, LayoutOption _layoutOption)
{
//Check media type
if (options.render == "html")
{
options.uri = PlayerSettings.libraryPath + @"\" + options.uri;
_layoutOption.MediaNodeList.Add(
new MediaOption(
options.layoutId,
options.regionId,
options.width,
options.height,
options.top,
options.left,
options.mediaId,
options.render,
options.type,
options.uri,
options.duration,
options.loop,
options.mute,
options.direction,
options.text,
options.documentTemplate,
options.copyrightNotice,
options.javaScript,
options.updateInterval,
options.scrollSpeed,
options.modeid,
options.audio,
options.transIn,
options.transInDuration,
options.transInDirection,
options.transOut,
options.transOutDuration,
options.transOutDirection,
options.launchThroughCmd, options.scName, options.terminateCommand, options.useTaskkill, options.windowsCommand)
);
}
else
{
switch (options.type)
{
case "image":
options.uri = PlayerSettings.libraryPath + @"\" + options.uri;
_layoutOption.MediaNodeList.Add(
new MediaOption(
options.layoutId,
options.regionId,
options.width,
options.height,
options.top,
options.left,
options.mediaId,
options.render,
options.type,
options.uri,
options.duration,
options.loop,
options.mute,
options.direction,
options.text,
options.documentTemplate,
options.copyrightNotice,
options.javaScript,
options.updateInterval,
options.scrollSpeed,
options.modeid,
options.audio,
options.transIn,
options.transInDuration,
options.transInDirection,
options.transOut,
options.transOutDuration,
options.transOutDirection,
options.launchThroughCmd, options.scName, options.terminateCommand, options.useTaskkill, options.windowsCommand)
);
break;
case "powerpoint":
options.uri = PlayerSettings.libraryPath + @"\" + options.uri;
_layoutOption.MediaNodeList.Add(
new MediaOption(
options.layoutId,
options.regionId,
options.width,
options.height,
options.top,
options.left,
options.mediaId,
options.render,
options.type,
options.uri,
options.duration,
options.loop,
options.mute,
options.direction,
options.text,
options.documentTemplate,
options.copyrightNotice,
options.javaScript,
options.updateInterval,
options.scrollSpeed,
options.modeid,
options.audio,
options.transIn,
options.transInDuration,
options.transInDirection,
options.transOut,
options.transOutDuration,
options.transOutDirection,
options.launchThroughCmd, options.scName, options.terminateCommand, options.useTaskkill, options.windowsCommand)
);
break;
case "video":
options.uri = PlayerSettings.libraryPath + options.uri;
_layoutOption.MediaNodeList.Add(
new MediaOption(
options.layoutId,
options.regionId,
options.width,
options.height,
options.top,
options.left,
options.mediaId,
options.render,
options.type,
options.uri,
options.duration,
options.loop,
options.mute,
options.direction,
options.text,
options.documentTemplate,
options.copyrightNotice,
options.javaScript,
options.updateInterval,
options.scrollSpeed,
options.modeid,
options.audio,
options.transIn,
options.transInDuration,
options.transInDirection,
options.transOut,
options.transOutDuration,
options.transOutDirection,
options.launchThroughCmd, options.scName, options.terminateCommand, options.useTaskkill, options.windowsCommand)
);
break;
case "localvideo":
//options.uri = Uri.UnescapeDataString(options.uri);
_layoutOption.MediaNodeList.Add(
new MediaOption(
options.layoutId,
options.regionId,
options.width,
options.height,
options.top,
options.left,
options.mediaId,
options.render,
options.type,
options.uri,
options.duration,
options.loop,
options.mute,
options.direction,
options.text,
options.documentTemplate,
options.copyrightNotice,
options.javaScript,
options.updateInterval,
options.scrollSpeed,
options.modeid,
options.audio,
options.transIn,
options.transInDuration,
options.transInDirection,
options.transOut,
options.transOutDuration,
options.transOutDirection,
options.launchThroughCmd, options.scName, options.terminateCommand, options.useTaskkill, options.windowsCommand)
);
break;
case "audio":
options.uri = PlayerSettings.libraryPath + options.uri;
_layoutOption.MediaNodeList.Add(
new MediaOption(
options.layoutId,
options.regionId,
options.width,
options.height,
options.top,
options.left,
options.mediaId,
options.render,
options.type,
options.uri,
options.duration,
options.loop,
options.mute,
options.direction,
options.text,
options.documentTemplate,
options.copyrightNotice,
options.javaScript,
options.updateInterval,
options.scrollSpeed,
options.modeid,
options.audio,
options.transIn,
options.transInDuration,
options.transInDirection,
options.transOut,
options.transOutDuration,
options.transOutDirection,
options.launchThroughCmd, options.scName, options.terminateCommand, options.useTaskkill, options.windowsCommand)
);
break;
case "datasetview":
case "embedded":
case "ticker":
case "text":
case "webpage":
_layoutOption.MediaNodeList.Add(
new MediaOption(
options.layoutId,
options.regionId,
options.width,
options.height,
options.top,
options.left,
options.mediaId,
options.render,
options.type,
options.uri,
options.duration,
options.loop,
options.mute,
options.direction,
options.text,
options.documentTemplate,
options.copyrightNotice,
options.javaScript,
options.updateInterval,
options.scrollSpeed,
options.modeid,
options.audio,
options.transIn,
options.transInDuration,
options.transInDirection,
options.transOut,
options.transOutDuration,
options.transOutDirection,
options.launchThroughCmd, options.scName, options.terminateCommand, options.useTaskkill, options.windowsCommand)
);
break;
case "flash":
options.uri = PlayerSettings.libraryPath + options.uri;
_layoutOption.MediaNodeList.Add(
new MediaOption(
options.layoutId,
options.regionId,
options.width,
options.height,
options.top,
options.left,
options.mediaId,
options.render,
options.type,
options.uri,
options.duration,
options.loop,
options.mute,
options.direction,
options.text,
options.documentTemplate,
options.copyrightNotice,
options.javaScript,
options.updateInterval,
options.scrollSpeed,
options.modeid,
options.audio,
options.transIn,
options.transInDuration,
options.transInDirection,
options.transOut,
options.transOutDuration,
options.transOutDirection,
options.launchThroughCmd, options.scName, options.terminateCommand, options.useTaskkill, options.windowsCommand)
);
break;
case "shellcommand":
_layoutOption.MediaNodeList.Add(
new MediaOption(
options.layoutId,
options.regionId,
options.width,
options.height,
options.top,
options.left,
options.mediaId,
options.render,
options.type,
options.uri,
options.duration,
options.loop,
options.mute,
options.direction,
options.text,
options.documentTemplate,
options.copyrightNotice,
options.javaScript,
options.updateInterval,
options.scrollSpeed,
options.modeid,
options.audio,
options.transIn,
options.transInDuration,
options.transInDirection,
options.transOut,
options.transOutDuration,
options.transOutDirection,
options.launchThroughCmd, options.scName, options.terminateCommand, options.useTaskkill, options.windowsCommand)
);
break;
default:
throw new InvalidOperationException("Not a valid media node type: " + options.type);
}
}
}
public void OnTestingLayoutChange(LayoutOption layout) => layoutManager.layout = layout;
public void ManageOverlays(Collection <ScheduleItem> overlays)
{
try
{
var _overlays = PlayerSettings.OverlayList;
Debug.WriteLine("Arrived at Manage Overlays with " + overlays.Count + " overlay schedules to show. We're already showing " + _overlays.Count + " overlay Regions", "Overlays");
// Take the ones we currently have up and remove them if they aren't in the new list or if they've been set to refresh
// We use a for loop so that we are able to remove the region from the collection
for (int i = 0; i < _overlays.Count; i++)
{
Debug.WriteLine("Assessing Overlay Region " + i, "Overlays");
string _ovelayName = "overlay" + _overlays[i].layoutId;
var region = PlayerSettings.OverlayList[i];
bool found = false;
bool refresh = false;
foreach (ScheduleItem item in overlays)
{
if (item.scheduleid == region.scheduleId)
{
found = true;
refresh = item.Refresh;
break;
}
}
if (!found || refresh)
{
if (refresh)
{
Trace.WriteLine(new LogMessage("MainForm - ManageOverlays", "Refreshing item that has changed."), LogType.Info.ToString());
}
Debug.WriteLine("Removing overlay " + i + " which is no-longer required. Overlay: " + region.scheduleId, "Overlays");
// Remove the Region from the overlays collection
_overlays.Remove(region);
// As we've removed the thing we're iterating over, reduce i
i--;
// Clear down and dispose of the region.
region = null;
this.Dispatcher.BeginInvoke(new Action(() =>
{
var item = root.FindName(_ovelayName) as System.Windows.Controls.UserControl;
try
{
this.Overlay.Children.Remove(item);
}
catch (Exception ex)
{
}
}));
}
else
{
Debug.WriteLine("Overlay Region found and not needing refresh " + i, "Overlays");
}
}
// Take the ones that are in the new list and add them
foreach (ScheduleItem item in overlays)
{
// Check its not already added.
bool found = false;
foreach (LayoutOption region in _overlays)
{
if (region.scheduleId == item.scheduleid)
{
found = true;
break;
}
}
if (found)
{
Debug.WriteLine("Region already found for overlay - we're assuming here that if we've found one, they are all there.", "Overlays");
continue;
}
// Reset refresh
item.Refresh = false;
var _ovelayOptions = new LayoutOption();
RenderOverlays.ReadOvelyas(item, _ovelayOptions);
PlayerSettings.OverlayList.Add(_ovelayOptions);
string _ovelayName = "overlay" + _ovelayOptions.layoutId.ToString();
this.Dispatcher.BeginInvoke(new Action(() =>
{
/* run your code here */
var overlayouts = new OverlayControl(_ovelayOptions.layoutId.ToString(), _ovelayOptions);
overlayouts.Name = _ovelayName;
root.RegisterName(_ovelayName, overlayouts);
this.Overlay.Children.Add(overlayouts);
}));
}
}
catch (Exception ex)
{
}
}
/// <summary>
/// Get region Details
/// </summary>
/// <param name="region"></param>
public static void RenderRegionDetails(XmlNode region, LayoutOption _layoutOption)
{
RegionOptions regionOption = new RegionOptions();
MediaOption options = new MediaOption();
// Override the default size if necessary
_clientSize.Height = SystemParameters.PrimaryScreenHeight;
_clientSize.Width = SystemParameters.PrimaryScreenWidth;
// Set the background and size of the form
double layoutWidth = int.Parse(_layoutOption.layoutWidth.ToString(), CultureInfo.InvariantCulture);
double layoutHeight = int.Parse(_layoutOption.layoutHeight.ToString(), CultureInfo.InvariantCulture);
// Scaling factor, will be applied to all regions
double scaleFactor = Math.Min(_clientSize.Width / layoutWidth, _clientSize.Height / layoutHeight);
// Want to be able to center this shiv - therefore work out which one of these is going to have left overs
int backgroundWidth = (int)(layoutWidth * scaleFactor);
int backgroundHeight = (int)(layoutHeight * scaleFactor);
double leftOverX;
double leftOverY;
try
{
leftOverX = Math.Abs(_clientSize.Width - backgroundWidth);
leftOverY = Math.Abs(_clientSize.Height - backgroundHeight);
if (leftOverX != 0)
{
leftOverX = leftOverX / 2;
}
if (leftOverY != 0)
{
leftOverY = leftOverY / 2;
}
}
catch
{
leftOverX = 0;
leftOverY = 0;
}
//region attributes
XmlAttributeCollection regionAttributes = region.Attributes;
if (regionAttributes.Count > 0)
{
//options.scheduleId = _scheduleId;
options.layoutId = _layoutOption.layoutId.ToString();
options.regionId = regionAttributes["id"].Value.ToString();
options.width = (int)(Convert.ToDouble(regionAttributes["width"].Value, CultureInfo.InvariantCulture) * scaleFactor);
options.height = (int)(Convert.ToDouble(regionAttributes["height"].Value, CultureInfo.InvariantCulture) * scaleFactor);
options.left = (int)(Convert.ToDouble(regionAttributes["left"].Value, CultureInfo.InvariantCulture) * scaleFactor);
options.top = (int)(Convert.ToDouble(regionAttributes["top"].Value, CultureInfo.InvariantCulture) * scaleFactor);
regionOption.scaleFactor = scaleFactor;
if (regionAttributes["zindex"] != null)
{
regionOption.zIndex = Convert.ToInt16(regionAttributes["zindex"].Value);
}
else
{
regionOption.zIndex = 0;
}
// Store the original width and original height for scaling
options.originalWidth = (int)Convert.ToDouble(regionAttributes["width"].Value, CultureInfo.InvariantCulture);
options.originalHeight = (int)Convert.ToDouble(regionAttributes["height"].Value, CultureInfo.InvariantCulture);
// Set the backgrounds (used for Web content offsets)
options.backgroundLeft = options.left * -1;
options.backgroundTop = options.top * -1;
// Account for scaling
options.left = options.left + (int)leftOverX;
options.top = options.top + (int)leftOverY;
}
XmlNode optionNode = region.SelectSingleNode("options");
foreach (XmlNode optionN in optionNode.ChildNodes)
{
if (optionN.Name == "transitionType")
{
regionOption.transitionType = optionN.InnerText;
}
else if (optionN.Name == "transitionDuration")
{
regionOption.transitionDuration = double.Parse(optionN.InnerText);
}
else if (optionN.Name == "transitionDirection")
{
regionOption.transitionDirection = optionN.InnerText;
}
}
_layoutOption.RegionList.Add(
new RegionOptions(
options.layoutId,
options.regionId,
options.width,
options.height,
options.top,
options.left,
regionOption.transitionType,
regionOption.transitionDuration,
regionOption.transitionDirection,
regionOption.zIndex
));
if (region.ChildNodes.Count != 0)
{
XmlNodeList listMedia = region.SelectNodes("media");
if (listMedia.Count > 0)
{
RenderMedia.MediaList(listMedia, options, _layoutOption);
}
else
{
return;
}
}
}
