ContentPresenter in a ControlTemplate

This will control the location of the display of all elements on your form. Note that it will even 'offset' the elements inside a StackPanel (perhaps causing them to be cut off). Just a hint for those experiencing the strange effect of having elements appear in strange locations relative to your panel or Grid or whatever container you have of your stack panel.

I... I... I think I may be in love with Observable Collections

     Oh Observable Collection

     You satisfy my selection

     Like a lonely flower, a desert rose

     When there is a new one, everyone knows

     If only we could use properties accessed internal
     Using properties accessed public may lead to an inferno

     Oh Observable Collection, I can't stay mad at you.

     Throughout my meandering code, your notifications are pure and true.

Observable collections are a handy way to get data transferred across multiple windows and XAML documents. I have found them versatile and useful:

XAML Code:

.
.
.
<TextBlock Height="36" Margin="0,6,56,0" Name="textTimeBlock" Width="200" Text="{Binding Path=TimeCollection[0],
                    RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}}"
                    FontSize="24" TextAlignment="Center" />
.
.
.

Corresponding C#.

Code:

.
.
.
        private readonly ObservableCollection<string> timeCollection;
.
.
.

        /// <summary>
        /// Gets the updating time
        /// </summary>
        public ObservableCollection<string> TimeCollection
        {
            get { return this.timeCollection; }
        }

Just set up a simple DispatcherTimer tick to update the collection every second...

Code:

this.dispatcherTimer.Tick += new EventHandler(delegate(object s, EventArgs a)
            {
                if (this.timeCollection.Count == 1)
                {
                    this.timeCollection.RemoveAt(0);
                }

                this.timeCollection.Add(DateTime.Now.ToLongTimeString());
            });

... and away you go.

Now you may have noticed a slight peculiarity, that the private field 'timeCollection' is readonly. This is necessary because I don't want anybody who comes along and grabs the exe to be able to just assign their own collection over my collection(!). Since the property must be public for the notifications to make it to the XAML code, this is the only way. You still expose, but atleast no one can overwrite. Hopefully in some future version of .NET, Microsoft will allow this notifications process to work with internal accessed properties as well. I can't see any obvious reason why they shouldn't.

Note that despite the fact that your collection is readonly, you will still have access to all of the methods of that collection and, perhaps counter intuitively, the ability to modify the collection outside of the constructor or initialization. The are two ways around this:

1. Use a ReadOnlyObservableCollection, though this does have the issue of a protected CollectionChanged event. I had several issues trying to get this to work with Xaml code. Most notoriously "A TwoWay or OneWayToSource binding cannot work on the read-only property." I tried everything I could find in the top 30 or 40 Google results. No love.

2. Extend the ObservableCollection class and hide all of the methods that can actually modify the collection. Since you can't make methods of the base class less accessible, what I did was just have the public methods perform no operation, and put in the comments that the collection is readonly. I then created equivalent internal methods with a different signature, which then called the respective base methods. This way, nobody can overwrite the collection or overwrite the actual values of the collection. The class itself is marked public.

C++, Delphi, Enumerations, Enum, switch, case,

In Borland Delphi, the way to check if a parameter of an enum type has a particular value is:

Code:

enum TGridDrawState {Grids_3, gdFocused, gdFixed};
 . 
 .
 . 
 procedure SomeProcedure(Value: Int;ARect: TRect; AState: TGridDrawState);
   .
   .
   .
   if (gdFixed in AState) then
    .
    .
    .

etc...
    

The C++ equivalent is:

Code:

