public static RoleNetworkService ForRole(SendingQueue sender, PresenterModel model, RoleModel role)
{
if(role is InstructorModel) {
return new InstructorNetworkService(sender, ((InstructorModel) role));
} else if(role is StudentModel) {
return new StudentNetworkService( sender, model, ((StudentModel) role) );
} else {
// Either the role type is unsupported, or it is a PublicModel
// which currently have no published properties which need to be broadcast.
return null;
}
}
public SubmissionStatusNetworkService(SendingQueue sender, RoleModel role)
{
submission_status_model_ = SubmissionStatusModel.GetInstance();
if (role is StudentModel) {
submission_status_model_.Role = "student";
submission_status_model_.Changed["SubmissionStatus"].Add(new PropertyEventHandler(this.StudentSendStatus));
} else if(role is InstructorModel){
submission_status_model_.Role = "instructor";
submission_status_model_.Changed["Id"].Add(new PropertyEventHandler(this.InstructorSendStatus));
}
sender_ = sender;
}
public ParticipantModel(Guid guid, RoleModel role, string humanName)
{
this.m_Id = guid;
this.m_Role = role;
this.m_HumanName = humanName;
this.m_Groups = new GroupCollection(this, "Groups");
using( Synchronizer.Lock( this.SyncRoot ) ) {
// Always add all participants to the AllParticipant group
this.Groups.Add( Group.AllParticipant );
// All participants also each belong to their own SingletonGroup.
this.Groups.Add(new SingletonGroup(this));
}
if (PresenterModel.TheInstance != null) {
PresenterModel.TheInstance.VersionExchange.CreateVersionExchange(this);
}
}
protected RoleMessage(RoleModel role)
: base(role.Id)
{
this.Target = role;
}
/// <summary>
/// Sets the <see cref="Role"/> property to the current
/// <see cref="ParticipantModel.Role">Role</see> of
/// the <see cref="ParticipantModel"/> of the associated <see cref="PresenterModel"/>.
/// </summary>
/// <remarks>
/// <para>
/// This method should be called from the <see cref="m_EventQueue"/> or
/// the control's creator thread.
/// </para>
/// </remarks>
protected void InitializeRole()
{
using (Synchronizer.Lock(this.m_Model.Participant.SyncRoot))
{
this.Role = this.m_Model.Participant.Role;
this.Visible = (this.m_Model.Participant.Role is InstructorModel);
}
}
protected virtual void Dispose(bool disposing)
{
if(this.m_Disposed) return;
if(disposing) {
this.m_Participant.Changed["Role"].Remove(this.m_RoleChangedDispatcher.Dispatcher);
// Dispose of the RoleNetworkService via the Role setter.
this.Role = null;
}
this.m_Disposed = true;
}
private void SendRoleChangedMessage(RoleModel role, Group receivers)
{
Message message = RoleMessage.ForRole(role);
message.Group = receivers;
if(message != null) {
this.m_Sender.Send(message);
}
}
private void HandleRoleChanged(object sender, PropertyEventArgs args)
{
using(Synchronizer.Lock(this.m_Participant.SyncRoot)) {
this.SendRoleChangedMessage(this.m_Participant.Role, Group.AllParticipant);
this.Role = this.m_Participant.Role;
}
}
public InstructorMenuItem(ControlEventQueue dispatcher, PresenterModel model)
{
this.m_Model = model;
this.m_EventQueue = dispatcher;
this.m_HandleRoleChangedDispatcher = new EventQueue.PropertyEventDispatcher(this.m_EventQueue, new PropertyEventHandler(this.HandleRoleChanged));
//Save a copy of the role
this.m_Role = this.m_Model.Participant.Role;
//Listen to changes in Role
this.m_Model.Participant.Changed["Role"].Add(this.m_HandleRoleChangedDispatcher.Dispatcher);
}
public RoleNetworkService(SendingQueue sender, RoleModel role)
{
this.Sender = sender;
this.m_Role = role;
}
private void SetNetworkAssociationRole(RoleModel role)
{
// Remove any old event listeners.
if (this.m_NetworkAssociationRole != null) {
this.m_NetworkAssociationRole.Changed["ForcingStudentNavigationLock"].Remove(this.m_ForcingStudentNavigationLockChangedDispatcher.Dispatcher);
}
this.m_NetworkAssociationRole = role as InstructorModel;
// If we're now associated with an instructor, we must obey its ForcingStudentNavigationLock policy.
// So we register event listeners to watch for changes to that property.
if (this.m_NetworkAssociationRole != null) {
this.m_NetworkAssociationRole.Changed["ForcingStudentNavigationLock"].Add(this.m_ForcingStudentNavigationLockChangedDispatcher.Dispatcher);
this.m_ForcingStudentNavigationLockChangedDispatcher.Dispatcher(this, null);
}
}
public ParticipantModel(Guid guid, RoleModel role)
: this(guid, role, null)
{
}
/// <summary>
/// Release all resources
/// </summary>
/// <param name="disposing">True if truely disposing</param>
protected override void Dispose( bool disposing )
{
if( this.m_Disposed ) return;
try {
if( disposing ) {
// Unregister event listeners via the Role setter.
this.Role = null;
this.m_Adapter.Dispose();
}
} finally {
base.Dispose( disposing );
}
this.m_Disposed = true;
}
/// <summary>
/// Release all resources
/// </summary>
/// <param name="disposing">True if truely disposing</param>
protected override void Dispose(bool disposing)
{
if (this.m_Disposed) return;
try {
if (disposing) {
// Unregister event listeners
ParticipantModel participant = null;
using (Synchronizer.Lock(this.m_Model.Workspace.CurrentPresentation.SyncRoot)) {
if (this.m_Model.Workspace.CurrentPresentation.Value != null) {
using (Synchronizer.Lock(this.m_Model.Workspace.CurrentPresentation.Value.SyncRoot)) {
participant = this.m_Model.Workspace.CurrentPresentation.Value.Owner;
}
}
}
if (participant != null) {
using (Synchronizer.Lock(participant.SyncRoot)) {
((InstructorModel)(participant.Role)).Changed["AcceptingStudentSubmissions"].Remove(this.m_AcceptingSSubsChangedDispatcher.Dispatcher);
}
}
this.Role = null;
}
}
finally {
base.Dispose(disposing);
}
this.m_Disposed = true;
}
public static RoleMessage ForRole(RoleModel role)
{
if(role is InstructorModel) {
return new InstructorMessage((InstructorModel) role);
} else if(role is StudentModel) {
return new StudentMessage((StudentModel) role);
} else if(role is PublicModel) {
return new PublicMessage((PublicModel) role);
} else {
return null;
}
}
protected override void HandleRoleChanged(object sender, PropertyEventArgs e)
{
using(Synchronizer.Lock(this.m_Model.Participant.SyncRoot)) {
if(this.m_Model.Participant.Role is PublicModel) {
this.Checked = true;
this.m_LastRole = this.m_Model.Participant.Role;
} else {
this.Checked = false;
}
}
}
/// <summary>
/// Creates a new QuickPoll and the associated slide (and deck)
/// </summary>
/// <param name="model">The PresenterModel</param>
/// <param name="role">The RoleModel</param>
public static void CreateNewQuickPoll( PresenterModel model, RoleModel role )
{
// Create the quickpoll
QuickPollModel newQuickPoll = null;
using( Synchronizer.Lock( model.ViewerState.SyncRoot ) ) {
newQuickPoll = new QuickPollModel( Guid.NewGuid(), Guid.NewGuid(), model.ViewerState.PollStyle );
}
// Add a new QuickPoll to the model
// NOTE: This should trigger a network message about the new QuickPoll
// NOTE: Need to do this first before adding the sheet otherwise the
// public display will not be able to associate the sheet with
// this quick poll.
using( model.Workspace.Lock() ) {
using( Synchronizer.Lock( (~model.Workspace.CurrentPresentation).SyncRoot ) ) {
(~model.Workspace.CurrentPresentation).QuickPoll = newQuickPoll;
}
}
// Add the quickpoll slide to the quickpoll
using( model.Workspace.Lock() ) {
using( Synchronizer.Lock( model.Participant.SyncRoot ) ) {
DeckTraversalModel qpTraversal = null;
DeckModel qpDeck = null;
// Find the first quickpoll slidedeck.
foreach( DeckTraversalModel candidate in model.Workspace.DeckTraversals ) {
if( (candidate.Deck.Disposition & DeckDisposition.QuickPoll) != 0 ) {
qpTraversal = candidate;
using( Synchronizer.Lock( qpTraversal.SyncRoot ) ) {
qpDeck = qpTraversal.Deck;
}
break;
}
}
// If there is no existing quickpoll deck, create one.
if( qpTraversal == null ) {
// Change the name of quickpoll according to the number of it
string qpName = "QuickPoll";
// NOTE: This code is duplicated in DecksMenu.CreateBlankWhiteboardDeckMenuItem.
qpDeck = new DeckModel( Guid.NewGuid(), DeckDisposition.QuickPoll, qpName );
qpDeck.Group = Network.Groups.Group.Submissions;
qpTraversal = new SlideDeckTraversalModel( Guid.NewGuid(), qpDeck );
if( model.Workspace.CurrentPresentation.Value != null ) {
using( Synchronizer.Lock( (~model.Workspace.CurrentPresentation).SyncRoot ) ) {
(~model.Workspace.CurrentPresentation).DeckTraversals.Add( qpTraversal );
}
} else {
model.Workspace.DeckTraversals.Add( qpTraversal );
}
}
// Add the slide
// TODO CMPRINCE: Associate the quickpoll with this slide
using( Synchronizer.Lock( qpDeck.SyncRoot ) ) {
// Get the Current Slide
SlideModel oldSlide;
using( Synchronizer.Lock( role.SyncRoot ) ) {
using( Synchronizer.Lock( ((InstructorModel)role).CurrentDeckTraversal.SyncRoot ) ) {
using( Synchronizer.Lock( ((InstructorModel)role).CurrentDeckTraversal.Current.SyncRoot ) ) {
oldSlide = ((InstructorModel)role).CurrentDeckTraversal.Current.Slide;
}
}
}
// Copy the values and sheets from the old slide to the new slide
using( Synchronizer.Lock( oldSlide.SyncRoot ) ) {
// Create the new slide to add
SlideModel newSlide = new SlideModel( Guid.NewGuid(), new LocalId(), SlideDisposition.Remote | SlideDisposition.StudentSubmission, DEFAULT_SLIDE_BOUNDS, oldSlide.Id );
// Make a list of image content sheets that need to be added to the deck.
List<ImageSheetModel> images = new List<ImageSheetModel>();
// Update the fields of the slide
using( Synchronizer.Lock( newSlide.SyncRoot ) ) {
newSlide.Title = oldSlide.Title;
newSlide.Bounds = oldSlide.Bounds;
newSlide.Zoom = oldSlide.Zoom;
newSlide.BackgroundColor = oldSlide.BackgroundColor;
newSlide.SubmissionSlideGuid = oldSlide.SubmissionSlideGuid;
newSlide.SubmissionStyle = oldSlide.SubmissionStyle;
// Copy all of the content sheets.
// Because ContentSheets do not change, there is no
// need to do a deep copy (special case for ImageSheetModels).
foreach( SheetModel s in oldSlide.ContentSheets ) {
newSlide.ContentSheets.Add( s );
// Queue up any image content to be added the deck below.
ImageSheetModel ism = s as ImageSheetModel;
if( ism != null )
images.Add( ism );
}
// Add the QuickPollSheet
newSlide.ContentSheets.Add( new QuickPollSheetModel( Guid.NewGuid(), newQuickPoll ) );
// Make a deep copy of all the ink sheets
foreach( SheetModel s in oldSlide.AnnotationSheets ) {
SheetModel newSheet = InkSheetModel.InkSheetDeepCopyHelper( s );
newSlide.AnnotationSheets.Add( newSheet );
// Queue up any image content to be added the deck below.
ImageSheetModel ism = s as ImageSheetModel;
if( ism != null )
images.Add( ism );
}
}
// Add the slide content to the deck.
foreach( ImageSheetModel ism in images ) {
System.Drawing.Image image = ism.Image;
if( image == null )
using( Synchronizer.Lock( ism.Deck.SyncRoot ) )
using( Synchronizer.Lock( ism.SyncRoot ) )
image = ism.Deck.GetSlideContent( ism.MD5 );
if( image != null )
qpDeck.AddSlideContent( ism.MD5, image );
}
// Add the slide to the deck.
qpDeck.InsertSlide( newSlide );
// Add an entry to the deck traversal so that we can navigate to the slide
using( Synchronizer.Lock( qpDeck.TableOfContents.SyncRoot ) ) {
TableOfContentsModel.Entry e = new TableOfContentsModel.Entry( Guid.NewGuid(), qpDeck.TableOfContents, newSlide );
qpDeck.TableOfContents.Entries.Add( e );
}
}
}
}
}
}