public static void InsertImage(Image image, SlideModel slide)
{
int width = image.Width;
int height = image.Height;
int w = 0, h = 0;
using (Synchronizer.Lock(slide.SyncRoot)) {
w = slide.Bounds.Width;
h = slide.Bounds.Height - 10;
}
if (width > w)
{
height = w * height / width;
width = w;
}
if (height > h)
{
width = h * width / height;
height = h;
}
/// add 4 to the with of image box as padding
height = (width + 4) * height / width;
width += 4;
Point position = new Point(Math.Max((w - width) / 2, 0), Math.Max((h - height) / 2, 10));
ImageSheetModel imagesheet = new ImageSheetModel(Guid.NewGuid(), image, true, position, new Size(width, height), 0);
imagesheet.Visible = true;
using (Synchronizer.Lock(slide.SyncRoot)) {
slide.AnnotationSheets.Add(imagesheet);
}
}
public IActionResult EditSlidePopup(int id, string btnId, string formId)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageWidgets))
{
return(AccessDeniedView());
}
var model = new SlideModel();
var slide = _slideService.GetSlideById(id);
//set localized values
AddLocales(_languageService, model.Locales, (locale, languageId) =>
{
locale.Hyperlink = _localizationService.GetLocalized(slide, x => x.HyperlinkAddress, languageId, false, false);
locale.Description = _localizationService.GetLocalized(slide, x => x.Description, languageId, false, false);
locale.PictureId = _localizationService.GetLocalized(slide, x => x.PictureId, languageId, false, false).GetValueOrDefault(0);
});
//set default values
model.Description = slide.Description;
model.Hyperlink = slide.HyperlinkAddress;
model.PictureId = slide.PictureId.GetValueOrDefault(0);
model.StartDateUtc = slide.StartDateUtc;
model.EndDateUtc = slide.EndDateUtc;
model.Published = slide.Published;
model.DisplayOrder = slide.DisplayOrder;
//process store mapping
PrepareStoreMapping(slide, model);
//ACL
PrepareAclModel(model, slide, false);
return(View("~/Plugins/Widgets.qBoSlider/Views/Admin/EditSlidePopup.cshtml", model));
}
private void HandleSlideAdded(object sender, PropertyEventArgs args_)
{
PropertyCollectionEventArgs args = ((PropertyCollectionEventArgs)args_);
SlideModel slide = ((SlideModel)args.Added);
this.AttachSlide(slide);
}
private void WindowSnapshotMenuItem_Click(object sender, EventArgs e)
{
if (this.m_AppWindow != null && !this.m_AppWindow.Minimized)
{
MemoryStream ms = new MemoryStream();
try {
this.m_AppWindow.WindowAsBitmap.Save(ms, System.Drawing.Imaging.ImageFormat.Png);
} catch {
return;
}
ms.Position = 0;
Image image = Image.FromStream(ms);
SlideModel slide = null;
using (Synchronizer.Lock(this.m_Model.Workspace.CurrentDeckTraversal.SyncRoot)) {
if ((~this.m_Model.Workspace.CurrentDeckTraversal) != null)
{
using (Synchronizer.Lock((~this.m_Model.Workspace.CurrentDeckTraversal).SyncRoot)) {
slide = (~this.m_Model.Workspace.CurrentDeckTraversal).Current.Slide;
}
}
}
if (slide != null)
{
InsertMenu.InsertImage(image, slide);
}
}
}
/// <summary>
/// Event handler that is invoked when a slide is added to the deck
/// </summary>
/// <param name="sender"></param>
/// <param name="args_"></param>
private void HandleSlideAdded(object sender, PropertyEventArgs args_)
{
PropertyCollectionEventArgs args = ((PropertyCollectionEventArgs)args_);
SlideModel slide = ((SlideModel)args.Added);
// Get the best associated slide
bool bAdded = false;
using (Synchronizer.Lock(this.m_DestDeck.SyncRoot)) {
foreach (SlideModel s in this.m_DestDeck.Slides)
{
if (SlidesEqual(s, slide))
{
// Add the association to the list
this.m_SlideMatches.Add(new SlideMatch(this.m_Sender, slide, s));
bAdded = true;
break;
}
}
// New slide, perhaps whiteboard, so add one
if (!bAdded)
{
// CMPRINCE TODO: This need to be done better
// Insert the new slide
// this.m_DestDeck.InsertSlide(
// Add the association to the list
}
}
}
public async Task <IActionResult> Edit(SlideModel model, bool continueEditing)
{
var pictureSlider = await _sliderService.GetById(model.Id);
if (pictureSlider == null)
{
return(RedirectToAction("Configure"));
}
if (ModelState.IsValid)
{
pictureSlider = model.ToEntity();
pictureSlider.Locales = model.Locales.ToLocalizedProperty();
pictureSlider.Stores = model.SelectedStoreIds != null?model.SelectedStoreIds.ToList() : new List <string>();
await _sliderService.UpdatePictureSlider(pictureSlider);
SuccessNotification(_localizationService.GetResource("Plugins.Widgets.Slider.Edited"));
return(continueEditing ? RedirectToAction("Edit", new { id = pictureSlider.Id }) : RedirectToAction("Configure"));
}
//Stores
await model.PrepareStoresMappingModel(pictureSlider, true, _storeService);
//Categories
await PrepareAllCategoriesModel(model);
//Manufacturers
await PrepareAllManufacturersModel(model);
return(View("~/Plugins/Widgets.Slider/Views/Edit.cshtml", model));
}
protected override void OnClick(EventArgs e)
{
base.OnClick(e);
IDataObject clipboardDateObject = Clipboard.GetDataObject();
if (clipboardDateObject.GetDataPresent(DataFormats.Bitmap))
{
Image image = (Bitmap)clipboardDateObject.GetData(DataFormats.Bitmap);
SlideModel slide = null;
using (Synchronizer.Lock(this.m_Model.Workspace.CurrentDeckTraversal.SyncRoot)) {
if ((~this.m_Model.Workspace.CurrentDeckTraversal) != null)
{
using (Synchronizer.Lock((~this.m_Model.Workspace.CurrentDeckTraversal).SyncRoot)) {
slide = (~this.m_Model.Workspace.CurrentDeckTraversal).Current.Slide;
}
}
}
if (slide != null)
{
InsertMenu.InsertImage(image, slide);
}
}
}
protected SlideModel GetSubmissionSlideModel()
{
SlideModel m = this.Slide;
if (this.Slide != null)
{
using (Synchronizer.Lock(this.Slide.SyncRoot)) {
// Determine if we need to create a guid ourselves or not
if (this.NewSlideGuid == Guid.Empty &&
this.Slide.SubmissionStyle == SlideModel.StudentSubmissionStyle.Realtime)
{
// Send the student submission and
// Set the NewSlideGuid to the slide value we used
this.NewSlideGuid = SendStudentSubmission();
}
if (this.Slide.SubmissionStyle == SlideModel.StudentSubmissionStyle.Realtime)
{
m = new SlideModel(this.NewSlideGuid, new LocalId(), SlideDisposition.Remote, this.Slide.Bounds);
}
else
{
m = new SlideModel(this.Slide.SubmissionSlideGuid, new LocalId(), SlideDisposition.Remote, this.Slide.Bounds);
}
using (Synchronizer.Lock(m.SyncRoot)) {
m.SubmissionSlideGuid = this.Slide.SubmissionSlideGuid;
m.SubmissionStyle = this.Slide.SubmissionStyle;
}
}
}
return(m);
}
public IActionResult Edit(SlideModel model, bool continueEditing)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManagePlugins))
{
return(AccessDeniedView());
}
var pictureSlider = _sliderService.GetById(model.Id);
if (pictureSlider == null)
{
return(RedirectToAction("Configure"));
}
if (ModelState.IsValid)
{
pictureSlider = model.ToEntity();
pictureSlider.Locales = model.Locales.ToLocalizedProperty();
pictureSlider.Stores = model.SelectedStoreIds != null?model.SelectedStoreIds.ToList() : new List <string>();
_sliderService.UpdatePictureSlider(pictureSlider);
SuccessNotification(_localizationService.GetResource("Plugins.Widgets.Slider.Edited"));
return(continueEditing ? RedirectToAction("Edit", new { id = pictureSlider.Id }) : RedirectToAction("Configure"));
}
//Stores
PrepareStoresMappingModel(model, pictureSlider, true);
//Categories
PrepareAllCategoriesModel(model);
//Manufacturers
PrepareAllManufacturersModel(model);
return(View("~/Plugins/Widgets.Slider/Views/Edit.cshtml", model));
}
protected override void OnClick(EventArgs e)
{
SlideModel slide = null;
Model.Viewer.ViewerStateModel vsm = null;
using (Synchronizer.Lock(this.m_Model.Workspace.CurrentDeckTraversal.SyncRoot)) {
if ((~this.m_Model.Workspace.CurrentDeckTraversal) != null)
{
using (Synchronizer.Lock((~this.m_Model.Workspace.CurrentDeckTraversal).SyncRoot)) {
slide = (~this.m_Model.Workspace.CurrentDeckTraversal).Current.Slide;
}
}
}
using (Synchronizer.Lock(this.m_Model.SyncRoot)) {
vsm = this.m_Model.ViewerState;
}
if (slide != null && vsm != null)
{
CaptureGraphForm cg_form = new CaptureGraphForm(slide, vsm);
if (cg_form.ShowDialog() == DialogResult.OK)
{
InsertMenu.InsertImage(cg_form.Image, slide);
}
}
}
private void InsertSlide()
{
///get the index of the current slide that's selected,
///so that we can insert our blank slide there
int current_slide_index;
using (Synchronizer.Lock(traversal_.SyncRoot)) {
current_slide_index = traversal_.AbsoluteCurrentSlideIndex;
}
///if current_slide_index == -1, this means there are no slides in current deck.
///This new slide we try to insert is the first slide.
if (current_slide_index < 0)
{
current_slide_index = 0;
}
// Create a blank slide
SlideModel slide;
using (Synchronizer.Lock(this.m_Deck.SyncRoot)) {
slide = new SlideModel(Guid.NewGuid(), new LocalId(), SlideDisposition.Empty, UW.ClassroomPresenter.Viewer.ViewerForm.DEFAULT_SLIDE_BOUNDS);
this.m_Deck.Dirty = true;
this.m_Deck.InsertSlide(slide);
}
///Insert our blank slide after the current index. This is modeled after the powerpoint
///UI
using (Synchronizer.Lock(this.m_Deck.TableOfContents.SyncRoot)) {
TableOfContentsModel.Entry entry = new TableOfContentsModel.Entry(Guid.NewGuid(), this.m_Deck.TableOfContents, slide);
this.m_WhereTheEntriesGo.Insert(current_slide_index, entry);
}
}
public ActionResult Edit(SlideModel model)
{
try
{
var slide = _slideService.GetSlideById(model.Id);
if (slide == null)
{
return(RedirectToAction("List"));
}
if (!ModelState.IsValid)
{
return(View(model));
}
var currentUser = Session[Values.USER_SESSION] as UserModel;
model.UpdatedBy = currentUser.Id;
model.UpdatedDateTime = DateTime.Now;
_slideService.UpdateSlide(model);
SuccessNotification("Update slider successfully!");
return(model.ContinueEditing ? RedirectToAction("Edit", new { id = model.Id }) : RedirectToAction("List"));
}
catch (Exception e)
{
ErrorNotification("Update slider failed!");
return(View(model));
}
}
/// <summary>
/// Construction for Form
/// </summary>
public BackgroundPropertiesForm(PresenterModel model)
{
this.m_Model = model;
this.SuspendLayout();
this.ClientSize = new Size(320, 320);
this.Font = ViewerStateModel.FormFont;
this.FormBorderStyle = FormBorderStyle.FixedDialog;
this.MaximizeBox = false;
this.Name = "BackgroundPropertiesForm";
this.Text = Strings.BackgroundPropertiesFormTitle;
//Get the BackgroundTemplate Model
using (this.m_Model.Workspace.Lock())
{
DeckTraversalModel traversal = this.m_Model.Workspace.CurrentDeckTraversal;
if (traversal != null)
{
using (Synchronizer.Lock(traversal.SyncRoot))
{
if (this.m_ApplyToCurrentSlideOnly)
{
SlideModel current = traversal.Current.Slide;
if (current != null)
{
using (Synchronizer.Lock(traversal.Current.Slide.SyncRoot))
{
if (traversal.Current.Slide.BackgroundTemplate != null)
{
this.m_Template = traversal.Current.Slide.BackgroundTemplate.Clone();
}
}
}
}
else
{
DeckModel deck = traversal.Deck;
using (Synchronizer.Lock(deck.SyncRoot))
{
if (deck.DeckBackgroundTemplate != null)
{
this.m_Template = deck.DeckBackgroundTemplate.Clone();
}
}
}
}
}
}
this.m_BkgTemplateSelectionGroup = new BkgTemplateSelectionGroup(this, this.m_Template, new Point(20, 10), new Size(280, 50), 0);
this.Controls.Add(this.m_BkgTemplateSelectionGroup);
this.m_BkgTemplatePreviewGroup = new BkgTemplatePreviewGroup(this, new Point(20, 70), new Size(280, 210), 1);
this.Controls.Add(this.m_BkgTemplatePreviewGroup);
this.Controls.Add(new PropertiesOKButton(this, this.m_Model, new Point(80, 285), 2));
this.Controls.Add(new PropertiesCancelButton(this, this.m_Model, this.m_Template, new Point(180, 285), 3));
this.ResumeLayout();
}
private void SendSlideInformation(SlideModel slide, Group receivers)
{
Message message, deck;
message = new PresentationInformationMessage(this.m_Presentation);
message.Group = receivers;
message.InsertChild(deck = new DeckInformationMessage(this.m_Deck));
// Ensure that nothing about the slide can change between sending the slide's information
// and creating the SlideNetworkService to listen for changes.
// TODO: Find a way to also ensure that nothing about the SheetModels change either, but this is less of a concern.
using (Synchronizer.Lock(this.m_SlideNetworkServices.SyncRoot)) {
using (Synchronizer.Lock(slide.SyncRoot)) {
deck.InsertChild(new SlideInformationMessage(slide));
message.Tags = new MessageTags();
message.Tags.SlideID = slide.Id;
this.m_Sender.Send(message);
if (!this.m_SlideNetworkServices.ContainsKey(slide))
{
SlideNetworkService service = new SlideNetworkService(this.m_Sender, this.m_Presentation, this.m_Deck, slide);
this.m_SlideNetworkServices.Add(slide, service);
}
}
}
}
private void SendAllSlidesAndContent(Group receivers)
{
using (Synchronizer.Lock(this.m_Deck.SyncRoot)) {
foreach (SlideModel slide in this.m_Deck.Slides)
{
this.SendSlideInformation(slide, receivers);
}
foreach (ByteArray hash in this.m_Deck.SlideContentKeys)
{
Message message, deck;
message = new PresentationInformationMessage(this.m_Presentation);
message.Group = receivers;
message.InsertChild(deck = new DeckInformationMessage(this.m_Deck));
deck.InsertChild(new DeckSlideContentMessage(this.m_Deck, hash));
message.Tags = new MessageTags();
message.Tags.BridgePriority = MessagePriority.Lowest;
SlideModel slide = this.m_Deck.GetSlideFromContent(hash);
if (slide != null)
{
using (Synchronizer.Lock(slide.SyncRoot)) {
message.Tags.SlideID = slide.Id;
}
}
this.m_Sender.Send(message, MessagePriority.Low);
}
}
}
protected override void OnClick(EventArgs e)
{
base.OnClick(e);
// Change the name of whiteboard according to the number of it
string wbname = "WhiteBoard " + (++UW.ClassroomPresenter.Viewer.ViewerForm.white_board_num).ToString();
// NOTE: This code is duplicated in DeckNavigationToolBarButtons.WhiteboardToolBarButton and DeckMessage.UpdateContext
DeckModel deck = new DeckModel(Guid.NewGuid(), DeckDisposition.Whiteboard, wbname);
using (Synchronizer.Lock(deck.SyncRoot)) {
SlideModel slide = new SlideModel(Guid.NewGuid(), new LocalId(), SlideDisposition.Empty, UW.ClassroomPresenter.Viewer.ViewerForm.DEFAULT_SLIDE_BOUNDS);
deck.InsertSlide(slide);
using (Synchronizer.Lock(deck.TableOfContents.SyncRoot)) {
TableOfContentsModel.Entry entry = new TableOfContentsModel.Entry(Guid.NewGuid(), deck.TableOfContents, slide);
deck.TableOfContents.Entries.Add(entry);
}
}
DeckTraversalModel traversal = new SlideDeckTraversalModel(Guid.NewGuid(), deck);
using (this.m_Model.Workspace.Lock()) {
if ((~this.m_Model.Workspace.CurrentPresentation) != null)
{
using (Synchronizer.Lock((~this.m_Model.Workspace.CurrentPresentation).SyncRoot)) {
(~this.m_Model.Workspace.CurrentPresentation).DeckTraversals.Add(traversal);
}
}
else
{
this.m_Model.Workspace.DeckTraversals.Add(traversal);
}
}
}
protected override bool UpdateTarget(ReceiveContext context)
{
SlideModel slide = this.Parent != null ? this.Parent.Target as SlideModel : null;
if (slide == null)
{
return(false);
}
DeckModel deck = this.Parent.Parent != null ? this.Parent.Parent.Target as DeckModel : null;
if (deck == null)
{
return(false);
}
TableOfContentsModel.Entry entry = this.Target as TableOfContentsModel.Entry;
if (entry == null)
{
this.Target = entry = new TableOfContentsModel.Entry(((Guid)this.TargetId), deck.TableOfContents, slide);
}
this.UpdatePathFromRoot(entry);
return(true);
}
protected override void OnClick(EventArgs e)
{
base.OnClick(e);
//Show up the OpenFileDialog
//get the image that the user wants to load
OpenFileDialog file_dialog = new OpenFileDialog();
file_dialog.Filter = "JPEG files (*.jpg)|*.jpg|BMP files (*.bmp)|*.bmp|PNG files (*.png)|*.png";
if (file_dialog.ShowDialog() == DialogResult.OK)
{
Image image = Image.FromFile(file_dialog.FileName);
SlideModel slide = null;
using (Synchronizer.Lock(this.m_Model.Workspace.CurrentDeckTraversal.SyncRoot)) {
if ((~this.m_Model.Workspace.CurrentDeckTraversal) != null)
{
using (Synchronizer.Lock((~this.m_Model.Workspace.CurrentDeckTraversal).SyncRoot)) {
slide = (~this.m_Model.Workspace.CurrentDeckTraversal).Current.Slide;
}
}
}
if (slide != null)
{
InsertMenu.InsertImage(image, slide);
}
}
}
public async Task <IActionResult> Create(SlideModel model, bool continueEditing)
{
if (!await _permissionService.Authorize(StandardPermissionProvider.ManagePlugins))
{
return(AccessDeniedView());
}
if (ModelState.IsValid)
{
var pictureSlider = model.ToEntity();
pictureSlider.Locales = model.Locales.ToLocalizedProperty();
pictureSlider.Stores = model.SelectedStoreIds != null?model.SelectedStoreIds.ToList() : new List <string>();
await _sliderService.InsertPictureSlider(pictureSlider);
SuccessNotification(_localizationService.GetResource("Plugins.Widgets.Slider.Added"));
return(continueEditing ? RedirectToAction("Edit", new { id = pictureSlider.Id }) : RedirectToAction("Configure"));
}
//Stores
await model.PrepareStoresMappingModel(null, true, _storeService);
//Categories
await PrepareAllCategoriesModel(model);
//Manufacturers
await PrepareAllManufacturersModel(model);
return(View("~/Plugins/Widgets.Slider/Views/Create.cshtml", model));
}
protected virtual void UpdateStoreMapping(Slide slide, SlideModel model)
{
var allStores = _storeService.GetAllStores();
var limitedToStores = _storeMappingService.GetStoreMappings(slide);
foreach (var store in allStores)
{
if (model.SelectedStoreIds != null && model.SelectedStoreIds.Contains(store.Id))
{
//new store mapping
if (!limitedToStores.Any(x => x.StoreId == store.Id))
{
_storeMappingService.InsertStoreMapping(slide, store.Id);
}
}
else
{
//delete mapping
var storeMapping = limitedToStores.FirstOrDefault(x => x.StoreId == store.Id);
if (storeMapping != null)
{
_storeMappingService.DeleteStoreMapping(storeMapping);
}
}
}
}
protected virtual void SaveCustomerRolesAcl(Slide slide, SlideModel model)
{
var existingAclRecords = _aclService.GetAclRecords(slide);
var allCustomerRoles = _customerService.GetAllCustomerRoles(true);
foreach (var customerRole in allCustomerRoles)
{
if (model.SelectedCustomerRoleIds.Contains(customerRole.Id))
{
//new role
if (existingAclRecords.Count(acl => acl.CustomerRoleId == customerRole.Id) == 0)
{
_aclService.InsertAclRecord(slide, customerRole.Id);
}
}
else
{
//remove role
var aclRecordToDelete = existingAclRecords.FirstOrDefault(acl => acl.CustomerRoleId == customerRole.Id);
if (aclRecordToDelete != null)
{
_aclService.DeleteAclRecord(aclRecordToDelete);
}
}
}
}
public virtual IActionResult Create(SlideModel model, bool continueEditing)
{
//redirect customer on accessdenied view, if client has no permissions
if (!_permissionService.Authorize(StandardPermissionProvider.ManageWidgets))
{
return(AccessDeniedView());
}
//return on slide creation page if model invalid
if (!ModelState.IsValid)
{
//prepare model mappings
_slideModelFactory.PrepareAclModel(model, null, true);
_slideModelFactory.PrepareStoreMapping(model, null);
return(View("~/Plugins/Widgets.qBoSlider/Views/Admin/Slide/Create.cshtml", model));
}
var slide = new Slide()
{
Description = model.Description,
HyperlinkAddress = model.Hyperlink,
PictureId = model.PictureId,
StartDateUtc = model.StartDateUtc,
EndDateUtc = model.EndDateUtc,
Published = model.Published,
LimitedToStores = model.SelectedStoreIds.Any(),
SubjectToAcl = model.SelectedCustomerRoleIds.Any()
};
_slideService.InsertSlide(slide);
//update slide locales
UpdateSlideLocales(slide, model);
//process slide store mappings
UpdateStoreMapping(slide, model);
//ACL (customer roles)
//Set catalogsettings.ignoreacl = True to use ALC
SaveCustomerRolesAcl(slide, model);
//ACL
_slideModelFactory.PrepareAclModel(model, null, true);
//store mappings
_slideModelFactory.PrepareStoreMapping(model, null);
//notify admin
_notificationService.SuccessNotification(_localizationService.GetResource("Nop.Plugin.Baroque.Widgets.qBoSlider.Admin.Slide.CreatedSuccessfully"));
//redirect on widget zone list page if customer don't want's to contiu editing
if (!continueEditing)
{
return(RedirectToAction("List"));
}
return(RedirectToAction("Edit", new { id = slide.Id }));
}
public void InsertSlide(SlideModel slideModel)
{
var slide = Mapper.Map <Slide>(slideModel);
_shoppingContext.Slides.Add(slide);
_shoppingContext.SaveChanges();
slideModel.Id = slide.Id;
}
/// <summary>
/// Returns true if two slide models are equal, false otherwise
/// </summary>
/// <param name="src">First model</param>
/// <param name="dst">Second model</param>
/// <returns>True if two slide models are equal</returns>
private bool SlidesEqual(SlideModel src, SlideModel dst)
{
using (Synchronizer.Lock(src.SyncRoot)) {
using (Synchronizer.Lock(dst.SyncRoot)) {
return(src.Title == dst.Title);
}
}
}
private void CopySlideToPublicDeck()
{
///get the index of the current slide that's selected,
///so that we can insert our blank slide there
int current_slide_index;
using (Synchronizer.Lock(traversal_.SyncRoot)) {
current_slide_index = traversal_.AbsoluteCurrentSlideIndex - 1;
}
///don't do anything if no object is selected
if (current_slide_index < 0)
{
return;
}
DeckModel publicDeck = GetPublicSubmissionDeck();
// Copy slide
SlideModel newSlide;
using (Synchronizer.Lock(this.m_Deck.SyncRoot)) {
SlideModel currentSlide = this.m_Deck.TableOfContents.Entries[current_slide_index].Slide;
newSlide = CloneSlideAndSheets(currentSlide);
using (Synchronizer.Lock(newSlide.SyncRoot)) {
using (Synchronizer.Lock(currentSlide.SyncRoot)) {
if (currentSlide.BackgroundTemplate == null)
{
newSlide.BackgroundTemplate = this.m_Deck.DeckBackgroundTemplate;
}
if (currentSlide.BackgroundColor == Color.Empty)
{
newSlide.BackgroundColor = this.m_Deck.DeckBackgroundColor;
}
}
}
newSlide.RemoveRemoteDisposition();
}
using (Synchronizer.Lock(publicDeck.SyncRoot)) {
publicDeck.Dirty = true;
publicDeck.InsertSlide(newSlide);
UW.ClassroomPresenter.Network.Messages.Message.AddLocalRef(newSlide.Id, newSlide);
}
using (Synchronizer.Lock(publicDeck.TableOfContents.SyncRoot)) {
TableOfContentsModel.Entry e = new TableOfContentsModel.Entry(Guid.NewGuid(), publicDeck.TableOfContents, newSlide);
publicDeck.TableOfContents.Entries.Add(e);
UW.ClassroomPresenter.Network.Messages.Message.AddLocalRef(e.Id, e);
}
///Insert our current slide after the current index. This is modeled after the powerpoint
///UI
// using (Synchronizer.Lock(this.m_Deck.TableOfContents.SyncRoot)) {
// TableOfContentsModel.Entry entry = new TableOfContentsModel.Entry(Guid.NewGuid(), this.m_Deck.TableOfContents, newSlide);
// this.m_WhereTheEntriesGo.Insert(current_slide_index + 1, entry);
// }
}
public async Task <IActionResult> Create()
{
var model = new SlideModel();
//locales
await AddLocales(_languageService, model.Locales);
return(View("~/Plugins/Widgets.Slider/Views/Create.cshtml", model));
}
protected SheetUndoService(UndoModel undo, DeckModel deck, SlideModel slide, SheetModel sheet)
{
this.m_Undo = undo;
this.m_Deck = deck;
this.m_Slide = slide;
this.m_Sheet = sheet;
this.m_Sheet.Changed["Bounds"].Add(new PropertyEventHandler(this.HandleSheetChanged));
}
public static DeckModel OpenXPS(string file)
{
try
{
Misc.ProgressBarForm progressForm = new UW.ClassroomPresenter.Misc.ProgressBarForm("Opening \"" + file + "\"...");
progressForm.Show();
//Open Xps Document
XpsDocument xpsDocument = null;
xpsDocument = new XpsDocument(file, FileAccess.Read);
//Create two DocumentPaginators for the XPS document. One is for local display, the other one is for the delivery to students.
DocumentPaginator paginator = xpsDocument.GetFixedDocumentSequence().DocumentPaginator;
//Create Deck Model
Guid deckGuid = Guid.NewGuid();
DeckModel deck = new DeckModel(deckGuid, DeckDisposition.Empty, file);
using (Synchronizer.Lock(deck.SyncRoot))
{
deck.IsXpsDeck = true;
//Iterate over all pages
for (int i = 0; i < paginator.PageCount; i++)
{
DocumentPage page = paginator.GetPage(i);
SlideModel newSlideModel = CreateSlide(page, deck);
//Create a new Entry + reference SlideModel
TableOfContentsModel.Entry newEntry = new TableOfContentsModel.Entry(Guid.NewGuid(), deck.TableOfContents, newSlideModel);
//Lock the TOC
using (Synchronizer.Lock(deck.TableOfContents.SyncRoot))
{
//Add Entry to TOC
deck.TableOfContents.Entries.Add(newEntry);
}
//Update the Progress Bar
progressForm.UpdateProgress(0, paginator.PageCount, i + 1);
}
}
//Close Progress Bar
progressForm.Close();
return(deck);
}
catch (Exception e)
{
System.Diagnostics.Trace.WriteLine(e.ToString());
}
GC.Collect();
return(null);
}
/// <summary>
/// This should be used only if local node is instructor and if this slide is a student submission which is being
/// sent to public displays. In this case we want to add a few details about the slide and deck which are the basis
/// for the student submission. This will allow a presentation archive to be post-processed and reused much more easily.
/// </summary>
/// <param name="guid"></param>
private void AddAssociationExtension(SlideModel slide)
{
SlideAssociationExtension ext = new SlideAssociationExtension(slide.AssociationId);
ext.SlideIndex = slide.AssociationSlideIndex;
ext.DeckID = slide.AssociationDeckId;
ext.DeckType = slide.AssociationDeckDisposition;
this.Extension = new ExtensionWrapper(ext, SlideAssociationExtension.ExtensionId);
}
public SSSheetNetworkService(SendingQueue sender, PresentationModel presentation, DeckModel deck, SlideModel slide, SheetModel sheet, SheetMessage.SheetCollection selector)
{
this.m_Sender = sender;
this.m_Presentation = presentation;
this.m_Deck = deck;
this.m_Slide = slide;
this.m_Sheet = sheet;
this.m_Selector = selector;
}
private void SetupSlideView(SlideModel _slideModel)
{
if (m_prefabSlideView == null) {
m_prefabSlideView = Resources.Load<GameObject>(SLIDE_PREFAB_NAME);
}
GameObject slideGameObject = Instantiate(m_prefabSlideView);
slideGameObject.GetComponent<Transform>().SetParent(transform);
slideGameObject.name = typeof(SlideView).Name;
SlideController slideController = slideGameObject.GetComponent<SlideController>();
slideController.SetModel(_slideModel);
slideController.Initialize();
SlideView slideView = slideGameObject.GetComponent<SlideView>();
slideView.Initialize(slideController);
m_slideView.Add(slideView);
}
private SlideModel CreateSlide()
{
// TODO: Refactor this
var availableTiles = m_tilesModel.Where(_s => _s.TeleporterModel == null && _s.PositionInBoard > (m_boardConfiguration.HorizontalTiles * 2f));
TileModel startTile = availableTiles.ElementAt(UnityEngine.Random.Range(0, availableTiles.Count()));
var posibleTiles = m_tilesModel.Where(_s => _s.TeleporterModel == null && _s.PositionInBoard < (startTile.PositionInBoard - m_boardConfiguration.HorizontalTiles));
int randomElementIndex = UnityEngine.Random.Range(0, posibleTiles.Count());
TileModel endTile = posibleTiles.ElementAt(randomElementIndex);
SlideModel slideModel = new SlideModel(startTile, endTile);
startTile.TeleporterModel = slideModel;
endTile.TeleporterModel = slideModel;
return slideModel;
}
public void SetModel(SlideModel _tileModel)
{
m_slideModel = _tileModel;
}
