- Fix rendering so that OLVColumn.WordWrap works when using customised Renderers and when using the ListViewPrinter

git-svn-id: https://svn.code.sf.net/p/objectlistview/code/cs/trunk@836 0bec5ed8-b53f-49e6-9885-ce7bc93af311

Author: grammarian

Demo/TabComplexExample.cs

@@ -296,6 +296,7 @@ private void SetupDarkerStyle() {
             this.olvComplex.BackColor = Color.FromArgb(30, 30, 40);
             this.olvComplex.AlternateRowBackColor = Color.FromArgb(35, 35, 42);
             this.olvComplex.ForeColor = Color.WhiteSmoke;
+            this.olvComplex.DefaultRenderer = new HighlightTextRenderer {FillBrush = Brushes.Transparent, FramePen = new Pen(Color.PaleGreen, 3)};
 
             HyperlinkStyle hls = new HyperlinkStyle();
             hls.Normal = new CellStyle();

ListViewPrinter/ListViewPrinter.cs

@@ -5,6 +5,7 @@
  * Date: 2007-11-01 11:15 AM
  *
  * Change log:
+ * 2018-10-06  JPP  - Fix rendering so that OLVColumn.WordWrap works when using the ListViewPrinter
  * 2009-02-24  JPP  - Correctly use new renderer scheme :)
  * 2009-01-26  JPP  - Use new renderer scheme
  *                  - Removed ugly hack about BarRenderer when printing.
@@ -41,7 +42,7 @@
  * 
  * To Do:
  * 
- * Copyright (C) 2006-2008 Phillip Piper
+ * Copyright (C) 2006-2018 Phillip Piper
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -1248,32 +1249,42 @@ protected override void PrintCell(Graphics g, ListView lv, ListViewItem lvi, int
                 return;
             }
 
-            // Configure the renderer
-            renderer.IsPrinting = true;
-            renderer.Aspect = null;
-            renderer.Column = olvc;
-            renderer.IsItemSelected = false;
-            renderer.Font = this.CellFormat.Font;
-            renderer.TextBrush = this.CellFormat.TextBrush;
-            renderer.ListItem = olvItem;
-            renderer.ListView = listView;
-            renderer.RowObject = olvItem.RowObject;
-            renderer.SubItem = (OLVListSubItem)this.GetSubItem(lvi, column);
-            renderer.CanWrap = this.CellFormat.CanWrap;
-
-            // Use the cell block format to draw the background and border of the cell
-            bool bkChanged = this.ApplyCellSpecificBackground(this.CellFormat, renderer.ListItem, renderer.SubItem);
-            this.CellFormat.Draw(g, cell, "", "", "");
-            if (bkChanged)
-                this.CellFormat.BackgroundBrush = null;
-
-            // The renderer draws into the text area of the block. Unfortunately, the renderer uses Rectangle's 
-            // rather than RectangleF's, so we have to convert, trying to prevent rounding errors
-            RectangleF r = this.CellFormat.CalculatePaddedTextBox(cell);
-            Rectangle r2 = new Rectangle((int)r.X + 1, (int)r.Y + 1, (int)r.Width - 1, (int)r.Height - 1);
-            renderer.Render(g, r2);
-
-            renderer.IsPrinting = false;
+            // Store renderer state
+            Font originalFont = renderer.Font;
+            bool? originalCanWrap = renderer.CanWrap;
+
+            try {
+                // Configure the renderer
+                renderer.IsPrinting = true;
+                renderer.Font = this.CellFormat.Font;
+                renderer.TextBrush = this.CellFormat.TextBrush;
+                renderer.CanWrap = this.CellFormat.CanWrap;
+                renderer.Aspect = null;
+                renderer.Column = olvc;
+                renderer.IsItemSelected = false;
+                renderer.ListItem = olvItem;
+                renderer.ListView = listView;
+                renderer.RowObject = olvItem.RowObject;
+                renderer.SubItem = (OLVListSubItem)this.GetSubItem(lvi, column);
+
+                // Use the cell block format to draw the background and border of the cell
+                bool bkChanged = this.ApplyCellSpecificBackground(this.CellFormat, renderer.ListItem, renderer.SubItem);
+                this.CellFormat.Draw(g, cell, "", "", "");
+                if (bkChanged)
+                    this.CellFormat.BackgroundBrush = null;
+
+                // The renderer draws into the text area of the block. Unfortunately, the renderer uses Rectangle's 
+                // rather than RectangleF's, so we have to convert, trying to prevent rounding errors
+                RectangleF r = this.CellFormat.CalculatePaddedTextBox(cell);
+                Rectangle r2 = new Rectangle((int)r.X + 1, (int)r.Y + 1, (int)r.Width - 1, (int)r.Height - 1);
+                renderer.Render(g, r2);
+            }
+            finally {
+                // Restore the original state
+                renderer.IsPrinting = false;
+                renderer.Font = originalFont;
+                renderer.CanWrap = originalCanWrap;
+            }
         }
     }
 

