Naresh.Jois » .net

Zune Window in WPF

naresh — Mon, 04 Jul 2011 10:30:53 +0000

I have become a huge fan of Metro UI design and i really like the Zune interface and the starting point would be the custom chrome so i searched a bit and found this neat little thing , thought I would share

 /// 
    /// Borderless Window Behavior
    /// 
    public class BorderlessWindowBehavior : Behavior<window>
    {
        #region Native Methods
 
        [StructLayout(LayoutKind.Sequential)]
        public struct MARGINS
        {
            public int leftWidth;
            public int rightWidth;
            public int topHeight;
            public int bottomHeight;
        }
 
        [DllImport("dwmapi.dll")]
        private static extern int DwmExtendFrameIntoClientArea(IntPtr hWnd, ref MARGINS pMarInset);
 
        /// 
        /// POINT aka POINTAPI
        /// 
        [StructLayout(LayoutKind.Sequential)]
        public struct POINT
        {
            /// 
            /// x coordinate of point.
            /// 
            public int x;
 
            /// 
            /// y coordinate of point.
            /// 
            public int y;
 
            /// 
            /// Construct a point of coordinates (x,y).
            /// 
            public POINT(int x, int y)
            {
                this.x = x;
                this.y = y;
            }
        }
 
        [StructLayout(LayoutKind.Sequential)]
        public struct MINMAXINFO
        {
            public POINT ptReserved;
            public POINT ptMaxSize;
            public POINT ptMaxPosition;
            public POINT ptMinTrackSize;
            public POINT ptMaxTrackSize;
        };
 
        /// 
        /// 
        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
        public class MONITORINFO
        {
            public int cbSize = Marshal.SizeOf(typeof(MONITORINFO));
 
            public RECT rcMonitor = new RECT();
 
            public RECT rcWork = new RECT();
 
            public int dwFlags = 0;
        }
 
 
        ///  Win32 
        [StructLayout(LayoutKind.Sequential, Pack = 0)]
        public struct RECT
        {
            /// 
            /// Win32
            /// 
            public int left;
 
            /// 
            /// Win32
            /// 
            public int top;
 
            /// 
            /// Win32
            /// 
            public int right;
 
            /// 
            /// Win32
            /// 
            public int bottom;
 
            /// 
            /// Win32
            /// 
            public static readonly RECT Empty = new RECT();
 
            /// 
            /// Win32
            /// 
            public int Width
            {
                // Abs needed for BIDI OS
                get { return Math.Abs(right - left); }  
            }
 
            /// 
            /// Win32
            /// 
            public int Height
            {
                get { return bottom - top; }
            }
 
            /// 
            /// Win32
            /// 
            /// The left.
            /// The top.
            /// The right.
            /// The bottom.
            public RECT(int left, int top, int right, int bottom)
            {
                this.left = left;
                this.top = top;
                this.right = right;
                this.bottom = bottom;
            }
 
            /// 
            /// Win32
            /// 
            /// The rc SRC.
            public RECT(RECT rcSrc)
            {
                this.left = rcSrc.left;
                this.top = rcSrc.top;
                this.right = rcSrc.right;
                this.bottom = rcSrc.bottom;
            }
 
            /// 
            /// Win32
            /// 
            /// 
            ///   true if this instance is empty; otherwise, false.
            /// 
            public bool IsEmpty
            {
                get
                {
                    // BUGBUG : On Bidi OS (hebrew arabic) left > right
                    return left >= right || top >= bottom;
                }
            }
 
            /// 
            /// Return a user friendly representation of this struct
            /// 
            /// 
            /// A  that represents this instance.
            /// 
            public override string ToString()
            {
                if (this == RECT.Empty) 
                    return "RECT {Empty}";
 
                return String.Format("RECT {{ left : {0} / top : {1} / right : {2} / bottom : {3} }}", left, top, right, bottom);
            }
 
            /// 
            /// Determine if 2 RECT are equal (deep compare)
            /// 
            /// The  to compare with this instance.
            /// 
            ///   true if the specified  is equal to this instance; otherwise, false.
            /// 
            public override bool Equals(object obj)
            {
                if (!(obj is Rect))
                    return false;
 
                return (this == (RECT)obj);
            }
 
            /// 
            /// Return the HashCode for this struct (not guaranteed to be unique)
            /// 
            /// 
            /// A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. 
            /// 
            public override int GetHashCode()
            {
                return left.GetHashCode() + top.GetHashCode() + right.GetHashCode() + bottom.GetHashCode();
            }
 
            /// 
            /// Determine if 2 RECT are equal (deep compare)
            /// 
            /// The rect1.
            /// The rect2.
            /// 
            /// The result of the operator.
            /// 
            public static bool operator ==(RECT rect1, RECT rect2)
            {
                return (rect1.left == rect2.left && rect1.top == rect2.top && rect1.right == rect2.right && rect1.bottom == rect2.bottom);
            }
 
            /// 
            /// Determine if 2 RECT are different (deep compare)
            /// 
            /// The rect1.
            /// The rect2.
            /// 
            /// The result of the operator.
            /// 
            public static bool operator !=(RECT rect1, RECT rect2)
            {
                return !(rect1 == rect2);
            }
        }
 
        /// 
        /// Gets the monitor info.
        /// 
        /// The h monitor.
        /// The lpmi.
        /// 
        [DllImport("user32")]
        internal static extern bool GetMonitorInfo(IntPtr hMonitor, MONITORINFO lpmi);
 
        /// 
        /// Monitors from window.
        /// 
        /// The handle.
        /// The flags.
        /// 
        [DllImport("User32")]
        internal static extern IntPtr MonitorFromWindow(IntPtr handle, int flags);
 
        /// 
        /// Wms the get min max info.
        /// 
        /// The HWND.
        /// The l param.
        private static void WmGetMinMaxInfo(System.IntPtr hwnd, System.IntPtr lParam)
        {
            MINMAXINFO mmi = (MINMAXINFO)Marshal.PtrToStructure(lParam, typeof(MINMAXINFO));
 
            // Adjust the maximized size and position to fit the work area of the correct monitor
            int MONITOR_DEFAULTTONEAREST = 0x00000002;
            System.IntPtr monitor = MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST);
 
            if (monitor != System.IntPtr.Zero)
            {
                MONITORINFO monitorInfo = new MONITORINFO();
                GetMonitorInfo(monitor, monitorInfo);
                RECT rcWorkArea = monitorInfo.rcWork;
                RECT rcMonitorArea = monitorInfo.rcMonitor;
                mmi.ptMaxPosition.x = Math.Abs(rcWorkArea.left - rcMonitorArea.left);
                mmi.ptMaxPosition.y = Math.Abs(rcWorkArea.top - rcMonitorArea.top);
                mmi.ptMaxSize.x = Math.Abs(rcWorkArea.right - rcWorkArea.left);
                mmi.ptMaxSize.y = Math.Abs(rcWorkArea.bottom - rcWorkArea.top);
            }
 
            Marshal.StructureToPtr(mmi, lParam, true);
        }
 
        /// 
        /// Defs the window proc.
        /// 
        /// The HWND.
        /// The MSG.
        /// The w param.
        /// The l param.
        /// 
        [DllImport("user32.dll")]
        public static extern IntPtr DefWindowProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam);
 
        #endregion
 
        private const int WM_NCCALCSIZE = 0x83;
        private const int WM_NCPAINT = 0x85;
        private const int WM_NCACTIVATE = 0x86;
        private const int WM_GETMINMAXINFO = 0x24;
 
        private HwndSource m_hwndSource;
        private IntPtr m_hwnd;
 
        public static DependencyProperty ResizeWithGripProperty = DependencyProperty.Register("ResizeWithGrip", typeof(bool), typeof(BorderlessWindowBehavior), new PropertyMetadata(true));
 
        /// 
        /// Gets or sets a value indicating whether [resize with grip].
        /// 
        /// 
        ///   true if [resize with grip]; otherwise, false.
        /// 
        public bool ResizeWithGrip
        {
            get { return (bool)GetValue(ResizeWithGripProperty); }
            set { SetValue(ResizeWithGripProperty, value); }
        }
 
        /// 
        /// Called after the behavior is attached to an AssociatedObject.
        /// 
        protected override void OnAttached()
        {
            if (AssociatedObject.IsInitialized)
                AddHwndHook();
            else
                AssociatedObject.SourceInitialized += AssociatedObject_SourceInitialized;
 
            AssociatedObject.WindowStyle = WindowStyle.None;
            AssociatedObject.ResizeMode = ResizeWithGrip ? ResizeMode.CanResizeWithGrip : ResizeMode.CanResize;
 
            base.OnAttached();
        }
 
        /// 
        /// Called when the behavior is being detached from its AssociatedObject, but before it has actually occurred.
        /// 
        protected override void OnDetaching()
        {
            RemoveHwndHook();
            base.OnDetaching();
        }
 
        /// 
        /// Adds the HWND hook.
        /// 
        private void AddHwndHook()
        {
            m_hwndSource = HwndSource.FromVisual(AssociatedObject) as HwndSource;
            m_hwndSource.AddHook(HwndHook);
            m_hwnd = new WindowInteropHelper(AssociatedObject).Handle;
        }
 
        /// 
        /// Removes the HWND hook.
        /// 
        private void RemoveHwndHook()
        {
            AssociatedObject.SourceInitialized -= AssociatedObject_SourceInitialized;
            m_hwndSource.RemoveHook(HwndHook);
        }
 
        /// 
        /// Handles the SourceInitialized event of the AssociatedObject control.
        /// 
        /// The source of the event.
        /// The  instance containing the event data.
        private void AssociatedObject_SourceInitialized(object sender, EventArgs e)
        {
            AddHwndHook();
        }
 
        /// 
        /// HWNDs the hook.
        /// 
        /// The h WND.
        /// The message.
        /// The w param.
        /// The l param.
        /// if set to true [handled].
        /// 
        private IntPtr HwndHook(IntPtr hWnd, int message, IntPtr wParam, IntPtr lParam, ref bool handled)
        {
            IntPtr returnval = IntPtr.Zero;
 
            switch (message)
            {
                case WM_NCCALCSIZE:
                    /* Hides the border */
                    handled = true;
                    break;
                case WM_NCPAINT:
                    {
                        if (Environment.OSVersion.Version.Major >= 6)
                        {
                            var m = new MARGINS { bottomHeight = 1, leftWidth = 1, rightWidth = 1, topHeight = 1 };
                            DwmExtendFrameIntoClientArea(m_hwnd, ref m);
                        }
                        handled = true;
                    }
                    break;
                case WM_NCACTIVATE:
                    {
                        /* As per http://msdn.microsoft.com/en-us/library/ms632633(VS.85).aspx , "-1" lParam
                         * "does not repaint the nonclient area to reflect the state change." */
                        returnval = DefWindowProc(hWnd, message, wParam, new IntPtr(-1));
                        handled = true;
                    }
                    break;
                case WM_GETMINMAXINFO:
                    /* From Lester's Blog (thanks @aeoth):  
                     * http://blogs.msdn.com/b/llobo/archive/2006/08/01/maximizing-window-_2800_with-windowstyle_3d00_none_2900_-considering-taskbar.aspx */
                    WmGetMinMaxInfo(hWnd, lParam);
                    handled = true;
                    break;
            }
 
            return returnval;
        }
    }
}
window>

