C# Class SIL.FieldWorks.Common.RootSites.SimpleRootSite

In DetailViews there are some root boxes which are created but (because scrolled out of view) never made visible. In certain circumstances, as their containers are disposed, something gets called that may cause calls to methods like OnLoad or OnHandleCreated. When we know a root site is about to become garbage, we want these methods to do as little as possible, both for performance and to prevent possible crashes as windows are created for (e.g.) objects that have been deleted.

By default this does nothing. Override to, for example, enable the 'Selection' button. See XmlSeqView for an example.

Adjust the scroll range when some lazy box got expanded. Needs to be done for both panes if we have more than one.

Return the internal rootbox as a list, or an empty list.

Begin a block of code which, even though it is not itself a message handler, should not be interrupted by other messages that need to be sequential. This may be called from within a message handler. EndSequentialBlock must be called without fail (use try...finally) at the end of the block that needs protection.

Allows the IRootSite to be cast as an IVwRootSite

This method is designed to be used by classes whose root object may be determined after the window's handle is created (when MakeRoot is normally called) and may be subsequently changed. It is passed the required arguments for SetRootObject, and if the root box already exists, all it does is call SetRootObject. If the root box does not already exist, it calls MakeRoot immediately, and arranges for the root box so created to be laid out, since it is possible that we have 'missed our chance' to have this happen when the window gets its initial OnSizeChanged message.

Throw if the IsDisposed property is true

Member ClientToScreen

Subclasses should override CloseRootBox if something else is still using it after the window closes. In that case the subclass should do nothing.

Return an indication of the behavior of some of the special keys (arrows, home, end).

Physical behavior means that left arrow key goes to the left regardless of the direction of the text; logical behavior means that left arrow key always moves the IP one character (possibly plus diacritics, etc.) in the underlying text, in the direction that is to the left for text in the main paragraph direction. So, in a normal LTR paragraph, left arrow decrements the IP position; in an RTL paragraph, it increments it. Both produce a movement to the left in text whose direction matches the paragraph ("downstream" text). But where there is a segment of upstream text, logical behavior will jump almost to the other end of the segment and then move the 'wrong' way through it.

Cause the immediate update of the display of the root box. This should cause all pending paint operations to be done immediately, at least for the screen area occupied by the root box. It is typically called after processing key strokes, to ensure that the updated text is displayed before trying to process any subsequent keystrokes.

See BeginSequentialBlock.

If there is a pending writing system that should be applied to typing, return it; also clear the state so that subsequent typing will not have a pending writing system until something sets it again. (This is mainly used so that keyboard-change commands can be applied while the selection is a range.)

Get the width available for laying things out in the view. Return the layout width for the window, depending on whether or not there is a scroll bar. If there is no scroll bar, we pretend that there is, so we don't have to keep adjusting the width back and forth based on the toggling on and off of vertical and horizontal scroll bars and their interaction. The return result is in pixels. The only common reason to override this is to answer instead a very large integer, which has the effect of turning off line wrap, as everything apparently fits on a line. N.B. If it is necessary to override this, it is not advisable to use Int32.MaxValue for fear of overflow caused by VwSelection::InvalidateSel() adjustments.

Get a graphics object in an appropriate state for drawing and measuring in the view. The calling method should pass the IVwGraphics back to ReleaseGraphics() before it returns. In particular, problems will arise if OnPaint() gets called before the ReleaseGraphics() method.

REVIEW JohnT(?): We probably need a better way to handle this. Most likely: make the VwGraphics object we cache a true COM object so its reference count is meaningful; have this method create a new one. Problem: a useable VwGraphics object has a device context that is linked to a particular window; if the window closes, the VwGraphics is not useable, whatever its reference count says. It may therefore be that we just need to allocate a copy in this method, leaving the member variable alone. Or, the current strategy may prove adequate.

Gets objects known to this site that can handle xCore command messages. For rootsite, the only such object it knows about is itself.

Get the primary rectangle occupied by a selection (relative to the top left of the client rectangle).

Get a selection at the indicated point (as in MouseEventArgs.Location). If fInstall is true make it the active selection.

Get a selection at the indicated point.

Get a transform for a given destination point...same for all points in this simple case.

Get a transform for a given layout point...same for all points in this simple case.

If a particular rootsite needs to do something special for putting the current selection on the keyboard, implement this method to do it, and have it return the filled-in ITsString object. See LT-9475 for justification.

Gets the writing system for the HVO. This could either be the vernacular or analysis writing system.