void __fastcall SomeMethod(int Value, TRect Rect, TGridDrawState AState) 
{ 
  . 
  . 
  . 
  if (AState.Contains(gdFixed)) 
  { 
    . 
    . 
    . 
  } 
  . 
  . 
  . 
etc....

Took me far too much time searching through the code and the internet to dig this up.

WPF DataGrid Binding to internal properties.

It seems that you can't bind to internal properties. They *must* be public. Otherwise you receive no notifications.

How to build a Borland equivalent Smooth progress bar

Embarcadero C++ Builder. How to build a Borland equivalent Smooth progress bar. This code is basically the translation of the description given for a SmoothProgress Bar at the Microsoft Support site http://support.microsoft.com/kb/816195.
The SmoothProgressBar replaces the standard windows default progress indicator for custom GUI's and answers several drawbacks to not only the default progressbar, but many other Windows-default components such as lack of customization, even in development environments such as Microsoft's own Visual Studio.

I will only post the the key methods Set_Value and OnPaint as they are the critical sections anyway and provide all the examples needed to code the other simpler sections described in the Microsoft article above. I should note this code, though it will be compilable working C++, will nonetheless still be a bit pseudo codish. This is because I had to do some tweaks and fudges here and there to get some more finesse behavior. Part of this is due to the fact that I derived this progress bar directly from TProgressBar. I had to 'hide' some of its base properties and replace them with my own equivalent. I also had to play around a bit with the drawing of some boundary lines to get this to fit into the default TProgressBar border properly. You could most certainly do this deriving directly from the more generic TComponent as well (similar to the article above).

Set_Value(...):

Code:

 /// <summary>
 /// Set_Value
 /// </summary>
 /// <param name="NewValue">The new value of the progressbar.</param>
 void __fastcall SmoothProgressBar::Set_Value(int NewValue)
 {
  int oldValue = value;

  // Make sure that the value does not stray outside the valid range.
  if (NewValue < minimum)
  {
   value = minimum;
  }
  else if (NewValue > maximum - 1)
  {
   value = maximum - 1;
   shrinkVertical = 3;
   lastLineFlag = true;
  }
  else
  {
   value = NewValue;
  }

  // Invalidate only the changed area.
  float percent;

  TRect newValueRect(this->ClientRect);
  TRect oldValueRect(this->ClientRect);

  newValueRect.Left = newValueRect.Left;
  // Use a new value to calculate the rectangle for progress.
  percent = (float)(value - minimum) / (float)(maximum - minimum);
  newValueRect.Right = newValueRect.Left + (int)((float)newValueRect.Width()
    * percent);
  newValueRect.Top = newValueRect.Top + shrinkVertical;
  newValueRect.Bottom = newValueRect.Bottom - shrinkVertical;

  oldValueRect.Left = oldValueRect.Left;
  // Use an old value to calculate the rectangle for progress.
  percent = (float)(oldValue - minimum) / (float)(maximum - minimum);
  oldValueRect.Right = oldValueRect.Left + 2 + (int)((float)oldValueRect.Width()
    * percent);
  oldValueRect.Top = oldValueRect.Top + shrinkVertical;
  oldValueRect.Bottom = oldValueRect.Bottom - shrinkVertical;

  TRect updateRect;

  // Find only the part of the screen that must be updated.
  if (newValueRect.Width() > oldValueRect.Width())
  {
   updateRect.Left = oldValueRect.Width();
   updateRect.IntersectRect(newValueRect, oldValueRect);
  }
  else
  {
   updateRect.Left = newValueRect.Width();
   updateRect.IntersectRect(oldValueRect, newValueRect);
  }

  InvalidateRect(this->Handle, &updateRect, 1);
  SmoothProgressBar::OnPaint(this);
 }

This, on the face of things, looks like (and pretty much is) a line for line translation. Borland clearly has some of its own little ways of doing things, but the equivalents are obvious (though not so easy to find! Hence my post here for others that may be looking). One thing that may jump out is the explicit call to OnPaint. TProgressBar does not seem to inherit this handler from its parent. I probably could have created a custom event without much additional complexity, but this was already simple, so I figured a direct call wouldn't hurt.

OnPaint(...):

Code:

 /// <summary>
 /// On Paint
 /// </summary>
 /// <param name="Sender">The sender of this event</param>
 void __fastcall SmoothProgressBar::OnPaint(TObject *Sender)
 {
  HDC dc;

  HPEN dcPen;
  dc = GetDC(this->Handle);
  this->Brush->Color = this->progressBar_Color;
  float percent = (float)(value - minimum) / (float)(maximum - minimum);
  TRect clientRect(this->ClientRect);
  FillRect(dc, &clientRect, this->Brush->Handle);
  dcPen = CreatePen(PS_SOLID, 1, this->progressBar_Color);
  SelectObject(dc, dcPen);
  SetBkColor(dc, this->progressBar_Color);

  if (lastLineFlag == true) // Global flag
  {
   MoveToEx(dc, clientRect.Right - 1, clientRect.Top + 1, NULL);
   LineTo(dc, clientRect.Right - 1, clientRect.Bottom - 1);
   MoveToEx(dc, clientRect.Right, clientRect.Top + 1, NULL);
   LineTo(dc, clientRect.Right, clientRect.Bottom - 1);
  }

  lastLineFlag = false;
 }

Embarcadero clearly relies heavily on the Windows API here for basic graphical functions. What stands out that is different from the Microsoft example is that I don't draw a border. Since I inherited directly from TProgressBar, I got that border for free. However, I did have to do some fudging to get my colored rectangles to fit (not shown) and in particular to not overwrite the base class progress bar boundary at the end (the line logic in the code above).

I hope this saves somebody some time in trudging through Google search results, questionably useful help files, and quite a bit of raw source code looking for similar examples to what I was trying to accomplish.

Just one more little blip. Since I derived this from TProgressBar (which is really just a shell around the Windows Progress bar), I did have to hide and lock-in the defaults of some of the base properties. I will give an example of hiding the Position property:

Code:

public:
 __property int Position = {read = position, default = 0}; // Hide the base

This is pretty straightforward... and the only direct example you will find on the net. Notice that to override the property, you must override it in the equivalent access section (public or published). Also, I left out the 'write' section, rendering the property read-only.