The WPF developer dude

My iPhone development career has kicked off

2010-10-02T01:22:00.000-07:00

And with a great start.

As mentioned in my previous post, I attended the iPhoneDevCon in San Diego. I was really surprised when I found out that it was the very first iPhone / iPad exclusive one. I felt special.

Anyway, the conference was great, important people were there, really important people. To name some:

- Aaron Hillegass - Founder of Big Nerd Ranch and really important modern internet / macintosh pioneer. Also, author of several iPhone development books. He said that if you want to learn iPhone development, this book is the definitive first step. Then he added "please buy it". I will definitely check it out.

His conference was basically about how we are in the golden age of mobile development, and how we should exploit it and prepare for whatever is next.

- Lee Barney - Writer of many books such as iPhone, AJAX, PHP.

One of his conference (the one I attended) was about a new approach to programming to minimize code, bugs and complexity. Really, really interesting approach.

This conference really got heated up at some point. The info he presented was really, really interesting, but is sounded too good to be true. At least I had my doubts, so I started asking him about the details and cons of this approach. A lot of really interesting questions arose from this, and at some point it turned into a debate of how good or bad the approach was.

Basically, this approach is using a "funnel" in which all you code will get in, be validated, if validation passes, the funnel will spit out a result, if not it will return 'nil' (that's objective-C 'null'), so you can send a failure notification. But I will go into more detail on this once I try it.

- Jonathan Saggau (blog) - An excellent programmer. I was surprised by how young he looks, really encourages me to keep plowing through my career.

One of his conferences was about third party controls that mimic iPhone controls that apple does not provide through the iPhone SDK, such as the calendar view and the album cover view. You can find these in these websites: three20, KAL Calendar and OpenFlow CoverFlow.

-

Most importantly (to me), I got really, really used to XCode and objective-C, which is no walk in the park. They are really different from what I've been learning right now (Visual Studio and C# respectively). Like a co-worker said: "It's like moving from Spanish to German, the structure of the sentences is completely different". And yes, it is. I won't go into detail here, but I will do a post to compare C# and objective-C really soon.

Anyway, I know this post was really brief; but it would take a week to talk about everything I learned in the conferences. I pinpointed the most important conferences I attended, and really important / good programmers, so if you want to improve your career as an iPhone developer, you should definitely check out these persons I mentioned and their work.

Next post will have code, I promise!

Thanks for reading, and happy coding!

Haven't blogged in a while

2010-09-21T12:34:00.000-07:00

Well, lately I've been broadening my work fields, I'm really excited about it. Been working with WCF (as I have stated before), Silverlight, iPhone (learning only, not professionally yet) and soon iPad (oh! and some StarCraft II =P). But the real reason I haven't blogged is because I haven't found any really interesting problems / solutions to blog about, but with these new fields I'm working on I bet I'll find some really soon.

This Monday through Wednesday (Sep 27 - 29, 2010) I'll be attending the iPhone DevCon in San Diego, which will kick-off my professional iPhone development. I'm THRILLED about it, perhaps that will be my next post.

Anyway, I guess I'd better think of a new name for my blog, because "WPF dude" doesn't quite describe what I work on and blog about anymore.

Thanks to everyone who reads me, and I hope you have found my blog at least a bit useful.

Thanks for reading and happy coding!

Get WPF control from HWND handle

2010-08-03T15:28:00.000-07:00

Just a quick post. I can't believe this is so easy and I spent hours trying to find something like this...

Anyway, I asked in StackOverflow, and turns out this is how you do it:

var rootVisual = HwndSource.FromHwnd(hWnd).RootVisual;

Yup, that easy.

Thanks to quartermeister for a great answer. It deserves your upvote.

The GifImage (Animated GIFs for WPF)

2010-07-28T22:40:00.000-07:00

So... Steve Ballmer... no GIF support in WPF? Ended up too tired after a conference or something?

Anyway, I found some code in codeplex (I can't find the link, I'll put a reference as soon as I find it), but I modified it a bit to fit our needs.

The code I found started the gif right away or something. I don't remember right, so I created a few methods to show / hide (you probably won't need those) and to start / stop the animation (start / stop will be useful for you). As well as an AutoStart property, so you don't have to call the Start() method manually.

So since you love downloading WPF projects, here you go:

And here's the code. It's small this time:

using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media.Animation;
using System.Windows.Media.Imaging;

namespace GifImageProject
{
    public class GifImage : Image
    {
        #region Memmbers

        private GifBitmapDecoder _gifDecoder;
        private Int32Animation _animation;
        private bool _isInitialized;

        #endregion Memmbers

        #region Properties

        private int FrameIndex
        {
            get { return (int)GetValue(FrameIndexProperty); }
            set { SetValue(FrameIndexProperty, value); }
        }

        private static readonly DependencyProperty FrameIndexProperty =
            DependencyProperty.Register("FrameIndex", typeof(int), typeof(GifImage), new FrameworkPropertyMetadata(0, new PropertyChangedCallback(ChangingFrameIndex)));

        private static void ChangingFrameIndex(DependencyObject obj, DependencyPropertyChangedEventArgs ev)
        {
            GifImage image = obj as GifImage;
            image.Source = image._gifDecoder.Frames[(int)ev.NewValue];
        }

        /// &lt;summary>
        /// Defines whether the animation starts on it's own
        /// &lt;/summary>
        public bool AutoStart
        {
            get { return (bool)GetValue(AutoStartProperty); }
            set { SetValue(AutoStartProperty, value); }
        }

        public static readonly DependencyProperty AutoStartProperty =
            DependencyProperty.Register("AutoStart", typeof(bool), typeof(GifImage), new UIPropertyMetadata(false, AutoStartPropertyChanged));

        private static void AutoStartPropertyChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            if ((bool)e.NewValue)
                (sender as GifImage).StartAnimation();
        }

        public string GifSource
        {
            get { return (string)GetValue(GifSourceProperty); }
            set { SetValue(GifSourceProperty, value); }
        }

        public static readonly DependencyProperty GifSourceProperty =
            DependencyProperty.Register("GifSource", typeof(string), typeof(GifImage), new UIPropertyMetadata(string.Empty, GifSourcePropertyChanged));

        private static void GifSourcePropertyChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            // Reinitialize animation everytime image is changed
            (sender as GifImage).Initialize();
        }

        #endregion Properties

        #region Private Instance Methods

        private void Initialize()
        {
            // initialize the gifDecoder
            _gifDecoder = new GifBitmapDecoder(new Uri("pack://application:,,," + this.GifSource), BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
            // initialize the animation
            _animation = new Int32Animation(0, _gifDecoder.Frames.Count - 1, new Duration(new TimeSpan(0, 0, 0, _gifDecoder.Frames.Count / 10, (int)((_gifDecoder.Frames.Count / 10.0 - _gifDecoder.Frames.Count / 10) * 1000))));
            // repeat forever
            _animation.RepeatBehavior = RepeatBehavior.Forever;
            // set the image source
            this.Source = _gifDecoder.Frames[0];

            // set this to true so it doesn't get initialized again
            _isInitialized = true;
        }

        #endregion Private Instance Methods

        #region Public Instance Methods

        /// &lt;summary>
        /// Shows and starts the gif animation
        /// &lt;/summary>
        public void Show()
        {
            this.Visibility = Visibility.Visible;
            this.StartAnimation();
        }

        /// &lt;summary>
        /// Hides and stops the gif animation
        /// &lt;/summary>
        public void Hide()
        {
            this.Visibility = Visibility.Collapsed;
            this.StopAnimation();
        }

        /// &lt;summary>
        /// Starts the animation
        /// &lt;/summary>
        public void StartAnimation()
        {
            if (!_isInitialized)
                this.Initialize();

            BeginAnimation(FrameIndexProperty, _animation);
        }

        /// &lt;summary>
        /// Stops the animation
        /// &lt;/summary>
        public void StopAnimation()
        {
            BeginAnimation(FrameIndexProperty, null);
        }

        #endregion Public Instance Methods
    }
}

Thanks for reading, and I hope you find it useful.

The SegmentedSlider

2010-07-16T21:09:00.000-07:00

Ok, I have to admit this was real fun to program. It was challenging and there was a lot of trial and error, but it's finished, and here it is.