ObjectListView/OLVColumn.cs

@@ -1416,7 +1416,7 @@ public IList ValuesChosenForFiltering {
         [Category("ObjectListView"),
         Description("The width in pixels of this column"),
         DefaultValue(60)]
-        new public int Width {
+        public new int Width {
             get { return base.Width; }
             set {
                 if (this.MaximumWidth != -1 && value > this.MaximumWidth)
@@ -1436,27 +1436,9 @@ public IList ValuesChosenForFiltering {
          DefaultValue(false)]
         public bool WordWrap {
             get { return wordWrap; }
-            set {
-                wordWrap = value;
-
-                // If there isn't a renderer and they are turning word wrap off, we don't need to do anything
-                if (this.Renderer == null && !wordWrap)
-                    return;
-
-                // All other cases require a renderer of some sort
-                if (this.Renderer == null)
-                    this.Renderer = new HighlightTextRenderer();
-
-                BaseRenderer baseRenderer = this.Renderer as BaseRenderer;
-
-                // If there is a custom renderer (not descended from BaseRenderer), 
-                // we leave it up to them to implement wrapping
-                if (baseRenderer == null)
-                    return;
-
-                baseRenderer.CanWrap = wordWrap;
-            }
+            set { wordWrap = value; }
         }
+
         private bool wordWrap;
 
         #endregion

ObjectListView/Rendering/Renderers.cs

@@ -5,6 +5,7 @@
  * Date: 27/09/2008 9:15 AM
  *
  * Change log:
+ * 2018-10-06   JPP  - Fix rendering so that OLVColumn.WordWrap works when using customised Renderers 
  * 2018-05-01   JPP  - Use ITextMatchFilter interface rather than TextMatchFilter concrete class.
  * v2.9.2
  * 2016-06-02   JPP  - CalculateImageWidth() no longer adds 2 to the image width
@@ -279,20 +280,32 @@ public class BaseRenderer : AbstractRenderer {
         /// <summary>
         /// Can the renderer wrap lines that do not fit completely within the cell?
         /// </summary>
-        /// <remarks>Wrapping text doesn't work with the GDI renderer.</remarks>
+        /// <remarks>
+        /// <para>If this is not set specifically, the value will be taken from Column.WordWrap</para>
+        /// <para>
+        /// Wrapping text doesn't work with the GDI renderer, so if this set to true, GDI+ rendering will used.
+        /// The difference between GDI and GDI+ rendering can give word wrapped columns a slight different appearance.
+        /// </para>
+        /// </remarks>
         [Category("Appearance"),
          Description("Can the renderer wrap text that does not fit completely within the cell"),
-         DefaultValue(false)]
-        public bool CanWrap {
+         DefaultValue(null)]
+        public bool? CanWrap {
             get { return canWrap; }
-            set {
-                canWrap = value;
-                if (canWrap)
-                    this.UseGdiTextRendering = false;
-            }
+            set { canWrap = value; }
         }
-        private bool canWrap;
 
+        private bool? canWrap;
+
+        /// <summary>
+        /// Get the actual value that should be used right now for CanWrap
+        /// </summary>
+        [Browsable(false)]
+        protected bool CanWrapOrDefault {
+            get {
+                return this.CanWrap ?? this.Column != null && this.Column.WordWrap;
+            }
+        }
         /// <summary>
         /// Gets or sets how many pixels will be left blank around this cell
         /// </summary>
@@ -419,13 +432,15 @@ public int Spacing {
         /// Should text be rendered using GDI routines? This makes the text look more
         /// like a native List view control.
         /// </summary>
+        /// <remarks>Even if this is set to true, it will return false if the renderer
+        /// is set to word wrap, since GDI doesn't handle wrapping.</remarks>
         [Category("Appearance"),
          Description("Should text be rendered using GDI routines?"),
          DefaultValue(true)]
         public virtual bool UseGdiTextRendering {
             get {
-                // Can't use GDI routines on a GDI+ printer context
-                return !this.IsPrinting && useGdiTextRendering;
+                // Can't use GDI routines on a GDI+ printer context or when word wrapping is required
+                return !this.IsPrinting && !this.CanWrapOrDefault && useGdiTextRendering;
             }
             set { useGdiTextRendering = value; }
         }
@@ -502,6 +517,16 @@ public DrawListViewSubItemEventArgs Event {
         /// <summary>
         /// Gets or  sets the font to be used for text in this cell
         /// </summary>
+        /// <remarks>
+        /// <para>
+        /// In general, this property should be treated as internal.
+        /// If you do set this, the given font will be used without any other consideration.
+        /// All other factors -- selection state, hot item, hyperlinks -- will be ignored.
+        /// </para>
+        /// <para>
+        /// A better way to set the font is to change either ListItem.Font or SubItem.Font
+        /// </para>
+        /// </remarks>
         [Browsable(false),
          DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
         public Font Font {
@@ -622,6 +647,14 @@ public OLVListSubItem SubItem {
         /// <summary>
         /// The brush that will be used to paint the text
         /// </summary>
+        /// <remarks>
+        /// <para>
+        /// In general, this property should be treated as internal. It will be reset after each render.
+        /// </para>
+        /// <para>
+        /// </para>
+        /// In particular, don't set it to configure the color of the text on the control. That should be done via SubItem.ForeColor
+        /// </remarks>
         [Browsable(false),
          DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
         public Brush TextBrush {
@@ -661,7 +694,6 @@ private void ClearState() {
             this.Event = null;
             this.DrawItemEvent = null;
             this.Aspect = null;
-            this.Font = null;
             this.TextBrush = null;
         }
 
@@ -1733,7 +1765,7 @@ protected virtual void DrawTextGdi(Graphics g, Rectangle r, String txt) {
 
             // I think there is a bug in the TextRenderer. Setting or not setting SingleLine doesn't make 
             // any difference -- it is always single line.
-            if (!this.CanWrap)
+            if (!this.CanWrapOrDefault)
                 flags |= TextFormatFlags.SingleLine;
             TextRenderer.DrawText(g, txt, this.Font, r, this.GetForegroundColor(), backColor, flags);
         }
@@ -1770,7 +1802,7 @@ protected virtual StringFormat StringFormatForGdiPlus {
                 fmt.LineAlignment = this.EffectiveCellVerticalAlignment;
                 fmt.Trimming = StringTrimming.EllipsisCharacter;
                 fmt.Alignment = this.Column == null ? StringAlignment.Near : this.Column.TextStringAlign;
-                if (!this.CanWrap)
+                if (!this.CanWrapOrDefault)
                     fmt.FormatFlags = StringFormatFlags.NoWrap;
                 return fmt;
             }
@@ -1816,6 +1848,13 @@ protected virtual void DrawTextGdiPlus(Graphics g, Rectangle r, String txt) {
     /// <summary>
     /// This renderer highlights substrings that match a given text filter. 
     /// </summary>
+    /// <remarks>
+    /// Implementation note:
+    /// This renderer uses the functionality of BaseRenderer to draw the text, and
+    /// then draws a translucent frame over the top of the already rendered text glyphs.
+    /// There's no way to draw the matching text in a different font or color in this
+    /// implementation.
+    /// </remarks>
     public class HighlightTextRenderer : BaseRenderer, IFilterAwareRenderer {
         #region Life and death