Play with Clay

naresh — Fri, 03 Jun 2011 08:13:10 +0000

I have been a big fan of ExpandoObject ever since it was introduced with .net 4.0, and I have been using the Expando Object object ever since, but I always felt that it was not enough, ExpandoObject was fun and all but it was just not enough, and me being really lazy remember coying and pasting code just to loop through properties of a class using reflection and all that headache.

Enter Clay : The moment I have laid my eyes on this beautiful piece of code, I have become a huge fan, and it has all the things the expando should have been.

So How do you begin , Its really simple and also follows unique naming convention you begin with a clay object with New (emphasis on uppercase ‘N’)

dynamic New = new ClayFactory();
var cUser = New.User();

and thats it,
In Clay Indexer Syntax and Property Accessors are the same so

cUser.Name = cUser["Name"];

you can pass anonymous objects and also accepts named arguments, you can also use jQuery style chain able setters or put use them as an array

var cUser = New.User(new { Name = "Naresh", Mail = "something@mail.com" });
var cUser = New.User( Name : "Naresh", Mail : "something@mail.com");
var cUser = New.User().Name("Naresh").Mail("something@mail.com");
var Users = New.Array(
           New.User().Name("Naresh").Mail("something@mail.com"),
           New.User().Name("Rakesh").Mail("something@mail.com")
);

