public StylusEntry(DrawingAttributes atts, StylusModel stylus, string toolTipText, PenType pt) { if (atts == null) throw new ArgumentNullException("atts"); if (stylus == null) throw new ArgumentNullException("stylus"); this.DrawingAttributes = atts; this.Stylus = stylus; this.ToolTipText = toolTipText; this.PenType = pt; }
/// <summary> /// Constructor /// </summary> /// <param name="dispatcher">The event queue</param> /// <param name="stylus">The stylus model</param> /// <param name="model">The presenter model</param> public StylusToolBarButton(ControlEventQueue dispatcher, StylusModel stylus, PresenterModel model) { this.m_EventQueue = dispatcher; this.m_Stylus = stylus; this.m_Model = model; this.m_StylusChangedDispatcher = new EventQueue.PropertyEventDispatcher(this.m_EventQueue, new PropertyEventHandler(this.HandleStylusChanged)); this.m_Model.Changed["Stylus"].Add(this.m_StylusChangedDispatcher.Dispatcher); // Initialize the Pushed state. this.m_StylusChangedDispatcher.Dispatcher(null, null); }
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; }
/// <summary> /// Handle the stylus changing /// </summary> /// <param name="sender">The event sender</param> /// <param name="args">The event arguments</param> private void HandleStylusChanged(object sender, PropertyEventArgs args) { bool enable; Color color; using(Synchronizer.Lock(this.m_Model.SyncRoot)) { if(this.m_Model.Stylus != null && this.m_Table.ContainsKey(this.m_Model.Stylus)) { using( Synchronizer.Lock( this.m_Model.Stylus.SyncRoot ) ) { color = this.m_Model.Stylus.DrawingAttributes.Color; } using (Synchronizer.Lock(this.m_Model.ViewerState.SyncRoot)) { if (this.m_Model.ViewerState.UseLightColorSet) { if (color == Color.Black) { color = Color.White; } else if (color == Color.Red) { color = Color.Pink; } else if (color == Color.Green) { color = Color.LightGreen; } else if (color == Color.Blue) { color = Color.LightBlue; } } else { if (color == Color.White) { color = Color.Black; } else if (color == Color.LightBlue) { color = Color.Blue; } else if (color == Color.Pink) { color = Color.Red; } else if (color == Color.LightGreen) { color = Color.Green; } } } using( Synchronizer.Lock( this.m_Model.Stylus.SyncRoot ) ) { if (color != this.m_Model.Stylus.DrawingAttributes.Color) this.m_Model.Stylus.DrawingAttributes.Color = color; } // In addition to enabling the button, update the current stylus // and DrawingAttributes (possibly causing redrawing the bitmap). this.m_CurrentStylus = this.m_Model.Stylus; this.HandleDrawingAttributesChanged(this.m_Model.Stylus, null); enable = true; } else { enable = false; } } this.Enabled = enable; }
/// <summary> /// Handle the stylus changing /// </summary> /// <param name="sender">The event sender</param> /// <param name="args">The event args</param> private void HandleStylusChanged( object sender, PropertyEventArgs args ) { bool enable; using( Synchronizer.Lock( this.m_Model.SyncRoot ) ) { if( this.m_Model.Stylus != null && this.m_Table.ContainsKey( this.m_Model.Stylus ) ) { // In addition to enabling the button, update the current stylus // and DrawingAttributes (possibly causing redrawing the bitmap). if (m_Model.Stylus is PenStylusModel) { this.m_CurrentStylus = (PenStylusModel)this.m_Model.Stylus; } else { this.m_CurrentStylus = (TextStylusModel)this.m_Model.Stylus; } this.HandleDrawingAttributesChanged( this.m_Model.Stylus, null ); enable = true; } else { enable = false; } } this.Enabled = enable; }
/// <summary> /// Updates the current stylus, registers and unregisters event listeners, and /// creates the edit textboxes when the current stylus is a TextStylusModel. /// </summary> private void SetCurrentStylus(StylusModel stylus) { // Unregister any existing event listeners. if (current_stylus_ != null) current_stylus_.Changed["DrawingAttributes"].Remove(stylus_color_listener_.Dispatcher); current_stylus_ = stylus; if( current_stylus_ != null && stylus_color_listener_ != null ) current_stylus_.Changed["DrawingAttributes"].Add( stylus_color_listener_.Dispatcher ); ///only change text settings if our page can be edited. ///and if we actually have a slide :P /// if (!editable_page_ || this.Slide == null) { return; } if (current_text_helper_ != null) { current_text_helper_.Dispose(); } if (current_image_helper_ != null) { current_image_helper_.Dispose(); } // Change UI if we are dealing with Images (change cursor, add collection helper if (stylus is ImageStylusModel) { this.Cursor = Cursors.Default; current_image_helper_ = new ImageItCollectionHelper(this, this.Slide); } else if (stylus is EraserStylusModel) { // Use an eraser cursor when the eraser is selected. this.Cursor = Cursors.Cross; } else { this.Cursor = Cursors.Default; } // Change UI if we are going to be adding text. if (stylus is TextStylusModel) { ///we are in text editing mode, so we need to change the stylus and editing mode editing_text_ = true; this.Cursor = Cursors.IBeam; //Remove the sheets that just represent empty text boxes. for (int i = Slide.AnnotationSheets.Count - 1; i >= 0; i--) { bool remove = false; SheetModel s = Slide.AnnotationSheets[i]; using (Synchronizer.Lock(s.SyncRoot)) { if (s is TextSheetModel) { using (Synchronizer.Lock(((TextSheetModel)(s)).Text)) { if (((TextSheetModel)(s)).Text == "") { remove = true; } } } } if (remove) { using (Synchronizer.Lock(Slide.SyncRoot)) { using (Synchronizer.Lock(Slide.AnnotationSheets)) { Slide.AnnotationSheets.Remove(s); } } } } current_text_helper_ = new TextItBoxCollectionHelper(this, this.Slide); TextStylusModel.GetInstance().Changed["Font"].Add(this.HandleStylusFontChanged); } else { editing_text_ = false; } }
internal StylusData(StylusModel stylus, DrawingAttributes atts) { this.m_Stylus = stylus; this.m_DrawingAttributes = atts; }
private void HandleStylusChanged(object sender, PropertyEventArgs args) { using(Synchronizer.Lock(this.m_Model.SyncRoot)) { this.Stylus = this.m_Model.Stylus; } }
protected virtual void Dispose(bool disposing) { if(this.m_Disposed) return; if(disposing) { this.m_Model.Changed["Stylus"].Remove(new PropertyEventHandler(this.HandleStylusChanged)); // Unregister the stylus event listeners via the Stylus setter. this.Stylus = null; } this.m_Disposed = true; }