/// <summary> /// Updates a specific feature. /// </summary> /// <param name="update">The feature selected for update.</param> /// <returns>True if feature accepted for update. False if an update is already in progress.</returns> internal bool Run(Feature update) { // Return if we're currently updating something, or we've // hit a problem during rollforward. if (m_Cmd != null || m_Problem != null) { return(false); } // If we prevously had something selected for update, // undo any drawing that we did for it. ErasePainting(); // Remember the specified feature. m_SelectedFeature = update; // If the info dialog has not already been displayed, display it now. if (m_Info == null) { m_Info = new UpdateForm(this); m_Info.Show(); } // Get the info window to display stuff about the selected feature. m_Info.Display(m_SelectedFeature); // Leave keyboard focus with the info dialog. m_Info.Focus(); // Draw stuff. Draw(); ActiveDisplay.PaintNow(); return(true); }
override public bool Execute() { ActiveDisplay.Delete(); var images = new ImageList(); ActiveImage = images[images.Count - 1]; return(true); }
internal void FinishCommand(CommandUI cmd) { if (!Object.ReferenceEquals(cmd, m_Command)) { throw new InvalidOperationException(); } /* * if ( pCmd->GetCommandId() == ID_FILE_PRINT_WINDOW ) * { * CuiGetRectangle* pRect = dynamic_cast<CuiGetRectangle*>(pCmd); * CeVertex corners[5]; * if ( pRect->GetCorners(corners) ) * m_PrintData.SetPrintCorners(corners); * else * { * m_PrintData.SetPrintCorners(0); * m_PrintData.SetRotation(0.0); * } * } */ SetNormalCursor(); // Refresh everything from the model. This may seem a bit of an effort, considering // that many edits don't do much to the display (some don't do anything). However, // it's fast and keeps things clean in more complex cases. Do it before saving the // map model, since it gives the impression that things are more responsive than // they actually are! RefreshAllDisplays(); // Notify any check dialog (re-check all potential problems). // And repaint immediately to avoid flicker (icons wouldn't otherwise be repainted // until the idle handler gets called) if (m_Check != null) { m_Check.OnFinishOp(); ActiveDisplay.PaintNow(); } // Re-enable auto-highlighting if it was on before. if (m_IsAutoSelect < 0) { m_IsAutoSelect = -m_IsAutoSelect; } /* * if ( pCmd->GetCommandId() == ID_FEATURE_UPDATE ) * GetDocument()->OnFinishUpdate(); * else * FinishEdit((INT4)m_pCommand); * // m_pAutoSaver->FinishEdit(edid); */ m_Command.Dispose(); m_Command = null; }
protected override void OnClosing(CancelEventArgs e) { base.OnClosing(e); if (_activeDisplay != null) { _activeDisplay.DisplayDeviceChanged -= DisplayDeviceChanged; _activeDisplay.Dispose(); _activeDisplay = null; } }
public static string ShowFileDialog(ActiveDisplay activeDisplay) { OpenFileDialog openFile = new OpenFileDialog(); openFile.Multiselect = false; openFile.RestoreDirectory = true; openFile.Filter = @"PowerPoint Presentations|*.ppt"; ; if (openFile.ShowDialog() == DialogResult.OK) { return openFile.FileName; } else { return null; } }
/// <summary> /// Defines the dimensions of the text that's being added. For this to /// work, the <see cref="Entity"/> property must be defined beforehand. /// </summary> /// <param name="str">The text involved</param> /// <returns>True if dimensions set ok. False if the entity type /// was not defined, or it does not have an associated font.</returns> protected bool SetDimensions(string str) { // Confirm the entity type has been defined if (m_Entity == null) { MessageBox.Show("AddLabelUI.SetDimensions - Text type not specified."); DialFinish(null); return(false); } // Remember the text that the dimensions correspond to m_Text = str; // The entity type provides the height of the text (in point units) IFont fontInfo = m_Entity.Font; if (fontInfo == null) { fontInfo = FontInfo.Default; } // Figure out the ground height at the map's nominal scale float fontSize = fontInfo.PointSize; uint nominalScale = EditingController.Current.Project.Settings.NominalMapScale; double ht = (double)fontSize * (double)nominalScale * MathConstants.POINTSIZE_TO_METERS; // Convert into pixels on the active display float htPixels = ActiveDisplay.LengthToDisplay(ht); Font font = new Font(fontInfo.TypeFace, htPixels, fontInfo.Modifiers, GraphicsUnit.Pixel); // Get the size of the text Size proposedSize = new Size(int.MaxValue, int.MaxValue); Size size = TextRenderer.MeasureText(str, font, proposedSize, (TextFormatFlags.NoPadding | TextFormatFlags.NoClipping | TextFormatFlags.NoPrefix)); // Remember the width and height of the text, in ground units (if // we stored logical units, the meaning of the values might change // if the scale changed during label positioning). ISpatialDisplay display = ActiveDisplay; m_Width = display.DisplayToLength((float)size.Width); m_Height = display.DisplayToLength((float)size.Height); // Reset the position of the last text outline that was drawn. m_LastPos = null; return(true); }
/// <summary> /// Called by the Authority to tell this surface to detach its current display. /// </summary> /// <param name="pDisplay">The display to detach. Must be the current display.</param> internal void Authority_DetachDisplay(Display pDisplay) { // If this surface already has a display, raise an error. if (ActiveDisplay == null) { throw new Exception("Surface does not have a display attached."); } // Check the specified display is the display we want to unbind. if (pDisplay != ActiveDisplay) { throw new Exception("Surface cannot remove specified display because a different one is attached."); } // Signal the display to unbind from this. ActiveDisplay.Surface_UnbindFromSurface(this); // Remove the reference to the rendered control. // n.b. this will already likely have been called by Surface_UnbindFromSurface Display_SetVisual(null); Display_ResetVisualRenderSize(); // Set our opacity back to fully shown (defensive incase the display does not put it back). ContentOpacity = 1.0; // Uncomment this if we want transient projection surfaces. /* * // Remove the projection surface from the projection. * ProjectionRenderer.RemoveDisplay(pProjectionDisplay); */ // Set the active display pointer. ActiveDisplay = null; // Raise the event for display change. if (OnDisplayChanged != null) { OnDisplayChanged(this); } }
/// <summary> /// Handles a key up event /// </summary> /// <param name="sender">The display where the key event originated</param> /// <param name="k">Information about the event</param> public override void KeyUp(ISpatialDisplay sender, KeyEventArgs k) { // Whereas Control.ModifierKeys sees Keys.Control, the KeyUp event passes Keys.ControlKey if (k.KeyCode == Keys.ControlKey && m_Sel != null) { // Grab the selected items (if any) and merge any currently selected features. Selection s = m_Sel.Selection; FreeAreaSelectionTool(); if (s.Count > 0) { s.AddRange(this.SpatialSelection.Items); SetSelection(s); } // Ensure everything is back to normal ActiveDisplay.RestoreLastDraw(); // Force any prior selection to show m_HasSelectionChanged = true; //ActiveDisplay.PaintNow(); } }
/// <summary> /// Cancels all updates. /// </summary> internal void Cancel() { // No can do if an update is currently in progress! if (m_Cmd != null) { string msg = "You are in the middle of making an update." + System.Environment.NewLine; msg += "You must cancel that first."; MessageBox.Show(msg); return; } // If we've currently got a problem, treat the cancellation // request as a request to undo just the last revision if (m_CurrentUpdate != null) { m_CurrentUpdate.RevertChanges(); m_CurrentUpdate = null; m_Problem = null; CadastralMapModel model = CadastralMapModel.Current; model.EnsureFeaturesAreIndexed(); model.CleanEdit(); if (m_SelectedFeature != null) { Run(m_SelectedFeature); } m_Info.OnFinishUpdate(null); ActiveDisplay.Redraw(); } else { // If we saved any updates, undo them all. UndoAll(); FinishCommand(); } }
/// <summary> /// Indicates that any painting previously done by a command should be erased. This /// tells the command's active display that it should revert the display buffer to /// the way it was at the end of the last draw from the map model. Given that a command /// supports painting, it's <c>Paint</c> method will be called during idle time. /// </summary> void ErasePainting() { ActiveDisplay.RestoreLastDraw(); }
public MainWindow() { InitializeComponent(); _activeDisplay = new ActiveDisplay(); }