Electron源码学习：让管理员运行的Electron（CEF）支持文件拖拽

最新推荐文章于 2024-08-14 09:18:37 发布
置顶 最新推荐文章于 2024-08-14 09:18:37 发布
阅读量1k 收藏 4
点赞数
文章标签： electron 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42208826/article/details/132850549
版权

Electron源码学习：让管理员运行的Electron（CEF）支持文件拖拽

背景

前段时间接到一个任务，需要从Windows桌面拖拽文件或文件夹到Electron网页中；网页本身是支持这种拖拽行为的；我们的程序是以管理员权限运行的，在测试的时候发现无法完成这个操作；文件拖拽到界面上时，直接显示了一个禁用的标志；如果换其他的方式来实现（比如：低权限运行，低权限蒙层），实在太过于复杂；没办法，只能尝试去研究为什么不能拖拽。

Windows从Vista开始，启用了UAC功能；然后造成了我们不能拖的原因是因为UIPI的机制；它是UAC功能之一；该功能启用时，用户无法完成地权到高权的文件拖拽操作；

先说结论

要实现本篇文章的目的，需要源码编译Electron, 如果想要不改源码的情况下做到支持管理员文件拖放，那是非常麻烦的事情，本篇不覆盖这方面的内容，不过文末有思路。

Windows下拖放文件的方式如下：

  • WM_DROPFILES：仅支持接收文件“投下”消息；但能够管理员运行；
  • IDropTarget: 功能全面，但不支持管理员下运行；

Electron正是采用的IDropTarget的方式来实现文件拖放功能；但是IDropTarget因为UIPI的原因，该操作被阻止，且没有办法放行；有一些"非常规"的手段，可以临时性解决该问题（例如：关闭UAC），但这样操作也太粗暴了。

那么如何解决electron管理员拖放的问题？围绕上面提到的拖放方式来开展，即：

  1. 以管理员运行时，用WM_DROPFILES；
  2. 以正常权限运行时，用IDropTarget;

改electron源码这里，很简单就能实现；往下看。

先介绍Windows下实现拖放文件的方法

  1. WM_DROPFILES消息：接收到该消息时，代表用户"投"下了一个文件；处理示例如下：

     int dragged_file_count = DragQueryFile(hDropInfo, 0xFFFFFFFF, 0, 0);
 for (int i = 0; i < dragged_file_count; i++)
 {
     TCHAR szPath[MAX_PATH] = { 0 };
     DragQueryFile(hDropInfo, i, szPath, MAX_PATH);
     
	 //... 
     // do something.
 }

    **管理员运行时：**需要用ChangeWindowMessageFilter或ChangeWindowMessageFilterEx放行拖放消息；并且给窗口加上WS_EX_ACCEPTFILES属性；处理示例如下：

    HWND InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   hInst = hInstance; // Store instance handle in our global variable

   HWND hWnd = CreateWindowW(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, nullptr, nullptr, hInstance, nullptr);

   if (!hWnd)
   {
      return 0;
   }
   
   // 该函数给当前的窗口加上属性WS_EX_ACCEPTFILES, 
   // 也可以在CreateWindow时附加属性WS_EX_ACCEPTFILES来替代；
   ::DragAcceptFiles(hWnd, true);

   // 解除以下消息UIPI的限制；
   CHANGEFILTERSTRUCT changeFilterStruct = { sizeof(CHANGEFILTERSTRUCT), 0 };
   BOOL ret = ChangeWindowMessageFilterEx(hWnd, WM_DROPFILES, MSGFLT_ALLOW, &changeFilterStruct);
   ret = ChangeWindowMessageFilterEx(hWnd, WM_COPYDATA, MSGFLT_ALLOW, &changeFilterStruct);
   ret = ChangeWindowMessageFilterEx(hWnd, 0x0049, MSGFLT_ALLOW, &changeFilterStruct);

   ShowWindow(hWnd, nCmdShow);
   UpdateWindow(hWnd);

   return hWnd;
}

  2. IDropTarget，这是一个由Ole所支持的拖拽方案；比WM_DROPFILE更强大，更好用；相比于WM_DROPFILES，通过改方法可以监听到文件的拖入，悬停，离开，投放事件；首先，先实现一个IDropTarget实例，如下：

    // dragdrop.h
