发新话题
打印

一个建立快捷方式的函数

一个建立快捷方式的函数

如果要为 可执行文件AAA.exe 创建快捷方式 AAA.LNK 并指定运行参数 /ID=1 用AAA.exe 自带的图标的话就这么调用:
CreateShortcut(_T("AAA.exe"),_T("AAA.exe"),_T("AAA.LNK"),_T("/ID=1"));
复制内容到剪贴板
代码:
//   建立快捷方式   
//   参数   lpszExe:   EXE   文件全路径名   
//   参数   lpszLnk:   快捷方式文件全路径名   
//   参数   lpszVar:   快捷方式运行时的参数
//   参数   lpszIco:   图标可以是.ico .dll .exe 文件
void   CreateShortcut(LPCTSTR   lpszExe,  LPCTSTR   lpszIco,   LPCTSTR   lpszLnk,   LPCTSTR   lpszVar)   
{   

        ::CoInitialize(   NULL   );   

        IShellLink   *   psl   =   NULL;   
        IPersistFile   *   ppf   =   NULL;   

        HRESULT   hr   =   ::CoCreateInstance(     //   启动组件   
                CLSID_ShellLink,             //   快捷方式   CLSID   
                NULL,                                   //   聚合用(注4)   
                CLSCTX_INPROC_SERVER,   //   进程内(Shell32.dll)服务   
                IID_IShellLink,               //   IShellLink   的   IID   
                (LPVOID   *)&psl   );           //   得到接口指针   

        if   (   SUCCEEDED(hr)   )   
        {   
                psl->SetPath(   lpszExe   );     //   全路径程序名   
                psl->SetArguments(lpszVar);             //   命令行参数   
                psl->SetIconLocation(lpszIco,0);       //   图标   
                // psl->SetHotkey();                   //   快捷键   
                // psl->SetShowCmd();                 //   窗口尺寸   

                //   根据   EXE   的文件名,得到目录名   
                TCHAR   szWorkPath[   MAX_PATH   ];   
                ::_tcscpy(   szWorkPath,   lpszExe   );   
                LPTSTR   lp   =   szWorkPath;   
                while(   *lp   )         lp++;   
                while(  _T('\\')   !=   *lp   )         lp--;   
                *lp=0;   

                //   设置   EXE   程序的默认工作目录   
                psl->SetWorkingDirectory(   szWorkPath   );   

                hr   =   psl->QueryInterface(     //   查找持续性文件接口指针   
                        IID_IPersistFile,             //   持续性接口   IID   
                        (LPVOID   *)&ppf   );             //   得到接口指针   

                if   (   SUCCEEDED(hr)   )   
                {   
                        USES_CONVERSION;               //   转换为   UNICODE   字符串   
                        ppf->Save(   T2COLE(   lpszLnk   ),   TRUE   );     //   保存   
                }   
        }   
        if   (   ppf   ) ppf->Release();   
        if   (   psl   ) psl->Release();   

        ::CoUninitialize();   
}   
chinacrackinggroup@qq.com
update ccg_members set groupid = 28 where groupid = 8

TOP

一个给我参考的文件

复制内容到剪贴板
代码:
// MtlCom.h
   

#ifndef __MTLCOM_H__
#define __MTLCOM_H__

#pragma once

#ifndef __MTLBASE_H__
        #error mtlcom.h requires mtlbase.h to be included first
#endif

#ifndef _SHLOBJ_H_
        #error mtlcom.h requires shlobj.h to be included first
#endif

////////////////////////////////////////////////////////////////////////////
// MTL Version 0.10
// Copyright (C) 2001 MB
// All rights unreserved.
//
// This file is a part of Mb Template Library.
// The code and information is *NOT* provided "as-is" without
// warranty of any kind, either expressed or implied.
//
// MtlCom.h: Last updated: February 12, 2001
////////////////////////////////////////////////////////////////////////////

#define HANDLE_MENU_MESSAGE_CONTEXTMENU(x) \
        if(uMsg == WM_INITMENUPOPUP || uMsg == WM_DRAWITEM || uMsg == WM_MEASUREITEM) \
        { \
                if (x != NULL) { \
                        bHandled = TRUE; \
                        lResult = x->HandleMenuMsg(uMsg, wParam, lParam); \
                } \
                else { \
                        bHandled = FALSE; \
                } \
                if(bHandled) \
                        return TRUE; \
        }

