Synnefo » Pithos MS Client

using System;

using System.Collections.Generic;

using System.ComponentModel.Composition;

using System.Diagnostics;

using System.Diagnostics.Contracts;

using System.Drawing;

using System.Linq;

using System.Runtime.InteropServices;

using System.Runtime.InteropServices.ComTypes;

using System.Text;

using Pithos.ShellExtensions.Properties;

namespace Pithos.ShellExtensions.Menus

{

    [ClassInterface(ClassInterfaceType.None)]

    [Guid("B1F1405D-94A1-4692-B72F-FC8CAF8B8700"), ComVisible(true)]

    public class FileContextMenu : IShellExtInit, IContextMenu

    {

        private static readonly log4net.ILog Log = log4net.LogManager.GetLogger("Pithos.FileContextMenu");

        private const string MenuHandlername = "Pithos.FileContextMenu";

        private readonly Dictionary<string, MenuItem> _items;

        [Import]

        public FileContext Context { get; set; }

        private IntPtr _gotoBitmap=IntPtr.Zero;

        private IntPtr _versionBitmap = IntPtr.Zero;

        private IntPtr _propertiesBitmap = IntPtr.Zero;

        public FileContextMenu()

        {                        

            _gotoBitmap = GetBitmapPtr(Resources.MenuGoToPithos);

            _versionBitmap = GetBitmapPtr(Resources.MenuHistory);

            _propertiesBitmap = GetBitmapPtr(Resources.MenuProperties);

            _items = new Dictionary<string, MenuItem>{

                {"gotoPithos",new MenuItem{

                                           MenuText = "&Go to Pithos",

                                            Verb = "gotoPithos",

                                             VerbCanonicalName = "PITHOSGoTo",

                                              VerbHelpText = "Go to Pithos",

                                               MenuDisplayId = 1,

                                               MenuCommand=OnGotoPithos,

                                               DisplayFlags=DisplayFlags.All,

                                               MenuBitmap = _gotoBitmap

                                           }},

                {"showProperties",new MenuItem{

                                           MenuText = "&Pithos Properties",

                                            Verb = "showProperties",

                                             VerbCanonicalName = "PITHOSProperties",

                                              VerbHelpText = "Pithos Properties",

                                               MenuDisplayId = 2,

                                               MenuCommand=OnShowProperties,

                                               DisplayFlags=DisplayFlags.All,

                                               MenuBitmap = _propertiesBitmap

                                           }}/*,

                {"prevVersions",new MenuItem{

                                           MenuText = "&Show Previous Versions",

                                            Verb = "prevVersions",

                                             VerbCanonicalName = "PITHOSPrevVersions",

                                              VerbHelpText = "Go to Pithos and display previous versions",

                                               MenuDisplayId = 3,

                                               MenuCommand=OnVerbDisplayFileName,

                                               DisplayFlags=DisplayFlags.File,

                                               MenuBitmap=_versionBitmap

                                           }}*/

            };

            IoC.Current.Compose(this);

        }

        ~FileContextMenu()

        {

            if (_gotoBitmap != IntPtr.Zero)

            {

                NativeMethods.DeleteObject(_gotoBitmap);

                _gotoBitmap= IntPtr.Zero;

            }

            if (_versionBitmap != IntPtr.Zero)

            {

                NativeMethods.DeleteObject(_versionBitmap);

                _versionBitmap = IntPtr.Zero;

            }

            if (_propertiesBitmap != IntPtr.Zero)

            {

                NativeMethods.DeleteObject(_propertiesBitmap);

                _propertiesBitmap = IntPtr.Zero;

            }

        }

        private static IntPtr GetBitmapPtr(Bitmap gotoBitmap)

        {

            gotoBitmap.MakeTransparent(gotoBitmap.GetPixel(0, 0));

            var hbitmap = gotoBitmap.GetHbitmap();

            return hbitmap;

        }

        void OnShowProperties(IntPtr hWnd)

        {

            var filePath = Context.CurrentFile ?? Context.CurrentFolder;

            if (String.IsNullOrWhiteSpace(filePath))

            {

                Debug.WriteLine("No current file or folder");

                return;

            }

            else

            {

                Debug.WriteLine("Will display properties for {0}",filePath);

            }

            using (var client = PithosHost.GetCommandsClient())

            {

                client.ShowProperties(Context.CurrentFile);

            }

        }

        void OnVerbDisplayFileName(IntPtr hWnd)

