Synnefo » Pithos MS Client

#region

/* -----------------------------------------------------------------------

 * <copyright file="IconOverlayBase.cs" company="GRNet">

 * 

 * Copyright 2011-2012 GRNET S.A. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or

 * without modification, are permitted provided that the following

 * conditions are met:

 *

 *   1. Redistributions of source code must retain the above

 *      copyright notice, this list of conditions and the following

 *      disclaimer.

 *

 *   2. Redistributions in binary form must reproduce the above

 *      copyright notice, this list of conditions and the following

 *      disclaimer in the documentation and/or other materials

 *      provided with the distribution.

 *

 *

 * THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 * POSSIBILITY OF SUCH DAMAGE.

 *

 * The views and conclusions contained in the software and

 * documentation are those of the authors and should not be

 * interpreted as representing official policies, either expressed

 * or implied, of GRNET S.A.

 * </copyright>

 * -----------------------------------------------------------------------

 */

#endregion

using System;

using System.Diagnostics;

using System.Diagnostics.Contracts;

using System.IO;

using System.ComponentModel.Composition;

using System.Linq;

using Microsoft.Win32;

using Pithos.Interfaces;

namespace Pithos.ShellExtensions.Overlays

{

    public class IconOverlayBase : IShellIconOverlayIdentifier

    {

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

        protected static string PithosPrefix = "0Pithos";

        public string OverlayName { get; private set; }

        public string IconPath { get; private set; }

        [Import(typeof (IStatusChecker))] 

        public IStatusChecker StatusChecker;

        [Import(typeof (IPithosSettings))] 

        public IPithosSettings Settings;

        public IconOverlayBase(string iconName)

        {

            if (String.IsNullOrWhiteSpace(iconName))

                throw new ArgumentNullException("iconName","Empty iconName");

            Debug.WriteLine("Icon Overlay Instance created", LogCategories.ShellOverlays);

            IoC.Current.Compose(this);

            string overlayName=PithosPrefix + iconName;

            string iconFile = iconName + "Icon.ico";

            var iconsFolder = Settings.IconsPath;

            var fullPath = Path.Combine(iconsFolder, iconFile);

            OverlayName = overlayName;

            IconPath = fullPath;

        }

        private static bool? _isExplorer = false;

        private bool IsExplorer

        {

            get

            {

                if (!_isExplorer.HasValue)

                {

                    var moduleName = Process.GetCurrentProcess().MainModule.ModuleName;

                    _isExplorer = (moduleName == "explorer.exe");

                }

                return _isExplorer.Value;

            }

        }

        public int IsMemberOf(string path, uint attributes)

        {

            var showOnlyInExplorer=(int)Registry.LocalMachine.GetValue(@"SOFTWARE\GRNet\Pithos\ShowOnlyInExplorer", 0);

            if (showOnlyInExplorer!=0 && !IsExplorer)

                return WinError.S_FALSE;

            if (String.IsNullOrWhiteSpace(path))

                throw new ArgumentNullException("path","Empty path");

            Debug.WriteLine(String.Format("ICON Status check for {0} - {1}", path, GetType().Name), LogCategories.ShellOverlays);

            if (!Settings.Accounts.Any(account=>account.RootPath!=null && path.StartsWith(account.RootPath,StringComparison.InvariantCultureIgnoreCase)))

                return WinError.S_FALSE;

            var status=StatusChecker.GetFileOverlayStatus(path);

            var isMember = (PithosPrefix + status == OverlayName);

            Debug.WriteLine(String.Format("[STATUS] Was {0}, expected {1} for {2}", status, OverlayName,path ), LogCategories.ShellOverlays);

            return isMember ? WinError.S_OK : WinError.S_FALSE;

        }

        public int GetOverlayInfo(

            IntPtr iconFileBuffer,

            int iconFileBufferSize,

            out int iconIndex,

            out uint flags)

        {

            Contract.Requires(iconFileBuffer!=IntPtr.Zero);

            Contract.Requires(iconFileBufferSize>0);

            if (iconFileBuffer == IntPtr.Zero)

                throw new ArgumentNullException("iconFileBuffer","iconFileBuffer not initialized");

            if (iconFileBufferSize<=0)

                throw new ArgumentException("iconFileBufferSize", "iconFileBufferSize must be greatere than 0");

            Debug.WriteLine("Looking for icons", LogCategories.ShellOverlays);

            Debug.WriteLine(string.Format("ICON file {0}", IconPath), LogCategories.ShellOverlays);

            int bytesCount = System.Text.Encoding.Unicode.GetByteCount(IconPath);

            Debug.WriteLine(string.Format(" GetOverlayInfo::{0}", bytesCount), LogCategories.ShellOverlays);

            MarshalHelpers.CopyToBuffer(IconPath, iconFileBuffer, iconFileBufferSize);

            flags = (uint)(ISIOI.ISIOI_ICONFILE);// | ISIOI.ISIOI_ICONINDEX);

            iconIndex = 0;

            return WinError.S_OK;

        }

        public int  GetPriority(out int priority)

        {

            Debug.WriteLine("Checking for priority");

            priority = 0;

            return WinError.S_OK;

        }

        public static void RegisterOverlay(Type type,string iconName)

        {

            Contract.Requires(type != null);

            Contract.Requires(!String.IsNullOrWhiteSpace(iconName));

            if (type == null)

                throw new ArgumentNullException("type", "type can't be null");

            if (String.IsNullOrWhiteSpace(iconName))

                throw new ArgumentNullException("iconName", "iconName can't be null");

            try

            {

                ShellExtReg.RegisterIconOverlayIdentifier(type.GUID, iconName);

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

                                             IntPtr.Zero, IntPtr.Zero);

                Debug.WriteLine("Registered icon handler");

            }

            catch (Exception ex)

            {

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

                throw;  // Re-throw the exception

            }

        }

        public static void UnregisterOverlay(Type type,string iconName)

        {

            Contract.Requires(type!=null);

            Contract.Requires(!String.IsNullOrWhiteSpace(iconName));

            if (type==null)

                throw new ArgumentNullException("type","type can't be null");

            if (String.IsNullOrWhiteSpace(iconName))

                throw new ArgumentNullException("iconName","iconName can't be null");

            try

            {                

                ShellExtReg.UnregisterIconOverlayIdentifier(type.GUID, iconName);

                Debug.WriteLine(String.Format("UnRegistered icon handler {0}:{1}",iconName,type.GUID), LogCategories.ShellOverlays);

            }

            catch (Exception ex)

            {

                //Log and rethrow

                Log.ErrorFormat("Failed to unregister overlay {0}:{1} with error {2}",iconName,type.GUID,ex.Message); 

                throw;  

            }

        }

    }

}