So What are you waiting for get started at
clay.codeplex.com

Using Linq to Find a Control

naresh — Fri, 29 Oct 2010 11:04:04 +0000

I think Every one has one time or the other tried to find a control by looping over and find the required control, but we can use Linq to do the same thing.

 public static class PageExtensions
    {
        public static IEnumerable<control> All(this ControlCollection controls)
        {
            foreach (Control control in controls)
            {
                foreach (Control grandChild in control.Controls.All())
                    yield return grandChild;
 
                yield return control;
            }
        }
    }
control>

Then you can use as a Linq Expression

var ctrls = controls.All().Where(c => c.GetType() == typeof(Button));

Mix and Mash Asp.net MVC with Webforms

naresh — Fri, 29 Oct 2010 07:48:26 +0000

A lot of people including me wanted to to get on the bandwagon of ASP.net MVC, but the main problem is we do not always get to start new projects and there is always a timeline hanging. I will not talk about the benefits of MVC Pattern as most of us already aware of it, But for an ASP.net Developer where everything is tied up in Webforms this may seem difficult, but once you start taking advantages of this pattern, the usefulness becomes obvious, me having worked on Rails and PHP frameworks such as CodeIgnitor and CakePHP, It was never a question of If, but when, and the best way to begin would be use your existing skills with webforms and start bringin in MVC Pattern, and before you know it you can be completely taking the benefits out of both worlds.