#include <windows.h>
#include <shlobj.h>

class MyDropTarget : public IDropTarget
{
public:
    MyDropTarget()
    {
        m_cRef = 0;
    }

    // IUnknown方法
    STDMETHODIMP QueryInterface(REFIID iid, void** ppvObject)
    {
        if (iid == __uuidof(IUnknown) || iid == __uuidof(IDropTarget))
        {
            *ppvObject = this;
            AddRef();
            return S_OK;
        }
        else
            return E_NOINTERFACE;
    }

    STDMETHODIMP_(ULONG) AddRef()
    {
        return ++m_cRef;
    }

    STDMETHODIMP_(ULONG) Release()
    {
        if (--m_cRef == 0)
        {
            delete this;
            return 0;
        }
        return m_cRef;
    }

    // IDropTarget方法
    STDMETHODIMP DragEnter(IDataObject* pDataObj, DWORD grfKeyState, POINTL pt, DWORD* pdwEffect)
    {
        // 在这里处理拖拽进入事件

        return S_OK;
    }

    STDMETHODIMP DragOver(DWORD grfKeyState, POINTL pt, DWORD* pdwEffect)
    {
        // 在这里处理拖拽悬停事件

        return S_OK;
    }
    STDMETHODIMP DragLeave()
    {
        // 在这里处理拖拽离开事件

        return S_OK;
    }

    STDMETHODIMP Drop(IDataObject* pDataObj, DWORD grfKeyState, POINTL pt, DWORD* pdwEffect)
    {
        // 在这里处理拖拽释放事件

        return S_OK;
    }

private:
    long m_cRef;
};

    首先先实例化MyDropTarget，然后使用RegisterDragDrop进行注册； 使用示例片段如下：

    // main.cpp
...
    
// 注意：只能使用OleInitialize初始化，不能使用CoInitialize初始化；
// 否则RegisterDragDrop将会失败，且返回E_OUTOFMEMORY, 详情查看MSDN；
OleInitialize(NULL);

...
HWND hWnd = InitInstance();
...
    
MyDropTarget *dropTarget = new MyDropTarget();
// 注册
HRESULT hr = RegisterDragDrop(hWnd, dropTarget);

...
RevokeDragDop(hWnd);
dropTarget->Release();

思路

前情提要：一旦程序使用了IDropTarget的方式，那么WM_DROPFILS的方式将不会生效；也就是说，如果一旦调用了RegisterDragDrop,那么不管你是管理员运行，还是标准账号运行，你都将收不到WM_DROPFILES消息；

因此，我们大致方案如下：

  1. 如果是管理员运行，初始化DragDrop模块时，那么不要执行RegisterDragDrop；并开放WM_DROPFILES,WM_COPYDATA等消息；
  2. 窗口收到WM_DROPFILES消息时，模拟一个IDropTarget事件给对应的模块；

实操实现