Use this method instead of ScrollToEnd if you need to go to the end of the view programmatically (not in response to a Ctrl-End). The code for handling Ctrl-End uses CallOnExtendedKey() in OnKeyDown() to handle setting the IP.

When the user has selected a keyboard from the system tray, adjust the language of the selection to something that matches, if possible.

Finds the distance between the scroll position and the IP (i.e. the distance between the top of the window and the IP).

Allows xCore-specific initialization. We don't need any.

Invalidate the pane because some lazy box expansion messed up the scroll position. Made a separate method so we can override.

Invalidate rectangle

Checks input characters to see if they should be processsed. Static to allow function to be shared with PublicationControl.

Answer whether boxes in the specified range of destination coordinates may usefully be converted to lazy boxes. Should at least answer false if any part of the range is visible. The default implementation avoids converting stuff within about a screen's height of the visible part(s).

Checks if selection is visible. For a range selection we check the end of the selection, for an IP the entire selection must be visible.

This version doesn't test the secondary part of the selection if the combined primary and secondary selection is higher or wider then the ClientRectangle.

Checks if selection is visible. For a range selection (that is not a picture) we check the end of the selection, otherwise the entire selection must be visible.

Checks if selection is visible, according to the parameters.

This version doesn't test the secondary part of the selection if the combined primary and secondary selection is higher or wider then the ClientRectangle.

This method tests that the selection rectangle is inside of the client rectangle, but it doesn't test if the selection is actually enabled!

Override this method in your subclass. It should make a root box and initialize it with appropriate data and view constructor, etc.

Performs the same coordinate transformation as C++ UtilRect rcSrc.MapXTo(x, rcDst).

Performs the same coordinate transformation as C++ UtilRect rcSrc.MapYTo(y, rcDst).

Called (by xcore) to control display params of the Styles menu, e.g. whether it should be enabled

Called when XCore wants to display something that relies on the list with the id "CombinedStylesList"

Called (by xcore) to control display params of the writing system menu, e.g. whether it should be enabled

Handle Print command

see OnInsertDiffParas

This is equivalent. These two names accommodate two conventions for naming commands...xCore labels commands just with what they do, TE includes the menu name.

The user has attempted to delete something which the system does not inherently know how to delete. The dpt argument indicates the type of problem.

Receives the xcore broadcast message "PropertyChanged"

Required by interface, but not used, because we don't user the MessageSequencer to sequence OnPaint calls.

Processes Windows messages.

When the state of the overlays changes, it propagates this to its site.

Executed on the Application Idle queue, this method invalidates the whole view. It is used when we cannot properly complete a paint because we detect that it is a recursive call, to ensure that the window is eventually painted properly.

This is a major kludge to prevent a spurious WM_KEYUP for VK_CONTROL from interrupting a mouse click. If mouse button was pressed elsewhere causing this root site to loose focus, this message filter is installed to throw away the spurious WM_KEYUP for VK_CONTROL that happens as a result of switching to the default keyboard layout. See OnKillFocus for the corresponding code that installs this message filter.

Perform any processing needed immediately prior to a paste operation. This is very rarely implemented, but always called by EditingHelper.PasteClipboard.

Helper method to allow for standard error reporting when something goes wrong during printing of the contents of a rootsite.

Refreshes the Display :)

Inform the container when done with the graphics object.

REVIEW JohnT(?): could we somehow have this handled by the Release method of the IVwGraphics? But that method does not know anything about the status or source of its hdc.

An error has occurred during drawing, and the component in which it occurred should have recorded a system error information object describing the problem

If we need to make a selection, but we can't because edits haven't been updated in the view, this method requests creation of a selection after the unit of work is complete. Derived classes should implement this if they have any hope of supporting multi- paragraph editing.

If we need to make a selection, but we can't because edits haven't been updated in the view, this method requests creation of a selection after the unit of work is complete. It will also scroll the selection into view. Derived classes should implement this if they have any hope of supporting multi- paragraph editing.

Notifies the site that the size of the root box changed; scroll ranges and/or window size may need to be updated. The standard response is to update the scroll range.

Review JohnT: might this also be the place to make sure the selection is still visible? Should we try to preserve the scroll position (at least the top left corner, say) even if the selection is not visible? Which should take priority?

Member ScreenToClient

Scrolls the selection into view, positioning it as requested

Scroll the selection in to the given client position.

Scroll to the bottom. This is somewhat tricky because after scrolling to the bottom of the range as we currently estimate it, expanding a closure may change things. GoToEnd