        {

            string message = String.Format("The selected file is {0}\r\n\r\nThe selected Path is {1}",

                                           Context.CurrentFile,

                                           Context.CurrentFolder);

            System.Windows.Forms.MessageBox.Show(

                message,

                "Pithos Shell Extensions");

            NativeMethods.SHChangeNotify(HChangeNotifyEventID.SHCNE_ASSOCCHANGED, HChangeNotifyFlags.SHCNF_IDLIST,

                                             IntPtr.Zero, IntPtr.Zero);

        }

        void OnGotoPithos(IntPtr hWnd)

        {

            var settings = Context.Settings;

            var activeAccount = settings.Accounts.FirstOrDefault(acc =>  Context.CurrentFile.StartsWith(acc.RootPath,StringComparison.InvariantCultureIgnoreCase));

            var address = String.Format("{0}/ui/?token={1}&user={2}",

                                        settings.PithosSite,

                                        activeAccount.ApiKey,

                                        Uri.EscapeUriString(activeAccount.AccountName));

            settings.Reload();

            Process.Start(address);

        }

        #region Shell Extension Registration

        [ComRegisterFunction]

        public static void Register(Type t)

        {

            try

            {

                ShellExtReg.RegisterShellExtContextMenuHandler(t.GUID, ".cs",

                    MenuHandlername);

                ShellExtReg.RegisterShellExtContextMenuHandler(t.GUID, "Directory",

                    MenuHandlername);

                ShellExtReg.RegisterShellExtContextMenuHandler(t.GUID, @"Directory\Background",

                    MenuHandlername);

                ShellExtReg.RegisterShellExtContextMenuHandler(t.GUID, "*",

                    MenuHandlername);

                //ShellExtReg.MarkApproved(t.GUID, MenuHandlername);

            }

            catch (Exception ex)

            {

                Console.WriteLine(ex.Message); // Log the error

                throw;  // Re-throw the exception

            }

        }

        [ComUnregisterFunction]

        public static void Unregister(Type t)

        {

            try

            {

                ShellExtReg.UnregisterShellExtContextMenuHandler(t.GUID, ".cs", MenuHandlername);

                ShellExtReg.UnregisterShellExtContextMenuHandler(t.GUID, "Directory", MenuHandlername);

                ShellExtReg.UnregisterShellExtContextMenuHandler(t.GUID, @"Directory\Background", MenuHandlername);

                ShellExtReg.UnregisterShellExtContextMenuHandler(t.GUID, "*", MenuHandlername);

                //ShellExtReg.RemoveApproved(t.GUID, MenuHandlername);

            }

            catch (Exception ex)

            {

                Console.WriteLine(ex.Message); // Log the error

                throw;  // Re-throw the exception

            }

        }

        #endregion

        #region IShellExtInit Members

        /// <summary>

        /// Initialize the context menu handler.

        /// </summary>

        /// <param name="pidlFolder">

        /// A pointer to an ITEMIDLIST structure that uniquely identifies a folder.

        /// </param>

        /// <param name="pDataObj">

        /// A pointer to an IDataObject interface object that can be used to retrieve 

        /// the objects being acted upon.

        /// </param>

        /// <param name="hKeyProgID">

        /// The registry key for the file object or folder type.

        /// </param>

        public void Initialize(IntPtr pidlFolder, IntPtr pDataObj, IntPtr hKeyProgID)