以electron版本6.1.12为例，其他版本大同小异；

  1. 首先找到文件src\ui\base\dragdrop\drop_target_win.cc，找到void DropTargetWin::Init(HWND hwnd)函数；原函数如下：

    void DropTargetWin::Init(HWND hwnd) {
  DCHECK(!hwnd_);
  DCHECK(hwnd);

  HRESULT result = RegisterDragDrop(hwnd, this);
  DCHECK(SUCCEEDED(result)); 
}

    修改为：

    void DropTargetWin::Init(HWND hwnd) {
  DCHECK(!hwnd_);
  DCHECK(hwnd);

  if (IsUserAnAdmin()) {
    SetPropW(hwnd, L"drag-drop-callback-{2E8EAA96-6DA5-49CB-8DE7-042F0796CDB6}",
             this);

    BOOL ret = ChangeWindowMessageFilter(WM_DROPFILES, MSGFLT_ADD);
    ret = ChangeWindowMessageFilter(0x0049,
                                    MSGFLT_ADD);  // 0x0049 == WM_COPYGLOBALDATA
    ret = ChangeWindowMessageFilter(WM_COPYDATA, MSGFLT_ADD);

  } else {
    HRESULT result = RegisterDragDrop(hwnd, this);
    DCHECK(SUCCEEDED(result));  
  }
}

    以上代码中，首先通过IsUserAnAdmin判断当前的运行权限是否为管理员运行；如果是管理员：

    1. 将当前指针赋值给窗口自定义属性drag-drop-callback-{2E8EAA96-6DA5-49CB-8DE7-042F0796CDB6};
    2. 放行WM_DROPFILES,WM_COPYGLOBALDATA,WM_COPYDATA消息；此处建议使用：ChangeWindowMessageFilterEx函数；

  2. 处理WM_DROPFILES，读者可自行选择处理的位置；可以选择chromium的消息处理函数；也可以选择消息流经的任何地方；本篇选择electron的消息处理函数NativeWindowViews::PreHandleMSG，位于src\electron\atom\browser\native_window_views_win.cc中；新增消息处理分支：

    case WM_DROPFILES: {
      IDropTarget* drop_target =
          (IDropTarget*)GetPropW(GetAcceleratedWidget(),
                   L"drag-drop-callback-{2E8EAA96-6DA5-49CB-8DE7-"
                   L"042F0796CDB6}");

      if (!drop_target) {
        return false;
      }

      
      IDataObject* drop_data = nullptr;
      // Create IDataObject and IDropSource COM objects
      if (S_OK != CDataObject::CreateDropObject((HGLOBAL)w_param, &drop_data)) {
          return false;
      }

      POINT pt = {};
      GetCursorPos(&pt);
      DWORD cursor_effect = 0;
      drop_target->DragEnter(drop_data, MK_LBUTTON, {pt.x, pt.y}, &cursor_effect);
      drop_target->Drop(drop_data, 0, {pt.x, pt.y}, &cursor_effect);
      drop_data->Release();
      return true;
    }
    break;

    以上代码中，当窗口收到WM_DROPFILES时，

    1. 创建一个Drop数据对象；
    2. 模拟一次Enter事件（必需，在Render中，如果不先触发Enter，Drop事件会被丢弃）
    3. 模拟一次Drop事件（投放事件）

    Drop数据对象的创建函数CDataObject::CreateDropObject的相关实现如下:

    // custom_drop_data_impl.hpp

#ifndef CUSTOM_DROP_DATA_IMPL_HPP_
#define CUSTOM_DROP_DATA_IMPL_HPP_
#include <windows.h>
#include <ObjIdl.h>
#include <ShlObj.h>

class CEnumFormatEtc : public IEnumFORMATETC {
 public:
  //
  // IUnknown members
  //
  HRESULT __stdcall QueryInterface(REFIID iid, void** ppvObject) {
    // check to see what interface has been requested
    if (iid == IID_IEnumFORMATETC || iid == IID_IUnknown) {
      AddRef();
      *ppvObject = this;
      return S_OK;
    } else {
      *ppvObject = 0;
      return E_NOINTERFACE;
    }
  }
  ULONG __stdcall AddRef(void) {
    // increment object reference count
    return InterlockedIncrement(&m_lRefCount);
  }
  ULONG __stdcall Release(void) {
    // decrement object reference count
    LONG count = InterlockedDecrement(&m_lRefCount);

    if (count == 0) {
      delete this;
      return 0;
    } else {
      return count;
    }
  }