So basically this is a Slider with a segmented range. The regular WPF slider goes from, say, -1000 to +1000, and you can go through the whole range in a single mouse movement. That's pretty cool. But what if you wanted the user to be able to go to very granular values in that Slider? Say, you want to give the user the possibility of going to values like .01 or 10.76, you would need a HUUUUUUUUGE slider to do that. Of course you can also have a TextBox and have the user type the specific value, but some users are too lazy to type.

Anyway, the cool thing about this segmented slider, is instead of showing you all the 2000 numbers at once, it goes by segments, so depending on your segment size you can be as granular as you want with your values. And of course, unless you want to give your users a really bad time, don't do a range of -1000 to 1000 with segments of 10, unless of course you want your users to remember their teenage years.

Anyway, this image will illustrate the way the slider works (sorry, I used paint and I'm no graphic designer):

Get it? Hope you do, cause creating that image was no walk in the park.

Every time the user is done moving the Slider's Thumb, the Thumb will return to the middle (unless the user is getting close to the absolute Min / Max), once the Thumb is back in the middle, there will be a range of, say -100 to the left and + 100 to the right.

So yeah, the first thing I needed to do was to create a Threshold property, which controls the range I just mentioned. Once the threshold was there I needed AbsoluteMaximum and AbsoluteMinimum properties, which of course, control the real max and min of the slider. The regular Slider's Minimum and Maximum properties are used to represent the range, and are changed every time the slider's value changes.

Here's everything I just described in a quick glance:

private void CalculateLimits()
{
    if (this.Threshold != 0)
    {
        double spaceLeftMax = this.AbsoluteMaximum - this.Value;
        double spaceLeftMin = this.AbsoluteMinimum - this.Value;

        // if the space left in the max limit is smaller than the threshold, don't use the threshold
        if (spaceLeftMax < this.Threshold)
        {
            this.Maximum = this.AbsoluteMaximum;
        }
        else // else use the threshold
        {
            this.Maximum = this.Value + this.Threshold;
        }
        // if the space left in the min limit is smaller than the threshold, use the AbsoluteMinimum
        if (spaceLeftMin > -this.Threshold)
        {
            this.Minimum = this.AbsoluteMinimum;
        }
        else // else use the threshold
        {
            this.Minimum = this.Value - this.Threshold;
        }
    }
}

Basically, when the slider's value is changed, the range is recalculated like so:

RangeMax = value + Threshold;
RangeMin = value - Threshold;

Only there are a few other operations to make sure we don't go over the absolute limits (that's what spaceLeftMax and spaceLeftMin are used for).

This is the core method of the slider. The rest are just properties and validation. I had to make sure the limits are not recalculated while the user is dragging the Thumb, or else, the thumb would never leave the center (every time the thumb is move, the value of the slider is changed). Also some coersions to make sure the Value doesn't go over the AbsoluteMax / Min and vice versa.

Binding gave me a lot of trouble too, so I had to create a relative value called SegmentValue to replace the regular Value. The problem was that when the Value was changed, the MaximumProperty went through the Validate method (a WPF standard method for DependencyProperties, I'll blog about this some time); basically, when the Value property reached the Max, the Maximum property said "Hey, this Value guy needs more space, I'll move a bit so he can get here", which caused some weird recursion problems, etc.

So to fix this, I created the SegmentValue property, make sure YOU BIND TO THAT, instead of the regular Value property, or else, the slider won't work (believe me, I created the code).

Anyway, since I know how you like downloading WPF projects, here it is.

Download project

And here's the whole SliderSegment code so my blog looks cool.

using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Input;

namespace SegmentedSliderProject
{
    public class SegmentedSlider : Slider
    {
        #region Constructors

        public SegmentedSlider()
        {
            // Loaded is used just to bind the SegmentedSlider.ValueProperty to the SegmentValuePropertie
            this.Loaded += new RoutedEventHandler(UndefinedLimitsSlider_Loaded);
        }

        #endregion Constructors

        #region Threshold Property

        /// <summary>
        /// This controls the segment size, the Threshold is applied both to the left and right. If there's a
        /// threshold of 100, the segment range will go from -100 to +100
        /// </summary>
        public double Threshold
        {
            get { return (double)GetValue(ThresholdProperty); }
            set { SetValue(ThresholdProperty, value); }
        }

        public static readonly DependencyProperty ThresholdProperty =
            DependencyProperty.Register("Threshold", typeof(double), typeof(SegmentedSlider),
            new UIPropertyMetadata(10d, ThresholdPropertyChanged));

        private static void ThresholdPropertyChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            SegmentedSlider slider = sender as SegmentedSlider;

            slider.CalculateLimits();
        }

        #endregion Threshold Property

        #region SegmentValue Property

        /// <summary>
        /// This value is treated as a relative value for each segment. And it's used instead
        /// of the other Value (which I call absolute value in the scope of this class)
        /// </summary>
        public double SegmentValue
        {
            get { return (double)GetValue(SegmentValueProperty); }
            set { SetValue(SegmentValueProperty, value); }
        }

        public static readonly DependencyProperty SegmentValueProperty =
            DependencyProperty.Register("SegmentValue", typeof(double), typeof(SegmentedSlider),
            new UIPropertyMetadata(0e, SegmentValuePropertyChanged, CoerceSegmentValue));

        private static void SegmentValuePropertyChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            double SegmentValue = (double)e.NewValue;
            SegmentedSlider slider = sender as SegmentedSlider;

            // don't update any values if the user is dragging the slider, only when the value is changed by a different input
            // I. E. a databound TextBox
            if (slider._isThumbDragging)
                return;

            // use the SegmentValue to update the maximum / minimum before updating the actual Value
            // this skips the MaximumValidateValue method, avoiding some problems when updating the Max and Value
            if (slider.SegmentValue >= slider.Maximum)
            {
                slider.Maximum = slider.SegmentValue + slider.Threshold;
            }
            else if (slider.SegmentValue <= slider.Minimum)
            {
                slider.Minimum = slider.SegmentValue - slider.Threshold;
            }

            // set the SegmentValue to the actual value
            slider.Value = slider.SegmentValue;
        }

        private static object CoerceSegmentValue(DependencyObject sender, object value)
        {
            SegmentedSlider slider = (SegmentedSlider)sender;

            if ((double)value < slider.AbsoluteMinimum)
                return slider.AbsoluteMinimum;

            if ((double)value > slider.AbsoluteMaximum)
                return slider.AbsoluteMaximum;

            return value;
        }

        #endregion SegmentValue Property

        #region AbsoluteMaximum

        public double AbsoluteMaximum
        {
            get { return (double)GetValue(AbsoluteMaximumProperty); }
            set { SetValue(AbsoluteMaximumProperty, value); }
        }

        public static readonly DependencyProperty AbsoluteMaximumProperty =
            DependencyProperty.Register("AbsoluteMaximum", typeof(double), typeof(SegmentedSlider),
            new UIPropertyMetadata(10d, AbsoluteMaximumPropertyChanged, CoerceAbsoluteMaximum));

        private static object CoerceAbsoluteMaximum(DependencyObject sender, object value)
        {
            SegmentedSlider slider = (SegmentedSlider)sender;

            if ((double)value < slider.AbsoluteMinimum)
                return slider.AbsoluteMinimum;

            if ((double)value < slider.SegmentValue)
                return slider.SegmentValue;

            return value;
        }

        private static void AbsoluteMaximumPropertyChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            (sender as SegmentedSlider).CalculateLimits();
        }

        #endregion AbsoluteMaximum

        #region AbsoluteMinimum

        public double AbsoluteMinimum
        {
            get { return (double)GetValue(AbsoluteMinimumProperty); }
            set { SetValue(AbsoluteMinimumProperty, value); }
        }

        public static readonly DependencyProperty AbsoluteMinimumProperty =
            DependencyProperty.Register("AbsoluteMinimum", typeof(double), typeof(SegmentedSlider),
            new UIPropertyMetadata(-10d, AbsoluteMaximumPropertyChanged, CoerceAbsoluteMinimum));

        private static object CoerceAbsoluteMinimum(DependencyObject sender, object value)
        {
            SegmentedSlider slider = (SegmentedSlider)sender;

            if ((double)value > slider.SegmentValue)
                return slider.SegmentValue;

            return value;
        }

        private static void AbsoluteMinmumPropertyChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            (sender as SegmentedSlider).CalculateLimits();
        }

        #endregion AbsoluteMinimum

        #region Event Handlers and Overrides

        private void UndefinedLimitsSlider_Loaded(object sender, RoutedEventArgs e)
        {
            // Bind SegmentValue to the actual Value so they are in sync
            // this method should only be called when the value changes by something different than dragging the slider
            // it's specifically made to avoid a problem with the "Maximum" property validation
            if (this.GetBindingExpression(SegmentedSlider.ValueProperty) == null)
                this.SetBinding(SegmentedSlider.ValueProperty, new Binding("SegmentValue") { Source = this });

            // If no value has been set through binding, trigger limit calculation
            if (this.SegmentValue == 0)
                this.CalculateLimits();
        }

        protected override void OnValueChanged(double oldValue, double newValue)
        {
            base.OnValueChanged(oldValue, newValue);

            // only recalculate limits on ValueChanged IF the thumb is not being dragged
            // I. E. it's ok to update if a TextBox bound to the slider's "Value" property is updated
            // if we update while the thumb is being dragged we'll get some erratic behavior
            if (!_isThumbDragging)
                CalculateLimits();
        }

        protected override void OnPreviewMouseLeftButtonDown(MouseButtonEventArgs e)
        {
            base.OnPreviewMouseLeftButtonDown(e);

            // indicate dragging has started
            _isThumbDragging = true;
        }

        protected override void OnPreviewMouseLeftButtonUp(MouseButtonEventArgs e)
        {
            base.OnPreviewMouseLeftButtonUp(e);

            // calculate limits when drag ends
            CalculateLimits();

            // indicate dragging has ended
            _isThumbDragging = false;
        }

        #endregion Event Handlers and Overrides
        
        #region Threshold Behavior

        private bool _isThumbDragging = false;

        private void CalculateLimits()
        {
            if (this.Threshold != 0)
            {
                double spaceLeftMax = this.AbsoluteMaximum - this.Value;
                double spaceLeftMin = this.AbsoluteMinimum - this.Value;

                // if the space left in the max limit is smaller than the threshold, don't use the threshold
                if (spaceLeftMax < this.Threshold)
                {
                    this.Maximum = this.AbsoluteMaximum;
                }
                else // else use the threshold
                {
                    this.Maximum = this.Value + this.Threshold;
                }
                // if the space left in the min limit is smaller than the threshold, use the AbsoluteMinimum
                if (spaceLeftMin > -this.Threshold)
                {
                    this.Minimum = this.AbsoluteMinimum;
                }
                else // else use the threshold
                {
                    this.Minimum = this.Value - this.Threshold;
                }
            }
        }

        #endregion Threshold Behavior
    }
}

