Laden...

ThumbnailButtons in der neuen Windows 7 Taskbar erzeugen (ITaskbarList3)

Letzter Beitrag vor 12 Jahren 6 Posts 2.636 Views
ThumbnailButtons in der neuen Windows 7 Taskbar erzeugen (ITaskbarList3)

Hallo,

ich habe ein Problem bei der Verwendung der ThumbnailButtons der neuen Windows 7 Taskleiste.

Ich habe folgenden Code und das Standard-ITaskbarList3-Interface (von hier).


public sealed class Windows7TaskBarTools
    {
        #region Static

        private static Windows7TaskBarTools tools = null;

        public static String LastError { get; private set; }

        public static Windows7TaskBarTools Instance
        {
            get
            {
                if (tools == null)
                {
                    try
                    {
                        //Default windows 7 taskbar tools
                        tools = new Windows7TaskBarTools(true);
                    }
                    catch (Exception e)
                    {
                        LastError = e.Message;
                        //Emergency windows 7 taskbar tools (do nothing)
                        tools = new Windows7TaskBarTools(false);
                    }
                }

                return tools;
            }
        }

        #endregion

        private ITaskbarList3 taskbar = null;
            
        private Windows7TaskBarTools(bool create)
        {
            if (create)
                taskbar = (ITaskbarList3)new TaskbarList();
        }

        public bool IsUsed
        {
            get { return taskbar != null; }
        }

        public void SetTaskbarProgress(IntPtr hwnd, ulong value, ulong max)
        {
            if (IsUsed)
                taskbar.SetProgressValue(hwnd, value, max);
        }

        public void SetTaskbarProgressStyle(IntPtr hwnd, TaskbarProgressStyle style)
        {
            if (IsUsed)
            {
                //int tmp = (int)style;
                taskbar.SetProgressState(hwnd, (TBPFLAG)style);
            }
        }

        public void SetOverlayIcon(IntPtr hwnd, Icon icon, string description)
        {
            if (IsUsed)
                taskbar.SetOverlayIcon(hwnd, icon.Handle, description);
        }

        public void SetOverlayIcon(IntPtr hwnd, Bitmap icon, string description)
        {
            if (IsUsed)
                taskbar.SetOverlayIcon(hwnd, icon.GetHicon(), description);
        }

        public void SetThumbnailClip(IntPtr hwnd, int x, int y, int width, int height)
        {
            if (IsUsed)
            {
                RECT r = new Rectangle(x, y, width, height);
                taskbar.SetThumbnailClip(hwnd, ref r);
            }
        }

        public void SetThumbnailToolTip(IntPtr hwnd, String tip)
        {
            if (IsUsed)
                taskbar.SetThumbnailTooltip(hwnd, tip);
        }

        public void UpdateThumbnailButtons(IntPtr hwnd, params ThumbnailButton[] buttons)
        {
            if (IsUsed)
            {
                List<THUMBBUTTON> comButtons = new List<THUMBBUTTON>();
                foreach (ThumbnailButton button in buttons)
                {
                    comButtons.Add(button);
                }

                HRESULT result = taskbar.ThumbBarUpdateButtons(hwnd, (uint)buttons.Length, comButtons.ToArray());
                if (result != HRESULT.S_OK)
                {
                    throw new COMException("Cannot update thumb button: " + result.ToString());
                }
            }
        }

        public void AddThumbnailButtons(IntPtr hwnd, params ThumbnailButton[] buttons)
        {
            if (IsUsed)
            {
                List<THUMBBUTTON> comButtons = new List<THUMBBUTTON>();
                foreach (ThumbnailButton button in buttons)
                {
                    comButtons.Add(button);
                }

                HRESULT result = taskbar.ThumbBarAddButtons(hwnd, (uint)buttons.Length, comButtons.ToArray());
                if (result != HRESULT.S_OK)
                {
                    throw new COMException("Cannot add thumb button: " + result.ToString()); 
                }
            }
        }
    }