  //
  // IEnumFormatEtc members
  //
  HRESULT __stdcall Next(ULONG celt,
                         FORMATETC* pFormatEtc,
                         ULONG* pceltFetched) {
    ULONG copied = 0;

    // validate arguments
    if (celt == 0 || pFormatEtc == 0)
      return E_INVALIDARG;

    // copy FORMATETC structures into caller's buffer
    while (m_nIndex < m_nNumFormats && copied < celt) {
      DeepCopyFormatEtc(&pFormatEtc[copied], &m_pFormatEtc[m_nIndex]);
      copied++;
      m_nIndex++;
    }

    // store result
    if (pceltFetched != 0)
      *pceltFetched = copied;

    // did we copy all that was requested?
    return (copied == celt) ? S_OK : S_FALSE;
  }
  HRESULT __stdcall Skip(ULONG celt) {
    m_nIndex += celt;
    return (m_nIndex <= m_nNumFormats) ? S_OK : S_FALSE;
  }
  HRESULT __stdcall Reset(void) {
    m_nIndex = 0;
    return S_OK;
  }
  HRESULT __stdcall Clone(IEnumFORMATETC** ppEnumFormatEtc) {
    HRESULT hResult;

    // make a duplicate enumerator
    hResult = CreateEnumFormatEtc(m_nNumFormats, m_pFormatEtc, ppEnumFormatEtc);

    if (hResult == S_OK) {
      // manually set the index state
      ((CEnumFormatEtc*)*ppEnumFormatEtc)->m_nIndex = m_nIndex;
    }

    return hResult;
  }

  //
  // Construction / Destruction
  //
  CEnumFormatEtc(FORMATETC* pFormatEtc, int nNumFormats) {
    m_lRefCount = 1;
    m_nIndex = 0;
    m_nNumFormats = nNumFormats;
    m_pFormatEtc = new FORMATETC[nNumFormats];

    // copy the FORMATETC structures
    for (int i = 0; i < nNumFormats; i++) {
      DeepCopyFormatEtc(&m_pFormatEtc[i], &pFormatEtc[i]);
    }
  }
  ~CEnumFormatEtc() {
    if (m_pFormatEtc) {
      for (ULONG i = 0; i < m_nNumFormats; i++) {
        if (m_pFormatEtc[i].ptd)
          CoTaskMemFree(m_pFormatEtc[i].ptd);
      }

      delete[] m_pFormatEtc;
    }
  }

 private:
  LONG m_lRefCount;         // Reference count for this COM interface
  ULONG m_nIndex;           // current enumerator index
  ULONG m_nNumFormats;      // number of FORMATETC members
  FORMATETC* m_pFormatEtc;  // array of FORMATETC objects

 public:
  static void DeepCopyFormatEtc(FORMATETC* dest, FORMATETC* source) {
    // copy the source FORMATETC into dest
    *dest = *source;

    if (source->ptd) {
      // allocate memory for the DVTARGETDEVICE if necessary
      dest->ptd = (DVTARGETDEVICE*)CoTaskMemAlloc(sizeof(DVTARGETDEVICE));

      // copy the contents of the source DVTARGETDEVICE into dest->ptd
      *(dest->ptd) = *(source->ptd);
    }
  }

  //
  //  "Drop-in" replacement for SHCreateStdEnumFmtEtc. Called by
  //  CDataObject::EnumFormatEtc
  //
  static HRESULT CreateEnumFormatEtc(UINT nNumFormats,
                                     FORMATETC* pFormatEtc,
                                     IEnumFORMATETC** ppEnumFormatEtc) {
    if (nNumFormats == 0 || pFormatEtc == 0 || ppEnumFormatEtc == 0)
      return E_INVALIDARG;

    *ppEnumFormatEtc = new CEnumFormatEtc(pFormatEtc, nNumFormats);

    return (*ppEnumFormatEtc) ? S_OK : E_OUTOFMEMORY;
  }
};

class CDataObject : public IDataObject {
 public:
  //
  // IUnknown members
  //
  HRESULT __stdcall QueryInterface(REFIID iid, void** ppvObject) override {
    // check to see what interface has been requested
    if (iid == IID_IDataObject || iid == IID_IUnknown) {
      AddRef();
      *ppvObject = this;
      return S_OK;
    } else {
      *ppvObject = 0;
      return E_NOINTERFACE;
    }
  }
  ULONG __stdcall AddRef(void) override {
    // increment object reference count
    return InterlockedIncrement(&m_lRefCount);
  }
  ULONG __stdcall Release(void) override {
    // decrement object reference count
    LONG count = InterlockedDecrement(&m_lRefCount);

    if (count == 0) {
      delete this;
      return 0;
    } else {
      return count;
    }
  }

