C# 클래스 SIL.FieldWorks.Common.Framework.DetailControls.DataTree

Calls ApplyLayout for each child of the argument node.

Apply a layout to an object, producing the specified slices.

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.

Throw if the IsDisposed property is true

Create slices for the specified object by finding a relevant template in the spec.

Resume the layout of this window and its immediate children. This version also maintains a count, and does not resume until the number of resume calls balances the number of suspend calls.

Suspend the layout of this window and its immediate children. This version also maintains a count, and does not resume until the number of resume calls balances the number of suspend calls.

See BeginSequentialBlock.

This version expands nulls but not dummy slices. Dummy slices should know their indent.

Try to find a slice that matches the information gleaned from another slice, probably one that has been disposed since the information was obtained. If there's a following slice that matches except for the object id, return that slice as well.

This is used by DTMenuHandler.OnDataTreeCopy() whenever creating the copy causes the data tree to be rebuilt. See FWR-2123 for motivation.

A rather inefficient way of finding the ID of the class that has a particular name. IFwMetaDataCache should be enhanced to provide this efficiently.

Get the context menu that would be displayed for a right click on the slice.

Moves the focus to the first visible slice in the tree

Moves the focus to the next visible slice in the tree

Moves the focus to the previous visible slice in the tree

Return the index of the slice which contains the given y position.

This is the initialize that is normally used. Others may not be extensively tested.

Set up monitoring, so that a change to this property will trigger reconstructing the current set of slices.

Respond to a broadcast message. This is needed to fix LT-9713 and LT-9714.

Implement the "Demote..." command.

See if it makes sense to provide the "Demote..." command.

Influence the display of a particular command by giving an opinion on whether we are prepared to handle the corresponding "InsertItemViaBackrefVector" message.

Enable/Disable menu items for jumping to the Lexicon Edit tool and applying a column filter on the Anthropology Category the user has right clicked on.

Enable/Disable menu items for jumping to the Notebook Edit tool and applying a column filter on the Anthropology Category the user has right clicked on.

Enable menu items for jumping to the concordance (or lexiconEdit) tool.

This property may be turned on and off any time a DataTree is an active colleague.

Called by reflection when a new object is inserted into the list. A change of current object should not ALWAYS make the data tree take focus, since that can be annoying when editing in the browse view (cf LT-8211). But we do want it for a new top-level list object (LT-8564). Also useful when we refresh the list after a major change to make sure something gets focused.

This is triggered by any command whose message attribute is "InsertItemViaBackrefVector"

Handle jumping to the lexiconEdit tool and filtering on the Anthropology Category the user has right clicked on.

Handle jumping to the NotebookEdit tool and filtering on the Anthropology Category the user has right clicked on.

Handle enabled menu items for jumping to another tool, or another location in the current tool.

Receives the broadcast message "PropertyChanged"

Process the message to allow setting/focusing CurrentSlice.

This method is the implementation of IRefreshableRoot, which FwXWindow calls on all children to implement Refresh. The DataTree needs to reconstruct the list of controls, and returns true to indicate that children need not be refreshed.

Refresh your contents. We try to re-use as many slices as possible, both to improve performance, and so as to preserve expansion state as much as possible.

If the DataTree's slices call this method, they should use 'false', or they will be disposed when this call returns to them.

For sure make the CurrentSlice if any visible. If possible also make the prececing summary slice visible. Then make as many as possible of the slices which are children of that summary visible.

Set the handler which will be invoked when the user right-clicks on the TreeNode portion of a slice, or for some other reason we need the context menu.

Shows the specified object and makes the slices for the descendant object visible.

This is the guts of ApplyLayout, but it has extra arguments to allow it to be used both to actually produce slices, and just to query whether any slices will be produced.

Clean up any resources being used.

Used both by main layout routine and also by OnPaint to make sure all visible slices are real. For full layout, clipRect is meaningless.

initialization for when you don't actually know what you want to show yet (and aren't going to use XML)

subclasses override for setting a default current slice.

Intended to be called by Datatree.FieldAt just before it creates a new slice.

Tests to see if it should add the field (IfData), then adds the field.

Converts a List of integers into a comma-delimited string of numbers.

Create slices appropriate for current root object and layout, reusing any existing slices, and clearing out any that remain unused. If it is for a different object, reuse is more limited.

Append to the part refs of template a suitable one for each custom field of the class of obj.

Ensure that the reused slice is in the re-generated position. if not, it may have shifted position as a result of changing its sequence order in the database (e.g. via OnMoveUpObjectInSequence).

Fixes the record list to cope with operations in detail pane that radically changes the current record.

For some strange reason, the first Controls.SetChildIndex doesn't always put it in the specified index. The second time seems to work okay though.

This seems a bit clumsy, but the metadata cache now throws an exception if the class id/field name pair isn't valid for GetFieldId2(). Limiting this to only one throw per class/field pair seems a reasonable compromise. To avoid all throws would require duplicating much of the metadata cache locally.

Common logic shared between OnDisplayJumpToTool and OnJumpToTool. forEnableOnly is true when called from OnDisplayJumpToTool.

Get a label-like attribute for the slice.

Find a suitable abbreviation for the given label.

Look for a reusable slice that matches the current path. If found, remove from map and return; otherwise, return null.

Get the template that should be used to display the specified object using the specified layout.

Answer the height that the slice at index ind is considered to have. If it is null return the default size.

This parses the label attribute in order to return a label from a specified field name. Currently only recognizes "$owner" to recognize the owning object, this could be expanded to include $obj or other references.

Answer true if the second slice is a 'child' of the first (common key)

Make a slice visible, either because it needs to be drawn, or because it needs to be focused.

Process a top-level child of a layout (other than a comment). Currently these are part nodes (with ref= indicating the part to use) and sublayout nodes.

Handle one (non-comment) child node of a template (or other node) being used to create slices. Update insertPosition to indicate how many were added (it also specifies where to add). If fTestOnly is true, do not update insertPosition, just return true if any slices would be created. Note that this method is recursive indirectly through ProcessPartChildren().

Use with care...if it's a real slice, or a real one being replaced, there are other things to do like adding to or removing from container. This is mainly for messing with dummy slices.

Go through each slice until we find one that needs to update its display. Helpful for reusable slices that don't get updated through RefreshList();

this should ONLY be called from slice.Dispose(). It makes sure that when a slice is removed by disposing it directly it gets removed from the Slices collection.

Removes a slice but does NOT clean up tooltips; caller should do that.

Resets the TabIndex for all slices that are located at, or above, the startingIndex.

Answer true if the two slices are displaying fields of the same object. Review: should we require more strictly, that the full path of objects in their keys are the same?

Find the first slice in the list which is (still) one of your current, valid slices and which is able to take focus, and give it the focus.

Build a list of flids needed to expand to the slice displaying hvoOwner.

Owning Flids may not be enough. We may need reference flids as well. This is tricky, since this is called where the slice itself isn't known.