public class ThumbnailButton : IDisposable
    {
        #region Static

        private static IList<uint> idList = new List<uint>();

        private static uint CreateID()
        {
            Random rand = new Random();

            uint id = (uint)rand.Next();
            while (idList.Contains(id))
                id = (uint)rand.Next();

            return id;
        }

        private static void DeleteID(uint id)
        {
            idList.Remove(id);
        }

        #endregion

        private THBMASK type;
        private THBFLAGS state;
        public uint ID { get; set; }
        private Icon icon;
        public String ToolTip { get; set; }
        public IntPtr Parent { get; private set; }

        public event EventHandler Click;
        public event EventHandler Updated;

        public bool IsEnabled
        {
            get { return (state & THBFLAGS.THBF_ENABLED) != 0; }
            set
            {
                if (value == IsEnabled)
                    return;

                if (value)
                {
                    state = state | THBFLAGS.THBF_ENABLED;
                    state = state ^ THBFLAGS.THBF_DISABLED;
                }
                else
                {
                    state = state ^ THBFLAGS.THBF_ENABLED;
                    state = state | THBFLAGS.THBF_DISABLED;
                }

                OnUpdate();
            }
        }

        public bool HasBackground
        {
            get { return (state & THBFLAGS.THBF_NOBACKGROUND) == 0; }
            set
            {
                if (value == HasBackground)
                    return;

                if (value)
                    state = state ^ THBFLAGS.THBF_NOBACKGROUND;
                else
                    state = state | THBFLAGS.THBF_NOBACKGROUND;

                OnUpdate();
            }
        }

        public bool IsVisible
        {
            get { return (state & THBFLAGS.THBF_HIDDEN) == 0; }
            set
            {
                if (value == IsVisible)
                    return;

                if (value)
                    state = state ^ THBFLAGS.THBF_HIDDEN;
                else
                    state = state | THBFLAGS.THBF_HIDDEN;

                OnUpdate();
            }
        }

        public bool IsDismissionClick
        {
            get { return (state & THBFLAGS.THBF_DISMISSONCLICK) != 0; }
            set
            {
                if (value == IsDismissionClick)
                    return;

                if (value)
                    state = state | THBFLAGS.THBF_DISMISSONCLICK;
                else
                    state = state ^ THBFLAGS.THBF_DISMISSONCLICK;

                OnUpdate();
            }
        }

        public Icon Icon
        {
            get { return icon; }
            set
            {
                icon = value;
                OnUpdate();
            }
        }

        private bool isInitialized = false;

        public ThumbnailButton(IntPtr parent, String tooltip, Icon icon)
        {
            this.ID = CreateID();
            this.ToolTip = tooltip;
            this.state = THBFLAGS.THBF_ENABLED;

            this.icon = icon;
            this.type = THBMASK.THB_ICON | THBMASK.THB_TOOLTIP | THBMASK.THB_FLAGS;

            this.Parent = parent;

            this.isInitialized = true;

            Windows7TaskBarTools.Instance.AddThumbnailButtons(this.Parent, this);
            Windows7TaskBarTools.Instance.UpdateThumbnailButtons(this.Parent, this);
        }

        public static implicit operator THUMBBUTTON(ThumbnailButton tb)
        {
            THUMBBUTTON res = new THUMBBUTTON();
            res.dwFlags = tb.state;
            res.dwMask = tb.type;
            res.hIcon = tb.icon.Handle;
            res.iBitmap = 0;
            res.iId = tb.ID;
            res.szTip = tb.ToolTip;

            return res;
        }

        public void WndProcCall(ref Message msg)
        {
            switch (msg.Msg)
            {
                case 0x0111:
                    if ((uint)(msg.WParam.ToInt32() & 0xFFFF) == this.ID)
                        if (Click != null)
                            Click(this, new EventArgs());
                    break;
            }
        }

        protected virtual void OnUpdate()
        {
            if (!isInitialized)
                return;

            if (Updated != null)
                Updated(this, new EventArgs());

            Windows7TaskBarTools.Instance.UpdateThumbnailButtons(this.Parent, this);
        }

        #region IDisposable Member

        public void Dispose()
        {
            
        }

        #endregion
    }

Das Problem: Kein Fehler, dennoch kein Button, der erscheint. Es soll dazu ausschließlich der Aufruf des ThumbnailButton-Constructors ausreichen.

Hier der Aufruf im Konstruktor in einer Windows Forms:


ThumbnailButton btn = new ThumbnailButton(this.Handle, "Bla Blub",
                Resources.File001);

Habe ich was bei der implicit-umwandlung was falsch gemacht? Oder habe ich was beim Aufruf falsch gemacht?

PS: Dass das Ganze wirklich aufgerufen wird, habe ich bereits geprüft durch Debugging.

Danke.

Hat wirklich keiner eine Ahnung, woran es liegen könnte?

Hallo,

gibt es eigentlich einen Grund warum du nicht das im Link erwähnte Windows API Code Pack benutzt? Das tut jedenfalls 😉

Baka wa shinanakya naoranai.

Mein XING Profil.

Nun ja, das ganze soll Bestandteil einer Tools-Sammlung werden. Da möchte ich möglichst auf externe DLLs verzichten.

Fehler gelöst

Hallo,

habe den Fehler gefunden.

Es liegt daran, dass die Thumbnail-Buttons erst hinzugefügt werden dürfen, wenn das Ereignis AddButtons auftritt, das man über die WndProc Methode abfangen kann:


protected override void WndProc(ref Message m)
        {
            if (m.Msg == COMConstants.COMCommands.WmTaskbarButtonCreated)
            {
                Log.Debug("Create thumb buttons");
                buttonManager.AddButtonsToTaskbar();
            }

            buttonManager.HandleEvents(ref m);

            base.WndProc(ref m);
        }


[DllImport("user32.dll", EntryPoint = "RegisterWindowMessage", SetLastError = true, CharSet = CharSet.Unicode)]
        private static extern uint RegisterWindowMessage([MarshalAs(UnmanagedType.LPWStr)] string lpString);
private static readonly uint wmTaskbarButtonCreated = RegisterWindowMessage("TaskbarButtonCreated");
            public static uint WmTaskbarButtonCreated { get { return wmTaskbarButtonCreated; } }

Hallo KleinerHacker,

es ist zwar schon lange her und ich bin etwas spät dran, aber ich habe schon viele Funktionen aus der Win7 Api herausgeholt. Leider schaffe ich es nicht, die ThumbnailButton zum laufen zu bringen.

Deine Funktionen, die du oben beschrieben hast, kann ich alle nachvollziehen, aber in deinem letzten Post zeigst du die Lösung mir der WndProc.

Das Problem ist nur, dass du so lappidar die Klasse buttonManager benutzt. Gibt es eine Chance, an die Klasse zu kommen, bzw. ein Sample o.ä. zu finden, indem die Taskbar Thumbbuttons dargestellt, aber ohne die Windows API Code Pack zu benutzen.

Danke
heinz_oel