  //
  // IDataObject members
  //
  HRESULT __stdcall GetData(FORMATETC* pFormatEtc,
                            STGMEDIUM* pMedium) override {
    int idx;

    //
    // try to match the requested FORMATETC with one of our supported formats
    //
    if ((idx = LookupFormatEtc(pFormatEtc)) == -1) {
      return DV_E_FORMATETC;
    }

    //
    // found a match! transfer the data into the supplied storage-medium
    //
    pMedium->tymed = m_pFormatEtc[idx].tymed;
    pMedium->pUnkForRelease = 0;

    switch (m_pFormatEtc[idx].tymed) {
      case TYMED_HGLOBAL:

        pMedium->hGlobal = DupMem(m_pStgMedium[idx].hGlobal);
        // return S_OK;
        break;

      default:
        return DV_E_FORMATETC;
    }

    return S_OK;
  }

  HRESULT __stdcall GetDataHere(FORMATETC* pFormatEtc,
                                STGMEDIUM* pMedium) override {
    // GetDataHere is only required for IStream and IStorage mediums
    // It is an error to call GetDataHere for things like HGLOBAL and other
    // clipboard formats
    //
    //  OleFlushClipboard
    //
    return DATA_E_FORMATETC;
  }

  HRESULT __stdcall QueryGetData(FORMATETC* pFormatEtc) override {
    return (LookupFormatEtc(pFormatEtc) == -1) ? DV_E_FORMATETC : S_OK;
  }

  HRESULT __stdcall GetCanonicalFormatEtc(FORMATETC* pFormatEct,
                                          FORMATETC* pFormatEtcOut) override {
    // Apparently we have to set this field to NULL even though we don't do
    // anything else
    pFormatEtcOut->ptd = NULL;
    return E_NOTIMPL;
  }

  HRESULT __stdcall SetData(FORMATETC* pFormatEtc,
                            STGMEDIUM* pMedium,
                            BOOL fRelease) override {
    return E_NOTIMPL;
  }

  HRESULT __stdcall EnumFormatEtc(DWORD dwDirection,
                                  IEnumFORMATETC** ppEnumFormatEtc) override {
    if (dwDirection == DATADIR_GET) {
      // for Win2k+ you can use the SHCreateStdEnumFmtEtc API call, however
      // to support all Windows platforms we need to implement IEnumFormatEtc
      // ourselves.
      return CEnumFormatEtc::CreateEnumFormatEtc(m_nNumFormats, m_pFormatEtc,
                                                 ppEnumFormatEtc);
    } else {
      // the direction specified is not support for drag+drop
      return E_NOTIMPL;
    }
  }

  //
  //  IDataObject::DAdvise
  //
  HRESULT __stdcall DAdvise(FORMATETC* pFormatEtc,
                            DWORD advf,
                            IAdviseSink* pAdvSink,
                            DWORD* pdwConnection) override {
    return OLE_E_ADVISENOTSUPPORTED;
  }
  //
  //  IDataObject::DUnadvise
  //
  HRESULT __stdcall DUnadvise(DWORD dwConnection) override {
    return OLE_E_ADVISENOTSUPPORTED;
  }

  //
  //  IDataObject::EnumDAdvise
  //
  HRESULT __stdcall EnumDAdvise(IEnumSTATDATA** ppEnumAdvise) override {
    return OLE_E_ADVISENOTSUPPORTED;
  }

  //
  // Constructor / Destructor
  //
  CDataObject(FORMATETC* fmtetc, STGMEDIUM* stgmed, int count) {
    m_lRefCount = 1;
    m_nNumFormats = count;

    m_pFormatEtc = new (std::nothrow) FORMATETC[count];
    m_pStgMedium = new (std::nothrow) STGMEDIUM[count];

    for (int i = 0; i < count; i++) {
      m_pFormatEtc[i] = fmtetc[i];
      m_pStgMedium[i] = stgmed[i];
    }
  }
  ~CDataObject() {
    // cleanup
    if (m_pFormatEtc)
      delete[] m_pFormatEtc;
    if (m_pStgMedium)
      delete[] m_pStgMedium;
  }