Thanks for reading and happy coding!

I hate PHP, and here's why

2010-07-16T11:35:00.000-07:00

This is a post from an old blog I had. It's basically how I started hating PHP. It was titled "My PHP nightmare". I hope you enjoy it and you hate PHP as much as I do. Thanks.

------------

My PHP nightmare [October 1st 2009]

So I was doing some PHP code in notepad last week; at this time I had a demo version of Expression Web, and I noticed it reads PHP files, and just like Visual Studio with C#, it has keyword highlighting and some syntax checking; it doesn’t have autocomplete, but that’s ok. Anyway, after accidentaly finding out about these features of Expression Web, I decided to give it a shot. Unlucky for me, my PHP library files, are saved as .inc files, which Expression does not recognize as PHP files, thus, no syntax checking, no highlighting. I decided to save the file as .php to work with it, and when I finished, save it back as .inc, it worked, I had a good time doing my PHP library code in Expression, and then I hit save as…, FileName.inc.

Hell broke loose when I uploaded my newly saved .inc file. My PHP headers didn’t work. Basically for headers to work, the webpage MUST be empty before you set the headers (no printing, not even a space character). I used the header to redirect to a different page when certain conditions were met:

header(”Location: SomeOtherPage.php”);

They worked before, but not anymore. What could’ve had happened? The error lacked information to base my search upon, or to ask around, and my code looked almost exactly the same as it was before. The error I was getting was:

Cannot modify header information – headers already sent in YourClassName.inc : 1

Where 1 is the line that threw the error. But wait… That’s the line where I declare the class… how can this be wrong:

class MyClass
{}

So I checked my code line by line, I started googling all over the place, searching for “echo” keywords, to find out what was being printed before the header (remember? headers don’t work if you print something on the page before setting them). Double checked the code line by line, compared both files again and again. Until I stumbled upon this solution in Google (after 6 hours of searching and trying code). My .inc file could've been saved in an encoding that PHP does not like... Honestly, I was skeptic, and the fact that this solution was for a third party library made me doubt it even more. But I decided to take the code I had saved from Expression, put it in a notepad file, and from there, save again as .inc. Believe it or not, this solved my problem. It seems like the encoding from Expression, makes the file print an empty space once it gets to the webpage, hence, the headers did not work.

My problem was the encoding that Expression used to save my file as .inc, PHP (or Apache) didn’t like it; my solution was to copy it over to notepad, and from there, save as .inc.

Lucky for me, there was another problem with another file that I left for later, after solving this problem; this file had the exact same error, took me 2 minutes to fix it.

Well this was my PHP nightmare from last week. I hope this helps someone out there who is struggling with PHP too.

Thanks for reading, and happy coding.

------------

Oh God how I HATE PHP....

The Slider's Thumb, and the inferior ToolTip

2010-07-14T03:00:00.000-07:00

So yeah, I was trying to get the Slider's Thumb, and I was having a lot of trouble finding a good way to do so. Why did I need the thumb you ask? Because I was having some trouble with the deficient options the Slider's ToolTip provides. I needed to show the ToolTip right above the Thumb, and some little Microsoft programmer decided to test our patience when trying to show the ToolTip ABOVE the Thumb.

This is the regular ToolTip position:

It's fine, as long as you don't want anything fancy.

Now what about moving it to the top:

<Slider Margin="8" x:Name="someSlider" ToolTip="Good day to you sir!"
 ToolTipService.Placement="Top" />

It's aligned to the Top Left of the Slider, not the Thumb anymore. No matter where your cursor is, the ToolTip is now fixed in that position.

Let's try the center:

<Slider Margin="8" x:Name="someSlider" ToolTip="Good day to you sir!"
 ToolTipService.Placement="Center" />

Same problem. Pretty annoying.

So yeah, apparently it was difficult to keep the ToolTip aligned with the Thumb (which is by default), if you change the position of the ToolTip with the ToolTipService, then the ToolTip is aligned to the absolute position of the Slider, and we don't want that. We want to keep the ToolTip aligned to the Thumb, but ABOVE it. So I had to decide between go have fun and drink beer with my friends, or do code to get the Thumb and set the ToolTip to THAT instead of the Slider itself.... hmmmmm decisions...

So yeah, I created a Slider that shares its Thumb. But most importantly (to me) two properties to handle the Thumb's position from XAML, you can even bind to them.

First this is one way to get the Thumb:

private DependencyObject GetThumb(DependencyObject root) 
{ 
    if (root is Thumb) 
        return root; 
 
    DependencyObject thumb = null; 
 
    for (int i = 0; i < VisualTreeHelper.GetChildrenCount(root); i++) 
    { 
        thumb = GetThumb(VisualTreeHelper.GetChild(root, i)); 
 
        if (thumb is Thumb) 
            return thumb; 
    } 
 
    return thumb; 
}

Or this is another one that a fellow programmer in StackOverflow suggested:

private static Thumb GetThumb(Slider slider) 
{ 
    var track = slider.Template.FindName("PART_Track", slider) as Track; 
    return track == null ? null : track.Thumb; 
}

Use whichever you like the most, I haven't tested speed or anything (if you do, comment with your results). Anyway, that was the tricky part, now that I have the Thumb, I can pull off the ToolTip trick, and put it wherever the hell I want it.

Another deficiency that really surprised me is that if you try to use StringFormat while binding on the Slider's thumb, it doesn't take it. Why? Beats me. Take this for example:

<Slider 
ToolTip="{Binding RelativeSource={RelativeSource Self},
 Path=Value, StringFormat=The Value: \{0:0.00\}}" />

It still shows up like this:

What's up with that? It clearly states that the value should show only 2 decimals, and that it should show a prefix of "The Value: ". It clearly DOES NOT. Why? Beats me too.

Anyway, with my superior ToolTip solution, I can put the ToolTip wherever the hell I want it, and however the hell I want it:

I don't want to bore you with the details of the ThumbToolTipText or ThumbToolTipPlacement properties, they're basically DependencyProperties with a PropertyChanged callback, whenever the properties change I run some code to update the Thumb's ToolTip.

But here's the code if you really want it:

Click to show code

public class FriendlySlider : Slider
    {
        #region Get the thumb

        public Thumb Thumb
        {
            get
            {
                return this.GetThumb(this) as Thumb;
            }
        }

        private DependencyObject GetThumb(DependencyObject root)
        {
            if (root is Thumb)
                return root;

            DependencyObject thumb = null;

            for (int i = 0; i < VisualTreeHelper.GetChildrenCount(root); i++)
            {
                thumb = GetThumb(VisualTreeHelper.GetChild(root, i));

                if (thumb is Thumb)
                    return thumb;
            }

            return thumb;
        }

        #endregion Get the thumb

        #region Thumb ToolTip Dependency Propertes

        public PlacementMode ThumbToolTipPlacement
        {
            get { return (PlacementMode)GetValue(ThumbToolTipPlacementProperty); }
            set { SetValue(ThumbToolTipPlacementProperty, value); }
        }

        public static readonly DependencyProperty ThumbToolTipPlacementProperty =
            DependencyProperty.Register("ThumbToolTipPlacement", typeof(PlacementMode),
            typeof(FriendlySlider), new UIPropertyMetadata(PlacementMode.Top, ThumbToolTipPlacementChanged));

        public string ThumbToolTipText
        {
            get { return (string)GetValue(ThumbToolTipTextProperty); }
            set { SetValue(ThumbToolTipTextProperty, value); }
        }

        public static readonly DependencyProperty ThumbToolTipTextProperty =
            DependencyProperty.Register("ThumbToolTipText", typeof(string),
            typeof(FriendlySlider), new UIPropertyMetadata(null, ThumbToolTipPlacementChanged));

        private static void ThumbToolTipPlacementChanged
            (DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            FriendlySlider slider = sender as FriendlySlider;

            if (slider.Thumb != null)
                slider.UpdateToolTip();
        }

        #endregion Thumb ToolTip Dependency Propertes

        #region Setup ToolTip

        public FriendlySlider()
        {
            this.Loaded += new RoutedEventHandler(FriendlySlider_Loaded);
        }

        private void FriendlySlider_Loaded(object sender, RoutedEventArgs e)
        {
            UpdateToolTip();
        }

        private void UpdateToolTip()
        {
            if(this.Thumb.ToolTip == null)
                this.Thumb.ToolTip = new ToolTip();

            (this.Thumb.ToolTip as ToolTip).Content = this.ThumbToolTipText;

            ToolTipService.SetPlacement(this.Thumb.ToolTip as ToolTip, this.ThumbToolTipPlacement);
        }

        #endregion Setup ToolTip
    }

So yeah, bottom line, pretty deficient ToolTip options for the Slider. Guess no Thumbs up for Microsoft this time (get it? Thumbs?).

Thanks for reading, and happy coding!

Dude, I'm so glad I'm not any of these guys

2010-06-25T11:31:00.000-07:00

New post featuring: The GNU/Stallmans

Somebody owes an apology to the internet...

They're almost like real Napoleon Dynamites, only he's cooler.

My second conference

2010-06-22T03:10:00.000-07:00

Well, it's been a long time since the conference happened, but I really want to blog about it.

First of all, I want to thank the persons who invited me, teachers Consuelo Salgado and Miguel Leyva. Consuelo was my Programming II teacher, she taught us some advanced C++ features (such as pointers and files), and two semesters later, she taught us a Database class. Miguel was our networking teacher, and we learned a lot of interesting stuff with him too (such as the OSI model, TCP/IP, etc.).

Anyway, I humbly (and really thankfully) accepted their offer; this time I was going to share the podium with 3 other persons, I had no idea who they were, and oh surprise. I arrived at the school, I was looking for Consuelo and Miguel to let them know that I was there already, when I find another one of my programming teachers, Diana Cazas (with her, we learned ASP.net with VisualBasic.net), I was really surprised and excited to see her, I told her I was there because I was invited to speak in a conference, and she said: "Oh yeah, me too! we're going to be there together!". This was a really REALLY big WTF moment in my life. I mean, she WAS my teacher, I learned a lot of stuff from HER, plus, she has like 10 years of working experience. I got so nervous after learning that I was sharing the podium with MY TEACHER. "What can I say that she doesn't know?" was a question that circled my mind for a while.

Anyway, my teacher was the first person I learned that was sharing the podium with me, 20 minutes later, we get to the conference room where everyone was waiting for us, and I get introduced to the other two persons: an entrepreneur, owner of 5 companies; and another programmer / IT technician with around 12 years experience... yeah... my teacher, an entrepreneur with 5 companies, and a programmer with 12 years of working experience. Me? Oh yeah, a young programmer with 3 years of experience. I felt honored, but scared at the same time.

Anyway, the conference started, and we started answering the students' questions. Among some questions I can remember:

- From what you learned in school. What subject helped you the most?
My answer: I learned to learn on my own, investigate, doubt, and compare.

- When did you decide you were going to work on your field and why?

In my case: Second semester, when I learned C++ pointers and files with teacher Consuelo. The reason is because I realized I was really good when started tutoring my classmates in the subject because they were doing bad, all of them did good after I tutored them btw =P.

* This question was really important because (at least in Mexico), the Computer Information Systems major is really broad, and there are many paths you can take like: programming, networking, database administration, software design, auditing, among others.

- What helps you stay competent and current in your field?

In my case: Read, read, read! And of course, lots of practice.

Anyway, these are some of the questions that I can remember.

Another thing that really got into me, is something my programming teacher Diana Cazas said:

- "When asked to do something difficult, don't think WHY CAN'T YOU do it, think HOW CAN YOU do it."

And yeah, she's right, in software, pretty much everything is possible, so it's stupid to say something can't be done, we should rather concentrate our energy in looking for a good way to do it, and not on thinking excuses on why we can't do it.

I also got this recognition that I'm very proud of, it's the second one I get, and I hope is not the last:

It says:

"To L. I. Juan Carlo Toribio Rojas for his valuable contribution in the 'Graduates Forum', where he shared his experiences in the professional scope.

May 7 2010

Signed by Julio Blas Flores, Director"

Where L. I. means "Licenciado en Informatica", in Mexico is common to acquire a title like this after finishing a bachelors degree.

The conference was a really great experience for me, sharing the podium with such succesful people was really astonishing, and being able to speak among them and have them agree with me, was priceless. The students were really attentive and interested on what we all had to say, and they really wanted to know our roles in our companies, and how we got there. In the end, I'm sure we all helped them out at least one bit.

Thanks for reading, I know this was long, and there was no code, but it's something that I'm really proud of, and I'd like to share with the world, so here it is.

Thanks again to my teachers Consuelo and Miguel for inviting me, and thanks to everyone who shared the moment with me.

I promise, next post will have code!

XKCD Monthly Tribute: Commented edition

2010-06-21T13:22:00.000-07:00

Yeah, I'm starting a new series.

http://xkcd.com/156/

The Cartesian Grid

2010-06-15T17:24:00.001-07:00

The CartesianGrid. I was here at work, working like usual, when I got assigned to create a control that shows a set of controls arranged in a 2x2 grid, and it worked all right, the controls were there. It needed to have selection, so I used a ListBox (yes, ListBox is lighter than ListView), I didn't need special functionality from the ListView anyway (at least not yet). Anyway, everything was merry, until I was told me the grid should show X and Y coordinates in the 2x2 grid (X = A, B, C to n1, Y = 1, 2, 3 to n2), and yes, hell broke loose.

I started looking into it, reading here and there, looking for code that was close to what I needed, and oh surprise, I found NOTHING (well not really a surprise, WPF is such a young technology). I spent like 8 hours investigating, when I finally got assigned to something else. It was a relief, but I knew the grid coordinates would come back to hunt me, and so they did. So this time, I decided I would create them on my own, using methods I already knew or at least had read about in books, and yes, that worked.

Sorry for the long story, but you have to know what I felt like, and you have to realize the excitement I felt when I finished my CartesianGrid, I almost jumped out of my chair, LITERALLY. So now that you know the story, and know how I felt, I'm really happy to share my code with you. Let's code!

First of all, this is what you will end up with:

Finished CartesianGrid Video

And here's the project

Now let the fun begin:


using System;
using System.Globalization;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Media;

