/// <summary>
/// Initialize a new instance of the KryptonLinkLabel class.
/// </summary>
public KryptonLinkLabel()
{
// The link label cannot take the focus
SetStyle(ControlStyles.Selectable, true);
// Turn off the target functionality present in the base class
EnabledTarget = false;
// Create the override states that redirect without inheriting
_stateVisitedRedirect = new PaletteContentInheritRedirect(Redirector, PaletteContentStyle.LabelNormalPanel);
_stateNotVisitedRedirect = new PaletteContentInheritRedirect(Redirector, PaletteContentStyle.LabelNormalPanel);
_statePressedRedirect = new PaletteContentInheritRedirect(Redirector, PaletteContentStyle.LabelNormalPanel);
_stateFocusRedirect = new PaletteContentInheritRedirect(Redirector, PaletteContentStyle.LabelNormalPanel);
OverrideVisited = new PaletteContent(_stateVisitedRedirect, NeedPaintDelegate);
OverrideNotVisited = new PaletteContent(_stateNotVisitedRedirect, NeedPaintDelegate);
OverrideFocus = new PaletteContent(_stateFocusRedirect, NeedPaintDelegate);
OverridePressed = new PaletteContent(_statePressedRedirect, NeedPaintDelegate);
// Override the normal state to implement the underling logic
_inheritBehavior = new LinkLabelBehaviorInherit(StateNormal, KryptonLinkBehavior.AlwaysUnderline);
// Create the override handling classes
_overrideVisited = new PaletteContentInheritOverride(OverrideVisited, _inheritBehavior, PaletteState.LinkVisitedOverride, false);
_overrideNotVisited = new PaletteContentInheritOverride(OverrideNotVisited, _overrideVisited, PaletteState.LinkNotVisitedOverride, true);
_overrideFocusNotVisited = new PaletteContentInheritOverride(OverrideFocus, _overrideNotVisited, PaletteState.FocusOverride, false);
_overridePressed = new PaletteContentInheritOverride(OverridePressed, _inheritBehavior, PaletteState.LinkPressedOverride, false);
_overridePressedFocus = new PaletteContentInheritOverride(OverrideFocus, _overridePressed, PaletteState.FocusOverride, false);
// Create controller for updating the view state/click events
_controller = new LinkLabelController(ViewDrawContent, StateDisabled, _overrideFocusNotVisited, _overrideFocusNotVisited, _overridePressedFocus, _overridePressed, NeedPaintDelegate);
_controller.Click += OnControllerClick;
ViewDrawContent.MouseController = _controller;
ViewDrawContent.KeyController = _controller;
ViewDrawContent.SourceController = _controller;
// Set initial palette for drawing the content
ViewDrawContent.SetPalette(_overrideFocusNotVisited);
}
/// <summary>
/// Initialize a new instance of the KryptonLabel class.
/// </summary>
public KryptonLabel()
{
SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
// The label cannot take the focus
SetStyle(ControlStyles.Selectable, false);
// Set default properties
_style = LabelStyle.NormalPanel;
_useMnemonic = true;
_orientation = VisualOrientation.Top;
_target = null;
EnabledTarget = true;
// Create content storage
Values = new LabelValues(NeedPaintDelegate);
Values.TextChanged += OnLabelTextChanged;
// Create palette redirector
_paletteCommonRedirect = new PaletteContentInheritRedirect(Redirector, PaletteContentStyle.LabelNormalPanel);
// Create the palette provider
StateCommon = new PaletteContent(_paletteCommonRedirect, NeedPaintDelegate);
StateDisabled = new PaletteContent(StateCommon, NeedPaintDelegate);
StateNormal = new PaletteContent(StateCommon, NeedPaintDelegate);
// Our view contains background and border with content inside
_drawContent = new ViewDrawContent(StateNormal, this, VisualOrientation.Top)
{
UseMnemonic = _useMnemonic
};
// Create the view manager instance
ViewManager = new ViewManager(this, _drawContent);
// We want to be auto sized by default, but not the property default!
AutoSize = true;
AutoSizeMode = AutoSizeMode.GrowAndShrink;
}
/// <summary>
/// Discover the preferred size of the element.
/// </summary>
/// <param name="context">Layout context.</param>
public override Size GetPreferredSize(ViewLayoutContext context)
{
Debug.Assert(context != null);
// Update text and image values
_contentValues.ShortText = ResolveText;
_contentValues.LongText = ResolveExtraText;
_contentValues.Image = ResolveImage;
_contentValues.ImageTransparentColor = ResolveImageTransparentColor;
// Find new enabled state
ItemEnabled = _provider.ProviderEnabled && ResolveEnabled;
// Update with enabled state
ViewDrawContent.SetPalette(ItemEnabled ? KryptonContextMenuCheckBox.OverrideNormal : KryptonContextMenuCheckBox.OverrideDisabled);
ViewDrawContent.Enabled = ItemEnabled;
ViewDrawCheckBox.Enabled = ItemEnabled;
// Update the checked state
ViewDrawCheckBox.CheckState = ResolveCheckState;
return(base.GetPreferredSize(context));
}
/// <summary>
/// Initialize a new instance of the VisualPopupTooltip class.
/// </summary>
/// <param name="redirector">Redirector for recovering palette values.</param>
/// <param name="contentValues">Source of content values.</param>
/// <param name="renderer">Drawing renderer.</param>
/// <param name="backStyle">Style for the tooltip background.</param>
/// <param name="borderStyle">Style for the tooltip border.</param>
/// <param name="contentStyle">Style for the tooltip content.</param>
public VisualPopupToolTip(PaletteRedirect redirector,
IContentValues contentValues,
IRenderer renderer,
PaletteBackStyle backStyle,
PaletteBorderStyle borderStyle,
PaletteContentStyle contentStyle)
: base(renderer, true)
{
Debug.Assert(contentValues != null);
// Remember references needed later
_contentValues = contentValues;
// Create the triple redirector needed by view elements
_palette = new PaletteTripleMetricRedirect(redirector, backStyle, borderStyle, contentStyle, NeedPaintDelegate);
// Our view contains background and border with content inside
_drawDocker = new ViewDrawDocker(_palette.Back, _palette.Border, null);
_drawContent = new ViewDrawContent(_palette.Content, _contentValues, VisualOrientation.Top);
_drawDocker.Add(_drawContent, ViewDockStyle.Fill);
// Create the view manager instance
ViewManager = new ViewManager(this, _drawDocker);
}
/// <summary>
/// Initialize a new instance of the LinkLabelController class.
/// </summary>
/// <param name="target">Target for state changes.</param>
/// <param name="paletteDisabled">Palette to use in the disabled state.</param>
/// <param name="paletteNormal">Palette to use in the normal state.</param>
/// <param name="paletteTracking">Palette to use in the tracking state.</param>
/// <param name="palettePressed">Palette to use in the pressed state.</param>
/// <param name="pressed">Override to update with the pressed state.</param>
/// <param name="needPaint">Delegate for notifying paint requests.</param>
public LinkLabelController(ViewDrawContent target,
IPaletteContent paletteDisabled,
IPaletteContent paletteNormal,
IPaletteContent paletteTracking,
IPaletteContent palettePressed,
PaletteContentInheritOverride pressed,
NeedPaintHandler needPaint)
{
Debug.Assert(target != null);
// Store the provided paint notification delegate
NeedPaint = needPaint;
// Remember target for state changes
_target = target;
_paletteDisabled = paletteDisabled;
_paletteNormal = paletteNormal;
_paletteTracking = paletteTracking;
_palettePressed = palettePressed;
_pressed = pressed;
// Default other properties
_clickTime = new DateTime();
}
/// <summary>
/// Initialize a new instance of the ViewDrawMenuHeading class.
/// </summary>
/// <param name="heading">Reference to owning heading entry.</param>
/// <param name="palette">Reference to palette source.</param>
public ViewDrawMenuHeading(KryptonContextMenuHeading heading,
PaletteTripleRedirect palette)
{
// Create fixed storage of the content values
_contentValues = new FixedContentValue(heading.Text,
heading.ExtraText,
heading.Image,
heading.ImageTransparentColor);
// Give the heading object the redirector to use when inheriting values
heading.SetPaletteRedirect(palette);
// Create the content for the actual heading text/image
_drawContent = new ViewDrawContent(heading.StateNormal.Content, _contentValues, VisualOrientation.Top);
// Use the docker to provide the background and border
_drawDocker = new ViewDrawDocker(heading.StateNormal.Back, heading.StateNormal.Border)
{
{ _drawContent, ViewDockStyle.Fill }
};
// Add docker as the composite content
Add(_drawDocker);
}
/// <summary>
/// Initialize a new instance of the ViewDrawNavRibbonTab class.
/// </summary>
/// <param name="navigator">Owning navigator instance.</param>
/// <param name="page">Page this ribbon tab represents.</param>
public ViewDrawNavRibbonTab(KryptonNavigator navigator,
KryptonPage page)
{
Debug.Assert(navigator != null);
Debug.Assert(page != null);
Navigator = navigator;
Page = page;
_lastClick = DateTime.Now.AddDays(-1);
// Associate the page component with this view element
Component = page;
// Create a controller for managing button behavior
_buttonController = new PageButtonController(this, OnNeedPaint)
{
ClickOnDown = true
};
_buttonController.Click += OnClick;
_buttonController.RightClick += OnRightClick;
// Allow the page to be dragged and hook into drag events
_buttonController.AllowDragging = true;
_buttonController.DragStart += OnDragStart;
_buttonController.DragMove += OnDragMove;
_buttonController.DragEnd += OnDragEnd;
_buttonController.DragQuit += OnDragQuit;
_buttonController.ButtonDragRectangle += OnButtonDragRectangle;
_buttonController.ButtonDragOffset += OnButtonDragOffset;
// A tab is selected on being pressed and not on the mouse up
_buttonController.ClickOnDown = true;
// We need to be notified of got/lost focus and keyboard events
SourceController = _buttonController;
KeyController = _buttonController;
// Create a decorator to interface with the tooltip manager
ToolTipController toolTipController = new ToolTipController(Navigator.ToolTipManager, this, _buttonController);
ToolTipController hoverController = new ToolTipController(Navigator.HoverManager, this, toolTipController);
// Assign controller for handing mouse input
MouseController = hoverController;
// Create overrides for handling a focus state
_paletteGeneral = Navigator.StateCommon.RibbonGeneral;
_overrideStateNormal = new PaletteRibbonTabContentInheritOverride(Page.OverrideFocus.RibbonTab.TabDraw, Page.OverrideFocus.RibbonTab.TabDraw, Page.OverrideFocus.RibbonTab.Content, Page.StateNormal.RibbonTab.TabDraw, Page.StateNormal.RibbonTab.TabDraw, Page.StateNormal.RibbonTab.Content, PaletteState.FocusOverride);
_overrideStateTracking = new PaletteRibbonTabContentInheritOverride(Page.OverrideFocus.RibbonTab.TabDraw, Page.OverrideFocus.RibbonTab.TabDraw, Page.OverrideFocus.RibbonTab.Content, Page.StateTracking.RibbonTab.TabDraw, Page.StateTracking.RibbonTab.TabDraw, Page.StateTracking.RibbonTab.Content, PaletteState.FocusOverride);
_overrideStatePressed = new PaletteRibbonTabContentInheritOverride(Page.OverrideFocus.RibbonTab.TabDraw, Page.OverrideFocus.RibbonTab.TabDraw, Page.OverrideFocus.RibbonTab.Content, Page.StatePressed.RibbonTab.TabDraw, Page.StatePressed.RibbonTab.TabDraw, Page.StatePressed.RibbonTab.Content, PaletteState.FocusOverride);
_overrideStateSelected = new PaletteRibbonTabContentInheritOverride(Page.OverrideFocus.RibbonTab.TabDraw, Page.OverrideFocus.RibbonTab.TabDraw, Page.OverrideFocus.RibbonTab.Content, Page.StateSelected.RibbonTab.TabDraw, Page.StateSelected.RibbonTab.TabDraw, Page.StateSelected.RibbonTab.Content, PaletteState.FocusOverride);
// Use a class to convert from ribbon tab to content interface
_contentProvider = new RibbonTabToContent(_paletteGeneral, _overrideStateNormal, _overrideStateNormal);
// Create the content view element and use the content provider as a way to
// convert from the ribbon palette entries to the content palette entries
_viewContent = new ViewDrawContent(_contentProvider, this, VisualOrientation.Top);
// Add content to the view
_layoutDocker = new ViewLayoutDocker
{
{ _viewContent, ViewDockStyle.Fill }
};
Add(_layoutDocker);
// Create button specification collection manager
ButtonSpecManager = new ButtonSpecNavManagerLayoutBar(Navigator, Navigator.InternalRedirector, Page.ButtonSpecs, null,
new ViewLayoutDocker[] { _layoutDocker },
new IPaletteMetric[] { Navigator.StateCommon },
new PaletteMetricInt[] { PaletteMetricInt.PageButtonInset },
new PaletteMetricInt[] { PaletteMetricInt.PageButtonInset },
new PaletteMetricPadding[] { PaletteMetricPadding.PageButtonPadding },
Navigator.CreateToolStripRenderer,
OnNeedPaint)
{
// Hook up the tooltip manager so that tooltips can be generated
ToolTipManager = Navigator.ToolTipManager,
RemapTarget = ButtonSpecNavRemap.ButtonSpecRemapTarget.ButtonStandalone
};
// Ensure current button specs are created
ButtonSpecManager.RecreateButtons();
// Create the state specific memento array
_mementos = new IDisposable[Enum.GetValues(typeof(PaletteState)).Length];
// Cache the last shape encountered
_lastRibbonShape = PaletteRibbonShape.Office2010;
}
/// <summary>
/// Create the view hierarchy for this view mode.
/// </summary>
protected override void CreateCheckItemView()
{
// Create the two headers and header content
_viewContentPrimary = new ViewDrawContent(Navigator.StateNormal.HeaderGroup.HeaderPrimary.Content,
Navigator.Header.HeaderValuesPrimary,
VisualOrientation.Top);
_viewHeadingPrimary = new ViewDrawDocker(Navigator.StateNormal.HeaderGroup.HeaderPrimary.Back,
Navigator.StateNormal.HeaderGroup.HeaderPrimary.Border,
Navigator.StateNormal.HeaderGroup.HeaderPrimary,
PaletteMetricBool.None,
PaletteMetricPadding.HeaderGroupPaddingPrimary,
VisualOrientation.Top);
_viewContentSecondary = new ViewDrawContent(Navigator.StateNormal.HeaderGroup.HeaderSecondary.Content,
Navigator.Header.HeaderValuesSecondary,
VisualOrientation.Top);
_viewHeadingSecondary = new ViewDrawDocker(Navigator.StateNormal.HeaderGroup.HeaderSecondary.Back,
Navigator.StateNormal.HeaderGroup.HeaderSecondary.Border,
Navigator.StateNormal.HeaderGroup.HeaderSecondary,
PaletteMetricBool.None,
PaletteMetricPadding.HeaderGroupPaddingSecondary,
VisualOrientation.Top);
// Place the the content as fillers in the headers
_viewHeadingPrimary.Add(_viewContentPrimary, ViewDockStyle.Fill);
_viewHeadingSecondary.Add(_viewContentSecondary, ViewDockStyle.Fill);
// Create a canvas for containing the selected page and put old root inside it
_drawGroup = new ViewDrawCanvas(Navigator.StateNormal.HeaderGroup.Back,
Navigator.StateNormal.HeaderGroup.Border,
VisualOrientation.Top)
{
ApplyIncludeBorderEdge = true
};
_drawGroup.Add(_oldRoot);
// Create the view element that lays out the check/tab buttons
ViewLayoutBarForTabs layoutBar = new ViewLayoutBarForTabs(Navigator.Bar.ItemSizing,
Navigator.Bar.ItemAlignment,
Navigator.Bar.BarMultiline,
Navigator.Bar.ItemMinimumSize,
Navigator.Bar.ItemMaximumSize,
Navigator.Bar.BarMinimumHeight,
Navigator.Bar.TabBorderStyle,
true);
_layoutBar = layoutBar;
// Create the scroll spacer that restricts display
_layoutBarViewport = new ViewLayoutViewport(Navigator.StateCommon.Bar,
PaletteMetricPadding.BarPaddingTabs,
PaletteMetricInt.CheckButtonGap,
Navigator.Bar.BarOrientation,
Navigator.Bar.ItemAlignment,
Navigator.Bar.BarAnimation)
{
_layoutBar
};
// Create the button bar area docker
_layoutBarDocker = new ViewLayoutDocker
{
{ _layoutBarViewport, ViewDockStyle.Fill }
};
// Add a separators for insetting items
_layoutBarSeparatorFirst = new ViewLayoutSeparator(0);
_layoutBarSeparatorLast = new ViewLayoutSeparator(0);
_layoutBarDocker.Add(_layoutBarSeparatorFirst, ViewDockStyle.Left);
_layoutBarDocker.Add(_layoutBarSeparatorLast, ViewDockStyle.Right);
// Create the layout that insets the contents to allow for rounding of the group border
_layoutOverlap = new ViewLayoutInsetOverlap(_drawGroup)
{
_layoutBarDocker
};
// Create the docker used to layout contents of main panel and fill with group
_layoutPanelDocker = new ViewLayoutDockerOverlap(_drawGroup, _layoutOverlap, layoutBar)
{
{ _layoutOverlap, ViewDockStyle.Top },
{ _drawGroup, ViewDockStyle.Fill }
};
// Place the headers and page holding area into the group
_topGroup = new ViewLayoutDocker
{
{ _viewHeadingSecondary, ViewDockStyle.Bottom },
{ _viewHeadingPrimary, ViewDockStyle.Top },
{ _layoutPanelDocker, ViewDockStyle.Fill }
};
// Prevent adjacent headers from having two borders
_topGroup.RemoveChildBorders = true;
// Create the top level panel and put a layout docker inside it
_drawPanel = new ViewDrawPanel(Navigator.StateNormal.Back)
{
_topGroup
};
_newRoot = _drawPanel;
// Set initial visible state of headers
_viewHeadingPrimary.Visible = Navigator.Header.HeaderVisiblePrimary;
_viewHeadingSecondary.Visible = Navigator.Header.HeaderVisibleSecondary;
// Set the correct tab style
UpdateTabStyle();
// Must call the base class to perform common actions
base.CreateCheckItemView();
}
/// <summary>
/// Initialize a new instance of the ViewDrawButton class.
/// </summary>
/// <param name="paletteDisabled">Palette source for the disabled state.</param>
/// <param name="paletteNormal">Palette source for the normal state.</param>
/// <param name="paletteTracking">Palette source for the tracking state.</param>
/// <param name="palettePressed">Palette source for the pressed state.</param>
/// <param name="paletteCheckedNormal">Palette source for the normal checked state.</param>
/// <param name="paletteCheckedTracking">Palette source for the tracking checked state.</param>
/// <param name="paletteCheckedPressed">Palette source for the pressed checked state.</param>
/// <param name="paletteMetric">Palette source for metric values.</param>
/// <param name="buttonValues">Source for content values.</param>
/// <param name="orientation">Visual orientation of the content.</param>
/// <param name="useMnemonic">Use mnemonics.</param>
public ViewDrawButton(IPaletteTriple paletteDisabled,
IPaletteTriple paletteNormal,
IPaletteTriple paletteTracking,
IPaletteTriple palettePressed,
IPaletteTriple paletteCheckedNormal,
IPaletteTriple paletteCheckedTracking,
IPaletteTriple paletteCheckedPressed,
IPaletteMetric paletteMetric,
IContentValues buttonValues,
VisualOrientation orientation,
bool useMnemonic)
{
// Remember the source information
_paletteDisabled = paletteDisabled;
_paletteNormal = paletteNormal;
_paletteTracking = paletteTracking;
_palettePressed = palettePressed;
_paletteCheckedNormal = paletteCheckedNormal;
_paletteCheckedTracking = paletteCheckedTracking;
_paletteCheckedPressed = paletteCheckedPressed;
CurrentPalette = _paletteNormal;
// Default to not being checked
Checked = false;
AllowUncheck = true;
_dropDown = false;
_splitter = false;
_dropDownPosition = VisualOrientation.Right;
// Create the drop down view
_drawDropDown = new ViewLayoutCenter(1);
_drawDropDownButton = new ViewDrawDropDownButton();
_drawDropDown.Add(_drawDropDownButton);
_drawOuterSeparator = new ViewLayoutSeparator(1);
// Create the view used to draw the split edge
_edgeRedirect = new PaletteBorderEdgeRedirect(_paletteNormal.PaletteBorder, null);
_drawSplitBorder = new ViewDrawBorderEdge(new PaletteBorderEdge(_edgeRedirect, null), CommonHelper.VisualToOrientation(orientation));
// Our view contains background and border with content inside
_drawContent = new ViewDrawContent(_paletteNormal.PaletteContent, buttonValues, orientation);
_drawCanvas = new ViewDrawSplitCanvas(_paletteNormal.PaletteBack, _paletteNormal.PaletteBorder, paletteMetric, PaletteMetricPadding.None, orientation);
// Use a docker layout to organize the contents of the canvas
LayoutDocker = new ViewLayoutDocker
{
{ _drawContent, ViewDockStyle.Fill },
{ _drawSplitBorder, ViewDockStyle.Right },
{ _drawDropDown, ViewDockStyle.Right },
{ _drawOuterSeparator, ViewDockStyle.Right }
};
LayoutDocker.Tag = this;
// Pass the mnemonic default to the content view
_drawContent.UseMnemonic = useMnemonic;
// Place the content inside the canvas
_drawCanvas.Add(LayoutDocker);
// Set initial view element visible states
UpdateDropDown();
// Place the canvas inside ourself
Add(_drawCanvas);
}
/// <summary>
/// Initialize a new instance of the RadioButton class.
/// </summary>
public KryptonRadioButton()
{
// Turn off standard click and double click events, we do that manually
SetStyle(ControlStyles.StandardClick |
ControlStyles.StandardDoubleClick, false);
// Set default properties
_style = LabelStyle.NormalPanel;
_orientation = VisualOrientation.Top;
_checkPosition = VisualOrientation.Left;
_checked = false;
_useMnemonic = true;
_autoCheck = true;
// Create content storage
Values = new LabelValues(NeedPaintDelegate);
Values.TextChanged += OnRadioButtonTextChanged;
Images = new RadioButtonImages(NeedPaintDelegate);
// Create palette redirector
_paletteCommonRedirect = new PaletteContentInheritRedirect(Redirector, PaletteContentStyle.LabelNormalPanel);
_paletteRadioButtonImages = new PaletteRedirectRadioButton(Redirector, Images);
// Create the palette provider
StateCommon = new PaletteContent(_paletteCommonRedirect, NeedPaintDelegate);
StateDisabled = new PaletteContent(StateCommon, NeedPaintDelegate);
StateNormal = new PaletteContent(StateCommon, NeedPaintDelegate);
OverrideFocus = new PaletteContent(_paletteCommonRedirect, NeedPaintDelegate);
// Override the normal values with the focus, when the control has focus
_overrideNormal = new PaletteContentInheritOverride(OverrideFocus, StateNormal, PaletteState.FocusOverride, false);
// Our view contains background and border with content inside
_drawContent = new ViewDrawContent(_overrideNormal, Values, VisualOrientation.Top)
{
UseMnemonic = _useMnemonic,
// Only draw a focus rectangle when focus cues are needed in the top level form
TestForFocusCues = true
};
// Create the check box image drawer and place inside element so it is always centered
_drawRadioButton = new ViewDrawRadioButton(_paletteRadioButtonImages)
{
CheckState = _checked
};
_layoutCenter = new ViewLayoutCenter
{
_drawRadioButton
};
// Place check box on the left and the label in the remainder
_layoutDocker = new ViewLayoutDocker
{
{ _layoutCenter, ViewDockStyle.Left },
{ _drawContent, ViewDockStyle.Fill }
};
// Need a controller for handling mouse input
_controller = new RadioButtonController(_drawRadioButton, _layoutDocker, NeedPaintDelegate);
_controller.Click += OnControllerClick;
_controller.Enabled = true;
_layoutDocker.MouseController = _controller;
_layoutDocker.KeyController = _controller;
// Change the layout to match the inital right to left setting and orientation
UpdateForOrientation();
// Create the view manager instance
ViewManager = new ViewManager(this, _layoutDocker);
// We want to be auto sized by default, but not the property default!
AutoSize = true;
AutoSizeMode = AutoSizeMode.GrowAndShrink;
}
/// <summary>
/// Initialize a new instance of the ViewDrawMenuRadioButton class.
/// </summary>
/// <param name="provider">Reference to provider.</param>
/// <param name="radioButton">Reference to owning radio button entry.</param>
public ViewDrawMenuRadioButton(IContextMenuProvider provider,
KryptonContextMenuRadioButton radioButton)
{
_provider = provider;
KryptonContextMenuRadioButton = radioButton;
// Create fixed storage of the content values
_contentValues = new FixedContentValue(radioButton.Text,
radioButton.ExtraText,
radioButton.Image,
radioButton.ImageTransparentColor);
// Decide on the enabled state of the display
ItemEnabled = provider.ProviderEnabled && KryptonContextMenuRadioButton.Enabled;
// Give the heading object the redirector to use when inheriting values
KryptonContextMenuRadioButton.SetPaletteRedirect(provider.ProviderRedirector);
// Create the content for the actual heading text/image
ViewDrawContent = new ViewDrawContent(ItemEnabled ? KryptonContextMenuRadioButton.OverrideNormal : KryptonContextMenuRadioButton.OverrideDisabled,
_contentValues, VisualOrientation.Top)
{
UseMnemonic = true,
Enabled = ItemEnabled
};
// Create the radio button image drawer and place inside element so it is always centered
ViewDrawRadioButton = new ViewDrawRadioButton(KryptonContextMenuRadioButton.StateRadioButtonImages)
{
CheckState = KryptonContextMenuRadioButton.Checked,
Enabled = ItemEnabled
};
_layoutCenter = new ViewLayoutCenter
{
ViewDrawRadioButton
};
// Place the radio button on the left of the available space but inside separators
_innerDocker = new ViewLayoutDocker
{
{ ViewDrawContent, ViewDockStyle.Fill },
{ _layoutCenter, ViewDockStyle.Left },
{ new ViewLayoutSeparator(1), ViewDockStyle.Right },
{ new ViewLayoutSeparator(3), ViewDockStyle.Left },
{ new ViewLayoutSeparator(1), ViewDockStyle.Top },
{ new ViewLayoutSeparator(1), ViewDockStyle.Bottom }
};
// Use outer docker so that any extra space not needed is used by the null
_outerDocker = new ViewLayoutDocker
{
{ _innerDocker, ViewDockStyle.Top },
{ new ViewLayoutNull(), ViewDockStyle.Fill }
};
// Use context menu specific version of the radio button controller
MenuRadioButtonController mrbc = new(provider.ProviderViewManager, _innerDocker, this, provider.ProviderNeedPaintDelegate);
mrbc.Click += OnClick;
_innerDocker.MouseController = mrbc;
_innerDocker.KeyController = mrbc;
// We need to be notified whenever the checked state changes
KryptonContextMenuRadioButton.CheckedChanged += OnCheckedChanged;
if (KryptonContextMenuRadioButton.KryptonCommand != null)
{
_cachedCommand = KryptonContextMenuRadioButton.KryptonCommand;
KryptonContextMenuRadioButton.KryptonCommand.PropertyChanged += OnCommandPropertyChanged;
}
// Add docker as the composite content
Add(_outerDocker);
}
/// <summary>
/// Initialize a new instance of the ViewDrawMenuLinkLabel class.
/// </summary>
/// <param name="provider">Reference to provider.</param>
/// <param name="linkLabel">Reference to owning link label entry.</param>
public ViewDrawMenuLinkLabel(IContextMenuProvider provider,
KryptonContextMenuLinkLabel linkLabel)
{
_provider = provider;
KryptonContextMenuLinkLabel = linkLabel;
// Create fixed storage of the content values
_contentValues = new FixedContentValue(linkLabel.Text,
linkLabel.ExtraText,
linkLabel.Image,
linkLabel.ImageTransparentColor);
// Decide on the enabled state of the display
ItemEnabled = provider.ProviderEnabled;
// Give the heading object the redirector to use when inheriting values
linkLabel.SetPaletteRedirect(provider.ProviderRedirector);
// Create the content for the actual heading text/image
_drawContent = new ViewDrawContent(linkLabel.OverrideFocusNotVisited, _contentValues, VisualOrientation.Top)
{
UseMnemonic = true,
Enabled = ItemEnabled
};
// Place label link in the center of the area but inside some separator to add spacing
_innerDocker = new ViewLayoutDocker
{
{ _drawContent, ViewDockStyle.Fill },
{ new ViewLayoutSeparator(1), ViewDockStyle.Right },
{ new ViewLayoutSeparator(1), ViewDockStyle.Left },
{ new ViewLayoutSeparator(1), ViewDockStyle.Top },
{ new ViewLayoutSeparator(1), ViewDockStyle.Bottom }
};
// Use outer docker so that any extra space not needed is used by the null
_outerDocker = new ViewLayoutDocker
{
{ _innerDocker, ViewDockStyle.Top },
{ new ViewLayoutNull(), ViewDockStyle.Fill }
};
// Use context menu specific version of the link label controller
MenuLinkLabelController mllc = new(provider.ProviderViewManager, _drawContent, this, provider.ProviderNeedPaintDelegate);
mllc.Click += OnClick;
_drawContent.MouseController = mllc;
_drawContent.KeyController = mllc;
// Add docker as the composite content
Add(_outerDocker);
// Want to know when a property changes whilst displayed
KryptonContextMenuLinkLabel.PropertyChanged += OnPropertyChanged;
// We need to know if a property of the command changes
if (KryptonContextMenuLinkLabel.KryptonCommand != null)
{
_cachedCommand = KryptonContextMenuLinkLabel.KryptonCommand;
KryptonContextMenuLinkLabel.KryptonCommand.PropertyChanged += OnCommandPropertyChanged;
}
}
/// <summary>
/// Initialize a new instance of the ViewDrawMonth class.
/// </summary>
/// <param name="calendar">Reference to calendar provider.</param>
/// <param name="months">Reference to months instance.</param>
/// <param name="redirector">Redirector for getting values.</param>
/// <param name="needPaintDelegate">Delegate for requesting paint changes.</param>
public ViewDrawMonth(IKryptonMonthCalendar calendar,
ViewLayoutMonths months,
PaletteRedirect redirector,
NeedPaintHandler needPaintDelegate)
: base(false)
{
_calendar = calendar;
_months = months;
// Add a header for showing the month/year value
_drawContent = new ViewDrawContent(_calendar.StateNormal.Header.Content, this, VisualOrientation.Top);
_borderForced = new PaletteBorderInheritForced(_calendar.StateNormal.Header.Border);
_borderForced.ForceBorderEdges(PaletteDrawBorders.None);
_drawHeader = new ViewDrawDocker(_calendar.StateNormal.Header.Back, _borderForced, null)
{
{ _drawContent, ViewDockStyle.Fill }
};
Add(_drawHeader);
// Create the left/right arrows for moving the months
_arrowPrev = new ButtonSpecCalendar(this, PaletteButtonSpecStyle.Previous, RelativeEdgeAlign.Near);
_arrowNext = new ButtonSpecCalendar(this, PaletteButtonSpecStyle.Next, RelativeEdgeAlign.Far);
_arrowPrev.Click += OnPrevMonth;
_arrowNext.Click += OnNextMonth;
_buttonSpecs = new CalendarButtonSpecCollection(this)
{
_arrowPrev,
_arrowNext
};
// Using a button spec manager to add the buttons to the header
_buttonManager = new ButtonSpecManagerDraw(_calendar.CalendarControl, redirector, null, _buttonSpecs,
new[] { _drawHeader },
new IPaletteMetric[] { _calendar.StateCommon },
new[] { PaletteMetricInt.HeaderButtonEdgeInsetCalendar },
new[] { PaletteMetricPadding.None },
_calendar.GetToolStripDelegate, needPaintDelegate);
// Create stacks for holding display items
ViewLayoutStack namesStack = new(true);
ViewLayoutStack weeksStack = new(true);
ViewLayoutStack daysStack = new(false);
_numberStack = new ViewLayoutStack(false);
weeksStack.Add(_numberStack);
weeksStack.Add(daysStack);
// Add day names
_drawMonthDayNames = new ViewDrawMonthDayNames(_calendar, _months);
_drawWeekCorner = new ViewLayoutWeekCorner(_calendar, _months, _calendar.StateNormal.Header.Border);
namesStack.Add(_drawWeekCorner);
namesStack.Add(_drawMonthDayNames);
Add(namesStack);
Add(weeksStack);
// Add border between week numbers and days area
_borderEdgeRedirect = new PaletteBorderEdgeRedirect(_calendar.StateNormal.Header.Border, null);
_borderEdge = new PaletteBorderEdge(_borderEdgeRedirect, null);
_drawBorderEdge = new ViewDrawBorderEdge(_borderEdge, Orientation.Vertical);
_drawWeekNumbers = new ViewDrawWeekNumbers(_calendar, _months);
ViewLayoutDocker borderLeftDock = new()
{
{ _drawWeekNumbers, ViewDockStyle.Left },
{ new ViewLayoutSeparator(0, 4), ViewDockStyle.Top },
/// <summary>
/// Initialize a new instance of the ViewDrawMenuCheckBox class.
/// </summary>
/// <param name="provider">Reference to provider.</param>
/// <param name="checkBox">Reference to owning check box entry.</param>
public ViewDrawMenuCheckBox(IContextMenuProvider provider,
KryptonContextMenuCheckBox checkBox)
{
_provider = provider;
KryptonContextMenuCheckBox = checkBox;
// Create fixed storage of the content values
_contentValues = new FixedContentValue(ResolveText,
ResolveExtraText,
ResolveImage,
ResolveImageTransparentColor);
// Decide on the enabled state of the display
ItemEnabled = provider.ProviderEnabled && ResolveEnabled;
// Give the heading object the redirector to use when inheriting values
KryptonContextMenuCheckBox.SetPaletteRedirect(provider.ProviderRedirector);
// Create the content for the actual heading text/image
ViewDrawContent = new ViewDrawContent(ItemEnabled ? KryptonContextMenuCheckBox.OverrideNormal : KryptonContextMenuCheckBox.OverrideDisabled,
_contentValues, VisualOrientation.Top)
{
UseMnemonic = true,
Enabled = ItemEnabled
};
// Create the check box image drawer and place inside element so it is always centered
ViewDrawCheckBox = new ViewDrawCheckBox(KryptonContextMenuCheckBox.StateCheckBoxImages)
{
CheckState = ResolveCheckState,
Enabled = ItemEnabled
};
_layoutCenter = new ViewLayoutCenter
{
ViewDrawCheckBox
};
// Place the check box on the left of the available space but inside separators
_innerDocker = new ViewLayoutDocker
{
{ ViewDrawContent, ViewDockStyle.Fill },
{ _layoutCenter, ViewDockStyle.Left },
{ new ViewLayoutSeparator(1), ViewDockStyle.Right },
{ new ViewLayoutSeparator(3), ViewDockStyle.Left },
{ new ViewLayoutSeparator(1), ViewDockStyle.Top },
{ new ViewLayoutSeparator(1), ViewDockStyle.Bottom }
};
// Use outer docker so that any extra space not needed is used by the null
_outerDocker = new ViewLayoutDocker
{
{ _innerDocker, ViewDockStyle.Top },
{ new ViewLayoutNull(), ViewDockStyle.Fill }
};
// Use context menu specific version of the check box controller
MenuCheckBoxController mcbc = new(provider.ProviderViewManager, _innerDocker, this, provider.ProviderNeedPaintDelegate);
mcbc.Click += OnClick;
_innerDocker.MouseController = mcbc;
_innerDocker.KeyController = mcbc;
// Add docker as the composite content
Add(_outerDocker);
// Want to know when a property changes whilst displayed
KryptonContextMenuCheckBox.PropertyChanged += OnPropertyChanged;
// We need to know if a property of the command changes
if (KryptonContextMenuCheckBox.KryptonCommand != null)
{
_cachedCommand = KryptonContextMenuCheckBox.KryptonCommand;
KryptonContextMenuCheckBox.KryptonCommand.PropertyChanged += OnCommandPropertyChanged;
}
}