Scroll to the top

Make a selection that includes all the text.

Notifies the site that something about the selection has changed.

Don't you dare make this virtual!

Set the accessible name that the root box will return for this root site.

Show the context menu for the specified root box at the location of its selection (typically an IP).

Find out if this RootSite had Focus before being grabbed by some other entity (such as a Windows ComboBox)

Needs a cache in order to provide a meaningful implementation. SimpleRootsite does not know how to handle GUIDs so just return an empty GUID which will cause the run to be deleted.

Real drawing VG same as layout one for simple view.

Return true if this kind of window uses semi-tagging.

Needs a cache in order to provide a meaningful implementation. SimpleRootsite should never have objects cut, copied, pasted.

Adjust the scroll range when some lazy box got expanded. This is rather similar to SizeChanged, but is used when the size changed as a result of recomputing something that is invisible (typically about to become visible, but not currently on screen). Thus, the scroll bar range and possibly position need adjusting, but it isn't necessary to actually redraw anything except the scroll bar--unless the scroll position is forced to change, because we were in the process of scrolling to somewhere very close to the end, and the expansion was smaller than predicted, and the total range is now less than the current position.

The ScrollableControl.DisplayRectangle determines the scroll range. To set it, you have to set ScrollableControl.AutoScrollMinSize and do a PerformLayout.

Call MouseDblClk on rootbox

Call MouseDown on the rootbox

Call MouseDownExtended on the rootbox

Call MouseMoveDrag on the rootbox

Call MouseUp on the rootbox

Return true if a paint needs to be aborted because something like a paint or layout is already in progress. Arranges for a postponed paint if so.

Return a wrapper around the COM IAccessible for the root box.

Creates a new EditingHelper of the proper type.

Creates the graphics manager.

We do this in a method for testing.

The default creates a normal horizontal orientation manager. Override to create one of the other classes as needed.

Creates a new selection restorer.

Overriding this method to return null will keep the selection from being restored

Clean up any resources being used.

Overide this to provide a context menu for some subclass.

Lay out your root box. If nothing significant has changed since the last layout, answer false; if it has, return true. Assumes that m_graphicsManager.VwGraphics is in a valid state (having a DC).

We assume that the VwGraphics object has already been setup for us

Draw to the given clip rectangle.

OPTIMIZE JohnT: pass clip rect to VwGraphics and make use of it.

Makes a default selection if no selection currently exists in our RootBox.

Makes a default selection if no selection currently exists in our RootBox.

Fill in the list of style names.

Construct coord transformation rectangles. Height and width are dots per inch. src origin is 0, dest origin is controlled by scrolling.

This function returns a selection that includes the entire LinkedFile link at the current insertion point. It doesn't actually make the selection active. If the return value is false, none of the paramters should be looked at. If pfFoundLinkStyle is true, ppvwsel will contain the entire LinkedFiles Link string and pbstrFile will contain the filename the LinkedFiles link is pointing to. If pfFoundLinkStyle is false, the selection will still be valid, but it couldn't find any LinkedFiles link at the current insertion point. If ppt is not NULL, it will look for an LinkedFiles Link at that point. Otherwise, the current insertion point will be used.

Unless overridden, this will return a value indicating that range selections should be hidden.

get the writing systems we should consider as candidates to be selected whent the user makes an external choice of keyboard. overridden in root site to use only active ones.

Default is to print the exact same thing as displayed in the view, but subclasses (e.g., ConstChartBody) can override.

Returns the scroll position. Values are positive.

Returns the ShiftStatus that shows if Ctrl and/or Shift keys were pressed

Position the insertion point at the page bottom

Position the insertion point at the page top

The user has chosen a keyboard combination which requests a context menu. Handle it, given the active selection and a point around the center of it.

This also helps us handle all input keys...the documentation doesn't make very clear the distinction between this and IsInputKey, but failing to override this one can cause typing in the view to invoke buttons in the parent form. If you want to remove this, make sure it doesn't mess up windows that contain both views and buttons, such as the LexText interlinear view.

IsInputChar gets called while processing WM_CHAR or WM_SYSCHAR.

Determines whether the specified key is a regular input key or a special key that requires preprocessing. Default implementation always returns true because we want to handle all keys!

IsInputKey gets called while processing WM_KEYDOWN or WM_SYSKEYDOWN.