namespace CartesianGridProject
{
/// &lt;summary>
/// Interaction logic for Window1.xaml
/// &lt;/summary>
public partial class Window1 : Window
{
public Window1()
{
InitializeComponent();
}

private void Button_Click(object sender, RoutedEventArgs e)
{
cartesianGrid.Children.Add(new Label() { Content = "Hello" });
}
}

// First of all, inherit from UniformGrid, why do all the arranging logic when Bill Gates already did it for me?
public class CartesianGrid : UniformGrid
{
#region Members

private int _columns;
private int _rows;
private int _margin = 22;
private LinearGradientBrush _linearGradientBrush;
private string _fontFamily = "Myriad Pro";
private double _fontSize = 18;

#endregion Members

#region Properties

public bool ShowCoordinatesText
{
get { return (bool)GetValue(ShowCoordinatesTextProperty); }
set { SetValue(ShowCoordinatesTextProperty, value); }
}

public static readonly DependencyProperty ShowCoordinatesTextProperty =
DependencyProperty.Register("ShowCoordinatesText", typeof(bool), typeof(CartesianGrid), new FrameworkPropertyMetadata(true, FrameworkPropertyMetadataOptions.AffectsRender));
/* 
         * This part:
         * new FrameworkPropertyMetadata(true, FrameworkPropertyMetadataOptions.AffectsRender)
         * Is so whenever that property changes (ShowCoordinatesText) it tells the WPF drawing system it should re-render the control.
         * So whenever you have a DependencyProperty that will affect the visual state of your control, use a FrameworkPropertyMetadata
         * object, and set it's FrameworkPropertyMetadataOptions to AffectsRender. There's plenty more options, but I'll go over them
         * as I create more controls
         */

#endregion Properties

#region Constructors

public CartesianGrid()
{
/*
             * Just setting some private member I will use throughout my class, right now they're used in one method (at
             * least most of them), but this will make it a lot easier to extend the class later on.
             */
_linearGradientBrush = new LinearGradientBrush();

_linearGradientBrush.StartPoint = new Point(0.5, 1);
_linearGradientBrush.EndPoint = new Point(0.5, 0);

_linearGradientBrush.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x0A, 0x4C, 0x7D), 0));
_linearGradientBrush.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0x0D, 0x5E, 0x9B), 0.996));
}

#endregion Constructors

#region Overrides

protected override void OnRender(DrawingContext drawingContext)
{
/*
             * This is where the fun starts. First of all, if the ShowCoordinatesText property is set to false, do nothing,
             * otherwise, carry on.
             */
if (!this.ShowCoordinatesText)
{
this.Margin = new Thickness(0);
return;
}

// This is the margin where the coordinates will show up, I'm using 22 right now, and only for the left and top margins
// (remember that margins are set like Thickness(&lt;LEFT>, &lt;TOP>, &lt;RIGHT>, &lt;BOTTOM>), and the coordinates will show up
// on the left and top of the control, so no need to set the bottom and right margins.
this.Margin = new Thickness(_margin, _margin, 0, 0);

// These are some offsets I use to draw the letters, numbers and lines
double xOffset = (this.RenderSize.Width) / _columns;
double yOffset = (this.RenderSize.Height) / _rows;

// Some variables of the x and y positions, to make the code more readable and prettier
double x1 = 0;
double x2 = 0;
double y1 = 0;
double y2 = 0;

// And this guy will help me center the numbers and latters right in the middle of each Row / Column
double centerMargin = 0;

// Set the pen I will use to draw everything
Pen pen = new Pen(Brushes.Navy, 1);

// Freeze the pen to improve performance (won't change any of it's attributes anyway)
if (pen.CanFreeze)
pen.Freeze();

// Now, let's start drawing!! We'll use the DrawingContext object (drawingContext) that the OnRender event provides us,
// this is the drawingCotnext object that is used by WPF to draw the control, so we might as well use it.

// This draws the line on top (I'm using a -1 offset so the line is not drawn behind the items, because the items would
// cover it)
drawingContext.DrawLine(pen, new Point(this.RenderSize.Width, -1), new Point(-1, -1));

// This draws the line on the left (-1 here too for the same reason)
drawingContext.DrawLine(pen, new Point(-1, -1), new Point(-1, this.RenderSize.Height));

// I know nowadays this is an odd way to initialize and indexing variable, but I'll use it outside the for loop,
// so live with it.
int i;

for (i = 0; i &lt; _columns; i++)
{
// draw the text
FormattedText formattedText =
new FormattedText((i + 1).ToString(),
CultureInfo.CurrentCulture,
FlowDirection.LeftToRight,
new Typeface(_fontFamily),
_fontSize,
_linearGradientBrush);

/* this is the little equation to calculate the center of the column drawn, so I can use the value
                 * as a margin and the text will end up right in the center of the column
                 * basically, I'm taking the offset diving it by 2, to get the absolute center, then subtract half the width of the
                 * number I'm drawing, then I add the real left offset, so it pushes, sounds complex, but it's not =P.
                 * This way the number center is aligned with the center of the column, otherwise, the left edge
                 * of the number would be align to the center of the column, and no, we don't want that
                 */
centerMargin = (i * xOffset) + ((xOffset / 2) - (formattedText.Width / 2));

// draw the number
drawingContext.DrawText(formattedText, new Point(centerMargin, -_margin + 3));

// update the offsets so they move one notch to the right
x1 = (xOffset * i) - 1;
x2 = 0;
y1 = xOffset * i;
y2 = _margin * -1.5;

// Draw the separator
drawingContext.DrawLine(pen, new Point(x1, x2), new Point(y1, y2));
}

x1 = (xOffset * i) - 1;
x2 = 0;
y1 = xOffset * i;
y2 = _margin * -1.5;

// this draws one last separator on the right (the code above is where I used i outside the for loop
drawingContext.DrawLine(pen, new Point(x1, x2), new Point(y1, y2));

// no need to reinitialize i, I saved myself some coding
for (i = 0; i &lt; _rows; i++)
{
FormattedText formattedText = new FormattedText(((char)(i + 65)).ToString(),
CultureInfo.CurrentCulture,
FlowDirection.LeftToRight,
new Typeface(_fontFamily),
_fontSize,
_linearGradientBrush);

// same logic to get the absolute center, only this time I use they height of the letter, not the width
centerMargin = (i * yOffset) + ((yOffset / 2) - (formattedText.Height / 2));

// draw the letter
drawingContext.DrawText(formattedText, new Point(-_margin + 6, centerMargin));

// update offsets
x1 = 0;
x2 = (yOffset * i) - 1;
y1 = _margin * -1.5;
y2 = yOffset * i;

// using extension method to snap to pixels, supposedly this is a solution for pixelation, but it doesn't work here
drawingContext.DrawLine(pen, new Point(x1, x2), new Point(y1, y2));
}

// use i outside the for loop again (I hope I don't scare any potential employers for doing this, sheesh)
x1 = 0;
x2 = (yOffset * i) - 1;
y1 = _margin * -1.5;
y2 = yOffset * i;

// draw the last separator on the bottom
drawingContext.DrawLine(pen, new Point(x1, x2), new Point(y1, y2));

// send back the drawingContext object
base.OnRender(drawingContext);
}

protected override Size ArrangeOverride(Size arrangeSize)
{
// Here I call invalidate visual. This method gets called when the control contents are rearranged (that is, when the
// the number of Rows / Columns changes, in the case of the UniformGrid)
this.InvalidateVisual();

// Now get the number of columns and rows (this method happens before OnRender, and OnRender needs the number of
// columns and rows
if (this.Columns != 0 && this.Rows != 0)
{
// if explictly set, just get them from their properties
_rows = this.Rows;
_columns = this.Columns;

return base.ArrangeOverride(arrangeSize);
}
else
{
// if not explicitly set, calculate the size of the largets of its children (since it's a UNIFORM grid, every cell
// will be as big as the biggest one, that is, if a control needs a 10x10, and another a 100x100, the 10x10 will be
// 100x100 to keep the uniformity, otherwise it would be called NotUniformGrid.
// Once we have the size of the largest child, divide the actual height / width of the grid, by the height / width
// of said child, THAT will give you the number of rows and columns
Size arrangedSize = base.ArrangeOverride(arrangeSize);

double maxChildDesiredWidth = 0.0;

double maxChildDesiredHeight = 0.0;

//  Measure each child, keeping track of max desired width & height.  
for (int i = 0, count = Children.Count; i &lt; count; ++i)
{
UIElement child = Children[i];

Size childDesiredSize = child.DesiredSize;

if (maxChildDesiredWidth &lt; childDesiredSize.Width)
{
maxChildDesiredWidth = childDesiredSize.Width;
}
if (maxChildDesiredHeight &lt; childDesiredSize.Height)
{
maxChildDesiredHeight = childDesiredSize.Height;
}
}

if (maxChildDesiredHeight == 0 || maxChildDesiredWidth == 0)
return arrangedSize;

// calculate the columns
_columns = Convert.ToInt32(Math.Floor(this.DesiredSize.Width / maxChildDesiredWidth));
// calculate the rows
_rows = Convert.ToInt32(Math.Floor(this.DesiredSize.Height / maxChildDesiredHeight));

return arrangedSize;
}
}