        {

            if(pDataObj == IntPtr.Zero && pidlFolder == IntPtr.Zero)

            {

                throw new ArgumentException("pidlFolder and pDataObj shouldn't be null at the same time");

            }

            Debug.WriteLine("Initializing", LogCategories.ShellMenu);

            if (pDataObj != IntPtr.Zero)

            {

                Debug.WriteLine("Got a data object", LogCategories.ShellMenu);

                FORMATETC fe = new FORMATETC();

                fe.cfFormat = (short)CLIPFORMAT.CF_HDROP;

                fe.ptd = IntPtr.Zero;

                fe.dwAspect = DVASPECT.DVASPECT_CONTENT;

                fe.lindex = -1;

                fe.tymed = TYMED.TYMED_HGLOBAL;

                STGMEDIUM stm = new STGMEDIUM();

                // The pDataObj pointer contains the objects being acted upon. In this 

                // example, we get an HDROP handle for enumerating the selected files 

                // and folders.

                IDataObject dataObject = (IDataObject)Marshal.GetObjectForIUnknown(pDataObj);

                dataObject.GetData(ref fe, out stm);

                try

                {

                    // Get an HDROP handle.

                    IntPtr hDrop = stm.unionmember;

                    if (hDrop == IntPtr.Zero)

                    {

                        throw new ArgumentException();

                    }

                    // Determine how many files are involved in this operation.

                    uint nFiles = NativeMethods.DragQueryFile(hDrop, UInt32.MaxValue, null, 0);

                    Debug.WriteLine(String.Format("Got {0} files", nFiles), LogCategories.ShellMenu);

                    // This code sample displays the custom context menu item when only 

                    // one file is selected. 

                    if (nFiles == 1)

                    {

                        // Get the path of the file.

                        var fileName = new StringBuilder(260);

                        if (0 == NativeMethods.DragQueryFile(hDrop, 0, fileName,

                                                             fileName.Capacity))

                        {

                            Marshal.ThrowExceptionForHR(WinError.E_FAIL);

                        }

                        Context.CurrentFile = fileName.ToString();

                    }

                    /* else

                     {

                         Marshal.ThrowExceptionForHR(WinError.E_FAIL);

                     }*/

                    // [-or-]

                    // Enumerate the selected files and folders.

                    //if (nFiles > 0)

                    //{

                    //    StringCollection selectedFiles = new StringCollection();

                    //    StringBuilder fileName = new StringBuilder(260);

                    //    for (uint i = 0; i < nFiles; i++)

                    //    {

                    //        // Get the next file name.

                    //        if (0 != NativeMethods.DragQueryFile(hDrop, i, fileName,

                    //            fileName.Capacity))

                    //        {

                    //            // Add the file name to the list.

                    //            selectedFiles.Add(fileName.ToString());

                    //        }

                    //    }

                    //

                    //    // If we did not find any files we can work with, throw 

                    //    // exception.

                    //    if (selectedFiles.Count == 0)

                    //    {

                    //        Marshal.ThrowExceptionForHR(WinError.E_FAIL);

                    //    }

                    //}

                    //else

                    //{

                    //    Marshal.ThrowExceptionForHR(WinError.E_FAIL);

                    //}

                }

                finally

                {

                    NativeMethods.ReleaseStgMedium(ref stm);

                }

            }

            if (pidlFolder != IntPtr.Zero)

            {

                Debug.WriteLine("Got a folder", LogCategories.ShellMenu);

                StringBuilder path = new StringBuilder();

                if (!NativeMethods.SHGetPathFromIDList(pidlFolder, path))

                {

                    int error = Marshal.GetHRForLastWin32Error();

                    Marshal.ThrowExceptionForHR(error);

                }

                Context.CurrentFolder = path.ToString();

                Debug.WriteLine(String.Format("Folder is {0}", Context.CurrentFolder), LogCategories.ShellMenu);

            }

        }

        #endregion

        #region IContextMenu Members

        /// <summary>

        /// Add commands to a shortcut menu.

        /// </summary>

        /// <param name="hMenu">A handle to the shortcut menu.</param>

        /// <param name="iMenu">

        /// The zero-based position at which to insert the first new menu item.

        /// </param>

        /// <param name="idCmdFirst">

        /// The minimum value that the handler can specify for a menu item ID.

        /// </param>

        /// <param name="idCmdLast">

        /// The maximum value that the handler can specify for a menu item ID.

        /// </param>

        /// <param name="uFlags">

        /// Optional flags that specify how the shortcut menu can be changed.

        /// </param>

        /// <returns>

        /// If successful, returns an HRESULT value that has its severity value set 

        /// to SEVERITY_SUCCESS and its code value set to the offset of the largest 

        /// command identifier that was assigned, plus one.

        /// </returns>

        public int QueryContextMenu(

            IntPtr hMenu,

            uint iMenu,

            uint idCmdFirst,

            uint idCmdLast,

            uint uFlags)

