~canonical-dx-team/unity/unity.fix-ql-losing-focus

// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-

/*

 * Copyright (C) 2010 Canonical Ltd

 *

 * This program is free software: you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 3 as

 * published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program.  If not, see <http://www.gnu.org/licenses/>.

 *

 * Authored by: Jason Smith <jason.smith@canonical.com>

 * 

 */

#ifndef LAUNCHERICON_H

#define LAUNCHERICON_H

#include <Nux/Nux.h>

#include <Nux/BaseWindow.h>

#include <NuxCore/Math/MathInc.h>

#include <sigc++/trackable.h>

#include <sigc++/signal.h>

#include <sigc++/functors/ptr_fun.h>

#include <sigc++/functors/mem_fun.h>

#include <gtk/gtk.h>

#include <libdbusmenu-glib/client.h>

#include <libdbusmenu-glib/menuitem.h>

#include "Tooltip.h"

#include "QuicklistView.h"

#include "Introspectable.h"

#include "Launcher.h"

#include "LauncherEntryRemote.h"

class Launcher;

class QuicklistView;

class LauncherIcon : public Introspectable, public nux::InitiallyUnownedObject

{

  NUX_DECLARE_OBJECT_TYPE (LauncherIcon, nux::InitiallyUnownedObject);

public:

    typedef enum

    {

      TYPE_NONE,

      TYPE_BEGIN,

      TYPE_FAVORITE,

      TYPE_APPLICATION,

      TYPE_EXPO,

      TYPE_PLACE,

      TYPE_DEVICE,

      TYPE_TRASH,

      TYPE_END,

    } IconType;

    typedef enum

    {

      QUIRK_VISIBLE,

      QUIRK_ACTIVE,

      QUIRK_RUNNING,

      QUIRK_URGENT,

      QUIRK_PRESENTED,

      QUIRK_STARTING,

      QUIRK_SHIMMER,

      QUIRK_CENTER_SAVED,

      QUIRK_PROGRESS,

      QUIRK_DROP_PRELIGHT,

      QUIRK_DROP_DIM,

      QUIRK_LAST,

    } Quirk;

    LauncherIcon(Launcher* launcher);

    virtual ~LauncherIcon();

    Launcher* GetLauncher () {return _launcher;};

    void SetTooltipText (const TCHAR* text);

    nux::NString GetTooltipText ();

    void    SetShortcut (guint64 shortcut);

    guint64 GetShortcut ();

    void RecvMouseEnter ();

    void RecvMouseLeave ();

    void RecvMouseDown (int button);

    void RecvMouseUp (int button);

    void HideTooltip ();

    void OpenQuicklist (bool default_to_first_item = false);

    void        SetCenter (nux::Point3 center);

    nux::Point3 GetCenter ();

    void Activate ();

    void OpenInstance ();

    void SaveCenter ();

    int SortPriority ();

    int RelatedWindows ();

    bool HasVisibleWindow ();

    float PresentUrgency ();

    float GetProgress ();

    void SetEmblemIconName (const char *name);

    void SetEmblemText (const char *text);

    void DeleteEmblem ();

    bool GetQuirk (Quirk quirk);

    struct timespec GetQuirkTime (Quirk quirk);

    IconType Type ();

    virtual nux::Color BackgroundColor ();

    virtual nux::Color GlowColor ();

    const gchar * RemoteUri () { return GetRemoteUri (); }

    nux::BaseTexture * TextureForSize (int size);

    nux::BaseTexture * Emblem ();

    std::list<DbusmenuMenuitem *> Menus ();

    void InsertEntryRemote (LauncherEntryRemote *remote);

    void RemoveEntryRemote (LauncherEntryRemote *remote);

    nux::DndAction QueryAcceptDrop (std::list<char *> paths) { return OnQueryAcceptDrop (paths); }

    void AcceptDrop (std::list<char *> paths) { return OnAcceptDrop (paths); }

    void SendDndEnter () { OnDndEnter (); }

    void SendDndLeave () { OnDndLeave (); }

    sigc::signal<void, int> MouseDown;

    sigc::signal<void, int> MouseUp;

    sigc::signal<void>      MouseEnter;

    sigc::signal<void>      MouseLeave;

    sigc::signal<void, int> MouseClick;

    sigc::signal<void, LauncherIcon *> show;