Webforms with MVC

If you are starting with a new project its really simple, start of with a new MVC Project in Visual Studio Add a New Webform run it and thats it no configuration required, the reason is that because MVC Framework is built on top of same ASP.net platform, it runs and the reason why the routing doesn’t try and hijack this request is because of the way it works, if the physical file of the request exists the request is always made to the aspx file, for better performance and save disk query on each .aspx request you can also add the following line in your global.asax

public static void RegisterRoutes(RouteCollection routes)
        {
 
            routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
            routes.IgnoreRoute("{resource}.aspx/{*pathInfo}");
 
            routes.MapRoute(
                "Default", // Route name
                "{controller}/{action}/{id}", // URL with parameters
                new { controller = "Home", action = "Index", id = UrlParameter.Optional } // Parameter defaults
            );
 
        }

MVC with Webforms

But most of us never start with new projects right ?, so you have to do a bit more work, Add the following as Reference to your Web Application

Now Update your web.config to reflect

  .web>
     debug="true" targetFramework="4.0">
      >
         assembly="System.Web.Abstractions, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" />
         assembly="System.Web.Routing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" />
         assembly="System.Web.Mvc, Version=2.0.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" />
      >
    >
    >
      >
         namespace="System.Web.Mvc" />
         namespace="System.Web.Mvc.Ajax" />
         namespace="System.Web.Mvc.Html" />
         namespace="System.Web.Routing" />
      >
    >
......
>

Add the following code to global.asax

 public static void RegisterRoutes(RouteCollection routes)
        {
            routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
            routes.IgnoreRoute("{resource}.aspx/{*pathInfo}");
            routes.MapRoute(
                "Default", // Route name
                "{controller}/{action}/{id}", // URL with parameters
                new { controller = "Home", action = "Index", id = UrlParameter.Optional } // Parameter defaults
            );
 
        }
 
 
 
        void Application_Start(object sender, EventArgs e)
        {
            AreaRegistration.RegisterAllAreas();
 
            RegisterRoutes(RouteTable.Routes);
 
        }

Now Add the Controllers, Views, Folders to the root of application and you are good to go:

Home Controller – /Controllers/HomeControllers.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
 
namespace WebApp.Test.Controllers
{
    [HandleError]
    public class HomeController : Controller
    {
        public ActionResult Index()
        {
            ViewData["Message"] = "Welcome to ASP.NET MVC!";
 
            return View();
        }
    }
}

View – /Views/Home/Index.aspx

< %@ Page Language="C#" MasterPageFile="~/Site.Master" Inherits="System.Web.Mvc.ViewPage" %>
 
<asp:content ID="Content1" ContentPlaceHolderID="HeadContent" runat="server">
asp:content>
<asp:content ID="Content2" ContentPlaceHolderID="MainContent" runat="server">
  <h2>< %: ViewData["Message"] %>h2>
    <p>
        To learn more about ASP.NET MVC visit <a href="http://asp.net/mvc" title="ASP.NET MVC Website">http://asp.net/mvc.
    p>
asp:content>

You can even use the same Master Page

P.S: The VS Project doesn’t support integrated way of creating Views and Controllers in this method

Cascade Delete with Linq2SQL

naresh — Tue, 22 Dec 2009 17:46:52 +0000

Consider this, you have Invoice and Invioce details in 2 tables and the details are referenced by InvoiceId, What happens to Invoice Details once you delete the invoice ?, In SQL atleast you can do cascade delete and also set the value to null, but most real life programs would want to delete the details, Linq2SQL by default tries to set a null value which in most cases fails, and there is no visual way to set this the only way to do this is to do some manual xml editing.
Right click and open the .dbml file with the XML Editor and then navigate to the table for which you want to do this, then look for the relation which references the parent table

 Name="...." Member="...." ThisKey="...." OtherKey="...." Type="...." IsForeignKey="true" />

Now add DeleteOnNull=”true” to this association so this behaves as expected

 Name="...." Member="...." ThisKey="...." OtherKey="...." Type="...." IsForeignKey="true" DeleteOnNull="true" />

My latest Work on WPF

naresh — Fri, 02 Jan 2009 18:19:24 +0000

WPF has been here for quite a while now and i done some basic projects on wpf, but for the last two months i had the opportunity to completely work on WPF, not just WPF but also used Linq2SQL as the base for the complete application, wet my hands with ADO.net Entity Model and lot of work in Expression Blend,
The software was for KPCC and it an complete automation and information management system for them, I will not reveal much more, but a few screens which are not part of the NDA have been posted here,