#endregion Overrides
}
}

What's going on?

2010-06-08T12:43:00.000-07:00

Gonna keep on blogging next week, I've been going through some personal stuff, but I'm tying the loose ends now. Anyway, there's a lot of stuff I want to blog about:

- I created a cool CartesianGrid control for WPF (basically it's a UniformGrid that shows X and Y axes coordinates, pretty fun stuff)

- My conference in Mexico (which went great! I'll post pics)
- WCF (I haven't had a lot of time to study lately for these problems, but I'm picking up again soon)
- Make some more fun of PHP (haha love that)

There's more stuff I want to blog about, but that's what I can remember right now. What hurts more is that I've stopped studying for my WCF certification for almost 3 weeks now, which would also give me some more material to blog about.

How do I know it's PHP? Google edition

2010-05-25T13:17:00.000-07:00

Fill the blank:

- If you google "___ sucks", you get more than 12,000,000 results.
- What is PHP?

Oh yes, PHP made my day again lol.

Anyway, here are the results:

PHP Sucks - 12,600,000 results
C# Sucks - 200,000 results (proximately 1.5% of PHP results)
C++ Sucks - 279,000 results (a little more than C#, I'm surprised)
Visual Basic sucks - WOAH! 163,000 results, even less than C#, now I AM surprised

I lol at PHP.

2nd conference in Mexico

2010-05-06T18:10:00.000-07:00

I'm very honored to have been invited again to speak in a conference in the university I graduated from Universidad Autónoma de Baja California (aka UABC). The first time I didn't have this blog, so I didn't blog it, but this time I do.

The first conference was back in November 2008, and I had a lot of fun. Students were really attentive and I think I helped out in their careers even a bit. I talked a little bit about C# 3.0, WPF, Silverlight, LINQ, and about the project I was working on back then. But what I stressed out the most is that they should read and be willing to learn anything new that comes out; since I believe that's what really helps you be competitive in today's programming market, technology evolves extremely fast, and you need to catch up as much as you can. And to enforce their reading, I gave out some books.

Anyway, this time I'll be talking about my career as a programmer, and not about programming per se. I won't be alone this time either, it'll be me and I'm guessing around 4 more people (all UABC graduates), we'll all be speaking and answering the students' questions. It sounds like it'll be even more fun than last time!

Well, hope everything goes well, and sure hope I get invited again! And I take this chance to semi-publicly thank my teachers who invited me there, Consuelo and Miguel.

Thanks!

At the Visual Studio 2010 launch event in San Diego

2010-05-03T14:13:00.000-07:00

Not really what I expected, they gave out a VS2010 Ultimate TRIAL WTH Bill Gates, where is my full copy?? Anyway, I'm learning interesting stuff, I'll blog about it later in the week. Among others:

SmallBasic - Programming for kids
Extension manager - Integrated extension manager in VS2010
XAML intellisense - Self explanatory

It's not as good as I thought, but not too bad either.

The StackTrace

2010-04-14T23:52:00.000-07:00

Well, here's a quick one. Ever wondered how to log an exception with to-the-line detail? Well, this is what you need. The StackTrace .net class can get a lot of info of your exception into an object that you can actually use.

Download project here

A few things are required though:

1) Preferably, you must deploy in Debug mode (so the JIT compiler Code Optimization doesn't kick in). If Code Optimization is on, you will get inaccurate line numbers, although pretty close, but inaccurate. You can still deploy in release mode, but make sure Code Optimization is turned off (from the project's Properties, Build Tab):

You must be asking yourself "Why does code optimization causes inaccurate line numbers?", well the answer is simple. The JIT compiler code optimization, takes your code (methods, loops and such), and uses a mechanism called "Inline Methods" to optimize your code (more details about inline methods here). So, when inline methods are used, your code actually changes, because the lines change, hence, the inaccuracy of the line numbers. You could say, the JIT makes your methods smaller by converting a method call into a one line operation.

2) You MUST include your Program Debug Database files (PDB). This is essential or the StackTrace class will NOT be able to get any info about your exception.

Let's do some code now:


using System;
using System.Diagnostics;
using System.IO; 



namespace StackTraceConsoleProject
{
    class Program
    {
        static void Main(string[] args)
        {
            FailClass FAIL = new FailClass();
            
            FAIL.Fail();

            Console.Read();
        }
    }

    /// <summary>
    /// FAIL class will fail
    /// </summary>
    class FailClass
    {
        /// <summary>
        /// FAIL method will fail.
        /// </summary>
        public void Fail()
        {
            try
            {
                throw new Exception("Fail class has FAILED.");
            }
            catch (Exception ex)
            {
                this.GetFAILInfo(ex);
            }
        }

        /// <summary>
        /// This gets the FAIL info
        /// </summary>
        /// <param name="ex">The FAIL exception</param>
        private void GetFAILInfo(Exception ex)
        {
            string infoString = String.Empty;

            // Generate your stack trace class and provide it with your exception
            // fNeedFileInfo is set to true so it gets the file name, number, etc. Otherwise it won't
            StackTrace stackTrace = new StackTrace(ex, true /* fNeedFileInfo */);

            // This for loop will navigate through the stack of your exception and display the whole trace
            // of the call to the method that caused the exception. In this case, just one method is displayed
            for (int i = 0; i < stackTrace.FrameCount; i++)
            {
                StackFrame frame = stackTrace.GetFrame(i);

                if (!String.IsNullOrEmpty(frame.GetFileName()))
                {
                    infoString = String.Format("File name: {0}\nMethod Name: {1}\nLine number: {2}\n\n",
                    Path.GetFileName(frame.GetFileName()), frame.GetMethod().ToString(), frame.GetFileLineNumber().ToString());
                }
            }

            // print the info
            Console.WriteLine("Exception info: {0} \n{1}", ex.Message, infoString);
        }
    }
}

Now, you have to realize that including the PDB files is potentially dangerous, as it makes reverese engineering your application a lot easier, so doing this sort of exception tracking is recommended in the testing phase of the app, and not for production.

Hope this helps you as it helped me. Thanks for reading, and happy coding!

How do I know it's PHP? No method overloading

2010-04-14T13:16:00.000-07:00

- It's a "general-purpose programming language" that has no method overloading.
- What is PHP?

Or perhaps there is a really painful way.

Anyway, I just wanted to make fun of PHP. PHP sucks... hahaha...

WCF Learning

2010-04-13T00:26:00.001-07:00

Just finished chapter one, pretty cool stuff. This is the book I'm reading, it's actually the first time I read a Microsoft training kit book, and it's pretty nice, so far I've understood everything I believe. So yeah, WCF is not bad at all!

Few acronyms I have to memorize:

SOAP - Service Oriented Application
MSMQ - Microsoft Message Queuing
MEP - Message Exchange Patterns
DSL - Domain Specific Language
MTOM - Message Transmition Optimization Mechanism (MTOM sounds funny)

I can only remember SOAP, MEP and of course MTOM right now. I suck at memorizing stuff.

Anyway, coming next, the different types of Service Contracts, then MEPs.

WCF Certification

2010-04-06T17:11:00.000-07:00

Guess I'm gonna have to make a new blog when I get it: "The WCF dude", or maybe merge them? "The WP/CF dude". W and F stand for the same words in both acronyms anyway, and it looks cool. Or maybe just forget about the acronym "The Windows Presentation and Communication Foundation Dude"? nah...

The WP/CF dude blog. Coming soon...

Anyway, I'll be posting about my progress and what I learn about WCF. Some big ass books I gotta read...

Stay tuned for some WCF magic!

How I became a programmer

2010-03-29T12:49:00.000-07:00

I just posted this answer in stackoverflow.com, I thought it would look cool in my blog:

- 1984: I was born.
- 1986: My first NES game console (which doomed me to be an indoors geek)
- 1996: My first personal computer, a Pentium
- 1996 - 1997: My dad hated me because I always broke the computer doing my experiments, but that helped me learn
- 1997 - 1999: I knew my way pretty good around the computer and started gaming there (Doom, Doom II, Wolfstein 3D, Duke Nukem I believe)
- 1999: I was an expert Windows 95 / 98 user, I knew a lot of features and I could do a lot of things in MS-DOS (In junior high I chose computer class because I knew I'd ace it, and I did)
- 2000 - 2002: My interest for programming started, up until then, computers told me what I could do with them, and I wanted to make computers do what I wanted them to
- 2002: My first C++ "Hello World" program int main { cout << "Hello world!"; return 0; }, also C++ basics (loops and control structures)
- 2003: C++ pointers and files, also data structures (I never got to study graphs though =()
- 2004: Started learning C# and asp.net on my own, I made my first asp.net real world application as social service for my university, it was a success! Although it was really poorly coded.
- 2004-2: Delphi, pascal, unix, as400, PHP, databases (loved databases, hated the rest)
- 2005: Got really good with C# and asp.net, started experimenting with Windows Apps
- 2006: They started teaching us the .net framework in school (although in VB, I asked the teacher if I could do my homework in C# and she said: NO! YOU GOTTA LEARN WHAT I TEACH YOU!) Also I learned a little bit of PROLOG, I thought it was fun
- 2007 - 2009: First programming job C# and asp.net (also database managing / programming)
- 2009: Second programming job C# and WPF (I'm currently here)

Yeah, I blame the NES.

Drawing the grid

2010-03-04T22:21:00.000-08:00

I ended up using a different method than what I explained in my previous post. The big difference is that I'm not using the list of visuals, and I'm not overriding the same stuff. My class still derives from framework, but since it isn't interactive (no clicks, mouse over, etc.) I didn't need to grab a visual, add that stuff, and put in the the list of visuals. Let's code.

First of all here's the project file.

Now, let us begin explaining.

The important thing here is to override the OnRender() method, why? Because at that time, the object inheriting from FrameworkElement already knows what's its DesiredSize (this is the size it WANTS to use to be drawn, the ActualSize is what its AFTER being drawn, by the end of the OnRender, the DesiredSize and ActualSize usually differ).

So, now that we know what size the grid desires to have, we can do something. In my case, I'm using that information to know how many grids and rows I'll draw, with some cool looking code, I was able to achieve that. Here's the code:

The CustomGrid:


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Media;

namespace GridTest
{
    public class CustomGrid : FrameworkElement
    {
        #region Dependency Properties

        private static double _minimumCellSize = 50;

        public double CellHeight
        {
            get { return (double)GetValue(CellHeightProperty); }
            set { SetValue(CellHeightProperty, value); }
        }

        public static readonly DependencyProperty CellHeightProperty =
            DependencyProperty.Register("CellHeight", typeof(double), typeof(CustomGrid), new UIPropertyMetadata(_minimumCellSize, VisualPropertyChangedCallback), new ValidateValueCallback(CellSizeValidateCallback));

        public double CellWidth
        {
            get { return (double)GetValue(CellWidthProperty); }
            set { SetValue(CellWidthProperty, value); }
        }

        public static readonly DependencyProperty CellWidthProperty =
            DependencyProperty.Register("CellWidth", typeof(double), typeof(CustomGrid), new UIPropertyMetadata(_minimumCellSize, VisualPropertyChangedCallback), new ValidateValueCallback(CellSizeValidateCallback));

        public Brush Stroke
        {
            get { return (Brush)GetValue(StrokeProperty); }
            set { SetValue(StrokeProperty, value); }
        }

        public static readonly DependencyProperty StrokeProperty =
            DependencyProperty.Register("Stroke", typeof(Brush), typeof(CustomGrid), new UIPropertyMetadata(Brushes.Transparent, VisualPropertyChangedCallback));

        public double StrokeThickness
        {
            get { return (double)GetValue(StrokeThicknessProperty); }
            set { SetValue(StrokeThicknessProperty, value); }
        }

        public static readonly DependencyProperty StrokeThicknessProperty =
            DependencyProperty.Register("StrokeThickness", typeof(double), typeof(CustomGrid), new UIPropertyMetadata(0E, VisualPropertyChangedCallback));

        public DashStyle DashStyle
        {
            get { return (DashStyle)GetValue(DashStyleProperty); }
            set { SetValue(DashStyleProperty, value); }
        }

        public static readonly DependencyProperty DashStyleProperty =
            DependencyProperty.Register("DashStyle", typeof(DashStyle), typeof(CustomGrid), new UIPropertyMetadata(new DashStyle(), VisualPropertyChangedCallback));

        // all the dependency properties are tied to this callback so the visual updates itself when any of them changes
        private static void VisualPropertyChangedCallback(DependencyObject o, DependencyPropertyChangedEventArgs e)
        {
            // this method invalidates the state of the visual, causing a render
            (o as CustomGrid).InvalidateVisual();
        }

        private static bool CellSizeValidateCallback(object target)
        {
            // just so the grid's height or width don't go below 50
            // this method is called by both Height and Width DependencyProperties
            if ((double)target < _minimumCellSize)
                return false;

            return true;
        }

        #endregion Dependency Properties

        #region Overrides

        // override drawing to draw the grid
        protected override void OnRender(DrawingContext drawingContext)
        {
            // get the RenderDesiredSize, and divide it by the size of its cells so we know how many cells to draw vertically
            int cellsVertically = (int)Math.Ceiling(this.RenderSize.Height / this.CellHeight);
            // same horizontally
            int cellsHorizontally = (int)Math.Ceiling(this.RenderSize.Width / this.CellWidth);

            // this offsets are used to move right or down to draw the next row or column
            double verticalOffset = 0;
            double horizontalOffset = 0;

            // the pen is defined here, with the stroke and thickness set in the xaml
            Pen pen = new Pen(this.Stroke, this.StrokeThickness);

            pen.DashStyle = this.DashStyle;

            // draw vertical cells
            for (int i = 0; i <= cellsHorizontally; i++)
            {
                for (int j = 0; j < cellsVertically; j++)
                {
                    drawingContext.DrawLine(pen,
                        new Point(horizontalOffset, verticalOffset),
                        new Point(horizontalOffset, this.CellHeight + verticalOffset));

                    verticalOffset += this.CellHeight;
                }

                horizontalOffset += this.CellWidth;
                verticalOffset = 0;
            }

            horizontalOffset = 0;
            verticalOffset = 0;

            // draw horizontal cells
            for (int i = 0; i <= cellsVertically; i++)
            {
                for (int j = 0; j < cellsHorizontally; j++)
                {
                    drawingContext.DrawLine(pen,
                        new Point(horizontalOffset, verticalOffset),
                        new Point(this.CellWidth + horizontalOffset, verticalOffset));

                    horizontalOffset += this.CellWidth;
                }

                verticalOffset += this.CellHeight;
                horizontalOffset = 0;
            }

            // and we're done! We're actally using the FrameworkElement's own DrawingContext,
            // so no need to add it anywhere or anything
        }

        #endregion Overrides
    }
}

The XAML:


<Window x:Class="GridTest.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="clr-namespace:GridTest"
    Title="Window2" Height="244" Width="600">
    <Grid>
        <!-- The sliders, textblocks, textboxes and stuff -->
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto" />
            <RowDefinition Height="Auto" />
            <RowDefinition Height="*" />
        </Grid.RowDefinitions>
        <Grid Grid.Row="0" Margin="5">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="Auto" />
                <ColumnDefinition Width="*" />
                <ColumnDefinition Width="Auto" />
            </Grid.ColumnDefinitions>
            <TextBlock Grid.Column="0" Text="Height:" Margin="5,0" VerticalAlignment="Center" Width="40" />
            <Slider Grid.Column="1" x:Name="theSliderX" Minimum="1" Maximum="1000" Value="25" />
            <TextBox Grid.Column="2" Text="{Binding ElementName=theSliderX, Path=Value, UpdateSourceTrigger=PropertyChanged}" VerticalAlignment="Center" Width="30" />
        </Grid>
        <Grid Grid.Row="1" Margin="5">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="Auto" />
                <ColumnDefinition Width="*" />
                <ColumnDefinition Width="Auto" />
            </Grid.ColumnDefinitions>
            <TextBlock Grid.Column="0" Text="Width:" Margin="5,0" VerticalAlignment="Center" Width="40" />
            <Slider Grid.Column="1" x:Name="theSliderY" Minimum="1" Maximum="1000" Value="25" />
            <TextBox Grid.Column="2" Text="{Binding ElementName=theSliderY, Path=Value, UpdateSourceTrigger=PropertyChanged}" VerticalAlignment="Center" Width="30" />
        </Grid>
        <!-- set the properties of the CustomGrid object -->
        <local:CustomGrid Grid.Row="2"
                          x:Name="CustomGrid"
                          CellHeight="{Binding ElementName=theSliderX, Path=Value}"
                          CellWidth="{Binding ElementName=theSliderY, Path=Value}"
                          Stroke="Brown"
                          StrokeThickness=".3"
                          HorizontalAlignment="Stretch"
                          VerticalAlignment="Stretch">
            <!-- This weird one sets the dashes for the Pen object to use to draw the lines -->
            <local:CustomGrid.DashStyle>
                <DashStyle Dashes="20,20" Offset="10" />
            </local:CustomGrid.DashStyle>
        </local:CustomGrid>
    </Grid>
</Window>

THE RESULT

Now, this seems a little more complex because I have all those crazy looking

DependencyProperties

to make the control a little more flexible, but if your grid will be one size, one color, one dash type, then you don't need all that crap.

Luckily, when you change the size of the container, it fires the OnRender() event, so you don't have to worry about handling that. However (pay attention here, this is important), I had a really hard time trying to find a way to trigger the OnRender() after modifying a property of the grid (change color, cell height, cell width, dashes, etc.), when I discovered this little method InvalidateVisual().

The InvalidateVisual() method, as it says, invalidates the visual state of your FrameworkElement derived object, which, fires the OnRender() again, hence, redraws the grid with all the new values (color, height, width, etc.), that is the reason I'm using it in the VisualPropertyChangedCallBack method, any time a visual property of the grid changes, it'll trigger that callback, and it'll redraw it.

Hope this helps you, I really had a hard time looking for a way to do this, so here I am, trying to save you that pain.

Thanks for reading! See you next post!

Drawing stuff

2010-03-03T22:39:00.000-08:00

Well, tomorrow I have to draw a grid for work... so here I am, almost 11pm, trying to find out how to. I thought I knew, but turns out I didn't. But hey! Now I do! But right now I haven't finalized the code to draw the grid, which is not important because it's just a set of equations, but I might post it later when it's finished. Btw, you can download the project here.

Anyway, to the point!

3 simple steps:

1. Your class must inherit from FrameworkElement (so WPF knows how to draw it)
2. Your class must have it's own collection of visuals
3. You must override: (a) VisualChildrenCount - To return the count of your collection of visuals, and (b) GetVisualChild(int index) - To get the correct visual from your collection of visuals.

Easy peasy.

Now, let's do some code. Here is my class:


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

namespace DrawingTest
{
    /// <summary>
    /// Interaction logic for Window1.xaml
    /// </summary>
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
        }
    }

    public class MyDrawings : FrameworkElement
    {
        public MyDrawings()
        {
            // call the draw method
            Draw();
        }

        private void Draw()
        {
            // create a visual, visuals help you draw
            DrawingVisual visual = new DrawingVisual();

            using (DrawingContext context = visual.RenderOpen())
            {
                // draw the first line
                context.DrawLine(new Pen(Brushes.Black, 1), new Point(0, 0), new Point(10, 100));
                // draw the second line
                context.DrawLine(new Pen(Brushes.Red, 1), new Point(10, 100), new Point(20, 50));
                // draw the third line
                context.DrawLine(new Pen(Brushes.Red, 1), new Point(20, 50), new Point(30, 100));
                // draw the fourth line
                context.DrawLine(new Pen(Brushes.Black, 1), new Point(30, 100), new Point(40, 0));

                // we'll end up with a weird looking red / black big W
            }

            // add your new visal to the list of visuals, you can go nuts adding stuff here, it'll show up!
            this._visuals.Add(visual);
            
            // this is required to stablish the relationship between the visual and your new control
            // (so the visual knows who it's Parent is, before this line visual.Parent will be null)
            AddVisualChild(visual);
        }

        private List<Visual> _visuals = new List<Visual>();

        // override VisualChildrenCount to...
        protected override int VisualChildrenCount
        {
            get
            {
                // ...return the count of your visuals collection, remember?
                return _visuals.Count;
            }
        }

        // override GetVisualChild to...
        protected override Visual GetVisualChild(int index)
        {
            // you might need an assert here, now an exception, but you get the idea
            if (index < 0 || index >= _visuals.Count)
                throw new IndexOutOfRangeException("index");

            // ...return the correct child in your collection, you don't want to return an empty visual do you?
            return _visuals[index];
        }
    }
}

XAML is pretty straight forward, just put your new drawing object there and that's it!


<Window x:Class="DrawingTest.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="clr-namespace:DrawingTest"
    Title="Window1" Height="300" Width="300">
    <Grid>
        <local:MyDrawings />  
    </Grid>
</Window>

Like I said, piece o' cake. Now you can add functionallity to this object (clicks, mouse over, and what not), but that is not in the scope of this post, I will post about that later on. For now, happy drawing!

ItemContainerGenerator

2010-02-19T20:12:00.000-08:00

I know I said I was going to talk about MVVM first, but I haven't found a chance to really write about it, and I don't just want to say stuff from the top of my head, so it'll have to wait. In the mean time...

Have you ever been in the situations where you have a ListBox, ComboBox or any other ItemsControl (TreeView, TabControl), and you need to get the selected item (note: NOT the object bound to it, the actual item: ListBoxItem, TreeViewItem, ComboBoxItem, etc.). I know I have, and just yesterday, after one year, I found the solution:


ListBox.ItemContainerGenerator.ContainerFromItem(object)


ListBox.ItemContainerGenerator.ContainerFromIndex(int);

Say you have this situation. A list of Persons bound to a ListBox, and for some reason you need to access the item, not the Person bound to it. Check out the following code:

C#:


    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
            // this returns a Crowd with a populated array of People objects
            this.DataContext = new Crowd(/* Populate */ true);
        }

        private void Button_Click(object sender, RoutedEventArgs e)
        {
            // gets the data context
            // if it weren't bound through WPF binding, it would return the ListBoxItem
            Person person = (Person)theListBox.SelectedItem;
            
            // gets the ListBoxItem, not the data context
            ListBoxItem itemFromObject = (ListBoxItem)theListBox.ItemContainerGenerator.ContainerFromItem(person);
            // or get it from the index
            ListBoxItem itemFromIndex = (ListBoxItem)theListBox.ItemContainerGenerator.ContainerFromIndex(theListBox.SelectedIndex);
        }
    }