 private:
  HGLOBAL DupMem(HGLOBAL hMem) {
    // lock the source memory object
    DWORD len = GlobalSize(hMem);
    PVOID source = GlobalLock(hMem);

    // create a fixed "global" block - i.e. just
    // a regular lump of our process heap
    PVOID dest = GlobalAlloc(GMEM_FIXED, len);

    memcpy(dest, source, len);

    GlobalUnlock(hMem);

    return dest;
  }

  int LookupFormatEtc(FORMATETC* pFormatEtc) {
    for (int i = 0; i < m_nNumFormats; i++) {
      if ((pFormatEtc->tymed & m_pFormatEtc[i].tymed) &&
          pFormatEtc->cfFormat == m_pFormatEtc[i].cfFormat &&
          pFormatEtc->dwAspect == m_pFormatEtc[i].dwAspect) {
        return i;
      }
    }

    return -1;
  }

  //
  // any private members and functions
  //
  LONG m_lRefCount;

  FORMATETC* m_pFormatEtc;
  STGMEDIUM* m_pStgMedium;
  LONG m_nNumFormats;

 public:
  static HRESULT CreateDropObject(HGLOBAL hDrop, IDataObject** ppDataObject) {
    if (!ppDataObject) {
      return E_INVALIDARG;
    }

    FORMATETC fmtetc = {CF_HDROP, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
    STGMEDIUM stgmed = {TYMED_HGLOBAL, {0}, 0};

    // transfer the drop handle into the IDataObject
    stgmed.hGlobal = hDrop;

    return CreateDataObject(&fmtetc, &stgmed, 1, ppDataObject);
  }

  static HRESULT CreateDataObject(FORMATETC* fmtetc,
                                  STGMEDIUM* stgmeds,
                                  UINT count,
                                  IDataObject** ppDataObject) {
    if (ppDataObject == 0)
      return E_INVALIDARG;

    *ppDataObject = new CDataObject(fmtetc, stgmeds, count);

    return (*ppDataObject) ? S_OK : E_OUTOFMEMORY;
  }
};
#endif  // !CUSTOM_DROP_DATA_IMPL_HPP_

  3. 清理工作，在窗口关闭时，清空属性, 原代码如下(src\ui\views\widget\desktop_aura\desktop_drag_drop_client_win.cc)：

    void DesktopDragDropClientWin::OnNativeWidgetDestroying(HWND window) {
  if (drop_target_.get()) {   
    RevokeDragDrop(window);    
    drop_target_ = nullptr;
  }
}

    改为：

    void DesktopDragDropClientWin::OnNativeWidgetDestroying(HWND window) {
  if (drop_target_.get()) {
    if (IsUserAnAdmin()) {
      RemovePropW(window,
                  L"drag-drop-callback-{2E8EAA96-6DA5-49CB-8DE7-042F0796CDB6}");
    } else {
      RevokeDragDrop(window);
    }
    drop_target_ = nullptr;
  }
}

    清空属性drag-drop-callback-{2E8EAA96-6DA5-49CB-8DE7-042F0796CDB6},以避免非预期的使用；