namespace MTL
{

inline void MtlCheckError(SCODE sc)
{
        if (FAILED(sc)) {
                if (sc == E_OUTOFMEMORY)
                        ATLTRACE2(atlTraceCOM, 0, "MtlCheckError Error : OOM\n");
                else
                        ATLTRACE2(atlTraceCOM, 0, "MtlCheckError Error : MISC\n");
        }
}

// cf. "ATL Internals"
inline HRESULT WINAPI _This(void* pv, REFIID iid, void** ppvObject, DWORD) {
        ATLASSERT(iid == IID_NULL);
        *ppvObject = pv;
        return S_OK;
}

// Helper for creating default FORMATETC from cfFormat
LPFORMATETC _MtlFillFormatEtc(
        LPFORMATETC lpFormatEtc, CLIPFORMAT cfFormat, LPFORMATETC lpFormatEtcFill)
{
        ATLASSERT(lpFormatEtcFill != NULL);
        if (lpFormatEtc == NULL && cfFormat != 0)
        {
                lpFormatEtc = lpFormatEtcFill;
                lpFormatEtc->cfFormat = cfFormat;
                lpFormatEtc->ptd = NULL;
                lpFormatEtc->dwAspect = DVASPECT_CONTENT;
                lpFormatEtc->lindex = -1;
                lpFormatEtc->tymed = (DWORD) -1;
        }
        return lpFormatEtc;
}

bool MtlIsDataAvailable(IDataObject* pDataObject, CLIPFORMAT cfFormat, LPFORMATETC lpFormatEtc = NULL)
{
        ATLASSERT(pDataObject != NULL);

        // fill in FORMATETC struct
        FORMATETC formatEtc;
        lpFormatEtc = _MtlFillFormatEtc(lpFormatEtc, cfFormat, &formatEtc);

        // attempt to get the data
        return pDataObject->QueryGetData(lpFormatEtc) == S_OK;
}

bool MtlGetDropFileName(IDataObject* pDataObject, CSimpleArray& arrFileNames)
{
        if (!MtlIsDataAvailable(pDataObject, CF_HDROP))
                return false;

        FORMATETC formatetc = { CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
        STGMEDIUM stgmedium;
        HRESULT hr = pDataObject->GetData(&formatetc, &stgmedium);
        if (FAILED(hr) || stgmedium.hGlobal == NULL) {
                return false;
        }

        HDROP hDropInfo = (HDROP)stgmedium.hGlobal;

        UINT nFiles = ::DragQueryFile(hDropInfo, (UINT)-1, NULL, 0);
        for (UINT iFile = 0; iFile < nFiles; iFile++) {
                TCHAR szFileName[_MAX_PATH];
                ::DragQueryFile(hDropInfo, iFile, szFileName, _MAX_PATH);
                arrFileNames.Add(CString(szFileName));
        }
        ::DragFinish(hDropInfo);// required?
         
        ::ReleaseStgMedium(&stgmedium);

        if (arrFileNames.GetSize() > 0)
                return true;
        else
                return false;
}

// Implementation
bool MtlGetHGlobalText(IDataObject* pDataObject, CString& strText, CLIPFORMAT cfFormat = CF_TEXT)
{
        bool bResult = false;

        if (!MtlIsDataAvailable(pDataObject, cfFormat))
                return false;

        FORMATETC formatetc = { cfFormat, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
        STGMEDIUM stgmedium;
        HRESULT hr = pDataObject->GetData(&formatetc, &stgmedium);
        if (SUCCEEDED(hr)) {
                if (stgmedium.hGlobal != NULL) {
                        HGLOBAL hText = stgmedium.hGlobal;
                        strText = reinterpret_cast(::GlobalLock(hText));
                        ::GlobalUnlock(hText);
                        bResult = true;
                }
                ::ReleaseStgMedium(&stgmedium);
        }

        return bResult;
}

// Even IE creates a shortcut file for every link, what the hell is OLE.
template  
HDROP MtlCreateDropFile(_InputStringIter __first, _InputStringIter __last)
{
        if (__first == __last)
                return NULL;

        //filename\0...\0filename\0...\0filename\0\0
        int nLen = 0;

        _InputStringIter it;
        for (it = __first; it != __last; ++it) {
                nLen += ::lstrlen(*it);
                nLen += 1;        // for '\0' separator
        }
        nLen += 1;                // for the last '\0'

        HDROP hDrop = (HDROP)::GlobalAlloc(GHND, sizeof(DROPFILES) + nLen*sizeof(TCHAR));
        if (hDrop == NULL)
                return NULL;

        LPDROPFILES lpDropFiles;
        lpDropFiles = (LPDROPFILES)::GlobalLock(hDrop);
        lpDropFiles->pFiles = sizeof(DROPFILES);
        lpDropFiles->pt.x = 0;
        lpDropFiles->pt.y = 0;
        lpDropFiles->fNC = FALSE;

#ifdef _UNICODE
        lpDropFiles->fWide = TRUE;
#else
        lpDropFiles->fWide = FALSE;
#endif

        TCHAR* psz = (TCHAR*)(lpDropFiles + 1);
        for (it = __first; it != __last; ++it) {
                ::lstrcpy(psz, (*it));
                psz += ::lstrlen(*it) + 1;// skip a '\0' separator
        }

        ::GlobalUnlock(hDrop);
        return hDrop;
}

HDROP MtlCreateDropFile(CSimpleArray& arrFiles)
{
        if (arrFiles.GetSize() == 0)
                return NULL;

        //filename\0...\0filename\0...\0filename\0\0
        int nLen = 0;

        int i;
        for (i = 0; i < arrFiles.GetSize(); ++i) {
                nLen += arrFiles[i].GetLength();
                nLen += 1;        // for '\0' separator
        }
        nLen += 1;                // for the last '\0'

        HDROP hDrop = (HDROP)::GlobalAlloc(GHND, sizeof(DROPFILES) + nLen*sizeof(TCHAR));
        if (hDrop == NULL)
                return NULL;

        LPDROPFILES lpDropFiles;
        lpDropFiles = (LPDROPFILES)::GlobalLock(hDrop);
        lpDropFiles->pFiles = sizeof(DROPFILES);
        lpDropFiles->pt.x = 0;
        lpDropFiles->pt.y = 0;
        lpDropFiles->fNC = FALSE;

#ifdef _UNICODE
        lpDropFiles->fWide = TRUE;
#else
        lpDropFiles->fWide = FALSE;
#endif

        TCHAR* psz = (TCHAR*)(lpDropFiles + 1);
        for (i = 0; i < arrFiles.GetSize(); ++i) {
                ::lstrcpy(psz, arrFiles[i]);
                psz += arrFiles[i].GetLength() + 1;// skip a '\0' separator
        }

        ::GlobalUnlock(hDrop);
        return hDrop;
}

/////////////////////////////////////////////////////////////////////////////
// CSafeArray class
typedef const SAFEARRAY* LPCSAFEARRAY;
typedef const VARIANT* LPCVARIANT;
/////////////////////////////////////////////////////////////////////////////
// Helper for initializing CComSafeArray
static bool _MtlCompareSafeArrays(SAFEARRAY* parray1, SAFEARRAY* parray2)
{
        bool bCompare = false;

        // If one is NULL they must both be NULL to compare
        if (parray1 == NULL || parray2 == NULL)
        {
                return parray1 == parray2;
        }

        // Dimension must match and if 0, then arrays compare
        DWORD dwDim1 = ::SafeArrayGetDim(parray1);
        DWORD dwDim2 = ::SafeArrayGetDim(parray2);
        if (dwDim1 != dwDim2)
                return false;
        else if (dwDim1 == 0)
                return true;

        // Element size must match
        DWORD dwSize1 = ::SafeArrayGetElemsize(parray1);
        DWORD dwSize2 = ::SafeArrayGetElemsize(parray2);
        if (dwSize1 != dwSize2)
                return false;

        long* pLBound1 = NULL;
        long* pLBound2 = NULL;
        long* pUBound1 = NULL;
        long* pUBound2 = NULL;

        void* pData1 = NULL;
        void* pData2 = NULL;

        // Bounds must match
        ATLTRY(pLBound1 = new long[dwDim1]);
        ATLTRY(pLBound2 = new long[dwDim2]);
        ATLTRY(pUBound1 = new long[dwDim1]);
        ATLTRY(pUBound2 = new long[dwDim2]);

        size_t nTotalElements = 1;

        // Get and compare bounds
        for (DWORD dwIndex = 0; dwIndex < dwDim1; dwIndex++)
        {
                MtlCheckError(::SafeArrayGetLBound(
                        parray1, dwIndex+1, &pLBound1[dwIndex]));
                MtlCheckError(::SafeArrayGetLBound(
                        parray2, dwIndex+1, &pLBound2[dwIndex]));
                MtlCheckError(::SafeArrayGetUBound(
                        parray1, dwIndex+1, &pUBound1[dwIndex]));
                MtlCheckError(::SafeArrayGetUBound(
                        parray2, dwIndex+1, &pUBound2[dwIndex]));

                // Check the magnitude of each bound
                if (pUBound1[dwIndex] - pLBound1[dwIndex] !=
                        pUBound2[dwIndex] - pLBound2[dwIndex])
                {
                        delete[] pLBound1;
                        delete[] pLBound2;
                        delete[] pUBound1;
                        delete[] pUBound2;

                        return false;
                }

                // Increment the element count
                nTotalElements *= pUBound1[dwIndex] - pLBound1[dwIndex] + 1;
        }

        // Access the data
        MtlCheckError(::SafeArrayAccessData(parray1, &pData1));
        MtlCheckError(::SafeArrayAccessData(parray2, &pData2));

        // Calculate the number of bytes of data and compare
        size_t nSize = nTotalElements * dwSize1;
        int nOffset = memcmp(pData1, pData2, nSize);
        bCompare = (nOffset == 0);

        // Release the array locks
        MtlCheckError(::SafeArrayUnaccessData(parray1));
        MtlCheckError(::SafeArrayUnaccessData(parray2));

        // Clean up bounds arrays
        delete[] pLBound1;
        delete[] pLBound2;
        delete[] pUBound1;
        delete[] pUBound2;

        return bCompare;
}
/////////////////////////////////////////////////////////////////////////////
// CComSafeArray class
class CComSafeArray : public tagVARIANT
{
public:
// Data members
        // Cache info to make element access (operator []) faster
        DWORD m_dwElementSize;
        DWORD m_dwDims;

//Constructors
        CComSafeArray()
        {
                _SafeArrayInit(this);
                vt = VT_EMPTY;
        }

        ~CComSafeArray()
        {
                Clear();
        }         

        CComSafeArray(const SAFEARRAY& saSrc, VARTYPE vtSrc)
        {
                _SafeArrayInit(this);
                vt = (VARTYPE)(vtSrc | VT_ARRAY);
                MtlCheckError(::SafeArrayCopy((LPSAFEARRAY)&saSrc, &parray));
                m_dwDims = GetDim();
                m_dwElementSize = GetElemSize();
        }

        CComSafeArray(LPCSAFEARRAY pSrc, VARTYPE vtSrc)
        {
                _SafeArrayInit(this);
                vt = (VARTYPE)(vtSrc | VT_ARRAY);
                MtlCheckError(::SafeArrayCopy((LPSAFEARRAY)pSrc, &parray));
                m_dwDims = GetDim();
                m_dwElementSize = GetElemSize();
        }

        CComSafeArray(const CComSafeArray& saSrc)
        {
                _SafeArrayInit(this);
                *this = saSrc;
                m_dwDims = GetDim();
                m_dwElementSize = GetElemSize();
        }

        CComSafeArray(const VARIANT& varSrc)
        {
                _SafeArrayInit(this);
                *this = varSrc;
                m_dwDims = GetDim();
                m_dwElementSize = GetElemSize();
        }

        CComSafeArray(LPCVARIANT pSrc)
        {
                _SafeArrayInit(this);
                *this = pSrc;
                m_dwDims = GetDim();
                m_dwElementSize = GetElemSize();
        }

        void _SafeArrayInit(CComSafeArray* psa)
        {
                ::memset(psa, 0, sizeof(*psa));
        }

        void Clear()
        {
                MTLVERIFY(::VariantClear(this) == NOERROR);
        }

        operator LPVARIANT()
        {
                return this;
        }

        operator LPCVARIANT() const
        {
                return this;
        }

        DWORD GetDim()
        {
                return ::SafeArrayGetDim(parray);
        }

        DWORD GetElemSize()
        {
                return ::SafeArrayGetElemsize(parray);
        }

// Operations
        void Attach(VARIANT& varSrc)
        {
                ATLASSERT(varSrc.vt & VT_ARRAY);

                // Free up previous safe array if necessary
                Clear();

                // give control of data to CComSafeArray
                ::memcpy(this, &varSrc, sizeof(varSrc));
                varSrc.vt = VT_EMPTY;
        }

        VARIANT Detach()
        {
                VARIANT varResult = *this;
                vt = VT_EMPTY;
                return varResult;
        }

// Assignment operators
        CComSafeArray& operator=(const CComSafeArray& saSrc)
        {
                ATLASSERT(saSrc.vt & VT_ARRAY);

                MtlCheckError(::VariantCopy(this, (LPVARIANT)&saSrc));
                return *this;
        }

        CComSafeArray& operator=(const VARIANT& varSrc)
        {
                ATLASSERT(varSrc.vt & VT_ARRAY);

                MtlCheckError(::VariantCopy(this, (LPVARIANT)&varSrc));
                return *this;
        }

        CComSafeArray& operator=(LPCVARIANT pSrc)
        {
                ATLASSERT(pSrc->vt & VT_ARRAY);

                MtlCheckError(::VariantCopy(this, (LPVARIANT)pSrc));
                return *this;
        }

        CComSafeArray& operator=(const CComVariant& varSrc)
        {
                ATLASSERT(varSrc.vt & VT_ARRAY);

                MtlCheckError(::VariantCopy(this, (LPVARIANT)&varSrc));
                return *this;
        }

// Comparison operators
        bool operator==(const SAFEARRAY& saSrc) const
        {
                return _MtlCompareSafeArrays(parray, (LPSAFEARRAY)&saSrc);
        }

        bool operator==(LPCSAFEARRAY pSrc) const
        {
                return _MtlCompareSafeArrays(parray, (LPSAFEARRAY)pSrc);
        }

        bool operator==(const CComSafeArray& saSrc) const
        {
                if (vt != saSrc.vt)
                        return false;

                return _MtlCompareSafeArrays(parray, saSrc.parray);
        }

        bool operator==(const VARIANT& varSrc) const
        {
                if (vt != varSrc.vt)
                        return false;

                return _MtlCompareSafeArrays(parray, varSrc.parray);
        }

        bool operator==(LPCVARIANT pSrc) const
        {
                if (vt != pSrc->vt)
                        return false;

                return _MtlCompareSafeArrays(parray, pSrc->parray);
        }

        bool operator==(const CComVariant& varSrc) const
        {
                if (vt != varSrc.vt)
                        return false;

                return _MtlCompareSafeArrays(parray, varSrc.parray);
        }

        void CreateOneDim(VARTYPE vtSrc, DWORD dwElements,
                const void* pvSrcData = NULL, long nLBound = 0)
        {
                ATLASSERT(dwElements > 0);

                // Setup the bounds and create the array
                SAFEARRAYBOUND rgsabound;
                rgsabound.cElements = dwElements;
                rgsabound.lLbound = nLBound;
                Create(vtSrc, 1, &rgsabound);

                // Copy over the data if neccessary
                if (pvSrcData != NULL)
                {
                        void* pvDestData;
                        AccessData(&pvDestData);
                        memcpy(pvDestData, pvSrcData, GetElemSize() * dwElements);
                        UnaccessData();
                }
        }

        DWORD GetOneDimSize()
        {
                ATLASSERT(GetDim() == 1);

                long nUBound, nLBound;

                GetUBound(1, &nUBound);
                GetLBound(1, &nLBound);

                return nUBound + 1 - nLBound;
        }

        void ResizeOneDim(DWORD dwElements)
        {
                ATLASSERT(GetDim() == 1);

                SAFEARRAYBOUND rgsabound;

                rgsabound.cElements = dwElements;
                rgsabound.lLbound = 0;

                Redim(&rgsabound);
        }

        void Create(VARTYPE vtSrc, DWORD dwDims, DWORD* rgElements)
        {
                ATLASSERT(rgElements != NULL);

                // Allocate and fill proxy array of bounds (with lower bound of zero)
                SAFEARRAYBOUND* rgsaBounds = new SAFEARRAYBOUND[dwDims];

                for (DWORD dwIndex = 0; dwIndex < dwDims; dwIndex++)
                {
                        // Assume lower bound is 0 and fill in element count
                        rgsaBounds[dwIndex].lLbound = 0;
                        rgsaBounds[dwIndex].cElements = rgElements[dwIndex];
                }

                Create(vtSrc, dwDims, rgsaBounds);
                delete[] rgsaBounds;
        }

        void Create(VARTYPE vtSrc, DWORD dwDims, SAFEARRAYBOUND* rgsabound)
        {
                ATLASSERT(dwDims > 0);
                ATLASSERT(rgsabound != NULL);

                // Validate the VARTYPE for SafeArrayCreate call
                ATLASSERT(!(vtSrc & VT_ARRAY));
                ATLASSERT(!(vtSrc & VT_BYREF));
                ATLASSERT(!(vtSrc & VT_VECTOR));
                ATLASSERT(vtSrc != VT_EMPTY);
                ATLASSERT(vtSrc != VT_NULL);

                // Free up old safe array if necessary
                Clear();

                ATLTRY(parray = ::SafeArrayCreate(vtSrc, dwDims, rgsabound));
                if (parray == NULL)
                {
                        ATLTRACE2(atlTraceDBProvider, 0, "CComSafeArray::Create Error : OOM\n");
                        return;
                }

                vt = unsigned short(vtSrc | VT_ARRAY);
                m_dwDims = dwDims;
                m_dwElementSize = GetElemSize();
        }

        void AccessData(void** ppvData)
        {
                MtlCheckError(::SafeArrayAccessData(parray, ppvData));
        }

        void UnaccessData()
        {
                MtlCheckError(::SafeArrayUnaccessData(parray));
        }

        void AllocData()
        {
                MtlCheckError(::SafeArrayAllocData(parray));
        }

        void AllocDescriptor(DWORD dwDims)
        {
                MtlCheckError(::SafeArrayAllocDescriptor(dwDims, &parray));
        }

        void Copy(LPSAFEARRAY* ppsa)
        {
                MtlCheckError(::SafeArrayCopy(parray, ppsa));
        }

        void GetLBound(DWORD dwDim, long* pLbound)
        {
                MtlCheckError(::SafeArrayGetLBound(parray, dwDim, pLbound));
        }

        void GetUBound(DWORD dwDim, long* pUbound)
        {
                MtlCheckError(::SafeArrayGetUBound(parray, dwDim, pUbound));
        }

        void GetElement(long* rgIndices, void* pvData)
        {
                MtlCheckError(::SafeArrayGetElement(parray, rgIndices, pvData));
        }

        void PtrOfIndex(long* rgIndices, void** ppvData)
        {
                MtlCheckError(::SafeArrayPtrOfIndex(parray, rgIndices, ppvData));
        }

        void PutElement(long* rgIndices, void* pvData)
        {
                MtlCheckError(::SafeArrayPutElement(parray, rgIndices, pvData));
        }

        void Redim(SAFEARRAYBOUND* psaboundNew)
        {
                MtlCheckError(::SafeArrayRedim(parray, psaboundNew));
        }

        void Lock()
        {
                MtlCheckError(::SafeArrayLock(parray));
        }

        void Unlock()
        {
                MtlCheckError(::SafeArrayUnlock(parray));
        }

        void Destroy()
        {
                MtlCheckError(::SafeArrayDestroy(parray));
        }

        void DestroyData()
        {
                MtlCheckError(::SafeArrayDestroyData(parray));
        }

        void DestroyDescriptor()
        {
                MtlCheckError(::SafeArrayDestroyDescriptor(parray));
        }
};

/////////////////////////////////////////////////////////////////////////////
// Helper for iter to CComSafeArray
inline void _MtlCreateOneDimArray(VARIANT& varSrc, DWORD dwSize)
{
        UINT nDim;

        // Clear VARIANT and re-create SafeArray if necessary
        if (varSrc.vt != (VT_UI1 | VT_ARRAY) ||
                (nDim = ::SafeArrayGetDim(varSrc.parray)) != 1)
        {
                MTLVERIFY(::VariantClear(&varSrc) == NOERROR);
                varSrc.vt = VT_UI1 | VT_ARRAY;

                SAFEARRAYBOUND bound;
                bound.cElements = dwSize;
                bound.lLbound = 0;
                ATLTRY(varSrc.parray = ::SafeArrayCreate(VT_UI1, 1, &bound));
                if (varSrc.parray == NULL)
                        ATLTRACE2(atlTraceDBProvider, 0, "MtlCheckError Error : OOM\n");
        }
        else
        {
                // Must redimension array if necessary
                long lLower, lUpper;
                MtlCheckError(::SafeArrayGetLBound(varSrc.parray, 1, &lLower));
                MtlCheckError(::SafeArrayGetUBound(varSrc.parray, 1, &lUpper));

                // Upper bound should always be greater than lower bound
                long lSize = lUpper - lLower;
                if (lSize < 0)
                {
                        ATLASSERT(FALSE);
                        lSize = 0;

                }

                if ((DWORD)lSize != dwSize)
                {
                        SAFEARRAYBOUND bound;
                        bound.cElements = dwSize;
                        bound.lLbound = lLower;
                        MtlCheckError(::SafeArrayRedim(varSrc.parray, &bound));
                }
        }
}

inline void _MtlCopyBinaryData(SAFEARRAY* parray, const void* pvSrc, DWORD dwSize)
{
        // Access the data, copy it and unaccess it.
        void* pDest;
        MtlCheckError(::SafeArrayAccessData(parray, &pDest));
        ::memcpy(pDest, pvSrc, dwSize);
        MtlCheckError(::SafeArrayUnaccessData(parray));
}

inline void MtlInitVariantFromArray(CComVariant& v, CSimpleArray& arrSrc)
{
        int nSize = arrSrc.GetSize();

        // Set the correct type and make sure SafeArray can hold data
        _MtlCreateOneDimArray(v, (DWORD)nSize);

        // Copy the data into the SafeArray
        _MtlCopyBinaryData(v.parray, arrSrc.GetData(), (DWORD)nSize);
}

inline void MtlInitVariantFromItemIDList(CComVariant& v, LPCITEMIDLIST pidl)
{
        if (pidl != NULL)
        {
                // walk through entries in the list and accumulate their size

                UINT cbTotal = 0;
                SAFEARRAY *psa = NULL;
                LPCITEMIDLIST pidlWalker = pidl;

                while (pidlWalker->mkid.cb)
                {
                        cbTotal += pidlWalker->mkid.cb;
                        pidlWalker = (LPCITEMIDLIST)
                                (((LPBYTE)pidlWalker) + pidlWalker->mkid.cb);
                }

                // add the base structure size
                cbTotal += sizeof(ITEMIDLIST);

                // get a safe array for them
                psa = ::SafeArrayCreateVector(VT_UI1, 0, cbTotal);

                // copy it and set members
                if (psa != NULL)
                {
                        ::memcpy(psa->pvData, (LPBYTE) pidl, cbTotal);
                        v.vt = VT_ARRAY | VT_UI1;
                        v.parray = psa;
                }
        }
}

////////////////////////////////////////////////////////////////////////////
} // namespace MTL

#endif // __MTLCOM_H__
chinacrackinggroup@qq.com
update ccg_members set groupid = 28 where groupid = 8

TOP

设置让自己开机自动运行.

复制内容到剪贴板
代码:
//设置让自己开机自动运行.
//bAdd=1表示添加快捷方式,bAdd=0表示删除此快捷方式
//此例中快捷方式名称为“自动运行.lnk”,创建在启动组内

BOOL CTestDlg::SetAutoRun(BOOL bAdd)

{

  HRESULT hres;

  IShellLink *psl;//IShellLink接口指针

  BOOL bRet=FALSE;

  char pszDesPath[MAX_PATH];//创建的目标路径

  char pszShortcutFile[MAX_PATH];//创建的源文件

  ::GetModuleFileName(NULL,pszShortcutFile,MAX_PATH);//得到本程序路径

  SHGetSpecialFolderPath(m_hWnd,pszDesPath,CSIDL_PROGRAMS,0);//程序组路径

  strcat(pszDesPath,"\\启动\\自动运行.lnk");//启动组

  if(!bAdd)

    return DeleteFile(pszDesPath);

  hres = CoCreateInstance (CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,

    IID_IShellLink, (void **)&psl);//得到CLSID_ShellLink标识的COM对象的IShellLink接口

  if (!SUCCEEDED(hres)) goto error;

  IPersistFile *ppf;//IPersistFile接口指针

  //查询IPersistFile接口以进行快捷方式的存储操作

  hres = psl->QueryInterface (IID_IPersistFile, (void **)&ppf);

  if (!SUCCEEDED (hres)) goto error;

  WORD wsz [MAX_PATH]; //Unicode字符串的缓冲地址

  //为适应COM标准一定要用Unicode

  //设置源文件地址

  hres = psl->SetPath (pszShortcutFile);

  if (! SUCCEEDED (hres)) goto error;

  //设置参数

  hres = psl->SetArguments("/ArgumentsHere");

  if (! SUCCEEDED (hres)) goto error;

  //设置快捷方式的描述

  hres = psl->SetDescription ("Shortcut to ScreenColor");

  if (! SUCCEEDED (hres)) goto error;

  //将ANSI字符串转换为Unicode字符串

  MultiByteToWideChar (CP_ACP, 0, pszDesPath, -1, wsz, MAX_PATH);

  //调用Save方法进行存储

  hres = ppf->Save (wsz, TRUE);

  if (! SUCCEEDED (hres)) goto error;

  bRet=TRUE;

error:

  //释放接口

  ppf->Release ();

  psl->Release ();

  return TRUE;

}
chinacrackinggroup@qq.com
update ccg_members set groupid = 28 where groupid = 8

TOP

复制内容到剪贴板
代码:
1、创建快捷方式
//创建快捷方式, SourcePath 源文件路径,  lnkPath 快捷方式路径, pParam 快捷方式的参数
BOOL CreateLnk( char * SourcePath,  char * lnkPath, char* pParam )
{
WORD wsz[ MAX_PATH] ;
MultiByteToWideChar( CP_ACP, 0, lnkPath, -1, wsz, MAX_PATH) ;
HRESULT hr = CoInitialize(NULL);
if (SUCCEEDED(hr))
{
  IShellLink *pisl;
  hr = CoCreateInstance(CLSID_ShellLink, NULL,
   CLSCTX_INPROC_SERVER, IID_IShellLink, (void**)&pisl);
  if (SUCCEEDED(hr))
  {
   IPersistFile* pIPF;
   
   //这里是我们要创建快捷方式的原始文件地址
   pisl->SetPath( SourcePath );
   pisl->SetArguments( pParam ) ;
   hr = pisl->QueryInterface(IID_IPersistFile, (void**)&pIPF);
   if (SUCCEEDED(hr))
   {
    //这里是我们要创建快捷方式的目标地址
    pIPF->Save( wsz, FALSE);
    pIPF->Release();
   }
   else
   {
    DbgPrint( "call QueryInterface failt " ) ;
    return FALSE ;
   }
   pisl->Release();
  }
  else
  {
   DbgPrint( " call CoCreateInstance failt " ) ;
   return FALSE ;
  }
  CoUninitialize();
}
else
{
  DbgPrint( "inint ConInitialize Failt " ) ;
  return FALSE ;
}
return TRUE ;
}

2、读取快捷方式文件的一些信息。
HWND hWnd ;
  HRESULT hres ;
  IShellLink  * PShLink ;
  WIN32_FIND_DATA wfd ;
  CString lpszLinkName;
  char   lpszPath[MAX_PATH] = {0};
  char   lpszDescription[MAX_PATH] = {0} ;
  lpszLinkName = f.GetFilePath() ;
  //DbgPrint( lpszLinkName ) ;
  hres = CoInitialize( NULL ) ;
  if ( SUCCEEDED(hres) )
  {
   hres = CoCreateInstance( CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, (void**)&PShLink ) ;
   
   if ( SUCCEEDED(hres) )
   {
    IPersistFile * ppf ;
   
    hres = PShLink->QueryInterface(  IID_IPersistFile, (LPVOID*)&ppf  );
    if ( SUCCEEDED(hres) )
    {
     WORD wsz[MAX_PATH] ;
     MultiByteToWideChar( CP_ACP, 0, lpszLinkName, -1, wsz, MAX_PATH ) ;
     hres = ppf->Load( wsz, STGM_READ ) ;
     if ( SUCCEEDED(hres) )
     {
      hres = PShLink->Resolve(  hWnd, SLR_ANY_MATCH|SLR_NO_UI ) ;
      if( SUCCEEDED(hres) )
      {

       //这里就可以用类提供的函数得到一些快捷方式的信息了。
       hres = PShLink->GetPath( lpszPath, MAX_PATH, &wfd, SLGP_SHORTPATH ) ;
       CString sFileNameTemp ;
       sFileNameTemp.Format( "%s", lpszPath ) ; //这里我只得到了源路径
      }
      else
       DbgPrint( "Resolve failt " ) ;
     }
     else
      DbgPrint( "load failt " ) ;
     ppf->Release( ) ;
    }
    else
     DbgPrint( "QueryInterface failt " ) ;
    PShLink->Release(  ) ;
   }
   else
    DbgPrint( "coCreateInStance failt " ) ;
  
   CoUninitialize() ;
  }
  else
  {
   DbgPrint( "call CoInitialize failt " ) ;
  }

这两个功能的实现都是从网上收集了些代码,自己修改了一下,现在对这两个类有了初步的认识,谁有更深入的理解,欢迎交流。
chinacrackinggroup@qq.com
update ccg_members set groupid = 28 where groupid = 8

TOP

谢谢分享,学习了

TOP

入库新书

TOP

发新话题
版块跳转 ...