        {

            Debug.WriteLine("Start qcm", LogCategories.ShellMenu);

            // If uFlags include CMF_DEFAULTONLY then we should not do anything.

            Debug.WriteLine(String.Format("Flags {0}", uFlags), LogCategories.ShellMenu);

            if (((uint)CMF.CMF_DEFAULTONLY & uFlags) != 0)

            {

                Debug.WriteLine("Default only flag, returning", LogCategories.ShellMenu);

                return WinError.MAKE_HRESULT(WinError.SEVERITY_SUCCESS, 0, 0);

            }

            if (!Context.IsManaged)

            {

                Debug.WriteLine("Not a PITHOS folder",LogCategories.ShellMenu);

                return WinError.MAKE_HRESULT(WinError.SEVERITY_SUCCESS, 0, 0);

            }

            /*

                        if (!selectedFolder.ToLower().Contains("pithos"))

                            return WinError.MAKE_HRESULT(WinError.SEVERITY_SUCCESS, 0, 0);

            */

            // Use either InsertMenu or InsertMenuItem to add menu items.

            uint largestID = 0;

            DisplayFlags itemType = (Context.IsFolder) ? DisplayFlags.Folder : DisplayFlags.File;

            Debug.WriteLine(String.Format("Item Flags {0}", itemType), LogCategories.ShellMenu);

            if (!NativeMethods.InsertMenu(hMenu, idCmdFirst, MF.MF_SEPARATOR | MF.MF_BYPOSITION, 0, String.Empty))

            {

                Log.ErrorFormat("Error adding separator 1\r\n{0}", Marshal.GetLastWin32Error());

                return Marshal.GetHRForLastWin32Error();

            }

            foreach (var menuItem in _items.Values)

            {

                Debug.WriteLine(String.Format("Menu Flags {0}", menuItem.DisplayFlags), LogCategories.ShellMenu);

                if ((itemType & menuItem.DisplayFlags) != DisplayFlags.None)

                {

                    Debug.WriteLine("Adding Menu", LogCategories.ShellMenu);

                    MENUITEMINFO mii = menuItem.CreateInfo(idCmdFirst);

                    if (!NativeMethods.InsertMenuItem(hMenu, iMenu, true, ref mii))

                    {

                        var lastError = Marshal.GetLastWin32Error();

                        var lastErrorHR = Marshal.GetHRForLastWin32Error();

                        return lastErrorHR;

                    }

                    if (largestID < menuItem.MenuDisplayId)

                        largestID = menuItem.MenuDisplayId;

                }

            }

            Debug.Write("Adding Separator 1", LogCategories.ShellMenu);

            // Add a separator.

           /* MENUITEMINFO sep = new MENUITEMINFO();

            sep.cbSize = (uint)Marshal.SizeOf(sep);

            sep.fMask = MIIM.MIIM_TYPE;

            sep.fType = MFT.MFT_SEPARATOR;*/

            if (!NativeMethods.InsertMenu(hMenu, (uint)_items.Values.Count + idCmdFirst+1,MF.MF_SEPARATOR|MF.MF_BYPOSITION, 0, String.Empty))

            {

                Log.ErrorFormat("Error adding separator 1\r\n{0}", Marshal.GetLastWin32Error());

                return Marshal.GetHRForLastWin32Error();

            }

            Debug.WriteLine("Menus added", LogCategories.ShellOverlays);

            // Return an HRESULT value with the severity set to SEVERITY_SUCCESS. 

            // Set the code value to the offset of the largest command identifier 

            // that was assigned, plus one (1).

            return WinError.MAKE_HRESULT(WinError.SEVERITY_SUCCESS, 0,

                largestID + 1);

        }

        /// <summary>

        /// Carry out the command associated with a shortcut menu item.

        /// </summary>

        /// <param name="pici">

        /// A pointer to a CMINVOKECOMMANDINFO or CMINVOKECOMMANDINFOEX structure 

        /// containing information about the command. 

        /// </param>

        public void InvokeCommand(IntPtr pici)

