UOS添加菜单项

1
2
3
4
5
6

[Desktop Entry]
Type=Application
Name=Test
Name[zh_CN]=测试

Exec=/bin/xdg-open %F

1
2
3
4

extern "C" void dfm_extension_initialize();
extern "C" void dfm_extension_shutdown();
extern "C" DFMExtMenuPlugin *dfm_extension_menu();
extern "C" DFMExtEmblemIconPlugin *dfm_extension_emblem();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

class DFMExtEmblemIconPluginPrivate;
class DFMExtEmblemIconPlugin
{
    DFM_DISABLE_COPY(DFMExtEmblemIconPlugin)

public:
    using IconsType = std::vector<std::string>;
    using EmblemIcons = std::function<IconsType(const std::string &)>;
    using LocationEmblemIcons = std::function<DFMExtEmblem(const std::string &, int)>;

public:
    DFMExtEmblemIconPlugin();
    ~DFMExtEmblemIconPlugin();

    // Note: If the corner mark set by emblemIcons conflicts with the corner mark position 
    // set by locationEmblemIcons,  the conflict position will only display the corner mark set by locationEmblemIcons
    DFM_FAKE_VIRTUAL IconsType emblemIcons(const std::string &fileUrl) const;

    void registerEmblemIcons(const EmblemIcons &func);

    DFM_FAKE_VIRTUAL DFMExtEmblem locationEmblemIcons(const std::string &fileUrl, int systemIconCount) const;
    
    void registerLocationEmblemIcons(const LocationEmblemIcons &func);

private:
    DFMExtEmblemIconPluginPrivate *d { nullptr };
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

class DFMExtEmblemIconLayoutPrivate;
class DFMExtEmblemIconLayout
{
    friend class DFMExtEmblemIconLayoutPrivate;
public:
    enum class LocationType : uint8_t
    {
        BottomRight = 0,
        BottomLeft,
        TopLeft,
        TopRight,
        Custom = 0xff
    };

    explicit DFMExtEmblemIconLayout(LocationType type, const std::string &path, int x = 0, int y = 0);
    ~DFMExtEmblemIconLayout();

    DFMExtEmblemIconLayout(const DFMExtEmblemIconLayout &emblem);
    DFMExtEmblemIconLayout &operator=(const DFMExtEmblemIconLayout &emblem);

    LocationType locationType() const;
    std::string iconPath() const;
    
    int x() const;
    int y() const;
private:
    DFMExtEmblemIconLayoutPrivate *d { nullptr };
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

class DFMExtEmblemPrivate;
class DFMExtEmblem
{
    friend class DFMExtEmblemPrivate;

public:
    explicit DFMExtEmblem();
    ~DFMExtEmblem();

    DFMExtEmblem(const DFMExtEmblem &emblem);
    DFMExtEmblem &operator=(const DFMExtEmblem &emblem);
    
    void setEmblem(const std::vector<DFMExtEmblemIconLayout> &iconPaths);
    std::vector<DFMExtEmblemIconLayout> emblems() const;

private:
    DFMExtEmblemPrivate *d { nullptr };
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

class DFMExtMenuPlugin
{
    DFM_DISABLE_COPY(DFMExtMenuPlugin)

public:
    using InitializeFunc = std::function<void (DFMEXT::DFMExtMenuProxy *proxy)>;
    using BuildNormalMenuFunc = std::function<bool (DFMExtMenu *, const std::list<std::string> &, const std::string &, bool)>;

    using BuildEmptyAreaMenuFunc = std::function<bool (DFMEXT::DFMExtMenu *, const std::string &, bool)>;

public:
    DFMExtMenuPlugin();
    virtual ~DFMExtMenuPlugin();
    
