/// <summary>
/// Constructs a new QuickPollResultNetworkService
/// </summary>
/// <param name="sender">The message queue to use</param>
/// <param name="presentation">The PresentationModel to associate this service with</param>
/// <param name="poll">The QuickPollModel to associate this service with</param>
/// <param name="result">The QuickPollResultModel to associate this service with</param>
public QuickPollResultNetworkService( SendingQueue sender, PresentationModel presentation, QuickPollModel poll, QuickPollResultModel result )
{
this.m_Sender = sender;
this.m_Presentation = presentation;
this.m_QuickPoll = poll;
this.m_Result = result;
// Listen to changes tot he ResultString
this.m_ResultChangedDispatcher = new EventQueue.PropertyEventDispatcher( this.m_Sender, new PropertyEventHandler( this.HandleResultChanged ) );
this.m_Result.Changed["ResultString"].Add( this.m_ResultChangedDispatcher.Dispatcher );
}
public PresenterModel()
{
this.m_Stylus = null;
this.m_CurrentResult = null;
this.m_Network = new NetworkModel();
this.m_VersionExchange = new VersionExchangeModel();
/// Note: We currently assume that the ParticipantModel Guid will be different for each application invocation.
/// (In particular TCP reconnection relies on this assumption.) If we need an identifer that persists across
/// sessions, we'd need to create a new identifier for this.
ParticipantId = Guid.NewGuid();
this.m_Participant = new ParticipantModel(ParticipantId, System.Windows.Forms.SystemInformation.UserName);
this.m_Workspace = new WorkspaceModel();
this.m_Undo = new UndoModel();
this.m_ViewerState = new ViewerStateModel();
this.m_PenState = new PenStateModel();
TheInstance = this;
}
public void AddResult(QuickPollResultModel result)
{
using (Synchronizer.Lock(this.SyncRoot)) {
if (!this.QuickPollResults.Contains(result))
{
// Add the value
this.QuickPollResults.Add(result);
}
else
{
// Update the value only
QuickPollResultModel res = this.QuickPollResults[this.QuickPollResults.IndexOf(result)];
using (Synchronizer.Lock(res.SyncRoot)) {
using (Synchronizer.Lock(result.SyncRoot)) {
res.ResultString = result.ResultString;
}
}
}
this.Updated = !this.Updated;
}
}
public int IndexOf(QuickPollResultModel value)
{
return(List.IndexOf(value));
}
public QuickPollResultInformationMessage( QuickPollResultModel result )
: base(result)
{
}
public void Remove( QuickPollResultModel value )
{
List.Remove( value );
}
public QuickPollResultMessage( Message parent, SerializedPacket p )
: base(parent, p)
{
this.m_Result = ( !SerializedPacket.IsNullPacket( p.PeekNextPart() ) ) ?
new QuickPollResultModel( p.PeekNextPart() ) : null; p.GetNextPart();
}
public void Remove(QuickPollResultModel value)
{
List.Remove(value);
}
public void Insert( int index, QuickPollResultModel value )
{
List.Insert( index, value );
}
public int Add( QuickPollResultModel value )
{
return List.Add( value );
}
public QuickPollResultRemovedMessage( QuickPollResultModel result )
: base(result)
{
}
/// <summary>
/// Handles when the value of the CurrentQuickPollResult changes
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private void HandleQuickPollResultChanged( object sender, PropertyEventArgs args )
{
if( this.m_CurrentResult != null ) {
this.m_CurrentResult.Changed["ResultString"].Remove( this.m_CurrentQuickPollResultStringChangedDispatcher.Dispatcher );
}
using( Synchronizer.Lock( this.m_Model.SyncRoot ) ) {
this.m_CurrentResult = this.m_Model.CurrentStudentQuickPollResult;
if( m_CurrentResult != null ) {
this.m_CurrentResult.Changed["ResultString"].Add( this.m_CurrentQuickPollResultStringChangedDispatcher.Dispatcher );
}
}
this.HandleQuickPollValueChanged( null, null );
}
public void AddResult( QuickPollResultModel result )
{
using( Synchronizer.Lock( this.SyncRoot ) ) {
if( !this.QuickPollResults.Contains( result ) ) {
// Add the value
this.QuickPollResults.Add( result );
} else {
// Update the value only
QuickPollResultModel res = this.QuickPollResults[this.QuickPollResults.IndexOf( result )];
using( Synchronizer.Lock( res.SyncRoot ) ) {
using( Synchronizer.Lock( result.SyncRoot ) ) {
res.ResultString = result.ResultString;
}
}
}
this.Updated = !this.Updated;
}
}
/// <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
this.m_CurrentResult = null;
this.m_Model.Changed["CurrentStudentQuickPollResult"].Remove( this.m_CurrentQuickPollResultChangedDispatcher.Dispatcher );
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["AcceptingQuickPollSubmissions"].Remove( this.m_QuickPollChangedDispatcher.Dispatcher );
}
}
this.Role = null;
}
} finally {
base.Dispose( disposing );
}
this.m_Disposed = true;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="dispatcher">The event queue</param>
/// <param name="model">The presenter model</param>
public StudentQuickPollToolBarButton( ControlEventQueue dispatcher, PresenterModel model, string name, string value )
: base(dispatcher, model)
{
this.m_Model = model;
this.m_Value = value;
this.Name = name;
this.ToolTipText = name;
this.Text = name;
this.DisplayStyle = ToolStripItemDisplayStyle.Text;
// Handle the changed result string
this.m_CurrentQuickPollResultStringChangedDispatcher = new EventQueue.PropertyEventDispatcher( this.m_EventQueue, new PropertyEventHandler( this.HandleQuickPollResultChanged ) );
// This listener listens to changes in the CurrentStudentQuickPollResult field of the
// PresenterModel, when this changes we need to update the UI and attach a new listener
// to the ResultString of the model so that we can update the UI.
this.m_CurrentQuickPollResultChangedDispatcher = new EventQueue.PropertyEventDispatcher( this.m_EventQueue, new PropertyEventHandler( this.HandleQuickPollResultChanged ) );
this.m_Model.Changed["CurrentStudentQuickPollResult"].Add( this.m_CurrentQuickPollResultChangedDispatcher.Dispatcher );
using( Synchronizer.Lock( this.m_Model.SyncRoot) ) {
this.m_CurrentResult = this.m_Model.CurrentStudentQuickPollResult;
}
this.HandleQuickPollResultChanged( null, null );
// This is the listener that we will attatch to the AcceptingStudentSubmissions field
// once we've got the current presentation. We can't do this directly because
// when this button is created there is no presentation yet.
this.m_QuickPollChangedDispatcher = new EventQueue.PropertyEventDispatcher( this.m_EventQueue, new PropertyEventHandler( this.HandleQuickPollChanged ) );
// Listen for the Presentation.
// Don't call the event handler immediately (use Listen instead of ListenAndInitialize)
// because it needs to be delayed until Initialize() below.
this.m_CurrentPresentationDispatcher =
this.m_Model.Workspace.CurrentPresentation.Listen( dispatcher,
delegate( Property<PresentationModel>.EventArgs args ) {
// Remove any previous listener
if( args.Old != null ) {
if( args.Old.Owner != null ) {
using( Synchronizer.Lock( args.Old.Owner ) ) {
((InstructorModel)(((PresentationModel)(args.Old)).Owner.Role)).Changed["AcceptingQuickPollSubmissions"].Remove( this.m_QuickPollChangedDispatcher.Dispatcher );
}
}
}
// Get the new InstructorModel
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;
}
}
}
// Attach to the new AcceptingQuickPollSubmissions
if( participant != null ) {
using( Synchronizer.Lock( participant.SyncRoot ) ) {
((InstructorModel)(participant.Role)).Changed["AcceptingQuickPollSubmissions"].Add( this.m_QuickPollChangedDispatcher.Dispatcher );
}
}
// Update the UI
this.HandleQuickPollChanged( null, null );
} );
base.InitializeRole();
}
public bool Contains(QuickPollResultModel value)
{
return(List.Contains(value));
}
/// <summary>
/// Constructor
/// </summary>
public QuickPollResultMessage( QuickPollResultModel result )
: base(Guid.Empty)
{
// this.AddLocalRef( result );
this.m_Result = result;
}
public void HandleQuickPollReceived( object server, Guid ownerId, string val )
{
QuickPollResultModel result = new QuickPollResultModel( ownerId, val );
this.m_Presentation.QuickPoll.AddResult( result );
}
/// <summary>
/// Handle the receipt of this message
/// </summary>
/// <param name="context">The context of the receiver from which the message was sent</param>
protected override bool UpdateTarget( ReceiveContext context )
{
QuickPollResultModel result = this.Target as QuickPollResultModel;
if( result == null ) {
using( Synchronizer.Lock( this.m_Result.SyncRoot ) ) {
this.Target = result = new QuickPollResultModel( this.m_Result.OwnerId, this.m_Result.ResultString );
}
}
if( result != null ) {
PresentationModel presentation = (this.Parent != null && this.Parent.Parent != null) ? this.Parent.Parent.Target as PresentationModel : null;
if( presentation == null )
return false;
QuickPollModel poll = (this.Parent != null) ? this.Parent.Target as QuickPollModel : null;
if( poll == null )
return false;
using( Synchronizer.Lock( presentation.SyncRoot ) ) {
poll.AddResult( result );
}
}
// Don't want to store this as a target
return false;
}
public int Add(QuickPollResultModel value)
{
return(List.Add(value));
}
public bool Contains( QuickPollResultModel value )
{
return List.Contains( value );
}
public void Insert(int index, QuickPollResultModel value)
{
List.Insert(index, value);
}
private void SendPollResultInformation( QuickPollResultModel result, Group receivers )
{
Message message, poll, res;
message = new PresentationInformationMessage( this.m_Service.m_Presentation );
message.Group = receivers;
poll = new QuickPollInformationMessage( this.m_Service.m_QuickPoll );
poll.Group = receivers;
message.InsertChild( poll );
res = new QuickPollResultInformationMessage( result );
res.Group = receivers;
poll.InsertChild( res );
this.m_Service.m_Sender.Send( message );
}
public int IndexOf( QuickPollResultModel value )
{
return List.IndexOf( value );
}