Scroll to make the selection visible. In general, scroll the minimum distance to make it entirely visible. If the selection is higher than the window, scroll the minimum distance to make it fill the window. If the window is too small to show both primary and secondary, show primary.

Note: subclasses for which scrolling is disabled should override. If sel is null, make the current selection visible.

Scroll to make the selection visible. In general, scroll the minimum distance to make it entirely visible. If the selection is higher than the window, scroll the minimum distance to make it fill the window. If the window is too small to show both primary and secondary, show primary. If fWantOneLineSpace is true we make sure that at least 1 line is visible above and below the selection. By default ranges (that are not pictures) are allowed to be only partly visible.

Scroll to make the selection visible. In general, scroll the minimum distance to make it entirely visible. If the selection is higher than the window, scroll the minimum distance to make it fill the window. If the window is too small to show both primary and secondary, show primary. If fWantOneLineSpace is true we make sure that at least 1 line is visible above and below the selection.

Note: subclasses for which scrolling is disabled should override. If the selection is invalid, return false.

This hook provides an opportunity for subclasses to move child windows. For example, InterlinDocChild moves its Sandbox window to correspond to the position of the selected word in the text. It may be important to do this before updating the scroll range...for example, Windows forms may not allow the scroll range to be less than enough to show the whole of the (old position of) the child window.

Process mouse double click

Handle the Edit/Select All menu command.

Called when the editing helper is created.

View is getting focus: Activate the rootbox and set the appropriate keyboard

The window is first being created.

Do cleaning up when handle gets destroyed

Formerly AfVwRootSite::OnReleasePtr()

User pressed a key.

Handles OnKeyPress. Passes most things to EditingHelper.OnKeyPress

Clean up after page scrolling.

Called when the focus is lost to another window.

Recompute the layout

Required method to implement the LayoutSizeChanged event.

Process left or right mouse button down

Process mouse move

Allow clients to override cursor type during OnMouseMove.

Process mouse button up event

Call Draw() which does all the real painting

Ignore the PaintBackground event because we do it ourself (in the views code).

Process right mouse button up (typically show a context menu). Was mouse Down in an earlier life, but we concluded that the usual convention is context menu on mouse up. There may be vestiges.

We intercept WM_SETFOCUS in our WndProc and call this because we need the information about the previous focus window, which .NET does not provide.

Size changed. Ensure that the selection is still visible.

Flash the insertion point.

When we go visible and we are waiting to refresh the display (do a rebuild) then call RefreshDisplay()

Adjust a point to view coords from device coords. This is the translation from a point obtained from a windows message like WM_LBUTTONDOWN to a point that can be passed to the root box. Currently it does nothing, as any conversion is handled by the source and destination rectangles passed to the mouse routines. It is retained for possible future use.

Wraps PrepareToDraw calls so as to suppress attempts to paint or any similar re-entrant call we might make while getting ready to do it.

Override to provide default handling of Context manu key.

Save some selection location information if needed.

Scroll by the specified amount (positive is down, that is, added to the scroll offset). If this would exceed the scroll range, move as far as possible. Update both actual display and scroll bar position. (Can also scroll up, if dy is negative. Name is just to indicate positive direction.)

Gets the rectangle of the selection. If it is a split selection we combine the two rectangles.

If help is available for the print dialog, set ShowHelp to true, and add an event handler that can display some help. See DraftView in TeDll for an example.

Update the scroll range with the new range and position.

Update your scroll range to reflect current conditions.

Override the WndProc to handle WM_GETOBJECT so we can return the IAccessible implementation from the root box, rather than wrapping it as an AccessibleObject in .NET style. This is important because the test harness wants to be able to get back to the root box. There are a couple of other messages we must handle at this level as well. This override is now delegated through the message sequencer; see OriginalWndProc.

Some situations lead to invalidating very large rectangles. Something seems to go wrong if they are way bigger than the client rectangle. Finding the intersection makes it more reliable.

Allow the orientation manager to convert arrow key codes.

Get a graphics object in an appropriate state for drawing and measuring in the view. The calling method should pass the IVwGraphics back to ReleaseGraphics() before it returns. In particular, problems will arise if OnPaint() gets called before the ReleaseGraphics() method.

Make sure the graphics object has a DC. If it already has, increment a count, so we know when to really free the DC.

Required method for Designer support - do not modify the contents of this method with the code editor.

This is called in Layout to notify the VC of anything it needs to know.

Creates the root site event handler.

Uninitialize the graphics object by releasing the DC.

Updates the state of the selection (enabled/disabled).