        {

            bool isUnicode = false;

            // Determine which structure is being passed in, CMINVOKECOMMANDINFO or 

            // CMINVOKECOMMANDINFOEX based on the cbSize member of lpcmi. Although 

            // the lpcmi parameter is declared in Shlobj.h as a CMINVOKECOMMANDINFO 

            // structure, in practice it often points to a CMINVOKECOMMANDINFOEX 

            // structure. This struct is an extended version of CMINVOKECOMMANDINFO 

            // and has additional members that allow Unicode strings to be passed.

            CMINVOKECOMMANDINFO ici = (CMINVOKECOMMANDINFO)Marshal.PtrToStructure(

                pici, typeof(CMINVOKECOMMANDINFO));

            CMINVOKECOMMANDINFOEX iciex = new CMINVOKECOMMANDINFOEX();

            if (ici.cbSize == Marshal.SizeOf(typeof(CMINVOKECOMMANDINFOEX)))

            {

                if ((ici.fMask & CMIC.CMIC_MASK_UNICODE) != 0)

                {

                    isUnicode = true;

                    iciex = (CMINVOKECOMMANDINFOEX)Marshal.PtrToStructure(pici,

                        typeof(CMINVOKECOMMANDINFOEX));

                }

            }

            // Determines whether the command is identified by its offset or verb.

            // There are two ways to identify commands:

            // 

            //   1) The command's verb string 

            //   2) The command's identifier offset

            // 

            // If the high-order word of lpcmi->lpVerb (for the ANSI case) or 

            // lpcmi->lpVerbW (for the Unicode case) is nonzero, lpVerb or lpVerbW 

            // holds a verb string. If the high-order word is zero, the command 

            // offset is in the low-order word of lpcmi->lpVerb.

            // For the ANSI case, if the high-order word is not zero, the command's 

            // verb string is in lpcmi->lpVerb. 

            if (!isUnicode && NativeMethods.HighWord(ici.verb.ToInt32()) != 0)

            {

                // Is the verb supported by this context menu extension?

                string verbAnsi = Marshal.PtrToStringAnsi(ici.verb);

                if (_items.ContainsKey(verbAnsi))

                {

                    _items[verbAnsi].MenuCommand(ici.hwnd);

                }

                else

                {

                    // If the verb is not recognized by the context menu handler, it 

                    // must return E_FAIL to allow it to be passed on to the other 

                    // context menu handlers that might implement that verb.

                    Marshal.ThrowExceptionForHR(WinError.E_FAIL);

                }

            }

                // For the Unicode case, if the high-order word is not zero, the 

            // command's verb string is in lpcmi->lpVerbW. 

            else if (isUnicode && NativeMethods.HighWord(iciex.verbW.ToInt32()) != 0)

            {

                // Is the verb supported by this context menu extension?

                string verbUTF = Marshal.PtrToStringUni(iciex.verbW);

                if (_items.ContainsKey(verbUTF))

                {

                    _items[verbUTF].MenuCommand(ici.hwnd);

                }

                else

                {

                    // If the verb is not recognized by the context menu handler, it 

                    // must return E_FAIL to allow it to be passed on to the other 

                    // context menu handlers that might implement that verb.

                    Marshal.ThrowExceptionForHR(WinError.E_FAIL);

                }

            }

                // If the command cannot be identified through the verb string, then 

            // check the identifier offset.

            else

            {

                // Is the command identifier offset supported by this context menu 

                // extension?

                int menuID = NativeMethods.LowWord(ici.verb.ToInt32());

                var menuItem = _items.FirstOrDefault(item => item.Value.MenuDisplayId == menuID).Value;

                if (menuItem != null)

                {

                    menuItem.MenuCommand(ici.hwnd);

                }

                else

                {

                    // If the verb is not recognized by the context menu handler, it 

                    // must return E_FAIL to allow it to be passed on to the other 

                    // context menu handlers that might implement that verb.

                    Marshal.ThrowExceptionForHR(WinError.E_FAIL);

                }

            }

        }

        /// <summary>

        /// Get information about a shortcut menu command, including the help string 

        /// and the language-independent, or canonical, name for the command.

        /// </summary>

        /// <param name="idCmd">Menu command identifier offset.</param>

        /// <param name="uFlags">

        /// Flags specifying the information to return. This parameter can have one 

        /// of the following values: GCS_HELPTEXTA, GCS_HELPTEXTW, GCS_VALIDATEA, 

        /// GCS_VALIDATEW, GCS_VERBA, GCS_VERBW.

        /// </param>

        /// <param name="pReserved">Reserved. Must be IntPtr.Zero</param>

        /// <param name="pszName">

        /// The address of the buffer to receive the null-terminated string being 

        /// retrieved.

        /// </param>

        /// <param name="cchMax">

        /// Size of the buffer, in characters, to receive the null-terminated string.

        /// </param>

        public void GetCommandString(

            UIntPtr idCmd,

            uint uFlags,

            IntPtr pReserved,

            StringBuilder pszName,

            uint cchMax)

        {

            uint menuID = idCmd.ToUInt32();

            var menuItem = _items.FirstOrDefault(item => item.Value.MenuDisplayId == menuID).Value;

            if (menuItem != null)

            {

                switch ((GCS)uFlags)

                {

                    case GCS.GCS_VERBW:

                        if (menuItem.VerbCanonicalName.Length > cchMax - 1)

                        {

                            Marshal.ThrowExceptionForHR(WinError.STRSAFE_E_INSUFFICIENT_BUFFER);

                        }

                        else

                        {

                            pszName.Clear();

                            pszName.Append(menuItem.VerbCanonicalName);

                        }

                        break;

                    case GCS.GCS_HELPTEXTW:

                        if (menuItem.VerbHelpText.Length > cchMax - 1)

                        {

                            Marshal.ThrowExceptionForHR(WinError.STRSAFE_E_INSUFFICIENT_BUFFER);

                        }

                        else

                        {

                            pszName.Clear();

                            pszName.Append(menuItem.VerbHelpText);

                        }

                        break;

                }

            }

        }

        #endregion

    }

}