private void UpdateShapeValues() { if (_ribbon != null) { if (_lastRibbonShape != _ribbon.RibbonShape) { switch (_ribbon.RibbonShape) { default: case PaletteRibbonShape.Office2007: _totalBorders = TOTAL_LEFT_RIGHT_BORDERS_2007; _layoutNormalMain.VertOffset = VERT_OFFSET_2007; _layoutNormalSepTop.SeparatorSize = new Size(NORMAL_BORDER_TOPLEFT2007, NORMAL_BORDER_TOPLEFT2007); _layoutNormalSepLeft.SeparatorSize = new Size(NORMAL_BORDER_TOPLEFT2007, NORMAL_BORDER_TOPLEFT2007); _layoutNormalSepRight.SeparatorSize = new Size(NORMAL_BORDER_RIGHT2007, NORMAL_BORDER_RIGHT2007); _layoutCollapsedImagePadding.PreferredPadding = COLLAPSED_IMAGE_PADDING_2007; _lastRibbonShape = PaletteRibbonShape.Office2007; break; case PaletteRibbonShape.Office2010: _totalBorders = TOTAL_LEFT_RIGHT_BORDERS_2010; _layoutNormalMain.VertOffset = VERT_OFFSET_2010; _layoutNormalSepTop.SeparatorSize = new Size(NORMAL_BORDER_TOP2010, NORMAL_BORDER_TOP2010); _layoutNormalSepLeft.SeparatorSize = new Size(NORMAL_BORDER_LEFT2010, NORMAL_BORDER_LEFT2010); _layoutNormalSepRight.SeparatorSize = new Size(NORMAL_BORDER_RIGHT2010, NORMAL_BORDER_RIGHT2010); _layoutCollapsedImagePadding.PreferredPadding = COLLAPSED_IMAGE_PADDING_2010; _lastRibbonShape = PaletteRibbonShape.Office2010; break; } } } }
/// <summary> /// Initialize a new instance of the ViewDrawRibbonGroupSeparator class. /// </summary> /// <param name="ribbon">Reference to owning ribbon control.</param> /// <param name="ribbonSeparator">Reference to group separator definition.</param> /// <param name="needPaint">Delegate for notifying paint requests.</param> public ViewDrawRibbonGroupSeparator(KryptonRibbon ribbon, KryptonRibbonGroupSeparator ribbonSeparator, NeedPaintHandler needPaint) { Debug.Assert(ribbon != null); Debug.Assert(ribbonSeparator != null); Debug.Assert(needPaint != null); _ribbon = ribbon; _ribbonSeparator = ribbonSeparator; _needPaint = needPaint; // Associate this view with the source component (required for design time selection) Component = _ribbonSeparator; if (_ribbon.InDesignMode) { // At design time we need to know when the user right clicks the label ContextClickController controller = new ContextClickController(); controller.ContextClick += new MouseEventHandler(OnContextClick); MouseController = controller; } // Define back reference to view for the separator definition _ribbonSeparator.SeparatorView = this; // Hook into changes in the ribbon separator definition _ribbonSeparator.PropertyChanged += new PropertyChangedEventHandler(OnSeparatorPropertyChanged); // Default the preferred size _lastShape = PaletteRibbonShape.Office2007; _preferredSize = _preferredSize2007; }
/// <summary> /// Initialize a new instance of the PaletteRibbonGeneral class. /// </summary> /// <param name="inherit">Source for inheriting general values.</param> /// <param name="needPaint">Delegate for notifying paint requests.</param> public PaletteRibbonGeneral(IPaletteRibbonGeneral inherit, NeedPaintHandler needPaint) { Debug.Assert(inherit != null); // Remember inheritance _inherit = inherit; // Store the provided paint notification delegate NeedPaint = needPaint; // Set default values _contextTextAlign = PaletteRelativeAlign.Inherit; _contextTextColor = Color.Empty; _contextTextFont = null; _disabledDarkColor = Color.Empty; _disabledLightColor = Color.Empty; _dialogDarkColor = Color.Empty; _dialogLightColor = Color.Empty; _dropArrowLightColor = Color.Empty; _dropArrowDarkColor = Color.Empty; _groupSeparatorDark = Color.Empty; _groupSeparatorLight = Color.Empty; _minimizeBarDarkColor = Color.Empty; _minimizeBarLightColor = Color.Empty; _ribbonShape = PaletteRibbonShape.Inherit; _tabSeparatorColor = Color.Empty; _tabSeparatorContextColor = Color.Empty; _textFont = null; _textHint = PaletteTextHint.Inherit; _qatButtonDarkColor = Color.Empty; _qatButtonLightColor = Color.Empty; }
/// <summary> /// Initialize a new instance of the ViewDrawRibbonGroupSeparator class. /// </summary> /// <param name="ribbon">Reference to owning ribbon control.</param> /// <param name="ribbonSeparator">Reference to group separator definition.</param> /// <param name="needPaint">Delegate for notifying paint requests.</param> public ViewDrawRibbonGroupSeparator(KryptonRibbon ribbon, KryptonRibbonGroupSeparator ribbonSeparator, NeedPaintHandler needPaint) { Debug.Assert(ribbon != null); Debug.Assert(ribbonSeparator != null); Debug.Assert(needPaint != null); _ribbon = ribbon; _ribbonSeparator = ribbonSeparator; _needPaint = needPaint; // Associate this view with the source component (required for design time selection) Component = _ribbonSeparator; if (_ribbon.InDesignMode) { // At design time we need to know when the user right clicks the label ContextClickController controller = new ContextClickController(); controller.ContextClick += OnContextClick; MouseController = controller; } // Define back reference to view for the separator definition _ribbonSeparator.SeparatorView = this; // Hook into changes in the ribbon separator definition _ribbonSeparator.PropertyChanged += OnSeparatorPropertyChanged; // Default the preferred size _lastShape = PaletteRibbonShape.Office2007; _preferredSize = _preferredSize2007; }
/// <summary> /// Initialize a new instance of the CalculatedValues class. /// </summary> /// <param name="ribbon">Source control instance.</param> public CalculatedValues(KryptonRibbon ribbon) { Debug.Assert(ribbon != null); _ribbon = ribbon; _lastShape = PaletteRibbonShape.Inherit; }
/// <summary> /// Draw the background of a ribbon element. /// </summary> /// <param name="shape">Ribbon shape.</param> /// <param name="context">Rendering context.</param> /// <param name="rect">Target rectangle.</param> /// <param name="state">State associated with rendering.</param> /// <param name="palette">Palette used for sourcing settings.</param> /// <param name="orientation">Orientation for drawing.</param> /// <param name="composition">Drawing onto a composition element.</param> /// <param name="memento">Cached values to use when drawing.</param> public override IDisposable DrawRibbonBack(PaletteRibbonShape shape, RenderContext context, Rectangle rect, PaletteState state, IPaletteRibbonBack palette, VisualOrientation orientation, bool composition, IDisposable memento) { // Note is the incoming state is detailed we are drawing inside a popip bool showingInPopup = ((state & PaletteState.FocusOverride) == PaletteState.FocusOverride); if (showingInPopup) { state = state & ~PaletteState.FocusOverride; } switch (palette.GetRibbonBackColorStyle(state)) { case PaletteRibbonColorStyle.RibbonGroupNormalBorderTracking: return(DrawRibbonGroupNormalBorder(context, rect, state, palette, true, false, memento)); case PaletteRibbonColorStyle.RibbonGroupAreaBorder: return(DrawRibbonGroupAreaBorder1And2(context, rect, state, palette, false, true, memento)); case PaletteRibbonColorStyle.RibbonGroupAreaBorder2: return(DrawRibbonGroupAreaBorder1And2(context, rect, state, palette, true, true, memento)); default: return(base.DrawRibbonBack(shape, context, rect, state, palette, orientation, composition, memento)); } }
/// <summary> /// Recalculate all the values. /// </summary> public void Recalculate() { // Do we need to update the shape dependant values? if (_lastShape != _ribbon.RibbonShape) { _lastShape = _ribbon.RibbonShape; switch (_lastShape) { default: case PaletteRibbonShape.Office2007: _groupHeightModifier = 0; _groupsHeightModifier = 0; break; case PaletteRibbonShape.Office2013: case PaletteRibbonShape.Office365: case PaletteRibbonShape.Office2010: _groupHeightModifier = -3; _groupsHeightModifier = -3; break; } } // Get the font used by the ribbon Font font = _ribbon.StateCommon.RibbonGeneral.GetRibbonTextFont(PaletteState.Normal); // Cache common font height related values RawFontHeight = font.Height; DrawFontHeight = RawFontHeight + FONT_HEIGHT_EXTRA; // Height of all tabs in the tabs area TabHeight = DrawFontHeight + TABS_TOP_GAP; // Find the height of the group title area (must be minimum size to show the dialog launcher button) GroupTitleHeight = Math.Max(DrawFontHeight, DIALOG_MIN_HEIGHT); // Get the height needed for showing the content of a group line GroupLineContentHeight = Math.Max(DrawFontHeight, GROUP_LINE_CONTENT_MIN); // Group line height must be the content plus spacing gap and then border GroupLineHeight = GroupLineContentHeight + GROUP_LINE_CONTENT_EXTRA; // Group inside height is 3 group lines plus space at bottom of the lines GroupTripleHeight = (GroupLineHeight * 3); // The gap between lines is one of the lines divide by a gap above, between and below lines GroupLineGapHeight = (GroupLineHeight / 3); // Group height is the inside plus title area at bottom and the top border GroupHeight = GroupTripleHeight + GROUP_INSIDE_BOTTOM_GAP + GroupTitleHeight + GROUP_TOP_BORDER; // Size of the groups area (not including the top pixel that is placed in the tabs // area is the height of a group plus the bottom and top gaps). GroupsHeight = GroupHeight + GROUPS_BOTTOM_GAP + GROUPS_TOP_GAP; // Apply shape specific modifiers GroupHeight += _groupHeightModifier; GroupsHeight += _groupsHeightModifier; }
/// <summary> /// Initialize a new instance of the CalculatedValues class. /// </summary> /// <param name="ribbon">Source control instance.</param> public CalculatedValues(KryptonRibbon ribbon) { Debug.Assert(ribbon != null); _ribbon = ribbon; _lastShape = PaletteRibbonShape.Inherit; }
/// <summary> /// Draw a context ribbon tab title. /// </summary> /// <param name="shape">Ribbon shape.</param> /// <param name="context">Rendering context.</param> /// <param name="rect">Target rectangle.</param> /// <param name="paletteGeneral">Palette used for general ribbon settings.</param> /// <param name="paletteBack">Palette used for background ribbon settings.</param> /// <param name="memento">Cached storage for drawing objects.</param> public override IDisposable DrawRibbonTabContextTitle(PaletteRibbonShape shape, RenderContext context, Rectangle rect, IPaletteRibbonGeneral paletteGeneral, IPaletteRibbonBack paletteBack, IDisposable memento) { return(DrawRibbonTabContext(context, rect, paletteGeneral, paletteBack, memento)); }
/// <summary> /// Draw the application button. /// </summary> /// <param name="shape">Ribbon shape.</param> /// <param name="context">Rendering context.</param> /// <param name="rect">Target rectangle.</param> /// <param name="state">State associated with rendering.</param> /// <param name="palette">Palette used for sourcing settings.</param> /// <param name="memento">Cached storage for drawing objects.</param> public override IDisposable DrawRibbonApplicationButton(PaletteRibbonShape shape, RenderContext context, Rectangle rect, PaletteState state, IPaletteRibbonBack palette, IDisposable memento) { return(DrawRibbonAppButton(shape, context, rect, state, palette, true, memento)); }
/// <summary> /// Perform drawing of a ribbon cluster edge. /// </summary> /// <param name="shape">Ribbon shape.</param> /// <param name="context">Render context.</param> /// <param name="displayRect">Display area available for drawing.</param> /// <param name="paletteBack">Palette used for recovering drawing details.</param> /// <param name="state">State associated with rendering.</param> public override void DrawRibbonClusterEdge(PaletteRibbonShape shape, RenderContext context, Rectangle displayRect, IPaletteBack paletteBack, PaletteState state) { Debug.Assert(context != null); Debug.Assert(paletteBack != null); // Get the first border color, and then lighten it by merging with white Color borderColour = paletteBack.GetBackColor1(state), lightColour = CommonHelper.MergeColors(borderColour, BORDER_PERCENT, Color.White, WHITE_PERCENT); // Draw inside of the border edge in a lighter version of the border using SolidBrush drawBrush = new(lightColour); context.Graphics.FillRectangle(drawBrush, displayRect); }
/// <summary> /// Perform drawing of a ribbon context arrow glyph. /// </summary> /// <param name="shape">Ribbon shape.</param> /// <param name="context">Render context.</param> /// <param name="displayRect">Display area available for drawing.</param> /// <param name="paletteGeneral">General ribbon palette details.</param> /// <param name="state">State associated with rendering.</param> /// <param name="qatAbove"></param> public override void DrawRibbonContextArrow(PaletteRibbonShape shape, RenderContext context, Rectangle displayRect, IPaletteRibbonGeneral paletteGeneral, PaletteState state, bool qatAbove) { Debug.Assert(context != null); Debug.Assert(paletteGeneral != null); // Validate parameter references if (context == null) { throw new ArgumentNullException("context"); } if (paletteGeneral == null) { throw new ArgumentNullException("paletteGeneral"); } Color c1 = qatAbove ? paletteGeneral.GetRibbonQATButtonLight(state) : paletteGeneral.GetRibbonQATButtonDark(state); // If disabled then convert to black and white if (state == PaletteState.Disabled) { c1 = CommonHelper.ColorToBlackAndWhite(c1); } using (var pen = new Pen(c1)) { if (DpiHelper.Default.DpiScaleFactor > 1.0 && DpiHelper.Default.EnableImagesScaling) { context.Graphics.DrawLine(pen, displayRect.Left, displayRect.Top, displayRect.Left + 6, displayRect.Top); context.Graphics.DrawLine(pen, displayRect.Left, displayRect.Top + 3, displayRect.Left + 6, displayRect.Top + 3); context.Graphics.DrawLine(pen, displayRect.Left + 1, displayRect.Top + 4, displayRect.Left + 5, displayRect.Top + 4); context.Graphics.DrawLine(pen, displayRect.Left + 2, displayRect.Top + 5, displayRect.Left + 4, displayRect.Top + 5); pen.DashStyle = DashStyle.Dot; // draw one pixel! context.Graphics.DrawLine(pen, displayRect.Left + 3, displayRect.Top + 6, displayRect.Left + 4, displayRect.Top + 6); } else { context.Graphics.DrawLine(pen, displayRect.Left, displayRect.Top, displayRect.Left + 4, displayRect.Top); context.Graphics.DrawLine(pen, displayRect.Left, displayRect.Top + 3, displayRect.Left + 4, displayRect.Top + 3); context.Graphics.DrawLine(pen, displayRect.Left + 1, displayRect.Top + 4, displayRect.Left + 3, displayRect.Top + 4); context.Graphics.DrawLine(pen, displayRect.Left + 2, displayRect.Top + 4, displayRect.Left + 2, displayRect.Top + 5); } } }
/// <summary> /// Initialize a new instance of the ViewLayoutRibbonGroupCluster class. /// </summary> /// <param name="ribbon">Owning ribbon control instance.</param> /// <param name="ribbonCluster">Reference to cluster definition.</param> /// <param name="needPaint">Delegate for notifying paint requests.</param> public ViewLayoutRibbonGroupCluster(KryptonRibbon ribbon, KryptonRibbonGroupCluster ribbonCluster, NeedPaintHandler needPaint) { Debug.Assert(ribbon != null); Debug.Assert(ribbonCluster != null); Debug.Assert(needPaint != null); // Cache references _ribbon = ribbon; _ribbonCluster = ribbonCluster; _needPaint = needPaint; _currentSize = GroupItemSize.Medium; // Associate the component with this view element for design time selection Component = _ribbonCluster; // Create the start and end separators _startSep = new ViewDrawRibbonGroupClusterSeparator(_ribbon, true); _endSep = new ViewDrawRibbonGroupClusterSeparator(_ribbon, false); _startSepVisible = false; _endSepVisible = false; // Create palette used to supply a width to a border edge view PaletteBorderEdgeRedirect borderEdgeRedirect = new PaletteBorderEdgeRedirect(_ribbon.StateCommon.RibbonGroupClusterButton.Border, needPaint); _paletteBorderEdge = new PaletteBorderEdge(borderEdgeRedirect, needPaint); _lastShape = PaletteRibbonShape.Office2007; // Use hashtable to store relationships _itemToView = new ItemToView(); _viewToEdge = new ViewToEdge(); _viewToSizeMedium = new ViewToSize(); _viewToSizeSmall = new ViewToSize(); // Hook into changes in the ribbon cluster definition _ribbonCluster.PropertyChanged += new PropertyChangedEventHandler(OnClusterPropertyChanged); _ribbonCluster.ClusterView = this; // At design time we want to track the mouse and show feedback if (_ribbon.InDesignMode) { ViewHightlightController controller = new ViewHightlightController(this, needPaint); controller.ContextClick += new MouseEventHandler(OnContextClick); MouseController = controller; } }
private void CreateNormalView() { // Create a layout for the main area _layoutNormalMain = new ViewLayoutRibbonTitle(); if (_ribbon.InDesignMode) { // At design time we need to know when the user right clicks the group ContextClickController controller = new ContextClickController(); controller.ContextClick += new MouseEventHandler(OnContextClick); _layoutNormalMain.MouseController = controller; } // Create layout elements _layoutNormalTitle = new ViewLayoutDocker(); _layoutNormalContent = new ViewLayoutRibbonGroupContent(_ribbon, _ribbonGroup, _needPaint); _layoutNormalSepTop = new ViewLayoutRibbonSeparator(NORMAL_BORDER_TOPLEFT2007, true); _layoutNormalSepLeft = new ViewLayoutRibbonSeparator(NORMAL_BORDER_TOPLEFT2007, true); _layoutNormalSepRight = new ViewLayoutRibbonSeparator(NORMAL_BORDER_RIGHT2007, true); // Add layout elements to correct areas of the normal group _layoutNormalMain.Add(_layoutNormalTitle, ViewDockStyle.Bottom); _layoutNormalMain.Add(_layoutNormalSepTop, ViewDockStyle.Top); _layoutNormalMain.Add(_layoutNormalSepLeft, ViewDockStyle.Left); _layoutNormalMain.Add(_layoutNormalSepRight, ViewDockStyle.Right); _layoutNormalMain.Add(_layoutNormalContent, ViewDockStyle.Fill); // Create and add the title string that fills remainder title area _viewNormalTitle = new ViewDrawRibbonGroupTitle(_ribbon, _ribbonGroup); _layoutNormalTitle.Add(_viewNormalTitle, ViewDockStyle.Fill); // Add the dialog box launcher button to the right side of title area _viewNormalDialog = new ViewLayoutRibbonGroupButton(_ribbon, _ribbonGroup, _needPaint); _layoutNormalContent.DialogView = _viewNormalDialog; _layoutNormalTitle.Add(_viewNormalDialog, ViewDockStyle.Right); // Use this class to return the context color for any null values _paletteContextBack = new PaletteRibbonContextBack(_ribbon); // All values are equal to a default of Office 2007 shape _lastRibbonShape = PaletteRibbonShape.Office2007; _totalBorders = TOTAL_LEFT_RIGHT_BORDERS_2007; }
/// <summary> /// Perform drawing of a ribbon cluster edge. /// </summary> /// <param name="shape">Ribbon shape.</param> /// <param name="context">Render context.</param> /// <param name="displayRect">Display area available for drawing.</param> /// <param name="paletteBack">Palette used for recovering drawing details.</param> /// <param name="state">State associated with rendering.</param> public override void DrawRibbonClusterEdge(PaletteRibbonShape shape, RenderContext context, Rectangle displayRect, IPaletteBack paletteBack, PaletteState state) { Debug.Assert(context != null); Debug.Assert(paletteBack != null); // Get the first border color Color borderColor = paletteBack.GetBackColor1(state); // We want to lighten it by merging with white Color lightColor = CommonHelper.MergeColors(borderColor, BORDER_PERCENT, Color.White, WHITE_PERCENT); // Draw inside of the border edge in a lighter version of the border using (SolidBrush drawBrush = new SolidBrush(lightColor)) context.Graphics.FillRectangle(drawBrush, displayRect); }
/// <summary> /// Perform a layout of the elements. /// </summary> /// <param name="context">Layout context.</param> public override void Layout(ViewLayoutContext context) { // Ensure we are using the correct palette CheckPaletteState(context); // Cache the ribbon shape _lastRibbonShape = (_navigator.Palette == null ? PaletteRibbonShape.Office2007 : _navigator.Palette.GetRibbonShape()); // We take on all the provided size ClientRectangle = context.DisplayRectangle; Padding layoutPadding = Padding.Empty; switch (_borderBackOrient) { case VisualOrientation.Top: layoutPadding = _layoutBorderTop; break; case VisualOrientation.Left: layoutPadding = _layoutBorderLeft; break; case VisualOrientation.Right: layoutPadding = _layoutBorderRight; break; case VisualOrientation.Bottom: layoutPadding = _layoutBorderBottom; break; } // Reduce the display size by our border spacing context.DisplayRectangle = CommonHelper.ApplyPadding(_borderBackOrient, context.DisplayRectangle, layoutPadding); // Layout the content using the reduced size base.Layout(context); // Put back the original size before returning context.DisplayRectangle = ClientRectangle; }
/// <summary> /// Gets an array of the allowed possible sizes of the container. /// </summary> /// <param name="context">Context used to calculate the sizes.</param> /// <returns>Array of size values.</returns> public ItemSizeWidth[] GetPossibleSizes(ViewLayoutContext context) { if (_lastShape != _ribbon.RibbonShape) { switch (_ribbon.RibbonShape) { default: case PaletteRibbonShape.Office2007: _lastShape = PaletteRibbonShape.Office2007; _preferredSize = _preferredSize2007; break; case PaletteRibbonShape.Office2010: _lastShape = PaletteRibbonShape.Office2010; _preferredSize = _preferredSize2010; break; } } // Return the one possible size allowed return(new ItemSizeWidth[] { new(GroupItemSize.Large, _preferredSize.Width) });
/// <summary> /// Perform drawing of a ribbon drop arrow glyph. /// </summary> /// <param name="shape">Ribbon shape.</param> /// <param name="context">Render context.</param> /// <param name="displayRect">Display area available for drawing.</param> /// <param name="paletteGeneral">General ribbon palette details.</param> /// <param name="state">State associated with rendering.</param> /// <exception cref="ArgumentNullException"></exception> public override void DrawRibbonDropArrow(PaletteRibbonShape shape, RenderContext context, Rectangle displayRect, IPaletteRibbonGeneral paletteGeneral, PaletteState state) { Debug.Assert(context != null); Debug.Assert(paletteGeneral != null); // Validate parameter references if (context == null) { throw new ArgumentNullException(nameof(context)); } if (paletteGeneral == null) { throw new ArgumentNullException(nameof(paletteGeneral)); } Color darkColor = (state == PaletteState.Disabled ? paletteGeneral.GetRibbonDisabledDark(state) : paletteGeneral.GetRibbonGroupDialogDark(state)); Color lightColor = (state == PaletteState.Disabled ? paletteGeneral.GetRibbonDisabledLight(state) : paletteGeneral.GetRibbonGroupDialogLight(state)); using (Pen darkPen = new Pen(darkColor), lightPen = new Pen(lightColor)) { context.Graphics.DrawLine(lightPen, displayRect.Left, displayRect.Top + 1, displayRect.Left + 2, displayRect.Top + 3); context.Graphics.DrawLine(lightPen, displayRect.Left + 2, displayRect.Top + 3, displayRect.Left + 4, displayRect.Top + 1); context.Graphics.DrawLine(lightPen, displayRect.Left + 4, displayRect.Top + 1, displayRect.Left + 1, displayRect.Top + 1); context.Graphics.DrawLine(lightPen, displayRect.Left + 1, displayRect.Top + 1, displayRect.Left + 2, displayRect.Top + 2); context.Graphics.DrawLine(darkPen, displayRect.Left, displayRect.Top + 2, displayRect.Left + 2, displayRect.Top + 4); context.Graphics.DrawLine(darkPen, displayRect.Left + 2, displayRect.Top + 4, displayRect.Left + 4, displayRect.Top + 2); } }
/// <summary> /// Draw the background of a ribbon element. /// </summary> /// <param name="shape">Ribbon shape.</param> /// <param name="context">Rendering context.</param> /// <param name="rect">Target rectangle.</param> /// <param name="state">State associated with rendering.</param> /// <param name="palette">Palette used for sourcing settings.</param> /// <param name="orientation">Orientation for drawing.</param> /// <param name="composition">Drawing onto a composition element.</param> /// <param name="memento">Cached values to use when drawing.</param> public override IDisposable DrawRibbonBack(PaletteRibbonShape shape, RenderContext context, Rectangle rect, PaletteState state, IPaletteRibbonBack palette, VisualOrientation orientation, bool composition, IDisposable memento) { // Note is the incoming state is detailed we are drawing inside a popup var showingInPopup = (state & PaletteState.FocusOverride) == PaletteState.FocusOverride; if (showingInPopup) { state &= ~PaletteState.FocusOverride; } return(palette.GetRibbonBackColorStyle(state) switch { PaletteRibbonColorStyle.RibbonGroupNormalBorderTracking => DrawRibbonGroupNormalBorder(context, rect, state, palette, true, false, memento), PaletteRibbonColorStyle.RibbonGroupAreaBorder => DrawRibbonGroupAreaBorder1And2(context, rect, state, palette, false, true, memento), PaletteRibbonColorStyle.RibbonGroupAreaBorder2 => DrawRibbonGroupAreaBorder1And2(context, rect, state, palette, true, true, memento), _ => base.DrawRibbonBack(shape, context, rect, state, palette, orientation, composition, memento) });
/// <summary> /// Perform drawing of a ribbon cluster edge. /// </summary> /// <param name="shape">Ribbon shape.</param> /// <param name="context">Render context.</param> /// <param name="displayRect">Display area available for drawing.</param> /// <param name="paletteBack">Palette used for recovering drawing details.</param> /// <param name="state">State associated with rendering.</param> public abstract void DrawRibbonClusterEdge(PaletteRibbonShape shape, RenderContext context, Rectangle displayRect, IPaletteBack paletteBack, PaletteState state);
/// <summary> /// Draw the application tab. /// </summary> /// <param name="shape">Ribbon shape.</param> /// <param name="context">Rendering context.</param> /// <param name="rect">Target rectangle.</param> /// <param name="state">State associated with rendering.</param> /// <param name="baseColor1">Base color1 used for drawing the ribbon tab.</param> /// <param name="baseColor2">Base color2 used for drawing the ribbon tab.</param> /// <param name="memento">Cached values to use when drawing.</param> public abstract IDisposable DrawRibbonApplicationTab(PaletteRibbonShape shape, RenderContext context, Rectangle rect, PaletteState state, Color baseColor1, Color baseColor2, IDisposable memento);
/// <summary> /// Internal rendering method. /// </summary> protected virtual IDisposable DrawRibbonAppButton(PaletteRibbonShape shape, RenderContext context, Rectangle rect, PaletteState state, IPaletteRibbonBack palette, bool trackBorderAsPressed, IDisposable memento) { // Reduce the area of the actual button as the extra space is used for shadow rect.Width -= 3; rect.Height -= 3; if ((rect.Width > 0) && (rect.Height > 0)) { // Get the colors from the palette Color topLight = palette.GetRibbonBackColor1(state); Color topMedium = palette.GetRibbonBackColor2(state); Color topDark = palette.GetRibbonBackColor3(state); Color bottomLight = palette.GetRibbonBackColor4(state); Color bottomMedium = palette.GetRibbonBackColor5(state); Color bottomDark = CommonHelper.MergeColors(topDark, 0.78f, Color.Empty, 0.22f); bool generate = true; MementoRibbonAppButton cache; // Access a cache instance and decide if cache resources need generating if ((memento == null) || !(memento is MementoRibbonAppButton)) { if (memento != null) memento.Dispose(); cache = new MementoRibbonAppButton(rect, topLight, topMedium, topDark, bottomLight, bottomMedium); memento = cache; } else { cache = (MementoRibbonAppButton)memento; generate = !cache.UseCachedValues(rect, topLight, topMedium, topDark, bottomLight, bottomMedium); } // Do we need to generate the contents of the cache? if (generate) { // Dispose of existing values cache.Dispose(); cache.borderShadow1 = new RectangleF(rect.X, rect.Y, rect.Width + 2, rect.Height + 2); cache.borderShadow2 = new RectangleF(rect.X, rect.Y, rect.Width + 1, rect.Height + 1); cache.borderMain1 = new RectangleF(rect.X + 1, rect.Y + 1, rect.Width - 2, rect.Height - 2); cache.borderMain2 = new RectangleF(cache.borderMain1.X + 1, cache.borderMain1.Y + 1, cache.borderMain1.Width - 2, cache.borderMain1.Height - 2); cache.borderMain3 = new RectangleF(cache.borderMain1.X + 1, cache.borderMain1.Y + 1, cache.borderMain1.Width - 2, cache.borderMain1.Height - 2); cache.borderMain4 = new RectangleF(cache.borderMain2.X, cache.borderMain2.Y + 1, cache.borderMain2.Width, cache.borderMain2.Height - 2); cache.rectBottomGlow = new RectangleF(0, 0, rect.Width * 0.75f, rect.Height * 0.75f); cache.rectLower = new RectangleF(rect.X, rect.Y - 1, rect.Width, rect.Height + 1); cache.rectUpperGlow = new RectangleF(); cache.rectUpperGlow.Width = rect.Width - 4; cache.rectUpperGlow.Height = rect.Height / 8; cache.rectUpperGlow.Y = rect.Y + (rect.Height - cache.rectUpperGlow.Height) / 2; cache.rectUpperGlow.X = rect.X + (rect.Width - cache.rectUpperGlow.Width) / 2; cache.brushUpper1 = new LinearGradientBrush(rect, Color.Transparent, Color.Transparent, LinearGradientMode.Horizontal); cache.brushLower = new LinearGradientBrush(cache.rectLower, Color.Transparent, Color.Transparent, LinearGradientMode.Horizontal); } using (AntiAlias aa = new AntiAlias(context.Graphics)) { DrawRibbonAppButtonBorder1(context.Graphics, cache); DrawRibbonAppButtonUpperHalf(context.Graphics, cache, state, topDark, bottomDark, topLight, topMedium, trackBorderAsPressed); DrawRibbonAppButtonLowerHalf(context.Graphics, cache, state, bottomDark, bottomLight, bottomMedium); DrawRibbonAppButtonGlowCenter(context.Graphics, cache, state, topLight, bottomLight); DrawRibbonAppButtonGlowUpperBottom(context.Graphics, cache, state, bottomLight, bottomMedium, bottomDark); DrawRibbonAppButtonBorder2(context.Graphics, cache, state, bottomLight, trackBorderAsPressed); } } return memento; }
/// <summary> /// Draw the application tab. /// </summary> /// <param name="shape">Ribbon shape.</param> /// <param name="context">Rendering context.</param> /// <param name="rect">Target rectangle.</param> /// <param name="state">State associated with rendering.</param> /// <param name="baseColor1">Base color1 used for drawing the ribbon tab.</param> /// <param name="baseColor2">Base color2 used for drawing the ribbon tab.</param> /// <param name="memento">Cached values to use when drawing.</param> public override IDisposable DrawRibbonApplicationTab(PaletteRibbonShape shape, RenderContext context, Rectangle rect, PaletteState state, Color baseColor1, Color baseColor2, IDisposable memento) { if ((rect.Width > 0) && (rect.Height > 0)) { var generate = true; MementoRibbonAppTab2013 cache; // Access a cache instance and decide if cache resources need generating if (memento is MementoRibbonAppTab2013 tab2013) { cache = tab2013; generate = !cache.UseCachedValues(rect, baseColor1); } else { memento?.Dispose(); cache = new MementoRibbonAppTab2013(rect, baseColor1); memento = cache; } // Do we need to generate the contents of the cache? if (generate) { // Dispose of existing values cache.Dispose(); // Create common paths to all the app tab states cache.GeneratePaths(rect, state); //cache.borderPen = new Pen(baseColor1); // Create state specific colors/brushes/pens cache.insideFillBrush = state switch { PaletteState.Normal => //cache.borderBrush = new SolidBrush(baseColor1); new SolidBrush(baseColor1), PaletteState.Tracking => new SolidBrush(baseColor2), PaletteState.Tracking | PaletteState.FocusOverride => new SolidBrush( ControlPaint.LightLight(baseColor2)), PaletteState.Pressed => new SolidBrush(baseColor2), _ => cache.insideFillBrush }; } // Fill the entire tab area and then add a border around the edge //context.Graphics.FillPath(cache.borderBrush, cache.borderFillPath); // Draw the outside border //using (AntiAlias aa = new AntiAlias(context.Graphics)) // context.Graphics.DrawPath(cache.borderPen, cache.borderPath); // Fill inside area //context.Graphics.FillPath(cache.insideFillBrush, cache.insideFillPath); context.Graphics.FillRectangle(cache.insideFillBrush, cache.rect); // Draw highlight over bottom half //using (Clipping clip = new Clipping(context.Graphics, cache.insideFillPath)) // context.Graphics.FillPath(cache.highlightBrush, cache.highlightPath); } return(memento); }
private void SyncChildrenToRibbonGroupItems() { // Grab the shape of the ribbon _lastShape = _ribbon.RibbonShape; bool itemEdgeVisible = (_lastShape != PaletteRibbonShape.Office2010); bool itemEdgeIgnoreNormal = (_lastShape == PaletteRibbonShape.Office2010); bool itemConstantBorder = (_lastShape != PaletteRibbonShape.Office2010); bool itemDrawNonTrackingAreas = (_lastShape != PaletteRibbonShape.Office2010); // Remove all child elements Clear(); // Always add the start separator as the first view element Add(_startSep); // Create new lookups which are up to date ItemToView regenView = new ItemToView(); ViewToEdge regenEdge = new ViewToEdge(); // Cache the first and last visible children ViewBase viewFirst = null; ViewBase viewLast = null; // Add a view element for each group item foreach (IRibbonGroupItem item in _ribbonCluster.Items) { ViewBase itemView; ViewDrawRibbonGroupClusterEdge itemEdge; // Do we already have a view for this item definition if (_itemToView.ContainsKey(item)) { itemView = _itemToView[item]; itemEdge = _viewToEdge[itemView]; // Remove from lookups _itemToView.Remove(item); _viewToEdge.Remove(itemView); } else { // Ask the item definition to return an appropriate view itemView = item.CreateView(_ribbon, _needPaint); // Create a border edge to go with the item view itemEdge = new ViewDrawRibbonGroupClusterEdge(_ribbon, _paletteBorderEdge); } // Update the visible state itemView.Visible = _ribbon.InDesignHelperMode || item.Visible; itemEdge.Visible = itemEdgeVisible && (_ribbon.InDesignHelperMode || item.Visible); // We need to remember associations regenView.Add(item, itemView); regenEdge.Add(itemView, itemEdge); Add(itemView); Add(itemEdge); // Update the cached first/last items if (itemView.Visible && (viewFirst == null)) { viewFirst = itemView; } if (itemView.Visible) { viewLast = itemView; } } // Update the display borders for the visible items foreach (ViewBase item in regenView.Values) { // Only interested in visible items if (item.Visible) { if ((item is ViewDrawRibbonGroupClusterButton) || (item is ViewDrawRibbonGroupClusterColorButton)) { // By default each button shows only the top and bottom PaletteDrawBorders maxBorders = PaletteDrawBorders.TopBottom; switch (_lastShape) { default: case PaletteRibbonShape.Office2007: maxBorders = PaletteDrawBorders.TopBottom; // First and last items have extra borders if (item == viewFirst) { // If first and last, it needs all borders if (item == viewLast) { maxBorders = PaletteDrawBorders.All; } else { maxBorders = PaletteDrawBorders.TopBottomLeft; } } else if (item == viewLast) { maxBorders = PaletteDrawBorders.TopBottomRight; } break; case PaletteRibbonShape.Office2010: maxBorders = PaletteDrawBorders.All; break; } // Remove the border edge after the last button if (item == viewLast) { Remove(regenEdge[item]); } // Cast to correct type ViewDrawRibbonGroupClusterButton clusterButton = item as ViewDrawRibbonGroupClusterButton; ViewDrawRibbonGroupClusterColorButton clusterColorButton = item as ViewDrawRibbonGroupClusterColorButton; if (clusterButton != null) { clusterButton.MaxBorderEdges = maxBorders; clusterButton.BorderIgnoreNormal = itemEdgeIgnoreNormal; clusterButton.ConstantBorder = itemConstantBorder; clusterButton.DrawNonTrackingAreas = itemDrawNonTrackingAreas; } if (clusterColorButton != null) { clusterColorButton.MaxBorderEdges = maxBorders; clusterColorButton.BorderIgnoreNormal = itemEdgeIgnoreNormal; clusterColorButton.ConstantBorder = itemConstantBorder; clusterColorButton.DrawNonTrackingAreas = itemDrawNonTrackingAreas; } } } } // Dispose of all the items no longer needed foreach (ViewBase view in _itemToView.Values) { view.Dispose(); } foreach (ViewBase view in _viewToEdge.Values) { view.Dispose(); } // Always add the end separator as the last view element (excluding any desing time additions) Add(_endSep); // Define visible state of the separators _startSep.Visible = (_lastShape == PaletteRibbonShape.Office2010); _endSep.Visible = (_lastShape == PaletteRibbonShape.Office2010); // When in design time help mode if (_ribbon.InDesignHelperMode) { // Create the design time 'Item' first time it is needed if (_viewAddItem == null) { _viewAddItem = new ViewDrawRibbonDesignCluster(_ribbon, _ribbonCluster, _needPaint); } // Always add at end of the list of items Add(_viewAddItem); } // Use the latest tables _itemToView = regenView; _viewToEdge = regenEdge; }
/// <summary> /// Draw the application tab. /// </summary> /// <param name="shape">Ribbon shape.</param> /// <param name="context">Rendering context.</param> /// <param name="rect">Target rectangle.</param> /// <param name="state">State associated with rendering.</param> /// <param name="baseColor1">Base color1 used for drawing the ribbon tab.</param> /// <param name="baseColor2">Base color2 used for drawing the ribbon tab.</param> /// <param name="memento">Cached values to use when drawing.</param> public override IDisposable DrawRibbonApplicationTab(PaletteRibbonShape shape, RenderContext context, Rectangle rect, PaletteState state, Color baseColor1, Color baseColor2, IDisposable memento) { return DrawRibbonAppTab(shape, context, rect, state, baseColor1, baseColor2, memento); }
/// <summary> /// Internal rendering method. /// </summary> protected virtual IDisposable DrawRibbonTabTracking2007(PaletteRibbonShape shape, RenderContext context, Rectangle rect, PaletteState state, IPaletteRibbonBack palette, VisualOrientation orientation, IDisposable memento) { if ((rect.Width > 0) && (rect.Height > 0)) { Color c1 = palette.GetRibbonBackColor1(state); Color c2 = palette.GetRibbonBackColor2(state); bool generate = true; MementoRibbonTabTracking2007 cache; // Access a cache instance and decide if cache resources need generating if ((memento == null) || !(memento is MementoRibbonTabTracking2007)) { if (memento != null) memento.Dispose(); cache = new MementoRibbonTabTracking2007(rect, c1, c2, orientation); memento = cache; } else { cache = (MementoRibbonTabTracking2007)memento; generate = !cache.UseCachedValues(rect, c1, c2, orientation); } // Do we need to generate the contents of the cache? if (generate) { // Dispose of existing values cache.Dispose(); switch (orientation) { case VisualOrientation.Top: DrawRibbonTabTrackingTop2007(rect, c1, c2, cache); break; case VisualOrientation.Left: DrawRibbonTabTrackingLeft2007(rect, c1, c2, cache); break; case VisualOrientation.Right: DrawRibbonTabTrackingRight2007(rect, c1, c2, cache); break; case VisualOrientation.Bottom: DrawRibbonTabTrackingBottom2007(rect, c1, c2, cache); break; } } // Draw the left and right sides with light version of tracking color context.Graphics.FillRectangle(cache.half1LeftBrush, cache.half1Rect); context.Graphics.FillRectangle(cache.half1RightBrush, cache.half1Rect); // Draw over with glassy effect context.Graphics.FillRectangle(cache.half1LightBrush, cache.half1Rect); //// Use a solid fill for the bottom half context.Graphics.FillRectangle(cache.half2Brush, cache.half2Rect); // Cannot draw a path that contains a zero sized element if ((cache.ellipseRect.Width > 0) && (cache.ellipseRect.Height > 0)) { // Draw twice to get a deeper color effect, once is to pale context.Graphics.FillRectangle(cache.ellipseBrush, cache.half2RectF); context.Graphics.FillRectangle(cache.ellipseBrush, cache.half2RectF); } // Draw the actual border using (AntiAlias aa = new AntiAlias(context.Graphics)) context.Graphics.DrawPath(cache.outsidePen, cache.outsidePath); switch (orientation) { case VisualOrientation.Top: DrawRibbonTabTrackingTopDraw2007(rect, cache, context.Graphics); break; case VisualOrientation.Left: DrawRibbonTabTrackingLeftDraw2007(rect, cache, context.Graphics); break; case VisualOrientation.Right: DrawRibbonTabTrackingRightDraw2007(rect, cache, context.Graphics); break; case VisualOrientation.Bottom: DrawRibbonTabTrackingBottomDraw2007(rect, cache, context.Graphics); break; } context.Graphics.DrawPath(cache.topPen, cache.topPath); } return memento; }
/// <summary> /// Internal rendering method. /// </summary> protected virtual IDisposable DrawRibbonTabHighlight(PaletteRibbonShape shape, RenderContext context, Rectangle rect, PaletteState state, IPaletteRibbonBack palette, VisualOrientation orientation, IDisposable memento, bool alternate) { if ((rect.Width > 0) && (rect.Height > 0)) { Color c1 = palette.GetRibbonBackColor1(state); Color c2 = palette.GetRibbonBackColor2(state); Color c3 = palette.GetRibbonBackColor3(state); Color c4 = palette.GetRibbonBackColor4(state); Color c5 = palette.GetRibbonBackColor5(state); bool generate = true; MementoRibbonTabHighlight cache; // Access a cache instance and decide if cache resources need generating if ((memento == null) || !(memento is MementoRibbonTabHighlight)) { if (memento != null) memento.Dispose(); cache = new MementoRibbonTabHighlight(rect, c1, c2, c3, c4, c5, orientation); memento = cache; } else { cache = (MementoRibbonTabHighlight)memento; generate = !cache.UseCachedValues(rect, c1, c2, c3, c4, c5, orientation); } // Do we need to generate the contents of the cache? if (generate) { // Dispose of existing values cache.Dispose(); switch (orientation) { case VisualOrientation.Top: DrawRibbonTabHighlightTop(rect, c4, c5, cache); break; case VisualOrientation.Left: DrawRibbonTabHighlightLeft(rect, c4, c5, cache); break; case VisualOrientation.Right: DrawRibbonTabHighlightRight(rect, c4, c5, cache); break; case VisualOrientation.Bottom: DrawRibbonTabHighlightBottom(rect, c4, c5, cache); break; } cache.innerVertPen = new Pen(c1); cache.innerHorzPen = new Pen(c2); cache.borderHorzPen = new Pen(c3); } // First of all draw as selected cache.selectedMemento = (MementoRibbonTabSelected2007)DrawRibbonTabSelected2007(context, rect, PaletteState.CheckedNormal, palette, orientation, cache.selectedMemento); switch (orientation) { case VisualOrientation.Top: DrawRibbonTabHighlightTopDraw(rect, c1, c2, c3, c4, c5, cache, context.Graphics, alternate); break; case VisualOrientation.Left: DrawRibbonTabHighlightLeftDraw(rect, c1, c2, c3, c4, c5, cache, context.Graphics, alternate); break; case VisualOrientation.Right: DrawRibbonTabHighlightRightDraw(rect, c1, c2, c3, c4, c5, cache, context.Graphics, alternate); break; case VisualOrientation.Bottom: DrawRibbonTabHighlightBottomDraw(rect, c1, c2, c3, c4, c5, cache, context.Graphics, alternate); break; } } return memento; }
/// <summary> /// Internal rendering method. /// </summary> protected virtual IDisposable DrawRibbonTabGlowing(PaletteRibbonShape shape, RenderContext context, Rectangle rect, PaletteState state, IPaletteRibbonBack palette, VisualOrientation orientation, IDisposable memento) { if ((rect.Width > 0) && (rect.Height > 0)) { Color c1 = palette.GetRibbonBackColor1(state); Color c2 = palette.GetRibbonBackColor2(state); Color insideColor = Color.FromArgb(36, c2); bool generate = true; MementoRibbonTabGlowing cache; // Access a cache instance and decide if cache resources need generating if ((memento == null) || !(memento is MementoRibbonTabGlowing)) { if (memento != null) memento.Dispose(); cache = new MementoRibbonTabGlowing(rect, c1, c2, insideColor, orientation); memento = cache; } else { cache = (MementoRibbonTabGlowing)memento; generate = !cache.UseCachedValues(rect, c1, c2, insideColor, orientation); } // Do we need to generate the contents of the cache? if (generate) { // Dispose of existing values cache.Dispose(); switch (orientation) { case VisualOrientation.Top: DrawRibbonTabGlowingTop(rect, c1, c2, insideColor, cache); break; case VisualOrientation.Left: DrawRibbonTabGlowingLeft(rect, c1, c2, insideColor, cache); break; case VisualOrientation.Right: DrawRibbonTabGlowingRight(rect, c1, c2, insideColor, cache); break; case VisualOrientation.Bottom: DrawRibbonTabGlowingBottom(rect, c1, c2, insideColor, cache); break; } } // Fill the path area with inside color context.Graphics.FillPath(cache.insideBrush, cache.outsidePath); switch (orientation) { case VisualOrientation.Top: // Draw the missing line from the bottom of the inside area context.Graphics.DrawLine(cache.insidePen, rect.Left + 1, rect.Bottom - 2, rect.Right - 2, rect.Bottom - 2); break; case VisualOrientation.Left: // Draw the missing line from the right of the inside area context.Graphics.DrawLine(cache.insidePen, rect.Right - 2, rect.Top + 1, rect.Right - 2, rect.Bottom - 2); break; } // Draw the border over the edge of the inside color using (AntiAlias aa = new AntiAlias(context.Graphics)) context.Graphics.DrawPath(cache.outsidePen, cache.outsidePath); // Draw the top glass effect context.Graphics.FillPath(cache.topBrush, cache.topPath); // Cannot draw a path that contains a zero sized element if ((cache.ellipseRect.Width > 0) && (cache.ellipseRect.Height > 0)) context.Graphics.FillRectangle(cache.ellipseBrush, cache.fullRect); } return memento; }
/// <summary> /// Internal rendering method. /// </summary> protected virtual IDisposable DrawRibbonTabContextSelected(PaletteRibbonShape shape, RenderContext context, Rectangle rect, PaletteState state, IPaletteRibbonBack palette, VisualOrientation orientation, IDisposable memento) { if ((rect.Width > 0) && (rect.Height > 0)) { Color c1 = palette.GetRibbonBackColor1(state); Color c2 = palette.GetRibbonBackColor2(state); bool generate = true; MementoRibbonTabContextSelected cache; // Access a cache instance and decide if cache resources need generating if ((memento == null) || !(memento is MementoRibbonTabContextSelected)) { if (memento != null) memento.Dispose(); cache = new MementoRibbonTabContextSelected(rect, c1, c2, orientation); memento = cache; } else { cache = (MementoRibbonTabContextSelected)memento; generate = !cache.UseCachedValues(rect, c1, c2, orientation); } // Do we need to generate the contents of the cache? if (generate) { // Dispose of existing values cache.Dispose(); switch (orientation) { case VisualOrientation.Top: DrawRibbonTabContextSelectedTop(rect, c2, cache); break; case VisualOrientation.Left: DrawRibbonTabContextSelectedLeft(rect, c2, cache); break; case VisualOrientation.Right: DrawRibbonTabContextSelectedRight(rect, c2, cache); break; case VisualOrientation.Bottom: DrawRibbonTabContextSelectedBottom(rect, c2, cache); break; } cache.outsidePen = new Pen(c1); cache.l1 = new Pen(Color.FromArgb(100, c2)); cache.l2 = new Pen(Color.FromArgb(75, c2)); cache.l3 = new Pen(Color.FromArgb(48, c2)); cache.bottomInnerPen = new Pen(Color.FromArgb(70, c2)); cache.bottomOuterPen = new Pen(Color.FromArgb(100, c2)); } // Fill the interior using a gradient brush context.Graphics.FillRectangle(Brushes.White, cache.interiorRect); context.Graphics.FillRectangle(cache.insideBrush, cache.interiorRect); // Draw the actual border using (AntiAlias aa = new AntiAlias(context.Graphics)) context.Graphics.DrawPath(cache.outsidePen, cache.outsidePath); switch (orientation) { case VisualOrientation.Top: DrawRibbonTabContextSelectedTopDraw(rect, cache, context.Graphics); break; case VisualOrientation.Left: DrawRibbonTabContextSelectedLeftDraw(rect, cache, context.Graphics); break; case VisualOrientation.Right: DrawRibbonTabContextSelectedRightDraw(rect, cache, context.Graphics); break; case VisualOrientation.Bottom: DrawRibbonTabContextSelectedBottomDraw(rect, cache, context.Graphics); break; } } return memento; }
/// <summary> /// Internal rendering method. /// </summary> protected virtual IDisposable DrawRibbonQATOverflow(PaletteRibbonShape shape, RenderContext context, Rectangle rect, PaletteState state, IPaletteRibbonBack palette, IDisposable memento) { if ((rect.Width > 0) && (rect.Height > 0)) { Color c1 = palette.GetRibbonBackColor1(state); Color c2 = palette.GetRibbonBackColor2(state); bool generate = true; MementoRibbonQATOverflow cache; // Access a cache instance and decide if cache resources need generating if ((memento == null) || !(memento is MementoRibbonQATOverflow)) { if (memento != null) memento.Dispose(); cache = new MementoRibbonQATOverflow(rect, c1, c2); memento = cache; } else { cache = (MementoRibbonQATOverflow)memento; generate = !cache.UseCachedValues(rect, c1, c2); } // Do we need to generate the contents of the cache? if (generate) { // Dispose of existing values cache.Dispose(); cache.backBrush = new SolidBrush(c1); cache.borderPen = new Pen(c2); } // Draw a gradient for the inside of the area context.Graphics.FillRectangle(cache.backBrush, rect); using (AntiAlias aa = new AntiAlias(context.Graphics)) { if (shape == PaletteRibbonShape.Office2010) { context.Graphics.DrawPolygon(cache.borderPen, new Point[]{ new Point(rect.Left + 1, rect.Top), new Point(rect.Right - 2, rect.Top), new Point(rect.Right - 1, rect.Top + 1), new Point(rect.Right - 1, rect.Bottom - 2), new Point(rect.Right - 2, rect.Bottom - 1), new Point(rect.Left + 1, rect.Bottom - 1), new Point(rect.Left, rect.Bottom - 2), new Point(rect.Left, rect.Top + 1) } ); } else { context.Graphics.DrawLine(cache.borderPen, rect.Left + 1f, rect.Top, rect.Right - 2f, rect.Top); context.Graphics.DrawLine(cache.borderPen, rect.Right - 2f, rect.Top, rect.Right - 1f, rect.Top + 2f); context.Graphics.DrawLine(cache.borderPen, rect.Right - 1f, rect.Top + 2f, rect.Right - 1f, rect.Bottom - 2f); context.Graphics.DrawLine(cache.borderPen, rect.Right - 1f, rect.Bottom - 2f, rect.Right - 2f, rect.Bottom - 1f); context.Graphics.DrawLine(cache.borderPen, rect.Right - 2f, rect.Bottom - 1f, rect.Left + 1f, rect.Bottom - 1f); context.Graphics.DrawLine(cache.borderPen, rect.Left + 1f, rect.Bottom - 1f, rect.Left, rect.Bottom - 2f); context.Graphics.DrawLine(cache.borderPen, rect.Left, rect.Bottom - 2f, rect.Left, rect.Top + 1f); context.Graphics.DrawLine(cache.borderPen, rect.Left, rect.Top + 1f, rect.Left + 1f, rect.Top); } } } return memento; }
/// <summary> /// Internal rendering method. /// </summary> protected virtual IDisposable DrawRibbonAppTab(PaletteRibbonShape shape, RenderContext context, Rectangle rect, PaletteState state, Color baseColor1, Color baseColor2, IDisposable memento) { if ((rect.Width > 0) && (rect.Height > 0)) { bool generate = true; MementoRibbonAppTab cache; // Access a cache instance and decide if cache resources need generating if ((memento == null) || !(memento is MementoRibbonAppTab)) { if (memento != null) memento.Dispose(); cache = new MementoRibbonAppTab(rect, baseColor1, baseColor2); memento = cache; } else { cache = (MementoRibbonAppTab)memento; generate = !cache.UseCachedValues(rect, baseColor1, baseColor2); } // Do we need to generate the contents of the cache? if (generate) { // Dispose of existing values cache.Dispose(); // Create common paths to all the app tab states cache.GeneratePaths(rect, state); cache.borderPen = new Pen(baseColor1); // Create state specific colors/brushes/pens switch (state) { case PaletteState.Normal: cache.borderBrush = new SolidBrush(CommonHelper.MergeColors(baseColor1, 0.2f, baseColor2, 0.8f)); cache.insideFillBrush = new LinearGradientBrush(new RectangleF(rect.X, rect.Y + 1, rect.Width, rect.Height), CommonHelper.MergeColors(baseColor1, 0.3f, baseColor2, 0.7f), CommonHelper.MergeColors(baseColor1, 0.6f, baseColor2, 0.4f), 90f); cache.insideFillBrush.SetSigmaBellShape(0.33f); cache.highlightBrush.CenterColor = Color.FromArgb(64, Color.White); break; case PaletteState.Tracking: cache.borderBrush = new SolidBrush(baseColor2); cache.insideFillBrush = new LinearGradientBrush(new RectangleF(rect.X, rect.Y + 1, rect.Width, rect.Height), CommonHelper.MergeColors(baseColor1, 0.3f, baseColor2, 0.7f), CommonHelper.MergeColors(baseColor1, 0.6f, baseColor2, 0.4f), 90f); cache.insideFillBrush.SetSigmaBellShape(0.33f); cache.highlightBrush.CenterColor = Color.FromArgb(100, Color.White); break; case PaletteState.Tracking | PaletteState.FocusOverride: cache.borderBrush = new SolidBrush(ControlPaint.LightLight(baseColor2)); cache.insideFillBrush = new LinearGradientBrush(new RectangleF(rect.X, rect.Y + 1, rect.Width, rect.Height), CommonHelper.MergeColors(baseColor1, 0.3f, baseColor2, 0.7f), CommonHelper.MergeColors(baseColor1, 0.6f, baseColor2, 0.4f), 90f); cache.insideFillBrush.SetSigmaBellShape(0.33f); cache.highlightBrush.CenterColor = ControlPaint.LightLight(baseColor2); break; case PaletteState.Pressed: cache.borderBrush = new SolidBrush(CommonHelper.MergeColors(baseColor1, 0.5f, baseColor2, 0.5f)); cache.insideFillBrush = new LinearGradientBrush(new RectangleF(rect.X, rect.Y + 1, rect.Width, rect.Height), CommonHelper.MergeColors(baseColor1, 0.3f, baseColor2, 0.7f), CommonHelper.MergeColors(baseColor1, 0.75f, baseColor2, 0.25f), 90f); cache.insideFillBrush.SetSigmaBellShape(0f); cache.highlightBrush.CenterColor = Color.FromArgb(90, Color.White); break; } } // Fill the entire tab area and then add a border around the edge context.Graphics.FillPath(cache.borderBrush, cache.borderFillPath); // Draw the outside border using (AntiAlias aa = new AntiAlias(context.Graphics)) context.Graphics.DrawPath(cache.borderPen, cache.borderPath); // Fill inside area context.Graphics.FillPath(cache.insideFillBrush, cache.insideFillPath); // Draw highlight over bottom half using(Clipping clip = new Clipping(context.Graphics, cache.insideFillPath)) context.Graphics.FillPath(cache.highlightBrush, cache.highlightPath); } return memento; }
/// <summary> /// Perform drawing of a ribbon group separator. /// </summary> /// <param name="shape">Ribbon shape.</param> /// <param name="context">Render context.</param> /// <param name="displayRect">Display area available for drawing.</param> /// <param name="paletteGeneral">General ribbon palette details.</param> /// <param name="state">State associated with rendering.</param> public override void DrawRibbonGroupSeparator(PaletteRibbonShape shape, RenderContext context, Rectangle displayRect, IPaletteRibbonGeneral paletteGeneral, PaletteState state) { Debug.Assert(context != null); Debug.Assert(paletteGeneral != null); // Validate parameter references if (context == null) throw new ArgumentNullException("context"); if (paletteGeneral == null) throw new ArgumentNullException("paletteGeneral"); int x = displayRect.X + (displayRect.Width - 2) / 2; Color darkColor = paletteGeneral.GetRibbonGroupSeparatorDark(state); Color lightColor = paletteGeneral.GetRibbonGroupSeparatorLight(state); switch (shape) { default: case PaletteRibbonShape.Office2007: using (Pen darkPen = new Pen(darkColor), lightPen = new Pen(lightColor)) { context.Graphics.DrawLine(lightPen, x, displayRect.Top + 2, x, displayRect.Bottom - 3); context.Graphics.DrawLine(darkPen, x + 1, displayRect.Top + 2, x + 1, displayRect.Bottom - 3); } break; case PaletteRibbonShape.Office2010: using (LinearGradientBrush darkBrush = new LinearGradientBrush(new RectangleF(displayRect.X, displayRect.Y - 1, displayRect.Width, displayRect.Height + 2), Color.FromArgb(72, darkColor), darkColor, 90f), lightBrush = new LinearGradientBrush(new RectangleF(displayRect.X - 1, displayRect.Y - 1, displayRect.Width + 2, displayRect.Height + 2), Color.FromArgb(128, lightColor), lightColor, 90f)) { darkBrush.SetSigmaBellShape(0.5f); lightBrush.SetSigmaBellShape(0.5f); using (Pen darkPen = new Pen(darkBrush)) { context.Graphics.FillRectangle(lightBrush, x, displayRect.Top, 3, displayRect.Height); context.Graphics.DrawLine(darkPen, x + 1, displayRect.Top, x + 1, displayRect.Bottom - 1); } } break; } }
/// <summary> /// Draw the background of a ribbon element. /// </summary> /// <param name="shape">Ribbon shape.</param> /// <param name="context">Rendering context.</param> /// <param name="rect">Target rectangle.</param> /// <param name="state">State associated with rendering.</param> /// <param name="palette">Palette used for sourcing settings.</param> /// <param name="orientation">Orientation for drawing.</param> /// <param name="composition">Drawing onto a composition element.</param> /// <param name="memento">Cached values to use when drawing.</param> public override IDisposable DrawRibbonBack(PaletteRibbonShape shape, RenderContext context, Rectangle rect, PaletteState state, IPaletteRibbonBack palette, VisualOrientation orientation, bool composition, IDisposable memento) { // Note is the incoming state is detailed we are drawing inside a popip bool showingInPopup = ((state & PaletteState.FocusOverride) == PaletteState.FocusOverride); if (showingInPopup) state = state & ~PaletteState.FocusOverride; switch (palette.GetRibbonBackColorStyle(state)) { case PaletteRibbonColorStyle.Empty: // Do nothing break; case PaletteRibbonColorStyle.Solid: using (SolidBrush backBrush = new SolidBrush(palette.GetRibbonBackColor1(state))) context.Graphics.FillRectangle(backBrush, rect); break; case PaletteRibbonColorStyle.Linear: return DrawRibbonLinear(context, rect, state, palette, memento); case PaletteRibbonColorStyle.LinearBorder: return DrawRibbonLinearBorder(context, rect, state, palette, memento); case PaletteRibbonColorStyle.RibbonAppMenuInner: return DrawRibbonAppMenuInner(context, rect, state, palette, memento); case PaletteRibbonColorStyle.RibbonAppMenuOuter: return DrawRibbonAppMenuOuter(context, rect, state, palette, memento); case PaletteRibbonColorStyle.RibbonQATFullbarRound: return DrawRibbonQATFullbarRound(context, rect, state, palette, memento); case PaletteRibbonColorStyle.RibbonQATFullbarSquare: return DrawRibbonQATFullbarSquare(context, rect, state, palette, memento); case PaletteRibbonColorStyle.RibbonQATMinibarSingle: return DrawRibbonQATMinibarSingle(context, rect, state, palette, composition, memento); case PaletteRibbonColorStyle.RibbonQATMinibarDouble: return DrawRibbonQATMinibarDouble(context, rect, state, palette, composition, memento); case PaletteRibbonColorStyle.RibbonQATOverflow: return DrawRibbonQATOverflow(shape, context, rect, state, palette, memento); case PaletteRibbonColorStyle.RibbonGroupGradientOne: return DrawRibbonGroupGradientOne(context, rect, state, palette, memento); case PaletteRibbonColorStyle.RibbonGroupGradientTwo: return DrawRibbonGroupGradientTwo(context, rect, state, palette, _groupGradientTwo, memento); case PaletteRibbonColorStyle.RibbonGroupCollapsedBorder: return DrawRibbonGroupCollapsedBorder(context, rect, state, palette, memento); case PaletteRibbonColorStyle.RibbonGroupCollapsedFrameBorder: return DrawRibbonGroupCollapsedFrameBorder(context, rect, state, palette, memento); case PaletteRibbonColorStyle.RibbonGroupCollapsedFrameBack: return DrawRibbonGroupGradientTwo(context, rect, state, palette, _groupGradientFrame, memento); case PaletteRibbonColorStyle.RibbonGroupNormalBorder: return DrawRibbonGroupNormalBorder(context, rect, state, palette, false, false, memento); case PaletteRibbonColorStyle.RibbonGroupNormalBorderSep: return DrawRibbonGroupNormalBorderSep(showingInPopup, context, rect, state, palette, memento, false, false, false); case PaletteRibbonColorStyle.RibbonGroupNormalBorderSepPressedLight: return DrawRibbonGroupNormalBorderSep(showingInPopup, context, rect, state, palette, memento, true, false, false); case PaletteRibbonColorStyle.RibbonGroupNormalBorderSepPressedDark: return DrawRibbonGroupNormalBorderSep(showingInPopup, context, rect, state, palette, memento, true, false, true); case PaletteRibbonColorStyle.RibbonGroupNormalBorderSepTrackingLight: return DrawRibbonGroupNormalBorderSep(showingInPopup, context, rect, state, palette, memento, false, true, false); case PaletteRibbonColorStyle.RibbonGroupNormalBorderSepTrackingDark: return DrawRibbonGroupNormalBorderSep(showingInPopup, context, rect, state, palette, memento, false, true, true); case PaletteRibbonColorStyle.RibbonGroupNormalBorderTracking: return DrawRibbonGroupNormalBorder(context, rect, state, palette, true, false, memento); case PaletteRibbonColorStyle.RibbonGroupNormalBorderTrackingLight: return DrawRibbonGroupNormalBorder(context, rect, state, palette, true, true, memento); case PaletteRibbonColorStyle.RibbonGroupNormalTitle: return DrawRibbonGroupNormalTitle(context, rect, state, palette, memento); case PaletteRibbonColorStyle.RibbonGroupAreaBorder: return DrawRibbonGroupAreaBorder1And2(context, rect, state, palette, false, false, memento); case PaletteRibbonColorStyle.RibbonGroupAreaBorder2: return DrawRibbonGroupAreaBorder1And2(context, rect, state, palette, true, false, memento); case PaletteRibbonColorStyle.RibbonGroupAreaBorder3: return DrawRibbonGroupAreaBorder3And4(context, rect, state, palette, memento, true); case PaletteRibbonColorStyle.RibbonGroupAreaBorder4: return DrawRibbonGroupAreaBorder3And4(context, rect, state, palette, memento, false); case PaletteRibbonColorStyle.RibbonGroupAreaBorderContext: return DrawRibbonGroupAreaBorderContext(context, rect, state, palette, memento); case PaletteRibbonColorStyle.RibbonTabTracking2007: return DrawRibbonTabTracking2007(shape, context, rect, state, palette, orientation, memento); case PaletteRibbonColorStyle.RibbonTabFocus2010: return DrawRibbonTabFocus2010(shape, context, rect, state, palette, orientation, memento); case PaletteRibbonColorStyle.RibbonTabTracking2010: return DrawRibbonTabTracking2010(shape, context, rect, state, palette, orientation, memento, true); case PaletteRibbonColorStyle.RibbonTabTracking2010Alt: return DrawRibbonTabTracking2010(shape, context, rect, state, palette, orientation, memento, false); case PaletteRibbonColorStyle.RibbonTabGlowing: return DrawRibbonTabGlowing(shape, context, rect, state, palette, orientation, memento); case PaletteRibbonColorStyle.RibbonTabHighlight: return DrawRibbonTabHighlight(shape, context, rect, state, palette, orientation, memento, false); case PaletteRibbonColorStyle.RibbonTabHighlight2: return DrawRibbonTabHighlight(shape, context, rect, state, palette, orientation, memento, true); case PaletteRibbonColorStyle.RibbonTabSelected2007: return DrawRibbonTabSelected2007(context, rect, state, palette, orientation, memento); case PaletteRibbonColorStyle.RibbonTabSelected2010: return DrawRibbonTabSelected2010(context, rect, state, palette, orientation, memento, true); case PaletteRibbonColorStyle.RibbonTabSelected2010Alt: return DrawRibbonTabSelected2010(context, rect, state, palette, orientation, memento, false); case PaletteRibbonColorStyle.RibbonTabContextSelected: return DrawRibbonTabContextSelected(shape, context, rect, state, palette, orientation, memento); default: // Should never happen! Debug.Assert(false); break; } return null; }
/// <summary> /// Internal rendering method. /// </summary> protected virtual IDisposable DrawRibbonTabTracking2010(PaletteRibbonShape shape, RenderContext context, Rectangle rect, PaletteState state, IPaletteRibbonBack palette, VisualOrientation orientation, IDisposable memento, bool standard) { if ((rect.Width > 0) && (rect.Height > 0)) { Color c1 = palette.GetRibbonBackColor1(state); Color c2 = palette.GetRibbonBackColor2(state); Color c3 = palette.GetRibbonBackColor3(state); Color c4 = palette.GetRibbonBackColor4(state); Color c5 = palette.GetRibbonBackColor5(state); bool generate = true; MementoRibbonTabTracking2010 cache; // Access a cache instance and decide if cache resources need generating if ((memento == null) || !(memento is MementoRibbonTabTracking2010)) { if (memento != null) memento.Dispose(); cache = new MementoRibbonTabTracking2010(rect, c1, c2, c3, c4, orientation); memento = cache; } else { cache = (MementoRibbonTabTracking2010)memento; generate = !cache.UseCachedValues(rect, c1, c2, c3, c4, orientation); } // Do we need to generate the contents of the cache? if (generate) { // Dispose of existing values cache.Dispose(); // If c5 has a colour then use that to highlight the tab if (c5 != Color.Empty) { if (!standard) c5 = CommonHelper.MergeColors(c5, 0.65f, Color.Black, 0.35f); c1 = c5; c2 = CommonHelper.MergeColors(c2, 0.8f, ControlPaint.Light(c5), 0.2f); c3 = CommonHelper.MergeColors(c3, 0.7f, c5, 0.3f); } switch (orientation) { case VisualOrientation.Top: DrawRibbonTabTrackingTop2010(rect, c3, c4, cache); break; case VisualOrientation.Left: DrawRibbonTabTrackingLeft2010(rect, c3, c4, cache); break; case VisualOrientation.Right: DrawRibbonTabTrackingRight2010(rect, c3, c4, cache); break; case VisualOrientation.Bottom: DrawRibbonTabTrackingBottom2010(rect, c3, c4, cache); break; } cache.outsidePen = new Pen(c1); cache.outsideBrush = new SolidBrush(c2); } // Fill the full background context.Graphics.FillPath(cache.outsideBrush, cache.outsidePath); // Draw the border using (AntiAlias aa = new AntiAlias(context.Graphics)) context.Graphics.DrawPath(cache.outsidePen, cache.borderPath); // Fill the inside area context.Graphics.FillPath(cache.insideBrush, cache.insidePath); } return memento; }
/// <summary> /// Draw the application button. /// </summary> /// <param name="shape">Ribbon shape.</param> /// <param name="context">Rendering context.</param> /// <param name="rect">Target rectangle.</param> /// <param name="state">State associated with rendering.</param> /// <param name="palette">Palette used for sourcing settings.</param> /// <param name="memento">Cached storage for drawing objects.</param> public override IDisposable DrawRibbonApplicationButton(PaletteRibbonShape shape, RenderContext context, Rectangle rect, PaletteState state, IPaletteRibbonBack palette, IDisposable memento) { return DrawRibbonAppButton(shape, context, rect, state, palette, false, memento); }
/// <summary> /// Perform drawing of a ribbon overflow image. /// </summary> /// <param name="shape">Ribbon shape.</param> /// <param name="context">Render context.</param> /// <param name="displayRect">Display area available for drawing.</param> /// <param name="paletteGeneral">General ribbon palette details.</param> /// <param name="state">State associated with rendering.</param> public abstract void DrawRibbonOverflow(PaletteRibbonShape shape, RenderContext context, Rectangle displayRect, IPaletteRibbonGeneral paletteGeneral, PaletteState state);
/// <summary> /// Initialize a new instance of the PaletteRibbonGeneral class. /// </summary> /// <param name="inherit">Source for inheriting general values.</param> /// <param name="needPaint">Delegate for notifying paint requests.</param> public PaletteRibbonGeneral(IPaletteRibbonGeneral inherit, NeedPaintHandler needPaint) { Debug.Assert(inherit != null); // Remember inheritance _inherit = inherit; // Store the provided paint notification delegate NeedPaint = needPaint; // Set default values _contextTextAlign = PaletteRelativeAlign.Inherit; _contextTextColor = Color.Empty; _contextTextFont = null; _disabledDarkColor = Color.Empty; _disabledLightColor = Color.Empty; _dialogDarkColor = Color.Empty; _dialogLightColor = Color.Empty; _dropArrowLightColor = Color.Empty; _dropArrowDarkColor = Color.Empty; _groupSeparatorDark = Color.Empty; _groupSeparatorLight = Color.Empty; _minimizeBarDarkColor = Color.Empty; _minimizeBarLightColor = Color.Empty; _ribbonShape = PaletteRibbonShape.Inherit; _tabSeparatorColor = Color.Empty; _tabSeparatorContextColor = Color.Empty; _textFont = null; _textHint = PaletteTextHint.Inherit; _qatButtonDarkColor = Color.Empty; _qatButtonLightColor = Color.Empty; }
/// <summary> /// Perform drawing of a ribbon dialog box launcher glyph. /// </summary> /// <param name="shape">Ribbon shape.</param> /// <param name="context">Render context.</param> /// <param name="displayRect">Display area available for drawing.</param> /// <param name="paletteGeneral">General ribbon palette details.</param> /// <param name="state">State associated with rendering.</param> public override void DrawRibbonDialogBoxLauncher(PaletteRibbonShape shape, RenderContext context, Rectangle displayRect, IPaletteRibbonGeneral paletteGeneral, PaletteState state) { Debug.Assert(context != null); Debug.Assert(paletteGeneral != null); // Validate parameter references if (context == null) throw new ArgumentNullException("context"); if (paletteGeneral == null) throw new ArgumentNullException("paletteGeneral"); switch (shape) { default: case PaletteRibbonShape.Office2007: using (Pen darkPen = new Pen(paletteGeneral.GetRibbonGroupDialogDark(state)), lightPen = new Pen(paletteGeneral.GetRibbonGroupDialogLight(state))) { context.Graphics.DrawLine(darkPen, displayRect.Left, displayRect.Top + 5, displayRect.Left, displayRect.Top); context.Graphics.DrawLine(darkPen, displayRect.Left, displayRect.Top, displayRect.Left + 5, displayRect.Top); context.Graphics.DrawLine(lightPen, displayRect.Left + 1, displayRect.Top + 5, displayRect.Left + 1, displayRect.Top + 1); context.Graphics.DrawLine(lightPen, displayRect.Left + 1, displayRect.Top + 1, displayRect.Left + 5, displayRect.Top + 1); context.Graphics.DrawLine(lightPen, displayRect.Right - 1, displayRect.Bottom - 5, displayRect.Right - 1, displayRect.Bottom - 1); context.Graphics.DrawLine(lightPen, displayRect.Right - 1, displayRect.Bottom - 1, displayRect.Right - 4, displayRect.Bottom - 1); context.Graphics.DrawLine(lightPen, displayRect.Right - 1, displayRect.Bottom - 1, displayRect.Right - 4, displayRect.Bottom - 5); context.Graphics.DrawLine(darkPen, displayRect.Right - 5, displayRect.Bottom - 2, displayRect.Right - 2, displayRect.Bottom - 2); context.Graphics.DrawLine(darkPen, displayRect.Right - 4, displayRect.Bottom - 3, displayRect.Right - 3, displayRect.Bottom - 3); context.Graphics.DrawLine(darkPen, displayRect.Right - 2, displayRect.Bottom - 2, displayRect.Right - 2, displayRect.Bottom - 5); context.Graphics.DrawLine(darkPen, displayRect.Right - 3, displayRect.Bottom - 3, displayRect.Right - 3, displayRect.Bottom - 4); context.Graphics.DrawLine(darkPen, displayRect.Right - 5, displayRect.Bottom - 5, displayRect.Right - 3, displayRect.Bottom - 3); } break; case PaletteRibbonShape.Office2010: LinearGradientBrush dialogBrush = new LinearGradientBrush(new RectangleF(displayRect.X - 1, displayRect.Y - 1, displayRect.Width + 2, displayRect.Height + 2), paletteGeneral.GetRibbonGroupDialogLight(state), paletteGeneral.GetRibbonGroupDialogDark(state), 45f); using (Pen dialogPen = new Pen(dialogBrush)) { context.Graphics.DrawLine(dialogPen, displayRect.Left, displayRect.Top + 5, displayRect.Left, displayRect.Top); context.Graphics.DrawLine(dialogPen, displayRect.Left, displayRect.Top, displayRect.Left + 5, displayRect.Top); context.Graphics.DrawLine(dialogPen, displayRect.Right - 5, displayRect.Bottom - 2, displayRect.Right - 2, displayRect.Bottom - 2); context.Graphics.DrawLine(dialogPen, displayRect.Right - 4, displayRect.Bottom - 3, displayRect.Right - 3, displayRect.Bottom - 3); context.Graphics.DrawLine(dialogPen, displayRect.Right - 2, displayRect.Bottom - 2, displayRect.Right - 2, displayRect.Bottom - 5); context.Graphics.DrawLine(dialogPen, displayRect.Right - 3, displayRect.Bottom - 3, displayRect.Right - 3, displayRect.Bottom - 4); context.Graphics.DrawLine(dialogPen, displayRect.Right - 5, displayRect.Bottom - 5, displayRect.Right - 3, displayRect.Bottom - 3); } break; } }
/// <summary> /// Perform drawing of a ribbon overflow image. /// </summary> /// <param name="shape">Ribbon shape.</param> /// <param name="context">Render context.</param> /// <param name="displayRect">Display area available for drawing.</param> /// <param name="paletteGeneral">General ribbon palette details.</param> /// <param name="state">State associated with rendering.</param> public override void DrawRibbonOverflow(PaletteRibbonShape shape, RenderContext context, Rectangle displayRect, IPaletteRibbonGeneral paletteGeneral, PaletteState state) { Debug.Assert(context != null); Debug.Assert(paletteGeneral != null); // Validate parameter references if (context == null) throw new ArgumentNullException("context"); if (paletteGeneral == null) throw new ArgumentNullException("paletteGeneral"); Color c1 = paletteGeneral.GetRibbonQATButtonDark(state); Color c2 = paletteGeneral.GetRibbonQATButtonLight(state); // Office 2010 uses the same color for both parts if (shape == PaletteRibbonShape.Office2010) c2 = c1; // If disabled then convert to black and white if (state == PaletteState.Disabled) { c1 = CommonHelper.ColorToBlackAndWhite(c1); c2 = CommonHelper.ColorToBlackAndWhite(c2); } using (Pen darkPen = new Pen(c1), lightPen = new Pen(c2)) { context.Graphics.DrawLine(darkPen, displayRect.Left, displayRect.Top + 1, displayRect.Left, displayRect.Top + 3); context.Graphics.DrawLine(darkPen, displayRect.Left + 1, displayRect.Top + 2, displayRect.Left, displayRect.Top + 3); context.Graphics.DrawLine(lightPen, displayRect.Left, displayRect.Top, displayRect.Left + 2, displayRect.Top + 2); context.Graphics.DrawLine(lightPen, displayRect.Left + 1, displayRect.Top + 3, displayRect.Left, displayRect.Top + 4); context.Graphics.DrawLine(darkPen, displayRect.Left + 4, displayRect.Top + 1, displayRect.Left + 4, displayRect.Top + 3); context.Graphics.DrawLine(darkPen, displayRect.Left + 5, displayRect.Top + 2, displayRect.Left + 4, displayRect.Top + 3); context.Graphics.DrawLine(lightPen, displayRect.Left + 4, displayRect.Top, displayRect.Left + 6, displayRect.Top + 2); context.Graphics.DrawLine(lightPen, displayRect.Left + 5, displayRect.Top + 3, displayRect.Left + 4, displayRect.Top + 4); } }
/// <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> /// Internal rendering method. /// </summary> protected override IDisposable DrawRibbonTabTracking2010(PaletteRibbonShape shape, RenderContext context, Rectangle rect, PaletteState state, IPaletteRibbonBack palette, VisualOrientation orientation, IDisposable memento, bool standard) { if ((rect.Width > 0) && (rect.Height > 0)) { Color c1 = palette.GetRibbonBackColor1(state); Color c2 = palette.GetRibbonBackColor2(state); Color c3 = palette.GetRibbonBackColor3(state); Color c4 = palette.GetRibbonBackColor4(state); Color c5 = palette.GetRibbonBackColor5(state); bool generate = true; MementoRibbonTabTracking2010 cache; // Access a cache instance and decide if cache resources need generating if ((memento == null) || !(memento is MementoRibbonTabTracking2010)) { if (memento != null) { memento.Dispose(); } cache = new MementoRibbonTabTracking2010(rect, c1, c2, c3, c4, orientation); memento = cache; } else { cache = (MementoRibbonTabTracking2010)memento; generate = !cache.UseCachedValues(rect, c1, c2, c3, c4, orientation); } // Do we need to generate the contents of the cache? if (generate) { // Dispose of existing values cache.Dispose(); // If c5 has a colour then use that to highlight the tab if (c5 != Color.Empty) { if (!standard) { c5 = CommonHelper.MergeColors(c5, 0.65f, Color.Black, 0.35f); } c1 = c5; c2 = CommonHelper.MergeColors(c2, 0.8f, ControlPaint.Light(c5), 0.2f); c3 = CommonHelper.MergeColors(c3, 0.7f, c5, 0.3f); } switch (orientation) { case VisualOrientation.Top: DrawRibbonTabTrackingTop2010(rect, c3, c4, cache); break; case VisualOrientation.Left: DrawRibbonTabTrackingLeft2010(rect, c3, c4, cache); break; case VisualOrientation.Right: DrawRibbonTabTrackingRight2010(rect, c3, c4, cache); break; case VisualOrientation.Bottom: DrawRibbonTabTrackingBottom2010(rect, c3, c4, cache); break; } cache.outsidePen = new Pen(c1); cache.outsideBrush = new SolidBrush(c2); } // Fill the full background //context.Graphics.FillPath(cache.outsideBrush, cache.outsidePath); context.Graphics.FillRectangle(cache.outsideBrush, cache.rect); // Draw the border //using (AntiAlias aa = new AntiAlias(context.Graphics)) // context.Graphics.DrawPath(cache.outsidePen, cache.borderPath); context.Graphics.DrawRectangle(cache.outsidePen, cache.rect); // Fill the inside area //context.Graphics.FillPath(cache.insideBrush, cache.insidePath); } return(memento); }
/// <summary> /// Draw a context ribbon tab title. /// </summary> /// <param name="shape">Ribbon shape.</param> /// <param name="context">Rendering context.</param> /// <param name="rect">Target rectangle.</param> /// <param name="paletteGeneral">Palette used for general ribbon settings.</param> /// <param name="paletteBack">Palette used for background ribbon settings.</param> /// <param name="memento">Cached storage for drawing objects.</param> public override IDisposable DrawRibbonTabContextTitle(PaletteRibbonShape shape, RenderContext context, Rectangle rect, IPaletteRibbonGeneral paletteGeneral, IPaletteRibbonBack paletteBack, IDisposable memento) { return DrawRibbonTabContext(context, rect, paletteGeneral, paletteBack, memento); }
/// <summary> /// Draw the application tab. /// </summary> /// <param name="shape">Ribbon shape.</param> /// <param name="context">Rendering context.</param> /// <param name="rect">Target rectangle.</param> /// <param name="state">State associated with rendering.</param> /// <param name="baseColor1">Base color1 used for drawing the ribbon tab.</param> /// <param name="baseColor2">Base color2 used for drawing the ribbon tab.</param> /// <param name="memento">Cached values to use when drawing.</param> public override IDisposable DrawRibbonApplicationTab(PaletteRibbonShape shape, RenderContext context, Rectangle rect, PaletteState state, Color baseColor1, Color baseColor2, IDisposable memento) { if ((rect.Width > 0) && (rect.Height > 0)) { bool generate = true; MementoRibbonAppTab2013 cache; // Access a cache instance and decide if cache resources need generating if ((memento == null) || !(memento is MementoRibbonAppTab2013)) { if (memento != null) { memento.Dispose(); } cache = new MementoRibbonAppTab2013(rect, baseColor1); memento = cache; } else { cache = (MementoRibbonAppTab2013)memento; generate = !cache.UseCachedValues(rect, baseColor1); } // Do we need to generate the contents of the cache? if (generate) { // Dispose of existing values cache.Dispose(); // Create common paths to all the app tab states cache.GeneratePaths(rect, state); //cache.borderPen = new Pen(baseColor1); // Create state specific colors/brushes/pens switch (state) { case PaletteState.Normal: //cache.borderBrush = new SolidBrush(baseColor1); cache.insideFillBrush = new SolidBrush(baseColor1); //cache.insideFillBrush.SetSigmaBellShape(0.33f); //cache.highlightBrush.CenterColor = Color.FromArgb(64, Color.White); break; case PaletteState.Tracking: cache.insideFillBrush = new SolidBrush(baseColor2); //cache.borderBrush = new SolidBrush(baseColor2); //cache.insideFillBrush = new LinearGradientBrush(new RectangleF(rect.X, rect.Y + 1, rect.Width, rect.Height), // CommonHelper.MergeColors(baseColor1, 0.3f, baseColor2, 0.7f), // CommonHelper.MergeColors(baseColor1, 0.6f, baseColor2, 0.4f), // 90f); //cache.insideFillBrush.SetSigmaBellShape(0.33f); //cache.highlightBrush.CenterColor = Color.FromArgb(100, Color.White); break; case PaletteState.Tracking | PaletteState.FocusOverride: cache.insideFillBrush = new SolidBrush(ControlPaint.LightLight(baseColor2)); //cache.borderBrush = new SolidBrush(ControlPaint.LightLight(baseColor2)); //cache.insideFillBrush = new LinearGradientBrush(new RectangleF(rect.X, rect.Y + 1, rect.Width, rect.Height), // CommonHelper.MergeColors(baseColor1, 0.3f, baseColor2, 0.7f), // CommonHelper.MergeColors(baseColor1, 0.6f, baseColor2, 0.4f), // 90f); //cache.insideFillBrush.SetSigmaBellShape(0.33f); //cache.highlightBrush.CenterColor = ControlPaint.LightLight(baseColor2); break; case PaletteState.Pressed: cache.insideFillBrush = new SolidBrush(baseColor2); //cache.borderBrush = new SolidBrush(CommonHelper.MergeColors(baseColor1, 0.5f, baseColor2, 0.5f)); //cache.insideFillBrush = new LinearGradientBrush(new RectangleF(rect.X, rect.Y + 1, rect.Width, rect.Height), // CommonHelper.MergeColors(baseColor1, 0.3f, baseColor2, 0.7f), // CommonHelper.MergeColors(baseColor1, 0.75f, baseColor2, 0.25f), // 90f); //cache.insideFillBrush.SetSigmaBellShape(0f); //cache.highlightBrush.CenterColor = Color.FromArgb(90, Color.White); break; } } // Fill the entire tab area and then add a border around the edge //context.Graphics.FillPath(cache.borderBrush, cache.borderFillPath); // Draw the outside border //using (AntiAlias aa = new AntiAlias(context.Graphics)) // context.Graphics.DrawPath(cache.borderPen, cache.borderPath); // Fill inside area //context.Graphics.FillPath(cache.insideFillBrush, cache.insideFillPath); context.Graphics.FillRectangle(cache.insideFillBrush, cache.rect); // Draw highlight over bottom half //using (Clipping clip = new Clipping(context.Graphics, cache.insideFillPath)) // context.Graphics.FillPath(cache.highlightBrush, cache.highlightPath); } return(memento); }
private void CreateNormalView() { // Create a layout for the main area _layoutNormalMain = new ViewLayoutRibbonTitle(); if (_ribbon.InDesignMode) { // At design time we need to know when the user right clicks the group ContextClickController controller = new ContextClickController(); controller.ContextClick += new MouseEventHandler(OnContextClick); _layoutNormalMain.MouseController = controller; } // Create layout elements _layoutNormalTitle = new ViewLayoutDocker(); _layoutNormalContent = new ViewLayoutRibbonGroupContent(_ribbon, _ribbonGroup, _needPaint); _layoutNormalSepTop = new ViewLayoutRibbonSeparator(NORMAL_BORDER_TOPLEFT2007, true); _layoutNormalSepLeft = new ViewLayoutRibbonSeparator(NORMAL_BORDER_TOPLEFT2007, true); _layoutNormalSepRight = new ViewLayoutRibbonSeparator(NORMAL_BORDER_RIGHT2007, true); // Add layout elements to correct areas of the normal group _layoutNormalMain.Add(_layoutNormalTitle, ViewDockStyle.Bottom); _layoutNormalMain.Add(_layoutNormalSepTop, ViewDockStyle.Top); _layoutNormalMain.Add(_layoutNormalSepLeft, ViewDockStyle.Left); _layoutNormalMain.Add(_layoutNormalSepRight, ViewDockStyle.Right); _layoutNormalMain.Add(_layoutNormalContent, ViewDockStyle.Fill); // Create and add the title string that fills remainder title area _viewNormalTitle = new ViewDrawRibbonGroupTitle(_ribbon, _ribbonGroup); _layoutNormalTitle.Add(_viewNormalTitle, ViewDockStyle.Fill); // Add the dialog box launcher button to the right side of title area _viewNormalDialog = new ViewLayoutRibbonGroupButton(_ribbon, _ribbonGroup, _needPaint); _layoutNormalContent.DialogView = _viewNormalDialog; _layoutNormalTitle.Add(_viewNormalDialog, ViewDockStyle.Right); // Use this class to return the context color for any null values _paletteContextBack = new PaletteRibbonContextBack(_ribbon); // All values are equal to a default of Office 2007 shape _lastRibbonShape = PaletteRibbonShape.Office2007; _totalBorders = TOTAL_LEFT_RIGHT_BORDERS_2007; }
/// <summary> /// Draw the application button. /// </summary> /// <param name="shape">Ribbon shape.</param> /// <param name="context">Rendering context.</param> /// <param name="rect">Target rectangle.</param> /// <param name="state">State associated with rendering.</param> /// <param name="palette">Palette used for sourcing settings.</param> /// <param name="memento">Cached storage for drawing objects.</param> public abstract IDisposable DrawRibbonApplicationButton(PaletteRibbonShape shape, RenderContext context, Rectangle rect, PaletteState state, IPaletteRibbonBack palette, IDisposable memento);
private void UpdateShapeValues() { if (_ribbon != null) { if (_lastRibbonShape != _ribbon.RibbonShape) { switch (_ribbon.RibbonShape) { default: case PaletteRibbonShape.Office2007: _totalBorders = TOTAL_LEFT_RIGHT_BORDERS_2007; _layoutNormalMain.VertOffset = VERT_OFFSET_2007; _layoutNormalSepTop.SeparatorSize = new Size(NORMAL_BORDER_TOPLEFT2007, NORMAL_BORDER_TOPLEFT2007); _layoutNormalSepLeft.SeparatorSize = new Size(NORMAL_BORDER_TOPLEFT2007, NORMAL_BORDER_TOPLEFT2007); _layoutNormalSepRight.SeparatorSize = new Size(NORMAL_BORDER_RIGHT2007, NORMAL_BORDER_RIGHT2007); _layoutCollapsedImagePadding.PreferredPadding = COLLAPSED_IMAGE_PADDING_2007; _lastRibbonShape = PaletteRibbonShape.Office2007; break; case PaletteRibbonShape.Office2010: _totalBorders = TOTAL_LEFT_RIGHT_BORDERS_2010; _layoutNormalMain.VertOffset = VERT_OFFSET_2010; _layoutNormalSepTop.SeparatorSize = new Size(NORMAL_BORDER_TOP2010, NORMAL_BORDER_TOP2010); _layoutNormalSepLeft.SeparatorSize = new Size(NORMAL_BORDER_LEFT2010, NORMAL_BORDER_LEFT2010); _layoutNormalSepRight.SeparatorSize = new Size(NORMAL_BORDER_RIGHT2010, NORMAL_BORDER_RIGHT2010); _layoutCollapsedImagePadding.PreferredPadding = COLLAPSED_IMAGE_PADDING_2010; _lastRibbonShape = PaletteRibbonShape.Office2010; break; } } } }
/// <summary> /// Draw the background of a ribbon element. /// </summary> /// <param name="shape">Ribbon shape.</param> /// <param name="context">Rendering context.</param> /// <param name="rect">Target rectangle.</param> /// <param name="state">State associated with rendering.</param> /// <param name="palette">Palette used for sourcing settings.</param> /// <param name="orientation">Orientation for drawing.</param> /// <param name="composition">Drawing onto a composition element.</param> /// <param name="memento">Cached values to use when drawing.</param> public abstract IDisposable DrawRibbonBack(PaletteRibbonShape shape, RenderContext context, Rectangle rect, PaletteState state, IPaletteRibbonBack palette, VisualOrientation orientation, bool composition, IDisposable memento);
/// <summary> /// Perform drawing of a ribbon cluster edge. /// </summary> /// <param name="shape">Ribbon shape.</param> /// <param name="context">Render context.</param> /// <param name="displayRect">Display area available for drawing.</param> /// <param name="paletteBack">Palette used for recovering drawing details.</param> /// <param name="state">State associated with rendering.</param> public override void DrawRibbonClusterEdge(PaletteRibbonShape shape, RenderContext context, Rectangle displayRect, IPaletteBack paletteBack, PaletteState state) { Debug.Assert(context != null); Debug.Assert(paletteBack != null); // Draw inside of the border edge in a lighter version of the border using (SolidBrush drawBrush = new SolidBrush(paletteBack.GetBackColor1(state))) context.Graphics.FillRectangle(drawBrush, displayRect); }
/// <summary> /// Perform drawing of a ribbon dialog box launcher glyph. /// </summary> /// <param name="shape">Ribbon shape.</param> /// <param name="context">Render context.</param> /// <param name="displayRect">Display area available for drawing.</param> /// <param name="paletteGeneral">General ribbon palette details.</param> /// <param name="state">State associated with rendering.</param> public abstract void DrawRibbonDialogBoxLauncher(PaletteRibbonShape shape, RenderContext context, Rectangle displayRect, IPaletteRibbonGeneral paletteGeneral, PaletteState state);
/// <summary> /// Perform drawing of a ribbon drop arrow glyph. /// </summary> /// <param name="shape">Ribbon shape.</param> /// <param name="context">Render context.</param> /// <param name="displayRect">Display area available for drawing.</param> /// <param name="paletteGeneral">General ribbon palette details.</param> /// <param name="state">State associated with rendering.</param> public override void DrawRibbonDropArrow(PaletteRibbonShape shape, RenderContext context, Rectangle displayRect, IPaletteRibbonGeneral paletteGeneral, PaletteState state) { Debug.Assert(context != null); Debug.Assert(paletteGeneral != null); // Validate parameter references if (context == null) throw new ArgumentNullException("context"); if (paletteGeneral == null) throw new ArgumentNullException("paletteGeneral"); Color darkColor = (state == PaletteState.Disabled ? paletteGeneral.GetRibbonDisabledDark(state) : paletteGeneral.GetRibbonDropArrowDark(state)); Color lightColor = (state == PaletteState.Disabled ? paletteGeneral.GetRibbonDisabledLight(state) : paletteGeneral.GetRibbonDropArrowLight(state)); switch (shape) { default: case PaletteRibbonShape.Office2007: using (Pen darkPen = new Pen(darkColor), lightPen = new Pen(lightColor)) { context.Graphics.DrawLine(darkPen, displayRect.Left, displayRect.Top, displayRect.Left + 4, displayRect.Top); context.Graphics.DrawLine(darkPen, displayRect.Left + 1, displayRect.Top + 1, displayRect.Left + 3, displayRect.Top + 1); context.Graphics.DrawLine(darkPen, displayRect.Left + 2, displayRect.Top + 1, displayRect.Left + 2, displayRect.Top + 2); context.Graphics.DrawLine(lightPen, displayRect.Left, displayRect.Top + 1, displayRect.Left + 2, displayRect.Top + 3); context.Graphics.DrawLine(lightPen, displayRect.Left + 2, displayRect.Top + 3, displayRect.Left + 4, displayRect.Top + 1); } break; case PaletteRibbonShape.Office2010: using (LinearGradientBrush fillBrush = new LinearGradientBrush(new RectangleF(displayRect.X - 1, displayRect.Y - 1, displayRect.Width + 2, displayRect.Height + 2), lightColor, darkColor, 45f)) { context.Graphics.FillPolygon(fillBrush, new Point[]{ new Point(displayRect.Left - 1, displayRect.Top - 1), new Point(displayRect.Left + 2, displayRect.Top + 3), new Point(displayRect.Left + 5, displayRect.Top) }); } break; } }
/// <summary> /// Draw a context ribbon tab title. /// </summary> /// <param name="shape">Ribbon shape.</param> /// <param name="context">Rendering context.</param> /// <param name="rect">Target rectangle.</param> /// <param name="paletteGeneral">Palette used for general ribbon settings.</param> /// <param name="paletteBack">Palette used for background ribbon settings.</param> /// <param name="memento">Cached values to use when drawing.</param> public abstract IDisposable DrawRibbonTabContextTitle(PaletteRibbonShape shape, RenderContext context, Rectangle rect, IPaletteRibbonGeneral paletteGeneral, IPaletteRibbonBack paletteBack, IDisposable memento);
/// <summary> /// Resets the RibbonShape property to its default value. /// </summary> public void ResetRibbonShape() { RibbonShape = PaletteRibbonShape.Inherit; }