slayer.c

winNT技术操作系统,国外开放的原代码和LIUX一样

    rfc = (ULONG)InterlockedDecrement(&this->ref);
    if (rfc == 0)
    {
        HeapFree(GetProcessHeap(),
                 0,
                 this);
        InterlockedDecrement(&dllrefs);
    }
    return rfc;
}

HRESULT STDMETHODCALLTYPE
ICompatibilityPage_fnAddPages(LPCOMPATIBILITYPAGE this,
                              LPFNADDPROPSHEETPAGE lpfnAddPage,
                              LPARAM lParam)
{
    PROPSHEETPAGE psp = {0};
    HPROPSHEETPAGE hPage;

    psp.dwSize = sizeof(psp);
    psp.dwFlags = PSP_DEFAULT | PSP_USECALLBACK;
    psp.hInstance = hInstance;
    psp.pszTemplate = MAKEINTRESOURCE(IDD_SLAYERSHEET);
    psp.pfnDlgProc = CompatibilityPageProc;
    psp.lParam = (LPARAM)this;
    psp.pfnCallback = CompatibilityPageCallback;

    hPage = CreatePropertySheetPage(&psp);

    if (hPage != NULL)
    {
        if (!lpfnAddPage(hPage,
                         lParam))
        {
            DestroyPropertySheetPage(hPage);
            return E_OUTOFMEMORY;
        }

        ICompatibilityPage_fnAddRef(this);
        return S_OK;
    }

    return E_FAIL;
}

HRESULT STDMETHODCALLTYPE
ICompatibilityPage_fnReplacePage(LPCOMPATIBILITYPAGE this,
                                 UINT uPageID,
                                 LPFNADDPROPSHEETPAGE lpfnReplacePage,
                                 LPARAM lParam)
{
    return E_NOTIMPL;
}

HRESULT STDMETHODCALLTYPE
ICompatibilityPage_fnInitialize(LPCOMPATIBILITYPAGE this,
                                LPCITEMIDLIST pidlFolder,
                                IDataObject *pdtobj,
                                HKEY hkeyProgID)
{
    FORMATETC fetc;
    STGMEDIUM smdm;

    if (pdtobj == NULL)
    {
        return E_INVALIDARG;
    }

    fetc.cfFormat = CF_HDROP;
    fetc.ptd = NULL;
    fetc.dwAspect = DVASPECT_CONTENT;
    fetc.lindex = -1;
    fetc.tymed = TYMED_HGLOBAL;

    if (SUCCEEDED(pdtobj->lpVtbl->GetData(pdtobj,
                                          &fetc,
                                          &smdm)))
    {
        UINT nFiles = DragQueryFile(smdm.hGlobal,
                                    0xFFFFFFFF,
                                    this->szFile,
                                    sizeof(this->szFile) / sizeof(this->szFile[0]));
        if (nFiles == 1)
        {
            /* FIXME - support editing of multiple files later */
            DragQueryFile(smdm.hGlobal,
                          0, this->szFile,
                          sizeof(this->szFile) / sizeof(this->szFile[0]));
            ReleaseStgMedium(&smdm);

            return S_OK;
        }
    }

    return E_FAIL;
}

HRESULT STDMETHODCALLTYPE
ICompatibilityPage_fnCreateInstance(LPCOMPATIBILITYPAGE this,
                                    LPUNKNOWN pUnkOuter,
                                    REFIID riid,
                                    PVOID *ppvObject)
{
    LPCOMPATIBILITYPAGE cp;

    if (pUnkOuter != NULL &&
        !IsEqualIID(riid,
                    &IID_IUnknown))
    {
        return CLASS_E_NOAGGREGATION;
    }

    cp = ICompatibilityPage_fnConstructor();
    if (cp != NULL)
    {
        HRESULT ret = ICompatibilityPage_fnQueryInterface(cp,
                                                          riid,
                                                          ppvObject);
        ICompatibilityPage_fnRelease(cp);
        return ret;
    }

    return E_OUTOFMEMORY;
}

HRESULT STDMETHODCALLTYPE
ICompatibilityPage_fnLockServer(LPCOMPATIBILITYPAGE this,
                                BOOL fLock)
{
    if (fLock)
    {
        InterlockedIncrement(&dllrefs);
    }
    else
    {
        InterlockedDecrement(&dllrefs);
    }

    return S_OK;
}

/******************************************************************************
   Exported
 ******************************************************************************/

HRESULT STDCALL
DllGetClassObject(REFCLSID rclsid,
                  REFIID iid,
                  LPVOID *ppv)
{
    if (ppv == NULL)
    {
        return E_INVALIDARG;
    }

    if (IsEqualCLSID(&CLSID_ICompatibilityPage,
                     rclsid))
    {
        LPCOMPATIBILITYPAGE iface = ICompatibilityPage_fnConstructor();
        if (iface != NULL)
        {
            HRESULT ret = ICompatibilityPage_fnQueryInterface(iface,
                                                              iid,
                                                              ppv);
            ICompatibilityPage_fnRelease(iface);
            return ret;
        }
        return E_OUTOFMEMORY;
    }

    return CLASS_E_CLASSNOTAVAILABLE;
}

HRESULT STDCALL
DllCanUnloadNow(VOID)
{
    return ((dllrefs == 0) ? S_OK : S_FALSE);
}