  4. 结束；

结语：

以上方式的实现也并非完美，WM_DROPFILES因为仅仅是投放时才会触发，因此在拖放文件时，不能像IDropTarget一样可以设置鼠标样式，以及相应的移入移除事件；

最完美的办法应为：向explorer中注入一个dll，由该dll去检测拖拽事件，并模拟IDropTarget向electron发送对应的事件消息;

欢迎指正讨论；

完。

星空漫步者
关注
Electron程序不能拖拽文件的解决方案
06-01 1115
但是，如果以管理员权限运行Electron应用，由于资源管理器权限级别不及管理员级别高，文件拖拽操作将被禁止。今天收到客户提交的一个BUG反馈，报告我们的客户端软件不支持文件拖放操作。鼠标在拖拽文件至软件窗口时显示“禁止”标志，尝试使用其他软件进行文件拖拽都没有此问题。后来无意间注意到软件快捷方式上的小盾牌图标，发现客户是在用管理员权限运行此程序，于是我想到了Windows的UAC机制。确认原因后，我重新安装了软件，修改了默认安装目录，并将运行权限更改为标准用户。重新启动软件后，文件拖拽操作恢复正常。
在Electron中简单实现拖拽功能
weixin_40494579的博客
11-06 4361
背景 实现简单的拖拽文件、图片到系统本地，拖拽消息体文本发送（类似于微信、QQ中的功能） 实现拖拽到本地系统，不考虑mouse实现方式，使用Electron中的startdrag配合Browser的Drag and Drop startdrag Electron API (startDrag) 提供拖拽文件到桌面系统本地的能力 使用情况比较简单，主进程监听事件，调用startdrag // main-process ipcMain.on('drag-start', (event) => { e
electron 自定义窗体拖拽功能
最新发布
虎康的博客
08-14 460
在写好窗口后发现不能拖拽，这个时候就需要我们自行去设置一个拖拽功能。
使用 Electron 构建桌面应用（拖动控制篇）
weixin_30725467的博客
07-26 516
当窗口被定义了大小，我们也就是在自定义这个窗口，使得它不可拉伸没有框架，让它看起来就像一个真正的声效器浮在桌面上。 现在问题来了 – 要如何移动或者关闭一个没有标题栏的窗口。 很快我就会说到自定义窗口（和应用）的关闭动作，还会谈到如何在主进程和渲染器进程中通信。不过现在让我们先把目光聚焦到“拖拽效果”上。你可以在 app/css 目录下找到 index.css 文件： html,...
关于electron实现拖拽功能
m0_47538449的博客
02-21 991
主进程设置窗口的坐标时，一定不能使用setPosition()，只设置窗口坐标，不设置大小会出现问题，当系统屏幕锁放在175%或者150%时，拖拽窗口，窗口就会无限的放大，后面我改成了setbounds限制了大小就解决了。2.但是我这边的需求是，实现整个窗口拖拽的同时里面的内容可以进行滚动，方法一不能实现，所以后面使用了鼠标监听mousedown事件，主进程main.js接受渲染进程的事件，设置窗口的坐标和大小，win是我定义好的窗口。
Electron在Windows下以管理员运行
永恒开发
01-13 6947
electron在windows下以管理员方式运行
【electron】复制粘贴图片 && 拖拽文件
谁说学美术将来只能卖画了，我也有自己的梦想。
11-27 990
对话详情页 图片 类信息，单机右键弹出的操作栏中增加【复制】功能，复制后将该内容以图片形式保存在本地剪切板中，可直接粘贴到PC端输入栏中或文字内容编辑区（例如微信，飞书等其他IM会话软件内容输入区）粘贴图片有一个问题就是 从粘贴板获取到的File对象中没有 path 也就是文件路径， 需要我们自己保存下来获取到路径才能发送，腾讯IM的Electron SDK 目前只能这么操作。2.2 发送时候 发现没有PATH 发送不了 调用Electron controller 保存到本地 拿到本地路径。
electron-watch:更改主要过程文件时自动重新启动Electron应用程序
05-28
更改主过程文件后，自动重新启动Electron应用程序。 安装 npm install electron-watch 用法 例如， package.json ： { //... "scripts" : { "dev:electron-main" : "cross-env NODE_ENV='development' ...
electron-mocha:在Electron中运行Mocha测试
05-02
请注意，如果您使用的是Mac OS X，则路径将指向实际的可执行文件，而不是应用程序目录，例如/Applications/Electron.app/Contents/MacOS/Electron 。 运行测试 electron-mocha几乎是常规mocha命令的直接替代品，...
electron源码保护
04-09
总的来说，"electron源码保护"是一项旨在增强Electron应用源码安全性的技术，通过将源码编译为二进制文件，防止未授权的访问和篡改。使用如ByteNode这样的工具，开发者可以在不牺牲应用功能的前提下，为自己的源码...
electron-windows:优雅地管理Electron的多个窗口并提供强大的功能
05-01
优雅地管理Electron的多个窗口并提供强大的功能。 贡献者 此项目遵循git-contributor，该在Fri Dec 11 2020 11:31:32 GMT+0800自动更新。 分期付款 $ npm i electron-windows --save 演示版 蜜蜂 在里面 const ...
gelectron：适用于Electron，Qt和CEF的游戏叠加解决方案，就像不和谐游戏叠加和Steam游戏叠加一样，将任何应用程序注入到游戏叠加中
02-04
适用于任何桌面GUI（例如Electron，Qt和CEF）的游戏覆盖解决方案 :high_voltage: 电子游戏叠加层 利用网络的力量将任何网络应用注入游戏中 屏幕截图 注意 需要Visual Sudio 2017来构建本机C ++项目。 使用32位节点安装32位电子（无论电子版本如何，游戏叠加都支持x64），如果要使用64位电子，请修改client / package.json中的compile：electron脚本。 如果游戏将其禁用，我们可以关联一个新的IME扩展程序，但是在全屏模式下，它将导致窗口失去焦点。 node-gyp需要在系统上安装python2并确保将其添加到PATH中 运行演示 git克隆
vue-electron-chrome：基于电子开发的应用浏览器
01-29
电子浏览器 一个基于电子开发的应用浏览器，主要用于网页APP全屏模式运行，使WEB应用看起来更像一个原生应用浏览器主题可定制，配置简单，... build/electron-browser Setup 0.0.0.exe为安装文件。 软件运行配置说明
第14课：Electron 应用中的拖拽操作
一个被知识诅咒的人
09-22 2001
如果应用程序需要操作外部文件，通常会使用文件打开对话框选择这个文件，然后交由程序做进一步处理，文件打开对话框会返回一个或多个选择的文件路径。不过更友好的方式是将文件拖动到程序的窗口或某一个区域上，然后同样会返回一个或多个文件给应用程序，这种行为称为拖拽操作。 本节将会通过两个案例介绍如何实现 Electron 应用的拖拽操作。 14.1 拖拽操作：拖放并显示图像 本节将通过一个简单的案例演示如何实...
electron-vue 开发(4) 打包工具的使用以及管理员权限
weixin_34311757的博客
04-10 991
electron官网 开发环境 win10X64 Vscode nodejs yarn 使用到的框架 vue全家桶 element-ui mui electron-vue 技术栈 c++ nodejs html+css+js 接上篇 electron 中我们开发完成之后, 需要打包软件.官方推荐的打包工具有2中:electron-builder 和 electron-packag...
Electron-vue + electron-builder 配置打包后以管理员身份运行
weixin_41594790的博客
04-28 1668
【代码】Electron-vue + electron-builder 配置打包后以管理员身份运行。
vue electron 应用在windows系统上以管理员权限打开应用
qq_26328861的博客
02-06 1549
vue electron 应用在windows系统上以管理员权限打开应用
03_Electron 主进程和渲染进程、点击（拖放）打开文件功能
所学所思
08-08 1248
在页面运行其他脚本之前预先加载指定的脚本， 无论页面是否集成 Node，此脚本都可以访问 所有 Node API 脚本路径为文件的绝对路径。： 进程（process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配的调度的基本单位，是操作系统结构的基础。2、如果不使用 preload 加载的 js ，Electron5.x 之后没法在渲染进程中直接使用 nodejs，在主进程 中实例化 BrowserWindow 创建的 Web 页面被称为渲染进程，一个 Electron 应用。
第四节 Electron 调用H5事件结合node模块fs 实现文件拖拽读取
08-11 955
本文就介绍了使用H5的拖拽加上node的fs模块在electron里实现拖拽并读取文件内容。以上就是今天要讲的内容，主要思路就是利用H5的拖拽事件获取到文件的地址在用node提供的fs模块读取其内容并赋值给DOM。...
Electron API 演示：创建与管理窗口
1. `require('electron').remote` 让你在渲染进程中可以使用主进程的`BrowserWindow`模块。 2. `path.join()` 方法用于组合路径，生成一个规范化的路径字符串，确保路径正确无误。 3. `__dirname` 变量提供了当前...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值