Category: SDF 2.0

The OpenNETCF Smart Device Framework 2.0 is currently in Beta1 and is currently released in binary form only during the beta cycle.  Even though it’s currently available only in compiled mode you can still extend the functionality of controls.  For example, I’m working on a project where I’m using the OpenNETCF.Windows.Forms.Button2 and the Image property for the button.  There are a bunch of buttons that get enabled/disbled but unfortunately when the button is disabled it still looks disabled because of the image.

To resolve the problem we can inherit from the Button2 class.  We can create a class ExtendedButton (not the name I used in the project but used it for explanation purposes).  Here is the class implementation: 

/// <summary>
/// Provides the ability for enabled and disabled images
/// </summary>
public partial class ExtendedButton : Button2
{
   private Image disabledImage = null;
   private Image enabledImage = null;

   public ExtendedButton()
   {
      InitializeComponent();
   }

   /// <summary>
   /// Gets or sets the disabled Image
   /// </summary>
   public Image DisabledImage
   {
      get
      {
         return this.disabledImage;
      }
      set
      {
         this.disabledImage = value;
      }
   }

   /// <summary>
   /// Gets or sets the image. Hides the base class implementation but 
   /// internally still calls the base implementation
   /// </summary>
   public new Image Image
   {
      get
      {
         return base.Image;
      }
      set
      {
         this.enabledImage = value;
         base.Image = this.enabledImage;
      }
   }

   /// <summary>
   /// Hides the System.Windows.Forms.Control.Enabled property. This is
   /// where we set the Button2.Image property depending on the enabled
   /// status.
   /// </summary>
   public new bool Enabled
   {
      get
      {
         return base.Enabled;
      }
      set   
      {
         base.Enabled = value;
         if (base.Enabled)
            base.Image = this.enabledImage;
         else
         {
            if(this.disabledImage!=null)
            base.Image = this.disabledImage;
         }
         this.Invalidate();
      }
   }

Here is a screen shot of the sample application:

Sample application is also attached. 

Purpose of doing this is to show that you can extend controls without having the source available to you. This functionality wasn’t added to the SDF class because we are in somewhat of a code freeze for new features, but if there are enough request we can added it after the SDF2.0 release.

Back in February of last year I posted a sample on drawing rotated text using .NET Compact Framework 1.0 and OpenNETCF Smart Device Framework 1.4.  Since then, Compact Framework 2.0 has been released and Smart Device Framework 2.0 Beta1 has also been released.  Changes in the OpenNETCF.Drawing namespace caused the existing sample to not work anymore simply because the functionality in the SDF2.0 was removed.  Why was it it removed?  With CF2.0 there is a new class within the Microsoft.WindowsCE.Forms namespace called LogFont which replaces the SDF1.4 OpenNETCF.Drawing.FontEx class. 

Some of the more trickier parts of the code are setting the proper angle.  With the OpenNETCF.Drawing.FontEx class setting the font angle was as easy as setting the Angle property.  With the LogFont class, there was no Angle property, but from reading the MSDN documentation on the class points us to the Escapement property.  To set the font at an angle of 90 degrees, you will have to set the Escapement property to 900 or (90 * 10).  The other thing to note is the FaceName property has to be a null terminated string so you have to end it withe a ‘/0’.  Below are some other properties to add more functionality to the  LogFont:

• Weight – Sets the weight of the font from 0 – 1000.  You can use the LogFontWeight which defines some of the standard wieghts
  
• Quality  – sets the quality of the font when rendering.  For example you can set it to ClearType
  
• StrikeOut – same as setting the Font.Style to FontStyle.Strikeout
  
• Underline – same as setting the Font.Style to FontStyle.Strikeout

Here is an implementation of drawing rotated/angled text using the above information.  For a complete sample see the sample application. 

private void DrawTextSample()
{
   //For VGA support get the scale to adjust dynamically
   int scale = (int)this.Scale(this.offGfx);

   //Get the size of the current font
   SizeF size = this.offGfx.MeasureString(this.txtDraw.Text, this.Font);

   //Create a new logfont class
   Microsoft.WindowsCE.Forms.LogFont lf = new Microsoft.WindowsCE.Forms.LogFont();

   //Escapement defines the angle at which you want the text to draw
   lf.Escapement = Convert.ToInt32(this.numericUpDown1.Value)*10;
   
   //Set the wieght of the font
   lf.Weight = this.Weight;
   
   //Set the quality to draw the font
   lf.Quality = this.Quality;
   
   //Set the name of the font. Note the null termintion char
   lf.FaceName = this.Font.Name + “/0”;
   
   //Set the font height. Note that we mulitply by scale to adjust for VGA devices
   lf.Height = (int)size.Height * scale;
   
   //Specifies the font family
   lf.PitchAndFamily = Microsoft.WindowsCE.Forms.LogFontPitchAndFamily.Default;
   
   //Specify if it is strikeout
   lf.StrikeOut = Convert.ToByte(this.chkStrikeout.Checked);
   
   //Specify if underlined
   lf.Underline = Convert.ToByte(this.chkUnderline.Checked);
   
   //Create a font that is compatible with the graphics object
   Font font = Font.FromLogFont(lf);
   
   //Fill the background
   using(SolidBrush b = new SolidBrush(this.BackColor))
      this.offGfx.FillRectangle(b, new Rectangle(0,0,this.Width,this.Height));
   
   //Get the middle of the screen
   Point point = new Point(Screen.PrimaryScreen.WorkingArea.Width / 2,
                           this.chkStrikeout.Top / 2 );
   
   //String format is a new class for CF2.0. Here we need to specify to not wrap the text
   //and to not clip the text if it is outside the bounds
   StringFormat sf = new StringFormat(StringFormatFlags.NoWrap | StringFormatFlags.NoClip);
   
   //Draw the text
   using (SolidBrush brush = new SolidBrush(Color.Red))
      this.offGfx.DrawString(this.txtDraw.Text, font, brush, point.X, point.Y, sf);
   
   //Force the screen to repaint
   this.Invalidate();
}

It’s a little more work drawing rotated/angled text using CF2.0 but the end result is the same as previous.