XAML:


<Window x:Class="ItemContainerGeneratorTest.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Window1" Height="300" Width="300">
    <Grid Margin="8">
        <Grid.RowDefinitions>
            <RowDefinition Height="*" />
            <RowDefinition Height="Auto" />
        </Grid.RowDefinitions>
        <ListBox x:Name="theListBox"
                 Grid.Row="0"
                 ItemsSource="{Binding People}">
            <ListBox.ItemTemplate>
                <DataTemplate>
                    <StackPanel Orientation="Horizontal">
                        <TextBlock Margin="3" Text="{Binding FirstName}" />
                        <TextBlock Margin="3" Text="{Binding LastName}" />
                    </StackPanel>
                </DataTemplate>
            </ListBox.ItemTemplate>
        </ListBox>
        <Button Grid.Row="1" Content="Get selected item" Margin="0,8,0,0" Click="Button_Click" />
    </Grid>
</Window>

As you can see, the ListBox (theListBox) is bound through WPF, and I'm still able to get the ListBoxItem selected by the button in a very simple manner.

Hope this helps you as it is now helping me. Of course this is a very simplistic example, if you have a listbox with a couple hunders or thousands of items, or a tree with a very deep hierarchy, this will help you a lot.

Download project file

First post

2010-02-03T09:53:00.000-08:00

Ok, this is my second blog attempt. This time I'll be serious about it.

Next post will be about the MVVM pattern for WPF. Stay tuned.