JetBrains.Platform.UIInteractive.Shell

AcceptDocumentControl

Interaction logic for AcceptDocumentControl.xaml

InitializeComponent

AssetControl

Interaction logic for AssetControl.xaml

InitializeComponent

JBAccountInfoControl

Interaction logic for JBAccountInfoControl.xaml

InitializeComponent

JBAccountLoginControl

Interaction logic for JBAccountLoginControl.xaml

InitializeComponent

JBAccountOAuthLoginControl

Interaction logic for JBAccountOAuthLoginControl.xaml

InitializeComponent

JBAccountPasswordLoginControl

Interaction logic for JBAccountPasswordLoginControl.xaml

InitializeComponent

ManageJBAccountControl

Interaction logic for ManageJBAccountControl.xaml

InitializeComponent

ManageJBAccountWindow

Interaction logic for ManageJBAccountWindow.xaml

InitializeComponent

ConsentOptionsControl

InitializeComponent

EnabledEntitiesControl

Interaction logic for EnabledEntitiesControl.xaml

InitializeComponent

FooterControl

Interaction logic for FooterControl.xaml

InitializeComponent

Interaction logic for StateControl.xaml

StatusIndicatorControl

InitializeComponent

EntityControl

InitializeComponent

LicenseInformationControl

Interaction logic for LicenseInformationWindow.xaml

InitializeComponent

LicenseInformationWindow

Interaction logic for LicenseInformationWindow2.xaml

InitializeComponent

LicenseServerControl

Interaction logic for LicenseServerControl.xaml

InitializeComponent

LicenseServerInfoControl

Interaction logic for LicenseServerInfoControl.xaml

InitializeComponent

ManageControl

Interaction logic for ManageControl.xaml

InitializeComponent

ManageItemControl

Interaction logic for ManageItemControl.xaml

InitializeComponent

ManageWindow

Interaction logic for ManageWindow.xaml

InitializeComponent

Interaction logic for UserContactsControl.xaml

UserContactsControl

InitializeComponent

Interaction logic for UserContactsWindow.xaml

UserContactsWindow

InitializeComponent

UserLicenseControl

InitializeComponent

Interaction logic for LicenseKeysInfoControl.xaml

TextBoxInfoControl

InitializeComponent

AccountControl

Interaction logic for AccountControl.xaml

InitializeComponent

Attachment

Interaction logic for Attachment.xaml

InitializeComponent

AttachmentsControl

Interaction logic for AttachmentsControl.xaml

InitializeComponent

FeedbackCenterControl

Interaction logic for MainWindow.xaml

InitializeComponent

ProgressControl

Interaction logic for ProgressControl.xaml

InitializeComponent

ReportControlBase

Interaction logic for ReportControlBase.xaml

InitializeComponent

ResultControl

Interaction logic for MainWindow.xaml

InitializeComponent

Required designer variable.

Clean up any resources being used.

true if managed resources should be disposed; otherwise, false.

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

Required designer variable.

Clean up any resources being used.

true if managed resources should be disposed; otherwise, false.

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

Interaction logic for UserIdentifierControl.xaml

UserIdentifierControl

InitializeComponent

Interaction logic for MainWindow.xaml

UserIdentifierWindow

InitializeComponent

Interaction logic for UserNameAccountControl.xaml

UserNameAccountControl

InitializeComponent

Interaction logic for YouTrackTokenAuthorizationControl.xaml

YouTrackTokenAuthorizationControl

InitializeComponent

FeedbackReportControl

Interaction logic for FeedbackReportControl.xaml

InitializeComponent

ProblemReportControl

Interaction logic for ProblemReportControl.xaml

InitializeComponent

ActionSystemUIPlayground

Interaction logic for ActionSystemUIPlayground.xaml

InitializeComponent

ControlShowcaseView

Interaction logic for ControlShowcaseView.xaml

InitializeComponent

BrushesResourceDictionary

InitializeComponent

ColorsResourceDictionary

InitializeComponent

GenericDictionary

InitializeComponent

BooleanEditorResourceDictionary

InitializeComponent

DialogEditorResourceDictionary

InitializeComponent

EnumEditorResourceDictionary

InitializeComponent

ExtendedEditorResourceDictionary

InitializeComponent

InvalidEditorResourceDictionary

InitializeComponent

StringEditorResourceDictionary

InitializeComponent

ModelPropertyPanelResourceDictionary

InitializeComponent

ToolboxResourceDictionary

InitializeComponent

ButtonView

InitializeComponent

PairStringCollectionEditView

InitializeComponent

StringCollectionEditView

InitializeComponent

Layouter and renderer interface that handles the presentation for the . Directed and invoked by .

Gets the item this presentation handler is attached to.

Gets or sets the location. Must be set before calling the method.

Gets the actual size of the item at the current moment, as obtained after the last , according to which the item is about to . Flags affect the upper margin size.

Performs a hit-test of the menu item.

First (bottom-up) part of the layout: the preferred sizes are being collected. Calculates the per-column preferred size of the menu item. Should be called before on any change.

A device context to measure the text against. Cached dimensions for the item, for its current DPI. Gets the rendering parameters to be used while rendering or measuring the items text, as per the current dynamic DPI. Non thread-safe. You CAN and MUST set up all of the color parameters over this instance each time before the paint call (measure does not care). Returns an array of preferred sizes for each of the cells defined.

Performs the top-down part of the layout, when the item receives some size it should layout itself into. Should be called after .

The available size for layouting each of the cells into. A device context to measure the text against. Cached dimensions for the item, for its current DPI. Gets the rendering parameters to be used while rendering or measuring the items text, as per the current dynamic DPI. Non thread-safe. You CAN and MUST set up all of the color parameters over this instance each time before the paint call (measure does not care). The size the item succeeded to layout into. Typically, should be equal in width to the sum of all the cell widths, and in height to the maximum height encountered.

Paints the item according to the current layout. must be called before painting to achieve a meaningful result. The painting is performed within the , at the location . Either includes or not the upper margin that constitutes the spacing between the items and makes the item asymmetric. The first item in non-scrollable menu and the standalone item presentation should not have the upper margin.

Cached dimensions for the item, for its current DPI. Gets the rendering parameters to be used while rendering or measuring the items text, as per the current dynamic DPI. Non thread-safe. You CAN and MUST set up all of the color parameters over this instance each time before the paint call (measure does not care).

A base class for the popup menu item presentations in their default rendering ("as in menu").

Menu item we're rendering.

Painting implementation. Always includes the upper margin. Works in menu-item-local coordinates.

Gets the actual size of the item at the current moment, as obtained after the last , according to which the item is about to .

Performs a vertical hit-test (checks the y-coordinate only).

Zero if hit, less than zero if the point is located above the item, and more than zero if below.

First (bottom-up) part of the layout: the preferred sizes are being collected. Calculates the per-column preferred size of the menu item. Should be called before on any change.

A device context to measure the text against. Returns an array of preferred sizes for each of the cells defined.

Performs the top-down part of the layout, when the item receives some size it should layout itself into. Should be called after .

The available size for layouting each of the cells into. A device context to measure the text against. The size the item succeeded to layout into. Typically, should be equal in width to the sum of all the cell widths, and in height to the maximum height encountered.

Gets the item this presentation handler is attached to.

Gets or sets the location. Must be set before calling the method.

A class with dimension constants. See the layout image for meanings.

Width of the gap between the icon column and its bulk fill.

The minimum size under which it's not desirable to shrink the label.

Width of the left&right margins, height of the upper margin. Don't use this directly, instead, see the property that sets the margin height to zero for the first item.

Height of the separator.

Minimal gap between the menu item text and its mnemonic on the right.

Width of the tail glyph separator (for an execute-or-expand item).

Margin around the tail glyph (separates it from selection rect on the right and separator on the left).

The resolution of the item presentation.

Extra margin for the new UI - top and right from the label.

Extra margin for the new UI - between a left border and the icon.

Horizontal inset of selection from left/right edges in the new UI.

New UI flag.

Implements the Mainpart sub-control of the .

The scroll timer interval in case a mouse button (left or right) is down.

The scroll timer interval in case neither left nor right mouse button is down.

Index of the last visible item in the scrolling view. -1 means it has not been initialized yet.

The pre-rendered lower-scroller arrow, disabled state.

The pre-rendered lower-scroller arrow, enabled state.

The pre-rendered upper-scroller arrow, disabled state.

The pre-rendered upper-scroller arrow, enabled state.

After performing the first layouting, stores the menu-item-column-widths.

Collects the indices of dirty items that have to be repainted on the next paint iteration. The usual GetUpdateRgn mechanisms do not take scrolling into account correctly.

Caches the drop-shadow-enabled state, as it must be maintained constant between calc-sizes, but should update from time to time. Synced to OS settings on each .

After the mapping between items and views is established by , contains the up-to-date mapping from document items to item views.

Set by the depending on whether it has successfully processed the key-down message as a mnemonic, or not. If False, the should try looking up a mnemonic by char also, in addition to the key-down's v-key.

Caches the value so that the scroll ranges could be adjusted when the menu client height changes.

Codebehind that implements the menu logic.

Filters out zero movements. Also, helps with telling the initial menu display from normal mouse movements.

Caches the system metric.

A token that supports implementing the readonly items.

The current precalculated layout. Created on the first top-down layouting pass.

Whether the content does not fit into the control's constrained size, and scrolling is needed to present it all.

If , represents the scrolling position — an index of the item at the top of the view.

A timer that triggers scrolling by one item. Lazily-created.

Fires when the control would like to be reasked of its desired size.

Gets the object that implements the menu logic.

Gets the first visible item in the scrolling view.

Readonly. Set to True when the keyboard navigation is being performed. If the document's selected item is being changed due to a keyboard action, this property is True when the change actually occurs.

Readonly. Set to True when the mouse navigation is being performed. If the document's selected item is being changed due to a mouse action, this property is True when the change actually occurs.

Gets the parent menu view.

Gets whether scrolling is turned on in the menu (if the items do not fit into the constrained size).

Once an item is expaned to show its popup menu, remembers that item. A non-Null value here indicates we're in expanded state, which modifies behavior a bit (eg moving mouse out does not reset selection).

Whether menu should automatically highlight search hits from the Search Host when rendering menu items.

Renders the current presentation of an item.

Checks whether such a location represents a visible item.

Adjusts the view scrolling so that the item with the given index were visible at the position specified.

Gets whether the autoscrolling mode is on, and, if yes, what it direction is.

Autoscrolling direction, if the retval is True. Otherwise, undefined. Whether autoscrolling is currently on.

Looks up a menu item hit by the given point. -1 means outside any items.

Point, in client coordinates.

Inits the UI controls, including the form itself

Sinks the document events.

All of the keyboard tooltip handling for this menu. Keyboard-tooltips: appear when items are selected with keyboard. NOTE: when not given ITooltipManager, does not enable keyboard tooltips.

Monitors the document items, maintains the item views.

When mouse is hovered over expandable items, they'd expand even without clicking.

When selection changes - announce it through screen reader

Marks the regions occupied by those items considered dirty as invalid. Helps taking scrolling into account correctly.

Causes the specified item to be repainted on the next painting cycle.

Layouts the main part that includes the part borders, menu items, scrollers, quick-search editbox, etc.

Invokes the menu items' bottom-up layouting and collects the information about max-column-widths and total-menu-width.