static int
UnregisterPropSheetHandler(LPTSTR szType)
{
    TCHAR szKey[255];

    _stprintf(szKey,
              TEXT("%s\\shellex\\PropertySheetHandlers\\Compatibility Property Page"),
              szType);

    return RegDeleteKey(HKEY_CLASSES_ROOT,
                        szKey);
}

HRESULT STDCALL
DllUnregisterServer(VOID)
{
    LONG e;
    HKEY hk;
    WCHAR szGuid[40];
  
    StringFromGUID2(&CLSID_ICompatibilityPage,
                    szGuid,
                    sizeof(szGuid) / sizeof(szGuid[0]));

    e = RegOpenKey(HKEY_LOCAL_MACHINE,
                   TEXT("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Shell Extensions\\Approved"),
                   &hk);
    if (e == ERROR_SUCCESS)
    {
        e = RegDeleteValueW(hk,
                            szGuid);
        RegCloseKey(hk);
    }

    if (e == ERROR_SUCCESS)
    {
        e = UnregisterPropSheetHandler(TEXT("exefile"));
    }

    if (e == ERROR_SUCCESS)
    {
        e = RegOpenKey(HKEY_CLASSES_ROOT,
                       TEXT("CLSID"),
                       &hk);
        if (e == ERROR_SUCCESS)
        {
            TCHAR szInprocKey[255];

            _stprintf(szInprocKey,
                      TEXT("%ws\\InprocServer32"),
                      szGuid);

            e = RegDeleteKey(hk,
                             szInprocKey);
            if (e == ERROR_SUCCESS)
            {
                e = RegDeleteKeyW(hk,
                                  szGuid);
            }
            RegCloseKey(hk);
        }
    }

    return ((e == ERROR_SUCCESS) ? S_OK : E_ACCESSDENIED);
}

static int
RegisterPropSheetHandler(LPTSTR szType,
                         LPWSTR szGuid)
{
    TCHAR szKey[255];
    HKEY hk;
    int e;

    _stprintf(szKey,
              TEXT("%s\\shellex\\PropertySheetHandlers\\Compatibility Property Page"),
              szType);

    e = RegCreateKey(HKEY_CLASSES_ROOT,
                     szKey,
                     &hk);
    if (e == ERROR_SUCCESS)
    {
        e = RegSetValueExW(hk,
                           NULL,
                           0,
                           REG_SZ,
                           (BYTE*)szGuid,
                           (wcslen(szGuid) + 1) * sizeof(WCHAR));
        RegCloseKey(hk);
    }

    return e;
}

HRESULT STDCALL
DllRegisterServer(VOID)
{
    LONG e = E_ACCESSDENIED;
    HKEY hk;
    WCHAR szGuid[40];
    WCHAR szDescription[255];
    TCHAR szModule[MAX_PATH + 1];
    int lnszDescription;

    if (!GetModuleFileName(hInstance,
                           szModule,
                           sizeof(szModule) / sizeof(szModule[0])))
    {
        return E_ACCESSDENIED;
    }

    /* unregister first */
    DllUnregisterServer();

    lnszDescription = LoadStringW(hInstance,
                                  IDS_DESCRIPTION,
                                  szDescription, sizeof(szDescription) / sizeof(szDescription[0]));
    if (lnszDescription > 0)
    {
        StringFromGUID2(&CLSID_ICompatibilityPage,
                        szGuid,
                        sizeof(szGuid) / sizeof(szGuid[0]));

        e = RegOpenKey(HKEY_LOCAL_MACHINE,
                       TEXT("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Shell Extensions\\Approved"),
                       &hk);
        if (e == ERROR_SUCCESS)
        {
            e = RegSetValueExW(hk,
                               szGuid,
                               0,
                               REG_SZ,
                               (BYTE*)szDescription,
                               (lnszDescription + 1) * sizeof(WCHAR));
            RegCloseKey(hk);
        }

        if (e == ERROR_SUCCESS)
        {
            TCHAR szInprocKey[255];

            _stprintf(szInprocKey,
                      TEXT("CLSID\\%ws\\InprocServer32"),
                      szGuid);

            e = RegCreateKey(HKEY_CLASSES_ROOT,
                             szInprocKey,
                             &hk);
            if (e == ERROR_SUCCESS)
            {
                e = RegSetValueEx(hk,
                                  NULL,
                                  0,
                                  REG_SZ,
                                  (BYTE*)szModule,
                                  (_tcslen(szModule) + 1) * sizeof(TCHAR));
                if (e == ERROR_SUCCESS)
                {
                    const TCHAR szApartment[] = TEXT("Apartment");

                    e = RegSetValueEx(hk,
                                      TEXT("ThreadingModel"),
                                      0,
                                      REG_SZ,
                                      (BYTE*)szApartment,
                                      (_tcslen(szApartment) + 1) * sizeof(TCHAR));
                }

                RegCloseKey(hk);
            }
        }

        if (e == ERROR_SUCCESS)
        {
            e = RegisterPropSheetHandler(TEXT("exefile"),
                                         szGuid);
        }
    }

    return ((e == ERROR_SUCCESS) ? S_OK : E_ACCESSDENIED);
}

BOOL STDCALL
DllMain(HINSTANCE hinstDLL,
        DWORD dwReason,
        LPVOID lpvReserved)
{
    switch (dwReason)
    {
        case DLL_PROCESS_ATTACH:
            hInstance = hinstDLL;
            DisableThreadLibraryCalls(hInstance);
            break;
    }

    return TRUE;
}