    DFM_FAKE_VIRTUAL void initialize(DFMEXT::DFMExtMenuProxy *proxy);
    DFM_FAKE_VIRTUAL bool buildNormalMenu(DFMEXT::DFMExtMenu *main, const std::string &currentUrl, const std::string &focusUrl, const std::list<std::string> &urlList, bool onDesktop);
    DFM_FAKE_VIRTUAL bool buildEmptyAreaMenu(DFMExtMenu *main, const std::string &currentUrl, bool onDesktop);

public:
    void registerInitialize(const InitializeFunc &func);
    void registerBuildNormalMenu(const BuildNormalMenuFunc &func);
    void registerBuildEmptyAreaMenu(const BuildEmptyAreaMenuFunc &func);

private:
    DFMExtMenuPluginPrivate *d;
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

class DFMExtMenuProxy
{
public:
    explicit DFMExtMenuProxy(DFMExtMenuProxyPrivate *d_ptr);
    virtual ~DFMExtMenuProxy();
    DFMExtMenu *createMenu();
    bool deleteMenu(DFMExtMenu *menu);
    DFMExtAction *createAction();
    bool deleteAction(DFMExtAction *action);

private:
    DFMExtMenuProxyPrivate *d;
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

class DFMExtMenu
{
    friend class DFMExtMenuPrivate;

public:
    using TriggeredFunc = std::function<void (DFMExtAction *action)>;
    using HoveredFunc = std::function<void (DFMExtAction *action)>;
    using DeletedFunc = std::function<void (DFMExtMenu *)>;

public:
    std::string title() const;
    void setTitle(const std::string &title);
    std::string icon() const;
    void setIcon(const std::string &iconName);
    bool addAction(DFMExtAction *action);
    bool insertAction(DFMExtAction *before, DFMExtAction *action);
    DFMExtAction *menuAction() const;
    std::list<DFMExtAction *> actions() const;
    DFM_FAKE_VIRTUAL void triggered(DFMExtAction *action);
    DFM_FAKE_VIRTUAL void hovered(DFMExtAction *action);
    DFM_FAKE_VIRTUAL void deleted(DFMExtMenu *self);

public:
    void registerTriggered(const TriggeredFunc &func);
    void registerHovered(const HoveredFunc &func);
    void registerDeleted(const DeletedFunc &func);

protected:
    explicit DFMExtMenu(DFMExtMenuPrivate *d_ptr);
    virtual ~DFMExtMenu();
    DFMExtMenuPrivate *d;
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

class DFMExtAction
{
    friend class DFMExtActionPrivate;
public:
    using TriggeredFunc = std::function<void (DFMExtAction *, bool)>;
    using HoveredFunc = std::function<void (DFMExtAction *)>;
    using DeletedFunc = std::function<void (DFMExtAction *)>;

public:
    void setIcon(const std::string &icon);
    std::string icon() const;
    void setText(const std::string &text);
    std::string text() const;
    void setToolTip(const std::string &tip);
    std::string toolTip() const;
    void setMenu(DFMExtMenu *menu);
    DFMExtMenu *menu() const;
    void setSeparator(bool b);
    bool isSeparator() const;
    void setCheckable(bool b);
    bool isCheckable() const;
    void setChecked(bool b);
    bool isChecked() const;
    void setEnabled(bool b);
    bool isEnabled() const;
    DFM_FAKE_VIRTUAL void triggered(DFMExtAction *self, bool checked = false);
    DFM_FAKE_VIRTUAL void hovered(DFMExtAction *self);
    DFM_FAKE_VIRTUAL void deleted(DFMExtAction *self);

public:
    void registerTriggered(const TriggeredFunc &func);
    void registerHovered(const HoveredFunc &func);
    void registerDeleted(const DeletedFunc &func);

protected:
    explicit DFMExtAction(DFMExtActionPrivate *d_ptr);
    virtual ~DFMExtAction();
    DFMExtActionPrivate *d;
};

1
2
3
4

libdde-file-manager-dev
cmake
pkg-config
libfm-extension

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

cmake_minimum_required(VERSION 2.8)

#设置项目名称
project(dfmextension-demo)

#启用 pkg-config 标准
find_package(PkgConfig REQUIRED)

#只需要依赖 dfm-extension
pkg_search_module(dfm-extension REQUIRED
    dfm-extension
    IMPORTED_TARGET
)

#扩展插件源码
set(SRCS
        demomenuplugin.h
        demomenuplugin.cpp)

#生成共享库
add_library(${PROJECT_NAME} SHARED ${SRCS})
target_link_libraries(${PROJECT_NAME} PkgConfig::dfm-extension)

#安裝配置
include(GNUInstallDirs)
set(LIB_INSTALL_DIR /usr/lib/${CMAKE_LIBRARY_ARCHITECTURE}/dde-file-manager/plugins/extensions)

#安裝插件
install(TARGETS ${PROJECT_NAME} LIBRARY DESTINATION ${LIB_INSTALL_DIR})

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

static DFMExtMenuPlugin *kMenuPlugin = nullptr;
extern "C" void dfm_extension_initiliaze()
{
    if (!kMenuPlugin)
        kMenuPlugin = new ICBCMenuPlugin;
}

extern "C" DFMExtMenuPlugin *dfm_extension_menu()
{
    return kMenuPlugin;
}

extern "C" void dfm_extension_shutdown()
{
    if (kMenuPlugin) {
        delete kMenuPlugin;
        kMenuPlugin = nullptr;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

class ICBCMenuPlugin: public DFMEXT::DFMExtMenuPlugin
{
public:
    ICBCMenuPlugin();
    void initilaize(DFMEXT::DFMExtMenuProxy *proxy) DFM_FAKE_OVERRIDE;
    bool buildNormalMenu(DFMEXT::DFMExtMenu *main, const std::list<std::string> &urlList, const std::string &currentUrl, const std::string &focusUrl, bool onDesktop) DFM_FAKE_OVERRIDE;
    bool buildEmptyAreaMenu(DFMEXT::DFMExtMenu *main, const std::string &currentUrl, bool onDesktop) DFM_FAKE_OVERRIDE;
    void hoverd(DFMEXT::DFMExtAction *action);

private:
    DFMEXT::DFMExtMenuProxy *menuProxy = nullptr;
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

#include "icbcmenuplugin.h"
#include <menu/dfmextmenu.h>
#include <menu/dfmextmenuproxy.h>
#include <menu/dfmextaction.h>
#include <iostream>
#include <functional>
#include <unistd.h>

void ICBCMenuPlugin::hoverd(DFMEXT::DFMExtAction *action)
{
    std::cout << "hover!!!!!!!!!!" << std::endl;
    auto top = action->menu();

    if (top->actions().empty()) {
        sleep(1);
        auto a1 = menuProxy->createAction();
        a1->setText("nihao");
        top->addAction(a1);
        auto a2 = menuProxy->createAction();
        a2->setText("no hao");
        top->addAction(a2);
    }
}

ICBCMenuPlugin::ICBCMenuPlugin() : DFMEXT::DFMExtMenuPlugin()
{
    registerInitialize(std::bind(&ICBCMenuPlugin::initilaize, this, std::placeholders::_1));
    registerBuildNormalMenu(std::bind(&ICBCMenuPlugin::buildNormalMenu, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
    registerBuildEmptyAreaMenu(std::bind(&ICBCMenuPlugin::buildEmptyAreaMenu, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
}

void ICBCMenuPlugin::initilaize(DFMEXT::DFMExtMenuProxy *proxy)
{
    std::cout << "ICBCMenuPlugin::initilaize" << std::endl;
    menuProxy = proxy;
}

bool ICBCMenuPlugin::buildNormalMenu(DFMEXT::DFMExtMenu *main, const std::list<std::string> &urlList, const std::string &currentUrl, const std::string &focusUrl, bool onDesktop)
{
    std::cout << "ICBCMenuPlugin::buildNormalMenu" << std::endl;

    if (main == nullptr)
        return false;

    auto top = menuProxy->createMenu();
    //top->registerHovered(std::bind(&hoverd,std::placeholders::_1));

    auto ac = menuProxy->createAction();
    ac->setMenu(top);
    ac->setText("wps");
    ac->registerHovered(std::bind(&ICBCMenuPlugin::hoverd,this,std::placeholders::_1));
    main->addAction(ac);

    for (auto ac : main->actions()) {
        std::cout << "ssss :" << ac->text() << std::endl;
    }

    //todo 释放

    return true;
}

bool ICBCMenuPlugin::buildEmptyAreaMenu(DFMEXT::DFMExtMenu *main, const std::string &currentUrl, bool onDesktop)
{
    std::cout << "ICBCMenuPlugin::buildEmptyAreaMenu" << std::endl;
    
    return false;
}