Maximum encountered widths for each of the columns. Height of each of the items. Total size of all the items (item height is max cells' height, item width is the sum of cell widths). A device context to measure the text against. The limit for the size, as it helps to reduce the number of calculations.

During the top-down layout session, when the menu area is already placed, layouts the menu items and scrolling arrows.

Sets the menu items' coordinates according to the scrolling position.

The scroll timer has ticked, perform the scrolling.

Does just the very painting into the given .

Device context. Rectangle in which to paint

Prerenders some of the commonly used UI elements into bitmaps.

Prerenders the bitmaps for scrolling arrows.

Resets the scroll ranges and recalculates the current scrolling position so that the selected item were visible and the scrolling pos was not beyound the last reasonable position (ie no empty space beyond the end). Should be called after loading a new set of items or after the menu client height () changes.

Scrolls the view by one item, if possible. In either case, one item is expected to appear in view after the scrolling, and zero or more items to disappear at the opposite edge. This is to the case of non-equally-sized items.

Scrolls the menu vertically by the amount given by the value, in pixels. being positive, the content slides down. Otherwise, it slides up. This method causes no repaint.

Selects a menu item that is currently under the point specified.

Checks whether the autoscrolling mode should be turned on or off, and applies the state. Safe to call more than once even in the same auto-scrolling mode. No params, as it's evident form mouse position & capture state as whether we're autoscrolling or not.

Gets the set of colors involved in painting the control.

Paints a unified rounded background for the entire mainpart area.

Raises the event.

A that contains the event data.

The non-Transparency mode painting function.

Raises the event.

The that contains the event data.

Gets or sets whether the control should be activated initially when it's shown. The typical implementation for a form is to return a negative of this value from the override.

Fires when the control would like to be reasked of its desired size.

Should process only high-priority keys.

Should process all the keys.

A static class with dimension constants. See the layout image for meanings.

Size of the scroller arrow inside the scroller area.

A width-only size that defines the minimum distance between a scroll arrow and the edge of its parent scroll area.

Height-only size of the scroller area.

New UI: extra vertical padding (top and bottom) around the list of items. Applied when scrolling is not needed.

Groups a set of rectangles that completely define the layout and drawing parts of the control. An instance is filled on the layouting stage, and used for painting and hittesting.

Layouted in .

Location argument for the function.

The menu should be scrolled so that the item at the given index were visible, be it at the top, bottom or middle of the list.

The menu should be scrolled so that the item at the given index were at the top of the visible area.

The menu should be scrolled so that the item at the given index were at the bottom of the visible area.

Layouter and renderer for ordinary menu items.

On an execute-or-expand item, a separator between bulk and tail glyph (when item is in the selected state).

On an execute-or-expand item, a separator between bulk and tail glyph (when item is not in the selected state).

On an execute-or-expand item, the part of selection body in the tail glyph area, after the separator between bulk and tail glyph. If such an item is expanded, should be highlighted.

Whether the icon fits into the specified size or not.

Caches the calculations.

Caches the input cells. If they don't differ, the rects will not be recalculated.

Padding for the icon and to the icon-cell boundaries.

Padding for the label and to the label-cell boundaries.

Padding around the text part of the label (displayname + shortcut text) up to (not including) the selection margin & tail glyph.

Around the already-padded and tail glyph, the padding that makes up the selection border and cell margins (menu item margins) up to the whole size of the cell.

Gets the icon size, constrained by the min-icon-size.

Performs a vertical hit-test (checks the y-coordinate only).

Zero if hit, less than zero if the point is located above the item, and more than zero if below.

First (bottom-up) part of the layout: the preferred sizes are being collected. Calculates the per-column preferred size of the menu item. Should be called before on any change.

A device context to measure the text against. Returns an array of preferred sizes for each of the cells defined.

Override font to semibold in New UI (only for group headers).

Performs the top-down part of the layout, when the item receives some size it should layout itself into. Should be called after .

Painting implementation. Always includes the upper margin. Works in menu-item-local coordinates.

Shared helper methods for drawing rounded rectangles for JetPopupMenu views.

Layouter and renderer for separator menu items.

Non-gradient part above the separator line (the upper margin).

Non-gradient part to the left of the separator line, to the right of the gradient part.

The separator itself.

First (bottom-up) part of the layout: the preferred sizes are being collected. Calculates the per-column preferred size of the menu item. Should be called before on any change.

A device context to measure the text against. Returns an array of preferred sizes for each of the cells defined.

Performs the top-down part of the layout, when the item receives some size it should layout itself into. Should be called after .

Paints the item according to the current layout. must be called before painting to achieve a meaningful result. The painting is performed within the , and the coordinate system origin of must be adjusted so that it were in the top-left corner of the item place.

Implements the Title sub-control of the .

The extension control that's added to the title area. Null by default, which means there is no control.

The quick-search string input editbox. Must not be Null.

An icon for the quick search editbox line. Must not be Null.

The parent menu view.

Filters out zero movements. Also, helps with telling the initial menu display from normal mouse movements.

The current precalculated layout. Created on the first top-down layouting pass.

Whether, how and where the quick-search editbox should be displayed.

The toolbar in the header. Null if there are no toolbar items.

Fires when the control would like to be reasked of its desired size.

Init the instance, attach to the parent menu view.

Gets the object that implements the menu logic.

Gets or sets the custom extension control that is added to the title. May be Null, which means there is no extension control.

Specifies whether the QuickSearch editbox color reflects the ready-state and validness of the quick search.

Gets the parent menu view.

Gets the editbox that accepts the quick search string.

Gets the toolbar part of the title view.

Inits the UI controls, including the form itself

Does just the very painting into the given .

Device context.

Updates the quick-search editbox coloring to reflect the current state: pending, invalid, etc.

Syncs the quick-search-related UI controls state.

Gets the set of colors involved in painting the control.

The non-Transparency mode painting function.

Gets or sets whether the control should be activated initially when it's shown. The typical implementation for a form is to return a negative of this value from the override.

Fires when the control would like to be reasked of its desired size.

Should process only high-priority keys.

Should process all the keys.

A static class with dimension constants. See the layout image for meanings.

Padding around the caption element of the title.

Approximate padding of the editbox text, that includes the border and some additional padding inside it.

Gap between the title lines.

Gap between different items in the title.

Margin around the title client content inside the borders.

The minimum size of the QuickSearch editbox.

The desired visual passing around the Quick Search icon.

The part of the Quick Search icon leftside visual padding that falls within the second line rect.

The part of the Quick Search icon rightside visual padding that falls within the second line rect.

Thickness of the custom-painted border around the borderless editbox.

Dimentions for menu items (title borrows many dimensions from item's).

Thickness of the decorative underline drawn under the Quick Search editbox.

Corner radius for the Quick Search editbox background/underline in the new UI.

Horizontal gap between the search icon and the text area of the Quick Search editbox (new UI).

Horizontal inset from the left edge of the editbox area to the search icon (new UI).

Horizontal side padding (Left/Right) for the second line area around icon + editbox in the new UI.

Extra right outer padding for the first title line in the new UI.

Extra outer vertical padding added to the title block preferred size in the new UI. Does not affect internal layout; applied only to preferred size.

New UI flag. Affects metrics (margins, paddings, radii, etc.).

Groups a set of rectangles that completely define the layout and drawing parts of the control. An instance is filled on the layouting stage, and used for painting and hittesting.

Whether, how and where the quick-search editbox should be displayed.

The editbox is hidden, no space is layouted for it.

The editbox is displayed right in the title bar.

A toolbar item on the 's toolbar ().

The shortcut, as a text string.

The item bounds, in parent coordinates (unlike other Rects, that are WC-local).

The document of this view.

Gets whether this item is currently in the selected state.

Gets the shortcuts assigned to the toolbar button.

Gets the formatted as user-friendly text, or an empty string if the shortcut is not defined.

Gets the toolbar that owns this item.

Gets the tooltip text, as provided by the user, without appending any shortcuts. Must not be Null.

Gets the tooltip text with the shortcut tip, which is the with a user-friendly rep of appended. Must not be Null.

Executes the action of this menu button.

Hit-tests the item by the x-coordinate, which must be in item-local coordinates.

Inits the shortcuts text, appends to the tooltip.

Called by tooltip manager, if the tooltip is to be displayed

Point in control's coordinates , or Null if no tooltip should be displayed.

Performs the bottom-up layouting stage, when the control calculates its desired size using the given constraints. Should give generally the same results as , but could employ the device context for the sake of optimization.

The device context to measure against. The maximum available space (that could affect the shape of the control, or strip down unnecessary calculations over the invisible items). May be a with width and height equal to , which means that the size is not limited. The desired size, must be no larger than .

Renders the context of the windowless control. The rendering bounds are given by the

Performs the top-down layouting stage, when the control lais out its parts within the given bounds.

The device context to measure against. The new bounds. From now on, this value should be returned from the property.

Tells the control the details about the new layout applied to it by the controlling entity in conjunction with some . Typically, the control need not apply the given size and location because that should be done by the controlling entity. The control may change its presentation in response to the layouting details, for example, whether it's attached to the top or the bottom of the anchoring rect.

The layouting details.

Gets or sets whether the control should be activated initially when it's shown. The typical implementation for a form is to return a negative of this value from the override.

Gets the item bounds, in the same coordinate space, as the parent toolbar (probably, the parent window's client rect coords).

The control has gotten dirty and should be repainted.

Fires when the control would like to be reasked of its desired size.

Dimension constants.

The 's toolbar.

Use .

Maps keyboard shortcuts to the assigned items.

The bounds, in parent coordinates.

Gets the toolbar rendering aspects.

Gets the views for the toolbar items.

Gets the toolbar items.

Gets the menu that owns this toolbar.

Gets or sets the index of the selected toolbar button, or -1 if none is selected.

Gets the selected item of the toolbar, or Null if none is available.

Executes an action associated with the selected item. Safe to call even if there's no selection.

Processes the keyboard shortcuts associated with the toolbar.

Handles mouse movements.

Looks up a menu item hit by the given point. -1 means outside any items. The point must be in owner coordinates.

Called by tooltip manager, if the tooltip is to be displayed

Point in control's coordinates , or Null if no tooltip should be displayed.

Renders the context of the windowless control. The rendering bounds are given by the

Performs the top-down layouting stage, when the control lais out its parts within the given bounds.

The device context to measure against. The new bounds. From now on, this value should be returned from the property.

The layouting details.

Gets or sets whether the control should be activated initially when it's shown. The typical implementation for a form is to return a negative of this value from the override.

Gets the toolbar bounds (in parent window client rect coords).

The control has gotten dirty and should be repainted.

Fires when the control would like to be reasked of its desired size.

Masters the Jet Popup Menu main body presentation. Is a topmost popup window that looks like an MSO-11 v-menu, performs low-level custom layered-window painting to achieve the alpha-channel transparency (non-rectangular form, shadows). Visually reflects the state backended by . Implements the control that is displayed by the JetPopupMenu.Show() method. Do not create directly, use frontend instead.

Whether the scroll-arrows reflect the scrolling position and range, or not.

Whether the disabled scroll arrows have an outline and no fill.

Forces the Alpha rendering mode to be never used.

Forces the Alpha rendering mode to be used always.

The caption for the menu view.

Gets or sets whether the menu should capture mouse input on startup and trigger the action on mouseup, thus assuming the "mouse-down" part of the input already done.

helper.

The precalculated set of colors. Must not be Null.

Codebehind that implements the menu logic.

Caches the drop-shadow-enabled state, as it must be maintained constant between calc-sizes, but should update from time to time. Synced to OS settings on each .

The mainpart subcontrol.

The current precalculated layout. Created on the first top-down layouting pass.

Hands a shadow next to the window.

The list of rectangles describing the current shape of the window — that is, the region most recently specified at the top-down layouting stage. Useful for checking whether we should update the shape or not. Cannot be Null.

The title subcontrol.

Defines where the title should be placed, depending on the side of the anchoring rectangle at which the menu is displayed. Vertically, may only be or , which means that the header is either above or below the body. Horizontally, may only be one of the inside anchorings, , , or .

Defines whether the transparency special effects, like real shadow, are enabled, or not. Setting the initial value to False forcibly disables the effect. The field fallbacks to False automatically if there are too few display colors.

Fires when the control would like to be reasked of its desired size.

Font used for standard text in the new UI.

Font used for headers in the new UI.

Default UIInteractive view for the .

Menu backend. Popup window context for the case if the menu wants to show its own popups (like, tooltips).

Gets the menu disposition, which determines whether the title is above or below, and so on.

Gets the object that implements the menu logic.

Gets the Mainpart subcontrol.

Popup window context for the case if the menu wants to show its own popups (like, tooltips).

Gets the Title subcontrol.

Inits the UI controls, including the form itself

Calculates the preferred size of the control so that all the context fit. Does not apply the size, just returns it.

The device context to measure the text against. The limit for the size, as it helps to reduce the number of calculations. The preferred constrained size.

Performs the top-down layouting stage.

Does just the very painting into the given .

Device context. The color table currently in use by the menu. The dirty region within which the items should be painted. May be Null.

Gets the shadow size (width/height of vertical/horizontal shadow, respectively).

Creates a rounded rectangle region using GDI calls.

Rectangle to make rounded Radius of the corners Handle to the rounded region (must be deleted by caller)

Updates the window non-rectangular shape, as defined by the set.

Gets the set of colors involved in painting the control.

Raises the event.

A that contains the event data.

Raises the event.

An that contains the event data.

The non-Transparency mode painting function.

Raises the event.

The that contains the event data.

Gets a value indicating whether the window will be activated when it is shown.

True if the window will not be activated when it is shown; otherwise, false. The default is false.

Gets or sets whether the control should be activated initially when it's shown. The typical implementation for a form is to return a negative of this value from the override.

Fires when the control would like to be reasked of its desired size.

A static class with dimension constants. See the layout image for meanings.

Height-only.

Corner radius for a rounded popup (new UI).

Smaller corner radius for compact rounded elements (e.g., toolbar icon chips) in the new UI.

Inset for drawing a rounded border inside the control area (new UI).

An interface to be implemented by all the menu subparts.

Should process only high-priority keys.

Should process all the keys.

Groups a set of rectangles that completely define the layout and drawing parts of the control. An instance is filled on the layouting stage, and used for painting and hittesting.

A set of rectangles that produce the opaque part of the window, in client coordinates.

Clears all the fields in the specified container.

Gets the list of borders to be filled with when painting.

Sets the default render params for UI in this menu. Note that the colors, including the background hint, are only approximate, so you should always override it with concrete colors before use.

Gets the offset of the menu caption from the menu top left corder, which is needed in case you want to position the image right above some object.

If you want to dock the menu with a so that the caption presentation were positioned directly above some area — typically, if you duplicate some visual element into the menu caption so that it appeares as if menu opens out of it — use this padding for the layouter around the which represents the area. The left parameter of the padding is the distance between the caption and the left bound of the menu when the menu opens docked to the right. In this case caption is in the left corner of the menu. The top parameter of the padding is the distance between the caption and the left bound of the menu when the menu opens docked down. In this case caption is above the menu body. The right parameter of the padding is the distance between the caption and the right bound of the menu when the menu opens docked to the left. In this case caption is in the right corner of the menu. The bottom parameter of the padding is the distance between the caption and the bottom bound of the menu when the menu opens docked up. In this case caption is below the menu body. All in all, this should work if you give this as a thickness96 to the ctor. The thickness components are negative to suit the docking.

Creates the color set with setting up the solid color coersion correctly.

Fallback for the case when all gradient colors are the same. Does input checks and skips collapsed rects.

Two-color gradient routine. Fallbacks to flat painting if colors are the same. Does input checks and skips collapsed rects.

Four-color gradient routine, but with only three stops. The color at the center is non-contiguous, the two middle color go into the same coordinate. Fallbacks to three- or two-color or flat painting if some/all colors are the same. Does input checks and skips collapsed rects.

Three-color gradient routine. Fallbacks to two-color or flat painting if some/all colors are the same. Does input checks and skips collapsed rects.

Manages nested popup menus.

Creates the hierarchy.

Lifetime of the hierarchy, and of the root menu of the hierarchy (). Terminated automatically when the root menu exits the hierarchy. The root menu in the hierarchy.

Close all of the menus in the hierarchy, i.e. when a menu item gets executed.

Floats a shadow near to some other window.

Colors in the shadow corner.

Colors in the linear shadow.

Shadow corner.

One-pixel-long shadow segment.

The list of rectangles, in client coordinates, that form the thing that should be casting the shadow.

Fires when the object gets dirty. The object does not update immediately, but instead collects the requests.

Fires when the signals get collected and are finally executed (basically, when we get off the stack frame).

Gets the linear shadow thickness (height for horizontal, width for vertical).

Gets or sets the screen location to which the coordinates are relative. To set both and , use to do it in a batch.

Gets or sets the list of rectangles for which the shadow is displayed. The coordinates must be relative to the . To set both and , use to do it in a batch.

Sets the new location and new list of rectangles in a single call, thus only one recalculation and redisplay.

Attaches a vertical shadow, including the upper corner.

Lazy-creates the static bitmaps.

Tiles the to draw a horizontal shadow. A tricky thing in GDI+.

Tiles the to draw a vertical shadow. A tricky thing in GDI+.

Decreases the number of rects by merging, sorts them vertically, etc.

Creates the window when it's finally needed.

Sets the , tells whether modified, does not cause an update.

Updates the visual presentation on the screen to respect the new coordinates.

Factory for popup menus to inject all of the required components into the popup menu. Designed to be usable even without a running shell.

Provides an extensibility point for modifying newly created JetPopupMenuView

Gets the layouter supplied by the user, or creates the default one if missing (for the center of the screen, or the main window).

The control has gotten dirty and should be repainted.

Fires when the control would like to be reasked of its desired size.

Gap on the right and left of the text, but within the progress fill.

Gap between the icon and the progress area.

Step for changing the size when adapting.

Number of ticks before the immediate size starts adapting.

The indicator's desired size, as derived from the content.

The indicator size currently reported to the host as the desired size. Gradually changes to fit .

The control has gotten dirty and should be repainted.

Calculates the number of timer ticks after the change.

Gradually adjusts to fit .

Fires when the control would like to be reasked of its desired size.

Gets or sets whether the control should be activated initially when it's shown. The typical implementation for a form is to return a negative of this value from the override.

The windowless control bounds in the parent coordinates. The implementor should just store and return the value set by the owner.

Called by tooltip manager, if the tooltip is to be displayed

Point in control's coordinates , or Null if no tooltip should be displayed.

The control has gotten dirty and should be repainted.

When the timer ticks, gradually changes the immediate desired size value towards the actual desired size.

Calculates the true desired size.

Renders the context of the windowless control. The rendering bounds are given by the

Performs the top-down layouting stage, when the control lais out its parts within the given bounds.

The device context to measure against. The new bounds. From now on, this value should be returned from the property.

The layouting details.

Fires when the control would like to be reasked of its desired size.

Helps to add access keys to WPF controls.

Usage: create a control and add it to the WPF control tree.

Moves focus to the specified UI element.

Executes a custom action.

WPF UI element for the JetBrains loader animation.

A UI element for planting the Action Manager Toolbar into the WPF UI. Does not require any components for creating an instance. All of the components and data are databound from the viewmodel.

View for the automation object which represents a check box control in the UI.

WPF UI view for the JetBrains loader animation.

Defines the speed mul-factor.

Period of a full spin, in milliseconds.

Decorates a control to make it gradually acquire its desired size.

ContextNotificationControl

Interaction logic for BackgroundNotificationControl.xaml

InitializeComponent

CounterGroupView

InitializeComponent

CounterItemView

InitializeComponent

UsageStatisticsView

InitializeComponent

ExtensionManagerOptionsView

InitializeComponent

Loads an icon in such a way that it does not cause unhandled exceptions on Windows XP HiColor when it encounters the icons in the icon group which it can't handle with WIC. TODO: load icon with smth else but WIC actually, somewhen

Set optical zoom in IE activex component in the given WebBrowser

WebBrowser instance Scale, where 1.0 is 100% Returns true if zoom was successfully changed

Required designer variable

Clean up any resources being used.

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

ExtensionManagerWindow

Interaction logic for MainWindow.xaml

InitializeComponent

true if the operation requires reinstalling the product otherwise false

NotificationsLogView

InitializeComponent

SimpleOptionsPageView

InitializeComponent

Spawns the Settings Layers dialog.

Gets a default corner radius that should be used for controls such as buttons

Gets the corner radius that should be used for containers such as groups, popups, etc.

Gets a default width / height of an item on toolbars

Gets chevron's path data (down) (drop-downs, combo-boxes, etc.)

Gets the padding that should be used for popups (context menus, drop-downs, etc.).

Gets the selection indicator corners

Gets the selection indicator size

Defines whether toolbar should be vertical or horizontal. It was introduced to avoid using toolbartray

Sets up the app to favor dynamic DPI in the best possible manner.

Launcher for base app entry points. The full standalone app has its own launcher in its project, because it references more stuff.

Refer to this if you need to get the for the method of this launcher.

The GUI entry point for calling from the native part. Inits the simple GUI host, without the tabwell-required services. Expects to have the partial set of components written in resources, like host name and environment zone, while the set of the application packages is collected ad-hoc based on what's found in the application folder.

The exit code for the process.

Vaidates against . Mounts to an attempt to declare a host.

Normally, an automation object gets an Avalon view with a automatically. This allows to create an alternative -based view for use with WinForms APIs. Such view must be separately implemented for an automation object.

Gets all of the results

Gets the first search result.

Gets the first search result, or Null.

Gets the last search result, or Null.

Gets the one and only search result.

Gets the last search result.

Fluent. Adds an OR condition to the search.

Fluent. Adds an AND condition to the search.

A stub for switching into calling for Automation.ExecFreeThreaded.

Switching implementation: by UIA or HWND.

Gets the condition to be used for running UIA searches. Specifically handles the case with no condition.

HWND-based search, universal impl.

Gets the HWND of an UIA. Throws if the latter is not a window.

Renders the textual representation of the condition.

A fluent search API on automation elements. Supports searching in both HWND-based and virtual UIA trees.

A fluent search API on automation elements. Supports searching HWND automation elements only, but does this with less chances of a deadlock.

Toggle pattern: toggles until the desired result is achieved.

Value pattern: gets the value.

Value pattern: sets the value.

Property-specific overload for the method.

If you are implementing an automation peer for an UI element, this helper gets its automation children by looking up automation peers in the Visual Tree of the given UI element. This works generally the same way as the default implementation of or , by DFSing the visual descendants, stopping at nodes which are automation peers themselves.

Only children and grandchilren are considered. Even if the original element has a peer (which would prevent from looking at its children at all), it's ignored and children are considered. Use this if you are calling on an automation-peer-enabled element to find its children peers.

The original element is considered as well, and if it's a peer, it's the only one to be returned. Use when you're calling this not on your own element (which is a peer and which you want to obviously skip), but on some of its child visual elements.

Exposes automation properties. Because of the class name, R# Smart Completion can suggest them where applicable.

Property ID: AutomationId - An identifier for an element that is unique within its containing element.

Property ID: ClassName - name of underlying class - implementation dependant, but useful for test

Property ID: The ControlType of this Element

Property ID: name of this instance of control

Property ID: NativeWindowHandle - Window Handle, if the underlying control is a Window

Property ID: Enabled

Gets a WPF representing as s. As a result, using a listed automation type as in a , or as an item in an etc will result in the corresponding view automatically applied to the automation object.

Mounts into the common .

The base class for WPF view controls which could be registered as Data Templates for some view model automation object, to be applied automatically whenever such object attempts to be presented (see to register with resources automatically). This class calls a user function to render the content with code. The function is given the bound automation object (whom this data template is presenting) and the lifetime of the binding validity. For the duration of the lifetime, the WPF control is loaded, and the valid automation object is assigned as the data context to this view. The function might be called multiple times for the same view instance (non-overlapping lifetimes) if either the view is unloaded and reloaded, or the automation object is revoked from the data context and reassigned. This renderer is especially useful when your view has to operate lifetimed entities (e.g. create a complex Windows Forms control, or run an activity while the control is live). To implement the view renderer, create a derived class specialied with your automation object type as the generic parameter, and do one of the following: (a) Override the method (do NOT call the base implementation). This is the preferred way if you do not need to dependency-inject Shell components. (b) Write a public instance method called OnRenderView with a freehand signature. It might take basic parameters of type and (just like ), plus any number of other parameters of Shell component types, which would be injected from the Shell container upon view construction. This would be late-bound-called by name, so prefer overriding if possible. (c) Override the constructor and pass the rendering function as the lambda parameter. This scenario does not support importing Shell components.

The type of the automation object for which the data template would be registered. If using the attribute, the Shell would register your data template for this specific type, all its base types, and all its meaningful interfaces.

Handles the case when the view rendering FN has extra parameters to be dependency injected from the Shell container.

A helper class to wrap passing lambdas instead of having constructor overloads. IDEs aren't very good at helping with resolving multiple lambda overloads, while with this helper you can have the specific overload preselected.

Just a functor. Same as overriding .

Async version. In case you wish to jump threads or await for something needed for your view. A cue banner will be added while you wait.

Allows to take components into your function, like with writing a custom OnRenderView which is not overriding but has extra args. These args will be fetched from the component container (Shell when no solution is open, or Solution when it opens). Async version. In case you wish to jump threads or await for something needed for your view. A cue banner will be added while you wait.

A view to be used as a data template for presenting an , correctly with lifetiming.

A view to be used as a data template for presenting a WinForms control as a WPF content element. No additional lifetiming is applied, it's on part of the automation object.

Base implementation for quickly setting up attached-property-behaviors for WPF elements. Use in WPF: set an attached property to some value. Backend: when element is loaded and a value is set, you're called with that value and its lifetime.

Behaviors which are based on this helper use the property bag to store a DataFlow copy of the behavior state. The lifetime-driven behavior function binds to it and to the element's loaded state. The transition is as follows: when behavior property value is set, it's copied to the DataFlow property in this bag. When the property is first created, the behavior function is bound to it as follows: when both the property has a non-null value, and the element is loaded into WPF, execute with that lifetime.

On your behavior attached property, set the on the to the result of this function.

Behavior property value type. Type of elements to which the behavior is applicable. Must be at least a because of the event. Name of the behavior. MUST be unique, otherwise behavior states might get mixed up. You'll be called into this function for the behavior value. Set this to the of a of your behavior's call.

Registers the dependency property for your behavior. When a valid value is assigned to the behavior property and the element is loaded into WPF tree, your callback at is called with a lifetime to activate the behavior.

Type of the value which is given to the behavior by binding or setting the dependency property. The class which defines the behavior. This is used when registering the dependency property. Type of the UI elements on which this behavior is allowed ( at the least). This element will also be given to the behavior as a parameter. Name for the attached dependency property. Better be unique. The function whcih runs the behavior on the given value during the lifetime. The dependency property for your behavior.

Type of the value which is given to the behavior by binding or setting the dependency property. The class which defines the behavior. This is used when registering the dependency property. Name for the attached dependency property. Better be unique. The function whcih runs the behavior on the given value during the lifetime. The dependency property for your behavior.

Registers a boolean-based behavior which is only activated when it's set to True. When a True value is assigned to the behavior property and the element is loaded into WPF tree, your callback at is called with a lifetime to activate the behavior.

The class which defines the behavior. This is used when registering the dependency property. Type of the UI elements on which this behavior is allowed ( at the least). This element will also be given to the behavior as a parameter. Name for the attached dependency property. Better be unique. The function whcih runs the behavior on the given value during the lifetime. The dependency property for your behavior.

The class which defines the behavior. This is used when registering the dependency property. Name for the attached dependency property. Better be unique. The function whcih runs the behavior on the given value during the lifetime. The dependency property for your behavior.

Used by behavior implementation.

Binds a menu to a list of objects.

Binds a toolbar to a list of objects.

In WPF, nested focus scopes won't propagate its logical focused control state to the parent focus scope. Attach this behavior to the root focus scope of a control graph in which nested focus scopes should propagate this state. Why we need to propagate the state? (1) Action system toolbars use the logically-focused element to handle commands when focus is not under the scope of the toolbar. For example, tool window toolbar command should apply to the selection in that toolwindow even when focus is in some other tool window. (2) Restoring focus when window gets activated. Without proper propagation, if focus actually were in a nested focus scope, focus will be restored to the last-focused element in the topmost scope instead of the nested one.

Service property to support lifetiming of the view.

See comments to the class.

Raw property. For use from UI only. Note that more than one owner is not supported here. From code, use .

Call from code if you'd like to turn a focus scope into a focus scope root. Note that multiple owners are supported for the same element, identified by tokens, served till the last one goes.

Stores the tokens collection on the element. Binds the activity to happen when (there're request tokens present). NOTE: we don't check when the element is loaded because we're attaching to an event which is quite safe to listen forever.

Attaches to events, does the thing when the events are fired.

Displays modal task dialog in front of the specified window, returns a result of user choice.

Title bar caption of dialog window Purpose of the dialog Detailed information for the user action which is performed when hyperlink is clicked, null if no hyperlinks Selected task button index Handle of owner window of the dialog List of alternative actions from which the user makes a choice Index of action that the user has chosen or -1 if user closes dialog without choosing any alternative or current platform does not support task dialogs

Displays modal task dialog in front of the specified window, returns a result of user choice.

Title bar caption of dialog window Purpose of the dialog Detailed information for the user Selected task button index Owner window of the dialog List of alternative actions from which the user makes a choice Index of action that the user has chosen or -1 if user closes dialog without choosing any alternative or current platform does not support task dialogs

Displays modal task dialog in front of the specified window, returns a result of user choice.

Title bar caption of dialog window Purpose of the dialog Detailed information for the user Selected task button index Handle of owner window of the dialog List of alternative actions from which the user makes a choice Index of action that the user has chosen or -1 if user closes dialog without choosing any alternative or current platform does not support task dialogs

Determines whether current platform (operating system) supports task dialog

true, if supported

Rundown trace session allows to obtain the information on CLR 4.0 objects.

Runtime trace session with LoaderRundown and StartRundown keywords allows to obtain CLR 2.0 modules.

CLR ETW Rundown Keywords

CLR ETW Runtime Keywords.

ETW event levels.

ETW events can also be filtered by level. If the level is set at 0x5, events of all levels, including 0x5 and below (which are events that belong to categories enabled through keywords) are raised. If the level is set at 0x2, only events that belong to level 0x2 and below are raised.

These events collect information relating to loading and unloading application domains, assemblies, and modules.

All loader events are raised under the LoaderKeyword (0x8) keyword. The DCStart and the DCEnd events are raised under LoaderRundownKeyword (0x8) with StartRundown/EndRundown enabled. .NET Framework 4. http://msdn.microsoft.com/en-us/library/vstudio/ff356159(v=vs.100).aspx .NET Framework 4.5 http://msdn.microsoft.com/en-us/library/vstudio/ff356159(v=vs.110).aspx

http://msdn.microsoft.com/en-us/library/vstudio/ff356156(v=vs.100).aspx

Event data for AppDomain* events.

Event data for Assembly* events.

Event data for Module* events .NET Framework 4.

Event data for Module* events .NET Framework 4.5.

The fields that have "Pdb" in their names can be used by profiling tools to locate PDBs that match the modules that were loaded during the profiling session. The values of these fields correspond to the data written into the IMAGE_DIRECTORY_ENTRY_DEBUG sections of the module normally used by debuggers to help locate PDBs that match the loaded modules. The field names that begin with "ManagedPdb" refer to the managed PDB corresponding to the MSIL module that was generated by the managed compiler (such as the C# or Visual Basic compiler). This PDB uses the managed PDB format, and describes how elements from the original managed source code, such as files, line numbers, and symbol names, map to MSIL elements that are compiled into the MSIL module. The field names that begin with "NativePdb" refer to the NGen PDB generated by calling NGEN createPDB. This PDB uses the native PDB format, and describes how elements from the original managed source code, such as files, line numbers, and symbol names, map to native elements that are compiled into the NGen module.

Event data for DomainModule* events.

ETW calls EventCallback function for each event in the buffer.

Pointer to an EVENT_TRACE structure that contains the event information.

BufferCallback receives buffer-related statistics for each buffer ETW flushes. ETW calls this callback after it delivers all the events in the buffer. This callback is optional.

Pointer to an EVENT_TRACE_LOGFILE structure that contains information about the buffer. To continue processing events, return TRUE. Otherwise, return FALSE. Returning FALSE will terminate the ProcessTrace function.

Information on process and window under cursor.

It contains only the information that can be obtained on-the-fly without accessing the hard drive or having special privileges. That's why it doesn't contain process [file]name, we could not have enough rights to open the process handle.

Set this flag in your OnMove callback to stop process finding.

A rough way to detect .NET processes. Works even if the target process (identified by processId) is elevated and our one is not.

Based on Process Hacker's PhGetFileName().

Returns "C:\Windows\SysNative" if the current process is 32-bit and the folder exists, otherwise Empty.

(DK) For 32-bit processes "C:\Windows\System32\" is redirected to "C:\Windows\SysWOW64\". "C:\Windows\SysNative" is an alias to access a real "C:\Windows\System32" from a 32-bit process.

Provides the popup window context for the main application window. The popup layouter will be anchoring to the middle of the window, and ESC pressings will be handled correctly. If there is no main window, the working area of the primary screen is used as a fallback.

A custom-crafted progress dialog.

The first line of the progress dialog description. Shortens paths.

The second line of the progress dialog description. Shortens paths.

Whether the cancel button is available on the dialog. Cannot be changed when .

Whether the dialog is currently visible. Set to True to show. To hide, either set to False or dispose of the dialog.

The dialog is shown with a delay, this is the delayed value.

Whether the user has canceled the progress dialog. Readonly.

Progress dialog title.

Value of the progress, in the [0…1] range.

A handle to the progress window. Readonly.

Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.

Binds a progress indicator to its visual presentation. The values are prevented from being updated too often. Returns a diconnection token.

Implementation details for the .

Whether the user has canceled the progress dialog. Readonly.

The progress window is shown after a delay. If the task-under-progress shows a dialog box before the delay elapses, the progress would steal focus from that dialog box. Not nice. An example is the checkout dialog box. Make sure we return focus where it belongs.

The layouting details.

Gets or sets whether the control should be activated initially when it's shown. The typical implementation for a form is to return a negative of this value from the override.

Fires when the control would like to be reasked of its desired size.

Exposes the system-standard Progress Dialog.

An animation to be displayed on the dialog above the progress. A choice of the standard system animations.

The first line of the progress dialog description. Shortens paths.

The second line of the progress dialog description. Shortens paths.

Available only when not . The third line of the progress dialog description. Shortens paths. When , this line is used for displaying the time estimate.

Whether the cancel button is available on the dialog. Cannot be changed when .

Whether the system should estimate the remaining time and give it out in the third description line of the dialog. Cannot be changed when .

Show dialog immediately after creation. Cannot be changed when .

Whether the progress is indeterminate. Cannot be changed when .

Whether the dialog is currently visible. Set to True to show. To hide, either set to False or dispose of the dialog.

Whether the user has canceled the progress dialog. Readonly.

Progress dialog title.

Value of the progress, in the [0…1] range.

A handle to the progress window. Readonly.

Binds a progress indicator to its visual presentation.

Summary description for TaskProgressControl.

Controls a single run of the .

Creates an object that runs the task execution once.

Whether the task MUST be run on the primary thred (), or it COULD be run on a worker thread to avoid freezing the UI (). The task to run. The given to the task is always free-threaded for both reading and writing, even if . Allows the owner to attach its UI to the progress of the task. The object given as parameter is always primary-threaded, which means that it fires modifications on the primary thread only. To cancel out the UI or binding, submit to the parameter. Optionally return the window handle, if known already, to keep from disabling when applying the modal state. The owner-provided progress indicator. The window focus will be restored to if it was impossible to restore focus to the previous window.

Private.

Creates an object that runs the task execution once.

Throws the on .

Gets or creates the thread on which the task should be executed (either the current one, or the special worker thread, see "myTaskThreadAffinity".

Starts the task, on whichever thread needed.

The "myTask" caller impl, runs on task target thread, at the end notifies the owner thru "IsDone" async.

Progress UI for the task run, as specified by the owner of this Run object.

Pushes a main-window-disable, to emulate modality.

Stores the focused window, restores in a reliable manner later.

Pumps messages until the task is thru.

A window to enforce modality (which is technically a disable on other windows plus a separate message pump). We want modality to be in effect immediately, while progress windows are created later. All of the manual measures of modality seem to be unstable about restoring keyboard focus correctly after modality is reverted.

A task executor that displays graphical user interface while the progress is running. This object is reusable and is not connected to any given task execution.

Creates a new task executor. Specifies whether a task might be executed on another thread.

WAS: Vista has its progress nice with full Aero, and in XP it's awful Also fallback under RDP because the std progress is animated and thus greedy on bandwidth return (Environment.OSVersion.Version.Major >= 6) && (!SystemInformation.TerminalServerSession); - - - NOW: We do not run on XP anymore RDP uses async channels and AVC or RemoteFX and is not sensitive to these things that much anymore The custom progress layout is of inferior quality => always use the system progress dialog, it has some margin of quality at least

Progress UI for the task run: chooses whichever implementation to use.

Progress UI for the task run: homebrew progress dlg.

Progress UI for the task run: system progress dlg.

Executes the task without exiting the method until the task is completed.

Task title, short form. This is used for the progress window title by the UI progress indicators. The long form of the task caption should go to the of the 's . Prepended with the product name automatically. Might be empty, in which case the product name will be used. The task to execute. Whether the task could be canceled by the user, if the task progress indication provided by supports canceling. Whether the task has completed execution (ie was not canceled). Note that a could cancel even a task. Any return values of the task should be assigned inside the closure that implements the .

Allows to override the default implementation with test mocks or app-specifics.

Switching implementation for .

Asks user for a new tab name. Returns null on cancel

Interaction logic for ToolWindowContentPresenter.xaml

ToolWindowContentPresenter

InitializeComponent

Defines tooltips over Avalon elements.

The UI element over which the tooltip is shown. Note that, unlike , the tooltip described by our does not necessarily represent the whole element area, but only a subpart designated by .

Initializes the Avalon tooltip event handling.

Fires when the tooltip is requested for the element under the mouse. Bubbles up the elements tree to see if somebody has a tooltip. Handle the event and call its arguments' to provide a tooltip.

Sinks the . This implements our Tooltip Manager tooltips behavior for an Avalon element. This is the most generic method which siks the raw event and allows for the most flexible handling. Possibly the other method will be more handy for you.

This implements our Tooltip Manager tooltips behavior for an Avalon element, for the full area of the element, with dynamic or pull-based behavior for tooltip content.

This implements our Tooltip Manager tooltips behavior for an Avalon element, for the full area of the element, with dynamic or pull-based behavior for tooltip content. The functor which builds the tooltip text on-demand is an async funciton in this case.

This implements our Tooltip Manager tooltips behavior for an Avalon element, for the full area of the element, with static or retained-state tooltip content. Retained-state means push model rather than pull model: you can change Automation Object's text when you think it should change, regardless of whether tooltip manager asks for tooltip or not. This is less performant than pull-model.

Avalon tooltip provider. Finds elements to handle the call-for-tooltip event.

Arguments to the .

The hit test point, in coord space.

Needed for .

Root element of the tree, an ancestor for any possible hit element handling this event. Basically, just the element in which the is initially defined.

The result of a call. The entity firing the event must make sure this value is disposed of, eventually.

The element immediately hit by the mouse. Normally, if you get this event, you're an ancestor of the hit element (or the hit element itself).

Lifetime for all the entities you might create for this tooltip session, e.g. popup layouters and tooltip renderers.

Convenience access to the components which might be required in the tooltip handling code.

Gets the hit test point in local coordinate space of your element.

If you handle the event and would like to show a tooltip, call this method. Sets the property. The event will be marked as automatically.

The element to “own” the tooltip. Used for limiting the tooltip lifetime and treating the local coordinates in 's tool area and the newly-created . The tooltip.

The async version of the function. The actual tooltip info is calculated asynchronously, possibly yielding NULL if client decides later that it should not be shown.

Delegate to the .

Attribute for impls.

The higher the priority, the sooner the finder is asked (and can promote its own result in precedence of the others).

Classic tooltip provider. Finds tooltips over WinForms controls that implement .

WinForms controls register by implementing an . Try getting one here.

An entity to look for any s under the current cursor position (given by a from a mouse hook).

Looks for any elements with tooltips under cursor.

Lifetime for the tooltip data returned (eg layouters). Windows message data, including current cursor position. A future to the tooltip element, preferrably a ready value if it is known immdeiately. A on-Null future to a Null value if this provider cannot find a tooltip.

A generic element over which tooltips could be shown. The classic version is an HWND window, but now we need to add Avalon support. This object binds to the specific point and the specific tooltip text to be shown over that point.

The point for which the element were originally created.

The tooltip info at the point for which the element were requested.

Adds data to the exception to report this element.

Checks whether the element is still alive. If not, the tooltip will be dismissed.

Converts a point from screen (mouse native) coordinates to the local client coordinates of the element. Local clients must be in device-independent 96dpi pixels. Return NULL if the point does not fall within the client area.

A control that implements the tooltip window. Don't use this class directly if you need to show a tooltip. Instead, either use the TipControl static class for one-time tooltips, or implement the interface on your window.

, lazy-init.

worker field.

Tip painter, as a windowless control.

Color theme

Waits for the tooltip to hide.

Fires when the control would like to be reasked of its desired size.

Creates a tip control with the given painter inside.

Gets the default rendering parameters for a tooltip. Do not modify this instance.

The default timeout, the maximum time span for which the tooltip is visible, in milliseconds. Initially set to .

Clean up any resources being used.

Raises the event.

A that contains the event data.

Raises the event.

The that contains the event data.

Gets a value indicating whether the window will be activated when it is shown.

True if the window will not be activated when it is shown; otherwise, false. The default is false.

Gets or sets whether the control should be activated initially when it's shown. The typical implementation for a form is to return a negative of this value from the override.

Fires when the control would like to be reasked of its desired size.

Dimension constants for the tooltip control.

Width and height of the horizontal and vertical border sides.

Padding between the border and tooltip's inner content.

Base impl.

The standard implementation of the interface. Don't dispose of this instance until you're done with using its members, eg painters and layouters.

Creates a tooltip info with an automation object.

Gets the painter for the tooltip. Must be implemented. Must not be Null.

Gets the popup window context that fires the actions upon which the tooltip is dismissed and defines the layouter for this tooltip. Null means the default popup window context will be used, one that positions the tooltip against the mouse pointer.

Gets the tool area of this tooltip, in client coordinates. An empty rectangle means “no constraints”. Used by .

Checks whether the given point falls within the tool area of this tooltip. The tooltip is displayed while mouse pointer is within the tool area. One window may have more than one tooltip for different tool areas.

Point, in the client coordinates, to be tested for falling within the area. True if point is within the area, False otherwise.

Builder for .

Cretaes a tooltip which shows arbitrary content from an Automation Object. This is the native type of text for a tooltip.

Creates a tooltip info upon the supplied text. Makes an Automation Object which renders this text optimally.

Creates a tooltip info upon the supplied text (with icons). Makes an Automation Object which renders this text optimally.

Do not limit tool area for a tooltip within the element on which it is shown. When a tooltip is shown over a WinForms or Avalon control, the tool area will be set to the bounding rectangle automatically.

Defines tool area in local coordinate space.

Defines tool area in local coordinate space. The is only needed to determine the resolution for the local tool area rectangle.

Defines tool area to be the whole client area o the given Windows Forms control.

Defines tool area to be the render size rectangle of the given Avalon element.

An UI-interactive implementation for the .

Back-end for .

The element (HWND in classic case) that owns the currently displayed tooltip, or the tooltip that is about to be shown after a delay. Null if not displaying or awaiting the tooltip.

When user hits ESC to dismiss the tooltip, gets the prev cursor position to avoid re-showing the tooltip immediately over the same element.

An externally managed collection. Its maintenance has been extracted to avoid dependency from Tooltip Manager on each and every provider, which is not required on startup. // TODO: turn into demand imports Must be sorted by priority, first-comes-first.

Creates and immediately displays the tooltip, as described by . To schedule display on hover, fill the data fields and wind up this method on a timer.

Destroys the currently visible tooltip and cleans up its data fields. Does nothing if no tooltip is currently visible.

Mouse and keyboard hooks handler.

Show the new tooltip for the hovered area (only if we're not displaying a tooltip).

Condition of creating the new tooltip for .

Remove tooltip if we've exited its tool area.

Core impl for .

The control that renders the tooltip. Null if not displaying a tooltip. Check this field for Null to determine whether the tooltip is currently visible.

Manages the list. MUST NOT be referencing this class to spare its clients from circular dependencies.

A simple tooltip provider implementation for the cases when the tooltip provider is external to the window it's requested on. If you're implementing the tooltip-providing window class, implement the interface instead.

Creates a tooltip provider without a tooltip yet, sink the event.

Creates a tooltip provider with one handler.

Fires when the tooltip is requested by the caller.

Called by tooltip manager, if the tooltip is to be displayed

Point in control's coordinates , or Null if no tooltip should be displayed.

Tooltips over WinForms controls that implement .

Optional. The tooltip provider on the element (if applicable to the origin of the tooltip element, as is in the case of WinForms elements; used for exception diag mostly).

Checks whether the HWND belongs to a still-living .NET control or a good window.

In recent .NET Frameworks, WinForms somewhat can into dynamic DPI, but these capabilities have to be magically activated.

Applies fonts, sets up tracking for high DPI changes in the form, prevents form's own mechanisms from interfering with our hi-dpi operations.

Applies fonts, sets up tracking for high DPI changes in the control, prevents control's own mechanisms from interfering with our hi-dpi operations.

Applies fonts, sets up tracking for high DPI changes in the form, prevents form's own mechanisms from interfering with our hi-dpi operations.

Applies fonts, sets up tracking for high DPI changes in the control, prevents control's own mechanisms from interfering with our hi-dpi operations.

Suppresses form's handling of WM_DPICHANGED. This fixes troubles with winforms' over-scaling values and cases when keyboard focus is not set to the initial control due to affected init order.

Standard operations to attempt when (after) DPI is known to change on a form/control.

The event handler prototype uses a type which is only present in newer netfxes, so emit the implementation which cancels it.

Charms an Avalon HWND Source so that it behaved to per-monitor and dynamically changing DPI.

Recent WPF versions support dynamic DPI out of the box, but do not activate it by default. Try the manual activation on it.

Adds a DPI-charming request for the window. It is OK to call multiple times. Would force Avalon to switch to the new DPI values for coordinate translation and rendering when the window DPI changes, either due to system DPI change or when moved to a monitor with a different resolution. Would adjust window physical size when DPI changes to maintain the logical size.

Lifetime for this charming request. If there's more than one request for the same window, it would be charmed for high-DPI until the last lifetime terminates. The HWND Source of a window to process. Can be either a top-level window or an Element Host. See optional parameters which depend on that. When points to a top-level window (), might be NULL. For non-top-level windows such as an or , a valid instance of the component must be supplied. When points to a top-level window (), might be NULL. For non-top-level windows such as an or , a valid instance of the component must be supplied.

Forces an Avalon window update its DPI.

If we're running on a new Windows OS and a new WPF version, turns ON its dynamic DPI awareness and avoids hacking per-window DPI values. Safe to call multiple times.

That's crazy shit. A popup (PopupRoot class as the root visual in the HWND Target, serving the new window for the Popup element in some other visual tree) would sink HwndSource::DpiChanged event and do nothing and suppress any further processing, thus preventing tracking the actual dynamic DPI. Like this:


            private void OnDpiChanged(object sender, HwndDpiChangedEventArgs e)
            {
              if(!this.IsOpen)
                return;
              e.Handled = true;
            }

All of the dyn dpi processing aborts applying new DPI by this flag. Kill this event sink on the DpiChanged event in the HWND Source, and everything starts working smoothly. Do the check before forcing DPI (that would not happen often).

Whether we changed anything.

The original (or old enough) WPF solution: DPI resolution is acquired once and for all, takes part in coord mapping and painting. We hack into these values to reflect dynamic DPI, and force them reapply (with another set of hacks). This requires per-hwnd-source patching. There is no global hacking.

The recent PMv2 upgrade. Supposes DPI is different per window and might change at runtime, tries to track (with partial success) for such changes. This behavior is however not enabled by default but governed by app context switches. We hack the app context switch globally to enable PMv2 dynamic DPI (should be done before creating windows). Per-window hacking still might be required to force the window know its new DPI in some cases when it does not (a non-top-level window reparented into another DPI surrounding). The hack is mild here, just send the new PMv2 Windows Message.

Tracks active running Avalon windows.

We only track HWND-backed windows, that's its handle.

A window gets only listed here when a presentation source gets created for it, so it's as well non-NULL.

This class facilitates associating a key binding in XAML markup to a command defined in a View Model by exposing a Command dependency property. The class derives from Freezable to work around a limitation in WPF when data-binding from XAML.

A CommandBinding subclass that will attach its CanExecute and Executed events to the event handling methods on the object referenced by its CommandSink property. Set the attached CommandSink property on the element whose CommandBindings collection contain CommandSinkBindings. If you dynamically create an instance of this class and add it to the CommandBindings of an element, you must explicitly set its CommandSink property.

This class makes it easier to write code that works with the common members of both the FrameworkElement and FrameworkContentElement classes.

WebProxyCustomUsingView

InitializeComponent

BoolOptionView

InitializeComponent

ButtonOptionView

InitializeComponent

ComboEnumWithCaptionView

InitializeComponent

ComboOptionView

InitializeComponent

FileChooserView

InitializeComponent

HeaderOptionView

InitializeComponent

IconComboBoxView

InitializeComponent

IntOptionView

InitializeComponent

RadioOptionView

InitializeComponent

RemarksOptionView

InitializeComponent

RichTextOptionView

InitializeComponent

SingleRadioView

InitializeComponent

StringOptionView

InitializeComponent

CopySettingsDialog

Represents dialog for selection particular settings to copy/import/export them

InitializeComponent

OptionsDialogView

Represent the main settings dialog

InitializeComponent

OptionsPageList

Represents a control to show list of pages

InitializeComponent

Gets or sets list of pages to show

Using a DependencyProperty as the backing store for Pages. This enables animation, styling, binding, etc...

Occurs when user clicks on page in the list

SearchHelpOptionView

InitializeComponent

SettingsLayersDialog

Interaction logic for MainWindow.xaml

InitializeComponent

SettingsSnapshotTreeView

A tree visualizing a part of the settings schema corresponding to the current context, with hierarchical checkbox.

InitializeComponent

Gets or sets what element we should use to listen hot key for search box

Using a DependencyProperty as the backing store for ListenKeyboardOn. This enables animation, styling, binding, etc...

Pre-styled controls for the option pages.

Padding for the inner level of controls (to be laid out under the logically parenting controls)

Adds a child control to the next column of the grid.

Grid. The control to be added. Percent size, if 1 to 100. AutoSize, if 0.

Adds a child control to the next row of the grid.

Grid. The control to be added. Percent size, if 1 to 100. AutoSize, if 0.

Adds a child control to the next row of the grid.

Grid. The control to be added. The height in pixels.

Creates a grid, pre-set with auto-sizing modes.

In case we have to disable all the controls on the page without a solution, this function creates a control that should be placed on the page instead of them all.

Pushes the graphics context origin shift so that painting at (0,0) rendered at the location specified.

Pushes the graphics state until the return value is disposed of, using the and functions.

Pushes the operation, to be popped on disposal.

Sets up a grid, with docking and auto-sizing modes. Returns the same instance.

A pre-setup auto-sizing button.

An edit box.

A pre-setup horizontal stack panel for use on the dialogs.

A pre-setup label for use on the dialogs.

Added to the default margin.

A heading for the options section.

Adds vertical space to the vertical stack. Makes the stack occupy the whole width.

Gets the default empty separator of the default height.

Retrieves the size of a rectangular area into which a control can be fitted.

An ordered pair of type representing the width and height of a rectangle. The custom-sized area for a control. 2

Raises the event.

A that contains the event data.

A spin control with an integer property mirroring the .

The integer value of the control.

Gets or sets whether the timer will fire the signal immediately when it gets enabled. On False: first fires ms after enabling. On True: first fires right when it is enabled. Default is False.

A pre-setup horizontal stack panel for use on the dialogs.

The options dialog interface.

Gets or sets the current page in the options dialog.

Gets a window frame that represents the given Options Page.

Fetches instance by id. This method can be used for fetching values from another page (for dependent pages). As this method might cause creating the other page, must be called in a guarded context only.

Gets the Settings Store context for saving your Options Page settings. Use this for binding your Options Page settings controls in real time. In case you need to manually control the context your settings go to (like when they reference solution information and thus have no meaning in the global context), take and operate it directly. In default cases, use this context (which is a context in the same Settings Store). This context belongs to a Settings Store transaction, so you can freely modify it in Options UI and access this data across pages. The choice of the context depends on the user's settings editing mode: either Smart Save by default, or writing to a specific storage in Advanced mode.

Gives lifetime and components to the option dialog instances it creates.

We require that the guard is not held when this method is called.

Shows the Options dialog. We require that the guard is not held when this method is called.

Creates and caches the views of the pages.

Gets the collection of the views currently in the cache. Those are all the pages to take part in the current Options dialog run.

Gets cached or creates new page view. The factory function must operate in the guarded context.

Settings for .

CollectionEditItemView

InitializeComponent

PagedContainer

Interaction logic for PagedContainer.xaml

InitializeComponent

Renders the default boilerplate splash for the given product info.

Creates the default boilerplate vector splash for the given product info.

Prevent solution leak through WPF and/or UI Automation by disconnecting as much of the graph as possible when the lifetime terminates. Originates in VsCodeEditorDevTen impl.

Converts System.Drawing.Bitmap to System.Windows.Media.ImageSource. NOTE: example of using: ... Source="{Binding Source={x:Static ....MyResources.Bitmap1}, Converter={StaticResource bitmapToImageSourceConverter}}" ...

Converts a value.

A converted value. If the method returns null, the valid null value is used. The value produced by the binding source. The type of the binding target property. The converter parameter to use. The culture to use in the converter.

Converts a value.

A converted value. If the method returns null, the valid null value is used. The value that is produced by the binding target. The type to convert to. The converter parameter to use. The culture to use in the converter.

Converts System.Boolean to any type

Gets or sets a value used in case of null (useful in bindings to Nullable)

Converts System.Boolean to System.Windows.Visibility. Additionally it has support to invert value during converting and to select System.Windows.Visibility value for hidden state

Gets or sets whether bool value should be inverted before convering

Gets or sets a value used in case of null (useful in bindings to Nullable)

Gets or sets a value used for hidden case

Converts a value.

Enum to boolean converter. Especially useful to convert enum to several radiobuttons or checkbox. Use it like {Binding Path=YourEnumProperty, Converter={StaticResource EnumToBooleanConverter}, ConverterParameter={x:Static local:EnumType.Enum1}} or {Binding Path=YourEnumProperty, Converter={C:EnumToBooleanConverter True={x:Static local:EnumType.Enum1}, False={x:Static local:EnumType.Enum2}}}

Enum to its description. It is being taken from Description attribute of enum's option.

Enum to visibility converter. Especially useful to change visibility according to enum option Use it like {Binding Path=YourEnumProperty, Converter={StaticResource EnumToVisibilityConverter}, ConverterParameter={x:Static local:EnumType.Enum1}}

Gets or sets whether bool value should be inverted before convering

Gets or sets a value used for hidden case

Enum member to its member description. Descriptions are taken from Description attribute of enum's option. Useful to populate combobox with enum members.

Enum to array of its members descriptions. Descriptions are taken from Description attribute of enum's option. Useful to populate combobox with enum members.

Converts the given value to an inverted value the same type

Gets or sets a value used in case of null (useful in bindings to Nullable)

Converts a value.

XAML value converters should be inhereted from MarkupConverterBase to be allowed to use it as MarkupExtension without placing in resources

Converts the given value with additional mul by the parameter (or property Factor if parameter is not set). Useful to get relatively larger or smaller values in XAML

Converts a value.

Gets or sets a value used in case of null (useful in bindings to Nullable)

Converts a value.

Converts System.Boolean to any type

Converts reference to System.Windows.Visibility ('null' means hidden state) Additionally it has support to invert value during converting and to select System.Windows.Visibility value for hidden state

Gets or sets whether bool value should be inverted before convering

Gets or sets a value used for hidden case

Converts a value.

Enum member to its member description. Descriptions are taken from Description attribute of enum's option. Useful to populate combobox with enum members.

DragMouseAnchorPoint defines the horizontal and vertical proportion at which the pointer will anchor on the DragAdorner.

Holds information about a the source of a drag drop operation.

The class holds all of the framework's information about the source of a drag. It is used by to determine whether a drag can start, and what the dragged data should be.

Initializes a new instance of the DragInfo class.

The sender of the mouse event that initiated the drag. The mouse event that initiated the drag.

Gets or sets the drag data.

This must be set by a drag handler in order for a drag to start.

Gets the position of the click that initiated the drag, relative to .

Gets the point where the cursor was relative to the item being dragged when the drag was started.

Gets or sets the allowed effects for the drag.

This must be set to a value other than by a drag handler in order for a drag to start.

Gets the mouse button that initiated the drag.

Gets the collection that the source ItemsControl is bound to.

If the control that initated the drag is unbound or not an ItemsControl, this will be null.

Gets the position from where the item was dragged.

The index of the source.

Gets the object that a dragged item is bound to.

If the control that initated the drag is unbound or not an ItemsControl, this will be null.

Gets a collection of objects that the selected items in an ItemsControl are bound to.

If the control that initated the drag is unbound or not an ItemsControl, this will be empty.

Gets the control that initiated the drag.

Gets the item in an ItemsControl that started the drag.

If the control that initiated the drag is an ItemsControl, this property will hold the item container of the clicked item. For example, if is a ListBox this will hold a ListBoxItem.

Gets the FlowDirection of the current drag source.

Gets the which is used by the drag and drop operation. Set it to a custom instance if custom drag and drop behavior is needed.

Holds information about a the target of a drag drop operation.

The class holds all of the framework's information about the current target of a drag. It is used by method to determine whether the current drop target is valid, and by to perform the drop.

Initializes a new instance of the DropInfo class.

The sender of the drag event. The drag event. Information about the source of the drag, if the drag came from within the framework.

Gets the drag data.

If the drag came from within the framework, this will hold: - The dragged data if a single item was dragged. - A typed IEnumerable if multiple items were dragged.

Gets a object holding information about the source of the drag, if the drag came from within the framework.

Gets the mouse position relative to the VisualTarget

Gets or sets the class of drop target to display.

The standard drop target adorner classes are held in the class.

Gets or sets the allowed effects for the drop.

This must be set to a value other than by a drop handler in order for a drop to be possible.

Gets the current insert position within .

Gets the collection that the target ItemsControl is bound to.

If the current drop target is unbound or not an ItemsControl, this will be null.

Gets the object that the current drop target is bound to.

If the current drop target is unbound or not an ItemsControl, this will be null.

Gets the current group target.

If the drag is currently over an ItemsControl with groups, describes the group that the drag is currently over.

Gets the control that is the current drop target.

Gets the item in an ItemsControl that is the current drop target.

If the current drop target is unbound or not an ItemsControl, this will be null.

Gets the orientation of the current drop target.

Gets and sets the text displayed in the DropDropEffects adorner.

Gets the relative position the item will be inserted to compared to the TargetItem

Gets a flag enumeration indicating the current state of the SHIFT, CTRL, and ALT keys, as well as the state of the mouse buttons.

Gets or sets the drag data.

This must be set by a drag handler in order for a drag to start.

Gets the position of the click that initiated the drag, relative to .

Gets the point where the cursor was relative to the item being dragged when the drag was started.

Gets or sets the allowed effects for the drag.

This must be set to a value other than by a drag handler in order for a drag to start.

Gets the mouse button that initiated the drag.

Gets the collection that the source ItemsControl is bound to.

If the control that initated the drag is unbound or not an ItemsControl, this will be null.

Gets the position from where the item was dragged.

Gets the object that a dragged item is bound to.

If the control that initated the drag is unbound or not an ItemsControl, this will be null.

Gets a collection of objects that the selected items in an ItemsControl are bound to.

If the control that initated the drag is unbound or not an ItemsControl, this will be empty.

Gets the control that initiated the drag.

Gets the item in an ItemsControl that started the drag.

If the control that initiated the drag is an ItemsControl, this property will hold the item container of the clicked item. For example, if is a ListBox this will hold a ListBoxItem.

Gets the FlowDirection of the current drag source.

Gets the which is used by the drag and drop operation. Set it to a custom instance if custom drag and drop behavior is needed.

Interface implemented by Drag Handlers.

Queries whether a drag can be started.

Information about the drag. To allow a drag to be started, the property on should be set to a value other than .

Notifies the drag handler that a drop has occurred.

Information about the drop.

Notifies the drag handler that a drag has been aborted.

Gets the drag data.

If the drag came from within the framework, this will hold: - The dragged data if a single item was dragged. - A typed IEnumerable if multiple items were dragged.

Gets a object holding information about the source of the drag, if the drag came from within the framework.

Gets the mouse position relative to the VisualTarget

Gets or sets the class of drop target to display.

The standard drop target adorner classes are held in the class.

Gets or sets the allowed effects for the drop.

This must be set to a value other than by a drop handler in order for a drop to be possible.

Gets the current insert position within .

Gets the collection that the target ItemsControl is bound to.

If the current drop target is unbound or not an ItemsControl, this will be null.

Gets the object that the current drop target is bound to.

If the current drop target is unbound or not an ItemsControl, this will be null.

Gets the current group target.

If the drag is currently over an ItemsControl with groups, describes the group that the drag is currently over.

Gets the control that is the current drop target.

Gets the item in an ItemsControl that is the current drop target.

If the current drop target is unbound or not an ItemsControl, this will be null.

Gets the orientation of the current drop target.

Gets the FlowDirection of the current drop target.

Gets and sets the text displayed in the DropDropEffects adorner.

Gets the relative position the item will be inserted to compared to the TargetItem

Gets a flag enumeration indicating the current state of the SHIFT, CTRL, and ALT keys, as well as the state of the mouse buttons.

Indicates if the drop info should be handled by itself (useful for child elements)

Interface implemented by Drop Handlers.

Updates the current drag state.

Information about the drag. To allow a drop at the current drag position, the property on should be set to a value other than and should be set to a non-null value.

Performs a drop.

Information about the drop.

A strongly-typed resource class, for looking up localized strings, etc.

Returns the cached ResourceManager instance used by this class.

Overrides the current thread's CurrentUICulture property for all resource lookups using this strongly typed resource class.

Looks up a localized resource of type System.IO.UnmanagedMemoryStream similar to System.IO.MemoryStream.

An effect that makes pixels of a particular color target preserving original transparency.

The color that will be applied

Value from 0..1, which denotes how many lightness of target color should take into account

This method uses the Avalon engine to convert arc segments into bézier segments, which it does when it has to apply transforms to the points. This uses the undefined behavior and is not very cross-platform.

An interface for populating in a pull-fashion. As opposed to the push-fashion, this guarantees that your resources would already get published before anybody applies them for templating a view.

Add your resources under your lifetime in this callback. Expect to be called exactly once, so do not have to cache any produced stuff. Your code would be called on a STA thread by default, but it may not be the main thread. The dictionary is OK for free-threaded access.

The resource dictionary to give to.

Exposes the central Resource Dictionary whch should be available to every piece of WPF UI within the platform-based product. Some of the UI controls rely on theming colors, icons, automation object views and other resources which must be externally applied to them thru this dictionary. If you would like to publish a resource to make it universally available: (1) Look for an existing subsystem for registering your kind of resources, such as an icon or a color. Thus subsystem will expose them for you through this dictionary. (2) If this is a new kind of resources, add a new to the collection of . If you're authoring a new top-level WPF control (Window, Visual Studio Tool Window integration, etc), make sure to publish this dictionary on your WPF controls tree root. See for an MVVM helper for that.

Default impl.

An MVVM helper for exposing common WPF resources () on the top of a new WPF controls tree. Expose in your automation object and define the behavior on the top-level framework element, setting it to the value taken from the backend.

Mounts default styles into the common .

Wraps a lifetimed renderer function which requires guarded execution and guarded lifetime termination. The latter needs to create a new lifetime and schedule its termination correctly.

The original non-guarded lifetime originally available to you (e.g. from WhenLoaded, ViewControl, etc). Optional, but recommended. A guarded (!) lifetime of some component related to your implementation. The original unguarded lifetime might terminate _later_ than the components you're using for your view, and guarded termination execution initiated by it will execute even later. The guarded lifetime is nested within this one, if provided, to guarantee your view does not live for too long. Guards and scheduling. The renderer function, gets the guarded lifetime. The element from the renderer.

A named class to see in Snoop.

When a object is in the datacontext, presents it with .

ColorFormatSelector

Interaction logic for ColorFormats.xaml

InitializeComponent

ColorPickerControl

InitializeComponent

ColorPickerDialog

Interaction logic for ColorPickerDialog.xaml

InitializeComponent

ContentSlider

Interaction logic for ColorAxisSlider.xaml

InitializeComponent

Interaction logic for ColorPickerDialog.xaml

ControlWithSlidingContent

Interaction logic for WizardControlWithAnimation.xaml

InitializeComponent

Hack for the methods which miss the DPI.

Gets or sets template to present currently selected item

Gets or sets data template selector to present currently selected item

Gets or sets if control is checkable

Gets or sets if feature which allows to up and down items in itemssource is turned on

Gets or sets whether combo box should provide a way to search item

Gets or sets content when no items are checked

Gets or sets how many suggestion should be shown to user while it inputs

Gets or sets suggestion provider

Supports the VS behavior for a window to go transparent when the Control modifier key is down.

Apply the transparency on Ctrl key to a window.

A signal that allows to disable the transparency on the fly while the Ctrl key is down.

Apply the transparency on Ctrl key to a window handle.

A signal that allows to disable the transparency on the fly while the Ctrl key is down.

Polls keyboard for the current Ctrl key state.

Manages the automation providers, as available for our custom controls. Automation provider implementations require referencing the Avalon assemblies, which we cannot do yet. When an Avalon-aware DLL is about to query for providers on our controls, it should load the providers DLL and cause them to sign up for this Registry. Subsequently, controls will start returning the providers in response to their .

The default implementation should call into System.Windows.Automation.Provider.AutomationInteropProvider::ReturnRawElementProvider.

Lists the provider entries. The key is the class whose instance is requesting the automation peer. The takes in an instance of the key plus some more things and returns an instance of the automation provider, converted to an LResult (.NET Object -> COM Object -> IDispatch -> LResult), or Null if not available.

Called from a of a control that would like be supported by an external automation peer, fills in the message result with that peer, if available.

The owning object who's handling the windows message. A key to the and a parameter to its value . Windows message, as received by . Whether the message has been handled, and the base should not be called.

Parameters to the value func of the .

Handle to the window represented by the .

The owner object, of the type given by the key in the dictionary.

wParam of the Windows message we're handling. lParam is always .

lParam, always .

Utility class to reneder

Renders object on the specified graphics in the specified bounds.

object to render on. to render. Bounds to render in. Additional information about rendering.

Calculates rectangle of the RichText for specified bounds and rendering parameters.

Graphics to measure against. Bounds to measure in. to measure. Additional information about rendering. Rectangle for the RichText.

Finds subobject of object in the specified point.

object to test on. Point to test for. Bounds to test in. to analyze. Additional information about rendering. Rectangle of the element at the specified location, or if no element was found.

Renders object on the specified graphics in the specified bounds.

object to render on. to render. Additional information about rendering.

Utility class to reneder

Reusable object to avoid creating a new instance on each operation.

Horizontal gap between the icons and texts, in device-independent pixels.

Arranges the item in the given bounds and fills the layout data. This is the base routine for all of the measuring, hittesting and rendering methods.

Graphics object for measuring the GDI-painted text against. MUST have the correct resolution assigned. The item itself. The limiting size. Setting too small a size might cause the item to fail to measure its desired size correctly, so for the bottom-up layout pass use the max-size here. Additional information about rendering. Icons renderer. Hand in an empty or dirty object. It will be filled with layout results.

Calculates rectangle of the RichText for specified bounds and rendering parameters.

Graphics to measure against. Bounds to measure in. to measure. Additional information about rendering. Rectangle for the RichText.

Finds subobject of object at the specified point.

object to test on. Point to test for. Bounds to test in. to analyze. Additional information about rendering. Rectangle of the element at the specified location, or if no element was found.

Measures object on the specified graphics

object to measure on. to measure. Additional information about measuring. Size of the item

Renders object on the specified graphics in the specified bounds.

object to render on. to render. Bounds to render in. Additional information about rendering.

Renders object on the specified graphics in the specified bounds.

object to render on. to render. Bounds to render in. Additional information about rendering. Frame percentage, [0..1).

Renders object on the specified graphics in the specified bounds.

object to render on. to render. Point at which to render. The size, and whether it's the desired size or constrained-down size, is taken from the pre-calculated object. Additional information about rendering. Icon renderer. The cached layout to render in. Must be already filled with . Frame percentage, [0..1), if expecting animation. Null means render the static representation even if icon supports animation.

The results of an call. Used by rendering, hittesting, and desired size retrieval methods.

Desired size of the presentable item. Might be Null if the limiting size was too small at the time of Arrange.

Icon area rectangles, in order of appearance in the icons array, if any icons are present. This is relative to the upper-left point of the painting area. Don't prepare this field before calling , it will allocate the array of a sufficient size. Note that it won't shrink a larger array down to avoid unnecessary allocations (but will reset any excess items to collapsed rects), so care array lengths when consuming.

Arranged size of the presentable item (the Size parameter as it was passed to Arrange). All of the rectangles should be within the rectangle of this size located at (0,0).

Text area rectangle, if text is present. This is relative to the upper-left point of the painting area.

Utils for accessing controls

Returns control at screenPoint or a control, that contains a window at screenPoint

Centers the -sized rectangle over the main window, checks that it falls in screen.

Centers the -sized rectangle over the window, checks that it falls in screen.

Ensures the given bounds fall within a screen. Prefers to rather move than downsize. Chooses the screen that contains most of the initial .

Returns the control that currently has focus, or Null if either none of our windows has focus, or the focused window is not a control.

Returns Control whose handle equals to hwnd passed or containing window with current hwnd

Clear private cachedLayoutEventArgs field of a Control.

(DK) It could retain a solution and lead to a solution leak. cachedLayoutEventArgs is set if PerformLayout method is called when the layout is suspended. The field is cleared on the next PerformLayout. Stackoverflow.com suggests to call PerformLayout (again) but we had better clear the field using reflection.

Suspends the layout of the given control and resumes it automatically when disposed of. [Omea]

Whether to apply layout on resume.

The list of controls to be resumed.

Suspends the layout of the following control and resumes it when disposed of.

Control to be suspended/resumed. Must not be Null. Whether to suspend all the child controls also. will be called with as an argument.

Suspends the layout of the following control and resumes it when disposed of.

Control to be suspended/resumed. Must not be Null.

Suspends the list.

Resumes the control's layout.

Gets the logical font for the control, considering its property, and the current actual resolution. Beware these two might not be in sync: (a) if noone has called , or (b) if we're in between the synchronous change in dynamic DPI and the asynchronous event on that from the DPI Charmer which would update the font correctly.

Gets the logical font for the control, considering its property, and the current actual resolution, LIVE. Unlike the static version, this value is eventually consistent.

Gets a font for Windows Forms and for the current DPI value. The returned font is pixel-bound and would not autoscale on render (but might change its pixel value if your Form gets a DPI-change event and dynamic DPI tricks are active).

Retrieves the element in this fragment that is at the specified point.

The provider for the child element at the specified point, if one exists, or the root provider if the point is on this element but not on any child element. Otherwise returns null. The X coordinate,. The Y coordinate.

Retrieves an array of fragment roots that are embedded in the UI Automation element tree rooted at the current element.

An array of root fragments, or null.

Retrieves the element in this fragment that has the input focus.

The provider for the element in this fragment that has the input focus, if any; otherwise, a null reference (Nothing in Visual Basic).

Retrieves an object that provides support for a control pattern on a UI Automation element.

Object that implements the pattern interface, or null if the pattern is not supported. Identifier of the pattern.

Retrieves the value of a property supported by the UI Automation provider.

The property value, or a null if the property is not supported by this provider, or if it is not supported at all. The property identifier.

Retrieves the runtime identifier of an element.

The unique run-time identifier of the element.

Retrieves the UI Automation element in a specified direction within the tree.

The element in the specified direction, or null if there is no element in that direction The direction in which to navigate.

Sets the focus to this element.

Gets the bounding rectangle of this element.

The bounding rectangle, in screen coordinates.

Retrieves the root node of the fragment.

The root node.

Gets a base provider for this element.

The base provider, or null.

Gets a value that specifies characteristics of the UI Automation provider; for example, whether it is a client-side or server-side provider.

Either or .

Sends a request to activate a control and initiate its single, unambiguous action.

If the control is not enabled.

Retrieves an array of fragment roots that are embedded in the UI Automation element tree rooted at the current element.

An array of root fragments, or null.

Retrieves an object that provides support for a control pattern on a UI Automation element.

Object that implements the pattern interface, or null if the pattern is not supported. Identifier of the pattern.

Retrieves the value of a property supported by the UI Automation provider.

The property value, or a null if the property is not supported by this provider, or if it is not supported at all. The property identifier.

Retrieves the runtime identifier of an element.

The unique run-time identifier of the element.

Retrieves the UI Automation element in a specified direction within the tree.

The element in the specified direction, or null if there is no element in that direction The direction in which to navigate.

Sets the focus to this element.

Gets the bounding rectangle of this element.

The bounding rectangle, in screen coordinates.

Retrieves the root node of the fragment.

The root node.

Gets a base provider for this element.

The base provider, or null.

Gets a value that specifies characteristics of the UI Automation provider; for example, whether it is a client-side or server-side provider.

Either or .

Retrieves the element in this fragment that is at the specified point.

Retrieves the element in this fragment that has the input focus.

The provider for the element in this fragment that has the input focus, if any; otherwise, a null reference (Nothing in Visual Basic).

Sends a request to activate a control and initiate its single, unambiguous action.

If the control is not enabled.

Retrieves an array of fragment roots that are embedded in the UI Automation element tree rooted at the current element.

An array of root fragments, or null.

Retrieves an object that provides support for a control pattern on a UI Automation element.

Object that implements the pattern interface, or null if the pattern is not supported. Identifier of the pattern.

Retrieves the value of a property supported by the UI Automation provider.

The property value, or a null if the property is not supported by this provider, or if it is not supported at all. The property identifier.

Retrieves the runtime identifier of an element.

The unique run-time identifier of the element.

Retrieves the UI Automation element in a specified direction within the tree.

The element in the specified direction, or null if there is no element in that direction The direction in which to navigate.

Sets the focus to this element.

Gets the bounding rectangle of this element.

The bounding rectangle, in screen coordinates.

Retrieves the root node of the fragment.

The root node.

Gets a base provider for this element.

The base provider, or null.

Gets a value that specifies characteristics of the UI Automation provider; for example, whether it is a client-side or server-side provider.

Either or .

Sends a request to activate a control and initiate its single, unambiguous action.

If the control is not enabled.

Retrieves an object that provides support for a control pattern on a UI Automation element.

Object that implements the pattern interface, or null if the pattern is not supported. Identifier of the pattern.

Retrieves the value of a property supported by the UI Automation provider.

The property value, or a null if the property is not supported by this provider, or if it is not supported at all. The property identifier.

Gets a base provider for this element.

The base provider, or null.

Gets a value that specifies characteristics of the UI Automation provider; for example, whether it is a client-side or server-side provider.

Either or .

Retrieves an object that provides support for a control pattern on a UI Automation element.

Object that implements the pattern interface, or null if the pattern is not supported. Identifier of the pattern.

Retrieves the value of a property supported by the UI Automation provider.

The property value, or a null if the property is not supported by this provider, or if it is not supported at all. The property identifier.

Gets a base provider for this element.

The base provider, or null.

Gets a value that specifies characteristics of the UI Automation provider; for example, whether it is a client-side or server-side provider.

Either or .

Sets the value of a control.

The value to set. The provider is responsible for converting the value to the appropriate data type. If locale-specific information is passed to a control in an incorrect format such as an incorrectly formatted date. If a new value cannot be converted from a string to a format the control recognizes. When an attempt is made to manipulate a control that is not enabled.

Gets a value that specifies whether the value of a control is read-only.

true if the value is read-only; false if it can be modified.

Gets the value of the control.

The value of the control as a string.

A simple windowless control that just renders a bitmap.

Creates a control which tracks the live themed image.

Gets or sets the image to be rendered in the windowless control.

Renders the context of the windowless control. The rendering bounds are given by the

Performs the top-down layouting stage, when the control lais out its parts within the given bounds.

The device context to measure against. The new bounds. From now on, this value should be returned from the property.

The layouting details.

Gets or sets whether the control should be activated initially when it's shown. The typical implementation for a form is to return a negative of this value from the override.

The windowless control bounds in the parent coordinates. The implementor should just store and return the value set by the owner.

The control has gotten dirty and should be repainted.

Fires when the control would like to be reasked of its desired size.

A panel that has a lower border.

Gets or sets the border color. is not used so that to avoid inheriting it in the child controls.

Gets or sets which borders to paint.

Gets or sets the fill color. is not used so that to avoid inheriting it in the child controls.

Raises the event.

A that contains the event data.

A control that displays the HTML content.

Gets or sets the HTML contents of the page displayed in the System.Windows.Forms.WebBrowser control. Wraps the base implementation to catch the setter silly exceptions.

Raises the event.

A that contains the event data. This instance is no longer valid. A reference to an implementation of the IWebBrowser2http://msdn.microsoft.com/workshop/browser/webbrowser/reference/ifaces/iwebbrowser2/iwebbrowser2.asp could not be retrieved from the underlying ActiveX WebBrowserhttp://msdn.microsoft.com/library/default.asp?url=/workshop/browser/webbrowser/browser_control_node_entry.asp.

Returns a reference to the unmanaged WebBrowser ActiveX control site, which you can extend to customize the managed control.

A that represents the WebBrowser ActiveX control site.

A checkbox that gets visually unchecked when disabled. Use the property if you'd like to use the non-visual state, to use the visual state. Setting will not affect the value. The property reflects the visual state of the checkbox. Setting to always or never show keyboard mnemonics. Setting you can override default focus visual style.

True when the property is being manipulated by this control on enable/disable. The should not change in such a case.

Gets or sets whether the checkbox is logically checked, not only visibly.

Gets whether the checkbox is currently visually checked, or not. False when not .

Recacls the checked state of the control in response to various events.

Raises the event.

An that contains the event data.

Raises the event.

An that contains the event data.

A list box with a custom painter.

Type of the listbox items.

The item painter to use.

Fires when the list box is scrolled.

Shows the prompt form with the as the parent. Returns whether the user accepted the change.

Required designer variable.

Clean up any resources being used.

true if managed resources should be disposed; otherwise, false.

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

Places a static glyph into an editbox control.

Places the glyph into an owning editbox.

Gets the image for the glyph.

Gets or sets the provider that defines the tooltip for the control.

Called by tooltip manager, if the tooltip is to be displayed

Point in control's coordinates , or Null if no tooltip should be displayed.

Pending / Ready / Invalid color for the editbox text.

Listen for the Enter key in the editbox. In case it's pressed when there's no selection (eg when typed a symbol and still calculating in background), wait async for the items to appear in the list, and then execute the first one.

Places the extension control on the menu, which is a checkbox with an optional checkmark and dynamic text.

Sets up the “busy” glyph.

Implements the presentation of the Goto By Name functionality that works thru a .

Gets the menu view, when the menu is running onscreen. Otherwise Null.

Gets the menu popup window, when the menu is running onscreen. Otherwise Null.

Spawns the Goto By Name -based UI upon the given model. Disposes of the model when done.

Goto-by-name model that provides data for the UI.

Attaches to existing to provide ability to react to actions with shortcuts, evaluate and execute in DataContext with current Key

Special action handlers, which can work fine when active JPM exists on screen. They are used for revolver-style Go to everything menu and floating QuickDoc

Interface for creating custom painters

Checks if a given Item can be handled by the painter

The Item to check true if the Item can be handled, false it cannot.

Returns size of an item

Draws a given Item in specified rectangle

If the Item cannot be handled, the method should do nothing The Item to draw Graphics to draw in Bounding rectangle to use

A simple button which draws one of four images from the image list depending on its state.

A customized link label that natively supports URIs for opening in the Web browser and copying to clipboard.

A Web URI link.

An action link.

Raises the event.

An that contains the event data.

Raises the event.

A that contains the event data.

Called by tooltip manager, if the tooltip is to be displayed

Point in control's coordinates , or Null if no tooltip should be displayed.

This class represents a form that should be owned by a Win32 window. It should be used as a base class for various dialogs, etc.

Represents a group of radio buttons with a single value that is determined by the radiobutton that is checked. There is an option checkbox that disables or enables the whole group.

Type of the value chosen by this group.

The default radio button margin to which we're adding.

Values on the radio buttons.

Indicates whether the property buttons should be enabled.

Provides for restoring the selection that used to be before disabling the radio buttons.

WHether the label or checkbox is visible.

Text of the label (if there's no checkbox), or the checkbox (if it's ON).

The when nothing is selected (eg checkbox is unchecked).

The additional margin around the radio buttons, ie one that positions them indented under the title check/label.

The composite value of this group.

Adds a comment to the last radio button. The only difference with adding a control directly is that the enabled state of the comment will be synched to the previous radio button.

Adds a dependent control to the last radio button. The only difference with adding a control directly is that the enabled state of the dependent control will be synched to the previous radio button checked/enabled state.

Adds a new radio button to the group, along with its value.

Adds a reference so that it's held until the form is disposed of, after which it's disposed of.

Default ctor. Designer-compatible. Make available in the data context for the control to work.

Assigns view model to the data context of this control.

Assigns view model to the data context of this control. Flient.

Required designer variable.

Clean up any resources being used.

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

A spacer WinForms control to fill the unneeded space.

Retrieves the size of a rectangular area into which a control can be fitted.

An ordered pair of type representing the width and height of a rectangle. The custom-sized area for a control. 2

Gets or sets a value indicating whether [fill split height].

true if [fill split height]; otherwise, false.

Required designer variable.

Clean up any resources being used.

true if managed resources should be disposed; otherwise, false.

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

Caption above the strings list.

Icon for the items in the list.

Items in the editable list.

This class adds click-through behaviour to ToolStrip

Gets or sets whether the ToolStripEx honors item clicks when its containing form does not have input focus.

Default value is false, which is the same behavior provided by the base ToolStrip class.

Changes the background without actually changing the backcolor, to avoid inheritance to children.

Gets or sets the fill color that won't propagate to the children.

Paints the background of the panel.

A that contains information about the panel to paint.

Tab page can be drawn not directly from the rect bounds but with some spaces or margins. Without an account for these shifts, the presentable item will be drawn directly on the tab border. This margin shift the drawing of the presentable item and is accounted in the calculation of tab width;

A GDI+ renderer view for the Presentable Item Block.

Bounds, as assigned by the parent.

The rendered presentable item.

The rendering aspect.

Fires when the control would like to be reasked of its desired size.

Creates the tip painter.

Gets or sets whether the control should be activated initially when it's shown. The typical implementation for a form is to return a negative of this value from the override.

The windowless control bounds in the parent coordinates. The implementor should just store and return the value set by the owner.

The control has gotten dirty and should be repainted.

Gets or sets the presentable item rendered by the view. Can be Null for an empty view of zero size.

Gets or sets the rendering aspect. Must not be Null.

Fires when the control would like to be reasked of its desired size.

Renders the context of the windowless control. The rendering bounds are given by the

Performs the top-down layouting stage, when the control lais out its parts within the given bounds.

The device context to measure against. The available space.

The layouting details.

A tooltip control painter that renders a standard presentable item on it.

Bounds, as assigned by the parent.

The rendered presentable item.

The rendering aspect.

Fires when the control would like to be reasked of its desired size.

Creates the tip painter.

Creates the tip painter. Note: you should rather use for formatted text, because it supports reflow.

Gets or sets the presentable item rendered by the view. Can be Null for an empty view of zero size.

Gets or sets the rendering aspect. Must not be Null.

Renders the context of the windowless control. The rendering bounds are given by the

Performs the top-down layouting stage, when the control lais out its parts within the given bounds.

The device context to measure against. The available space.

The layouting details.

Gets or sets whether the control should be activated initially when it's shown. The typical implementation for a form is to return a negative of this value from the override.

The windowless control bounds in the parent coordinates. The implementor should just store and return the value set by the owner.

The control has gotten dirty and should be repainted.

Fires when the control would like to be reasked of its desired size.

Reflows a rich text block

Reflows the set of strings so that they fit the width specified. The existing line breaks are kept, new ones are added as needed.

The source lines of text. The maximum width. The device context for measuring the text against. The rendering aspect. The formatted rich text with new line breaks.

Reflows the single line of so that it fits the width specified. The line breaks are added as needed.

The source line of text. The maximum width. The device context for measuring the text against. The rendering aspect. The formatted rich text with new line breaks.

This is the main GDI+ painter façade for the rich texts. Use these methods and pass the Graphics Container to ensure correct dynamic resolution handling. Do not call the painter core unless you have no other options.

Renders a multiline wrappable heading with one bold paragraph and one normal-text paragraph.

Normal text part.

Bold text part.

Gets or sets the body part of the heading.

Gets or sets the title part of the heading.

A rich text label control capable of autosizing.

The formatted to fit the width.

Caches the width-to-size mappings for quick access.

Automatically derived from the Fonts Manager. Automatically driven by DPI.

Could be assigned by the user. Takes precedence over auto. User is in charge of DPIing in this case. UPD: RenderParams are DPI-invariant now!

The rich text, as set by the user.

Constructs a default rich text label.

Creates a rich text label, setting the given text and changing the default margin.

Creates a rich text label, setting the given text.

Gets or sets the accelerator keystroke of the control.

Gets or sets the rendering aspect for the text.

Gets or sets the rich text associated with the control.

Gets or sets the formatted text displayed by this label.

Reflows the formatted text block to the new width.

Clean up any resources being used.

Processes a mnemonic character.

true if the character was processed as a mnemonic by the control; otherwise, false. The character to process.

Gets or sets the background color for the control.

A that represents the background color of the control. The default is the value of the property. 1

Gets the rectangle that represents the display area of the control.

A that represents the display area of the control. 1

Gets or sets the foreground color of the control.

The foreground of the control. The default is the value of the property. 1

Gets or sets the text associated with this control.

The text associated with this control. 1

Draws the formatted string on a given graphics.

The rich text instance. The GDI+ device context to draw the string into. The rectangle where the string is drawn. Defines the rendering aspects. Optional. Pre-calculated sizes for rich text parts. If null, sizes will be calculated during drawing. is Null. is Null.

Gets the index of a character with the given local x-coordinate, or -1 if none. The y-coordinate is checked for hitting the RichText-global bounding rect only.

The rich text instance. The GDI+ device context to draw the string into. Defines the rendering aspects. The RichText-local coordinates to lookup the character by, in device pixels (same DPI as ).

Gets the index of a character with the given local x-coordinate, or -1 if none.

The rich text instance. The GDI+ device context to draw the string into. Defines the rendering aspects. The RichText-local x-coordinate to lookup the character by, in device pixels (same DPI as ).

Calculates the rich text bounding rectangle against the given device context. Caches the previously-calculated value.

The rich text instance. The GDI+ device context to draw the string into. Defines the rendering aspects. is Null. is Null.

Calculates the rich text bounding rectangle against the given device context. Caches the previously-calculated value.

The rich text instance. The GDI+ device context to draw the string into. Defines the rendering aspects. is Null. is Null.

Tip painter which paints tips with simple multiline formatted text. Reflows the text if the width does not fit.

Bounds, as assigned by the parent.

The desired size of the , in absence of any external constraints. Lazily-calculated, Null when invalid.

The resolution given on most recent layout assignment.

Reflowed content, lazily-created. Use the method. NULL block when not valid.

Rendering aspect.

Content.

The current width constraint.

Fires when the control would like to be reasked of its desired size.

Creates the painter over a rich text. If the text contains line breaks, it's split into several lines.

Creates the painter over a rich text block.

Size of the padding around the text.

Gets or sets the content. Must not be Null.

Gets the reflowed rich text block. Lazily reflows the original block if needed.

Gets or sets the rendering aspect. Must not be Null.

Renders the context of the windowless control. The rendering bounds are given by the

Performs the top-down layouting stage, when the control lais out its parts within the given bounds.

The device context to measure against. The available space.

The layouting details.

Gets or sets whether the control should be activated initially when it's shown. The typical implementation for a form is to return a negative of this value from the override.

The windowless control bounds in the parent coordinates. The implementor should just store and return the value set by the owner.

The control has gotten dirty and should be repainted.

Fires when the control would like to be reasked of its desired size.

Special nice button like in IDEA

A jet windowless control to paint an UI Element.

Virtual list box control

Helper class for various implementations. Mostly, dispatches the creation of various windowless controls for optimal performance.

Renders an

Switchable implementation that's activated only when we have a presentation.

Tracks the live resolution.

Gets or sets whether the windowless control will be rendered with an alpha channel or not.

Sets the presentation for the UI element. Get collapsed on Null.

Fires when we're queried for a tooltip. Retranslates the WPF event intercepted on the windowless control element level.

Tooltips support thru and and .

Provides colors used for display ToolBar and it's items. This class provides color set from currently used Theme. See ThemeManager component for additional details

A UI element for planting the Action Manager Toolbar into the WPF UI. Does not require any components for creating an instance. All of the components and data are databound from the viewmodel.

Action bar manager for the toolbar.

ID of the actions group whose actions should be presented as toolbar buttons.

Outermost control hosting the whole setup with toolbar and payload content controls. For example, in a tool window that would be your content element. In a window, that would be the window content element. Usually the returned action bar UI element is parented by the context parent. When keyboard focus is within the context parent, the focused element defines the data context (it's collected by bubbling from the focused element and collecting all the available data rules/constants). When keyboard focus is not within, the logical focus context is used for gathering data context, which is basically the most recently keyboard-focused element (or, rather, which element would get focused when keyboard focus returns to the window). This allows for keeping the window-local action buttons enabled on the toolbar even when focus is not in the window itself. To implement this, is set to True on .

When this decorator gets loaded into the presentation source tree, it creates the UI element with the provided functor under the loaded-state lifetime.

Applies a list of s to an Avalon .

In DevTen Beta2, the status bar itself lives on another thread, which makes it planting our controls very complicated because of the threading issues. That's why we prefer planting to the dock panel that hosts the status bar.

Helper for attaching to a status bar. Places a panel for our items in among its indicators. Must be executed on the status bar thread.

The status bar to plant into. The Avalon element to put on the status bar as its item.

Transforms a live collection of status bar indicator documents into a live collection of status bar indicator WPF views, which is suitable for binding to WPF items control item sources.

Creates the panel into which the indicator view items will be put.

Transforms a live collection of status bar indicator documents into a live collection of status bar indicator WPF views, which is suitable for binding to WPF items control item sources.

If there's an Avalon status bar which belongs to some IDE which we're plugged in to (such as DevTen Beta 1), adds our indicators to that status bar. DO NOT use this for running status bars in standalone applications, because this is a very non-straightforward way of doing things.

Means the on the bottom of the window, to which our status indicators should be added in a dock-right fashion. Usually the status bar itself sits in the same dock panel. This approach is used when we cannot deal with the status bar itself to put the items into it properly. The case in VS 10 beta 2, where the status bar control itself sits on another thread and causes a marshalling pain for us if operated directly. It's expected to be a really, but we'd fallback for cases when we find ourselves in an unexpected layout and look for just any suitable panel.

Tries to find an Avalon status bar in the given window. The window must be fully inited by the moment.

Take 1: find all explicit status bars in the application window. Workable on VS10 up to Beta2 (non-inclusive).

Take 2: in VS 10 beta 2, the status bar is hosted in another thread. There seems to be no legal way for ripping out the nested object graph. Do some hacks.

A custom items control for the indicator. Changes the measuring layout pass logic to fir the height of the existing Visual Studio status bar (VS itself asks for the vertical-size as unbounded, we default to actual status bar size as the vertical bound, or to the scrollwidth if not calculated yet).

Wraps the given indicator, detaches on dispose.

The data item to be presented. A property (non-readonly) because we sometimes want to explicitly detach the backend and its resources from the view (by setting to Null).

A checkbox that gets visually unchecked when disabled. Use the property if you'd like to use the non-visual state, to use the visual state. The property reflects the visual state of the checkbox.

Represents implementation of adorner to host any type of content

Represents drop down button

Gets or sets a context menu

Called when a control is clicked by the mouse or the keyboard.

Presenter to make vector based graphical content be as text glyph. It propagates Foreground to the content, replaces brushes to the target (Stroke & Fill). Stroke & Fill properties are bound to inherited Foreground by default

Gets or sets stroke brush which is applied to draw 'contours'

Gets or sets brush which is applied to fill shapes

Recolors its content to foreground color

Renderer implementation for the JetBrains loader animation.

Runs missed steps. Returns if there were steps and render should be invalidated.

Ordinary indeterminate progress bars don't disable animations while hidden. This control enforces disable IsIndeterminate for hidden progress bars.

Represents light-weight control to visualize busy state of dialog or other control in its header

Gets or sets whether TreeGrid is busy now

Using a DependencyProperty as the backing store for IsBusy. This enables animation, styling, binding, etc...

Gets or sets initial delay before busy indication

Using a DependencyProperty as the backing store for Background. This enables animation, styling, binding, etc...

Using a DependencyProperty as the backing store for IndicatorBrush. This enables animation, styling, binding, etc...

Gets or sets milliseconds for the full cycle of the animation

When overridden in a derived class, participates in rendering operations that are directed by the layout system. The rendering instructions for this element are not used directly when this method is invoked, and are instead preserved for later asynchronous use by layout and drawing.

The drawing instructions for a specific element. This context is provided to the layout system.

Exposes properties IsFirst \ IsLast on FrameworkElements for styling purposes EnableItemsStyle should be set on target panel or itemspresenter

Search behavior: allows to assign a property from the viewmodel. Converts the handler type to the view-type handler and sets another property (this is required because we need to track an instance to later do RemoveHandler).

The internal property with the view-version of the handler, modifies the event.

Exposes the routed event in a way suitable for viewmodel-binding.

Gets the current text in the search box.

Gets or sets selected index

Represent image control with snapping to pixel grid to make icon sharp (as workaround for .NET 3.5)

Decorator computes the position of its single child inside child's Margin and calls Arrange on the child.

Size the Decorator will assume.

Implements a progress indication control in a circle.

Called to arrange and size the content of a object.

The size of the control. The computed size that is used to arrange the content.

Called to remeasure a control.

The size of the control. Measurement constraints, a control cannot return a size larger than the constraint.

Called when the property changes.

New value of the property. Old value of the property.

Called when the property changes.

Old value of the property. New value of the property.

Called when the property changes.

Old value of the property New value of the property

Represents decorator which designed to show watermark over any control to let user know what to enter in the editor

Gets or sets promt content

Using a DependencyProperty as the backing store for Prompt. This enables animation, styling, binding, etc...

Gets or sets child of the content

Provides ability to recolor any content on per-pixel level to target color with some level of brightness preserving

Gets or sets color which will be used to recolor the content

Gets or sets 'percent' of original brightness in recolored result (from 0 to 1)

Event to handle explicit user request to search

Gets or sets content to show when no text in the search box, and it is not has keyboard focus

Gets whether has any text

Gets or sets milliseconds before Search event will be triggered

Gets or sets control where text input will be listen and intercept automatically in case of it is not handled

Get or set whether can receive focus when the user press up, down or tab button in the search box

Represents an automation peer for

Represents a view for TabStripItem

Gets or sets TabStripItem to present

Gets or sets tab's alignment

Gets or sets whether user can reorder tabs

Gets items in fail-safe way

Represents a view for TabStripViewModel

Gets or sets whether user can reorder tabs

Gets or sets side where tabs should be

Gets or sets whether animation is allowed

Gets or sets whether overflowing items should be hidden into drop down button

Gets or sets style for containers in menu into this view scope

RichText representation for WPF

Gets or sets whether the RichTextPresenter is key accessed by ALT + accesskey (access key is processed from the RichText)

Using a DependencyProperty as the backing store for IsKeyAccessed. This enables styling, binding, etc...

Gets or sets whether colors will be automatically adjusted to achieve visual contrast

The TextWrapping property controls whether or not text wraps when it reaches the flow edge of its containing block box.

The TextTrimming property specifies the trimming behavior situation in case of clipping some textual content caused by overflowing the line's box.

Use this property if some manipulation with the text is performed before binding it to and thus a text in the "main" presenter and in the tooltip differ.

Use this property if some manipulation with the text is performed before binding it to and thus a text in the "main" presenter and in the tooltip differ and should be revealed even it's not trimmed from this control's point of view.

The FontFamily property specifies the name of font family.

The FontSize property specifies the size of the font.

DependencyProperty for property.

The Foreground property specifies the foreground brush of an element's text content.

DependencyProperty for property.

The Padding property specifies the padding of the element.

DependencyProperty for property.

The TextAlignment property specifies horizontal alignment of the content.

DependencyProperty for property.

The FontWeight property specifies the weight of the font.

Gets or sets whether the RichTextPresenter is key accessed by ALT + accesskey (access key is processed from the RichText)

Using a DependencyProperty as the backing store for IsKeyAccessed. This enables styling, binding, etc...

Gets or sets whether colors will be automatically adjusted to achieve visual contrast

When a rich text string is in the datacontext, presents it with .

A text element whose text value can be bound to a property.

Initializes a new, default instance of the class.

Initializes a new instance of the class, taking a specified string as the initial contents of the text run.

A string specifying the initial contents of the object.

Creates and binds the property.

Represents control to view UIText

Gets styles definitions

This automation peer is for screen reader support mainly. It does not discover virtualized tree items (due to sufficient performance degradation)

Gets or sets drag item

Using a DependencyProperty as the backing store for DragItem. This enables animation, styling, binding, etc...

Exposes ability to get parent data item of the given data item

Returns parent data item of the given data item

Data item Parent data item

Represents implementation to provide parent via callback

Incapsulates action queuing and execution in right time

Gets or sets an optional custom scheduler

Represents high-performance control to visualize state of expansion of an TreeGrid item

Gets or sets whether the corresponding item is expanded

Gets or sets level of the tree row

Using a DependencyProperty as the backing store for Level. This enables animation, styling, binding, etc...

Gets or sets whether we can collapse this node

Gets or sets how many milliseconds expander will wait while drag over it before expand the target node

Represents light-weight control to visualize busy state of TreeGrid

Gets or sets whether TreeGrid is busy now

Using a DependencyProperty as the backing store for IsBusy. This enables animation, styling, binding, etc...

Using a DependencyProperty as the backing store for Background. This enables animation, styling, binding, etc...

Using a DependencyProperty as the backing store for IndicatorBrush. This enables animation, styling, binding, etc...

Gets or sets milliseconds for the full cycle of the animation

The drawing instructions for a specific element. This context is provided to the layout system.

Represents high-performance control to visualize sorting direction of an TreeGrid column

Represents implementation to provide children via binding

Represents implementation to provide children explicitly via function

Represents fallback implementation to detect children automatically. The provider detects 'children property' if type has a property of IEnumerable or Array with the same type or close one.

Default implementation via straightforward traversal, appropriate only for 'trees' of few nodes and should be avoided in other cases

Gets or sets drag item

Using a DependencyProperty as the backing store for DragItem. This enables animation, styling, binding, etc...

Definitife, an item is definetly accepted or declined (filter produce true or false). Derivative, an item is considered accepted or declined, but it was inherited from ancestor or children acceptance

A common weak event listener which can be used for different kinds of events.

The EventArgs type for the event.

Initializes a new instance of the WeakEventListener class.

The handler for the event.

Receives events from the centralized event manager.

The type of the WeakEventManager calling this method. Object that originated the event. Event data. true if the listener handled the event. It is considered an error by the WeakEventManager handling in WPF to register a listener for an event that the listener does not handle. Regardless, the method should return false if it receives an event that it does not recognize or handle.

Gets if node has children at this moment

Gets if this node can have children

Helps to iterate items of tree as if they are flattened

Implementation appropriate only for plane lists

Represents implementation to provide parent via callback

Represents high-performance control to visualize state of expansion of an TreeGrid item

Represents high-performance control to visualize sorting direction of an TreeGrid column

Represents general usage implementation

User definition of column

Gets or sets initial width of the column

Gets or sets minimal width of the column

Gets or sets maximum width of the column

Gets or sets whether the column is allowed to be re-sized by user

Gets or sets whether this column contains expander

Using a DependencyProperty as the backing store for HasExpander. This enables animation, styling, binding, etc...

Gets or sets header of column

Using a DependencyProperty as the backing store for Header. This enables animation, styling, binding, etc...

Gets or sets data template to fill cells of this column

Using a DependencyProperty as the backing store for CellTemplate. This enables animation, styling, binding, etc...

Gets or sets template for inplace editors

Using a DependencyProperty as the backing store for CellEditingTemplate. This enables animation, styling, binding, etc...

Gets or sets a custom logic how to select data template for cells corresponding to the column

Using a DependencyProperty as the backing store for CellTemplateSelector. This enables animation, styling, binding, etc...

Gets or sets a custom logic how to select data template for cells corresponding to the column

Using a DependencyProperty as the backing store for CellTemplateSelector. This enables animation, styling, binding, etc...

Gets or sets path to the member of data model which will be presented in cells

Using a DependencyProperty as the backing store for CellMemberPath. This enables animation, styling, binding, etc...

Gets or sets function to retrieve a member of data model which will be presented in cells

Gets or sets style for cells corresponding to the column

Using a DependencyProperty as the backing store for CellStyle. This enables animation, styling, binding, etc...

Gets or sets a selector to choose style applying to corresponding cells

Using a DependencyProperty as the backing store for CellStyleSelector. This enables animation, styling, binding, etc...

Gets or sets whether it is soratble column (i.e. user can click to sort by column)

Using a DependencyProperty as the backing store for SortMemberPath. This enables animation, styling, binding, etc...

Gets if projection has nodes with children

Raises each time when children of an item were changed. Note, it might be invoked from different threads where actual changes were made

Identifies the dependency property.

The identifier for the dependency property.

Identifies the dependency property.

The identifier for the dependency property.

Gets or sets a value that indicates how horizontal scroll bars are displayed in the .

One of the enumeration values that specifies the visibility of horizontal scroll bars in the . The registered default is . For more information about what can influence the value, see .

Gets or sets a value that indicates how vertical scroll bars are displayed in the .

One of the enumeration values that specifies the visibility of vertical scroll bars in the . The registered default is . For more information about what can influence the value, see .

Whether the control may handle space bar to check and uncheck selected items. Items must implement ICheckable interface

Gets or sets whether the control should sort and filter items. It should be switched off in case of arrangement is performed by view models or no arrangement is performed at all

Gets or sets data template for cells as default

Using a DependencyProperty as the backing store for CellTemplate. This enables animation, styling, binding, etc...

Gets or sets data template selector

Using a DependencyProperty as the backing store for CellTemplateSelector. This enables animation, styling, binding, etc...

Gets or sets how many levels will be expanded by default with method ExpandAll and when user press '*'

Using a DependencyProperty as the backing store for ColumnDefinitions. This enables animation, styling, binding, etc...

Gets or sets whether tree should automatically expand nodes with single child

Defines whether column headers should be shown. Note, that if all column definitions have no header set, it is hidden automatically no matter what value the propery has

Occurs when SortColumn value changes

Gets or sets which is using to sort items. Note, it has no effect if SortDescription set up

Using a DependencyProperty as the backing store for SortColumn. This enables animation, styling, binding, etc...

Gets or sets sort direction

Using a DependencyProperty as the backing store for SortDirection. This enables animation, styling, binding, etc...

Gets or sets additional sort description which can be used to pre sort items. It does not affect and and can be used to sort items before them.

Occurs when SelectedItem changes

Occurs when SelectedItems collection changes

Gets or sets selected item of

Using a DependencyProperty as the backing store for SelectedItem. This enables animation, styling, binding, etc...

Gets or sets a function to define focusability of nodes

Gets or sets a function to define selectability of nodes

Using brackets to warp model access

Custom access brackets

Catch exceptions, use access brackets to warp model access

Expand all nodes

How deep we can expand or null (MaxLevelsExpansion will be used)

Expand all nodes starting with the given node

Node to start expansion process How deep we can expand or null (MaxLevelsExpansion will be used)

Print current structure (for debug perpose)

Returns true if item is valid and exists in the tree data source

Gets currently expanded items

Expands all nodes along the path

Path from root to the last node to expand

Expands all nodes along the path to the target (target remains as is)

Path from root to the last node to expand

Expands all nodes along the path

Path from root to the last node to expand

Optimally calculates index, use knowledge that item should be in the viewport

Gets index of the first item or -1 if no items in the viewport

Select item

Item True if item was select or false in case of no such node or it is already selected

Deselect item

True if item was deselect or false in case of no such node or it is already deselected

Using a DependencyProperty as the backing store for Level. This enables animation, styling, binding, etc...

Gets or sets level in the TreeGrid

Gets or sets whether the cell is selected

Using a DependencyProperty as the backing store for IsSelected. This enables animation, styling, binding, etc...

Gets or sets whether item is expanded

Using a DependencyProperty as the backing store for IsExpanded. This enables animation, styling, binding, etc...

Using a DependencyProperty as the backing store for IsActive. This enables animation, styling, binding, etc...

Gets whether the cell active (i.e. parent has keyboard focus within)

When overridden in a derived class, is invoked whenever application code or internal processes call .

Gets or sets current content

Using a DependencyProperty as the backing store for Content. This enables animation, styling, binding, etc...

Constructor

Calculates desired width of the cell. (Performance costly)

Index of cell (column index) in the row Desired width in pixels

Gets the viewport where cells are

Represents a column in .

Gets or sets actual column definitions

Gets or sets actual column definition

Using a DependencyProperty as the backing store for ColumnDefinition. This enables animation, styling, binding, etc...

Defines whether it can be resized or it should be fixed. It should be used as trigger in a corresponding Style / ControlTemplate

Using a DependencyProperty as the backing store for Resizable. This enables animation, styling, binding, etc...

Using a DependencyProperty as the backing store for Level. This enables animation, styling, binding, etc...

Gets whether this column is used to sort

Gets whether drop is ready to be performed on the column to insert other one after this

Using a DependencyProperty as the backing store for IsDragOver. This enables animation, styling, binding, etc...

Gets current header height

User definition of column

Gets or sets column's name

Gets or sets initial width of the column

Gets or sets minimal width of the column

Gets or sets maximum width of the column

Gets or sets whether the column is allowed to be re-sized by user

Gets or sets whether this column contains expander

Using a DependencyProperty as the backing store for HasExpander. This enables animation, styling, binding, etc...

Occurs when HasExpander property has been changed

Gets or sets header of column

Using a DependencyProperty as the backing store for Header. This enables animation, styling, binding, etc...

Gets or sets data template to fill cells of this column

Using a DependencyProperty as the backing store for CellTemplate. This enables animation, styling, binding, etc...

Gets or sets whether cells can be edited

Using a DependencyProperty as the backing store for IsEditable. This enables animation, styling, binding, etc...