    sigc::signal<void, LauncherIcon *> hide;

    sigc::signal<void, LauncherIcon *> remove;

    sigc::signal<void, LauncherIcon *> needs_redraw;

protected:

    const gchar * GetName ();

    void AddProperties (GVariantBuilder *builder);

    void SetQuirk (Quirk quirk, bool value);

    void UpdateQuirkTimeDelayed (guint ms, Quirk quirk);

    void UpdateQuirkTime (Quirk quirk);

    void ResetQuirkTime (Quirk quirk);

    void SetRelatedWindows (int windows);

    void Remove ();

    void SetProgress (float progress);

    void SetHasVisibleWindow (bool val);

    void Present (float urgency, int length);

    void Unpresent ();

    void SetIconType (IconType type);

    void SetSortPriority (int priority);

    void SetEmblem (nux::BaseTexture *emblem);

    void SetSuperkeyLabel (nux::BaseTexture* label);

    nux::BaseTexture* GetSuperkeyLabel ();

    virtual std::list<DbusmenuMenuitem *> GetMenus ();

    virtual nux::BaseTexture * GetTextureForSize (int size) = 0;

    virtual void OnCenterStabilized (nux::Point3 center) {}

    virtual const gchar * GetRemoteUri () { return 0; }

    virtual nux::DndAction OnQueryAcceptDrop (std::list<char *> files) { return nux::DNDACTION_NONE; }

    virtual void OnAcceptDrop (std::list<char *> files) {}

    virtual void OnDndEnter () {}

    virtual void OnDndLeave () {}

    virtual void ActivateLauncherIcon () {}

    virtual void OpenInstanceLauncherIcon () {}

    nux::BaseTexture * TextureFromGtkTheme (const char *name, int size);

    nux::BaseTexture * TextureFromPath     (const char *name, int size);

    void OnRemoteEmblemChanged    (LauncherEntryRemote *remote);

    void OnRemoteCountChanged     (LauncherEntryRemote *remote);

    void OnRemoteProgressChanged  (LauncherEntryRemote *remote);

    void OnRemoteQuicklistChanged (LauncherEntryRemote *remote);

    void OnRemoteEmblemVisibleChanged   (LauncherEntryRemote *remote);

    void OnRemoteCountVisibleChanged    (LauncherEntryRemote *remote);

    void OnRemoteProgressVisibleChanged (LauncherEntryRemote *remote);

    nux::NString m_TooltipText;

    //! the window this icon belong too.

    nux::BaseWindow* m_Window;

    Launcher* _launcher;

    std::map<std::string, nux::Vector4*> _xform_coords;

    bool          _mouse_inside;

    float         _folding_angle;

    nux::Tooltip *_tooltip;

    QuicklistView *_quicklist;

    static nux::Tooltip *_current_tooltip;

    static QuicklistView *_current_quicklist;

    friend class Launcher;

    friend class LauncherController;

    friend class LauncherModel;

private:

    typedef struct

    {

      LauncherIcon *self;

      Quirk quirk;

    } DelayedUpdateArg;

    static void ChildRealized (DbusmenuMenuitem *newitem, QuicklistView *quicklist);

    static void RootChanged (DbusmenuClient * client, DbusmenuMenuitem *newroot, QuicklistView *quicklist);

    static gboolean OnPresentTimeout (gpointer data);

    static gboolean OnCenterTimeout (gpointer data);

    static gboolean OnDelayedUpdateTimeout (gpointer data);

    void ColorForIcon (GdkPixbuf *pixbuf, nux::Color &background, nux::Color &glow);

    nux::Color       _background_color;

    nux::Color       _glow_color;

    int              _sort_priority;

    int              _related_windows;

    float            _present_urgency;

    float            _progress;

    guint            _present_time_handle;

    guint            _center_stabilize_handle;

    bool             _quicklist_is_initialized;

    bool             _has_visible_window;

    gint64           _shortcut;

    nux::Point3      _center;

    nux::Point3      _last_stable;

    nux::Point3      _saved_center;

    IconType         _icon_type;

    nux::BaseTexture* _emblem;

    nux::BaseTexture* _superkey_label;

    bool             _quirks[QUIRK_LAST];

    struct timespec  _quirk_times[QUIRK_LAST];

    std::list<LauncherEntryRemote *> _entry_list;

};

#endif // LAUNCHERICON_H