API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Mar 26th, 2019
117
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 20.91 KB | None | 0 0
raw download clone embed print report
  1. // DLL.cpp: определяет экспортированные функции для приложения DLL.
  2. //
  3.  
  4. #include "stdafx.h"
  5. #include <windows.h>                // Program Demonstrates Late Bound OLE COM Access To MS Excel Spreadsheet Using C++.
  6. #include <cstdio>  
  7. #include <OAIdl.h>
  8. const CLSID CLSID_XLApplication = { 0x00024500,0x0000,0x0000,{ 0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46 } }; // CLSID of Excel
  9. const IID   IID_Application = { 0x000208D5,0x0000,0x0000,{ 0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46 } }; // IID of _Application
  10.  
  11.  
  12. HRESULT AutoWrap(int autoType, VARIANT *pvResult, IDispatch *pDisp, LPOLESTR ptName, int cArgs...)
  13. {
  14.     // Begin variable-argument list...
  15.     va_list marker;
  16.     va_start(marker, cArgs); //формируем список аргументов, передаваемых в cArgs
  17.    
  18.     if (!pDisp) {
  19.         MessageBox(NULL, TEXT("NULL IDispatch passed to AutoWrap()"),
  20.             TEXT("Error"), 0x10010);
  21.         _exit(0);
  22.     }
  23.    
  24.     DISPPARAMS dp = { NULL, NULL, 0, 0 };
  25.     DISPID dispidNamed = DISPID_PROPERTYPUT;
  26.     DISPID dispID;
  27.     HRESULT hr;
  28.     char buf[200];
  29.     char szName[200];
  30.     WideCharToMultiByte(CP_ACP, 0, ptName, -1, szName, 256, NULL, NULL);
  31.     hr = pDisp->GetIDsOfNames(IID_NULL, &ptName, 1, LOCALE_USER_DEFAULT,
  32.         &dispID);
  33.     if (FAILED(hr)) {
  34.         sprintf(buf,
  35.             "IDispatch::GetIDsOfNames(\"%s\") failed w/err0x%08lx",
  36.             szName, hr);
  37.         MessageBox(NULL, TEXT("Click"), TEXT("AutoWrap()"), 0x10010);
  38.         _exit(0);
  39.         return hr;
  40.     }
  41.  
  42.     // Allocate memory for arguments...
  43.     VARIANT *pArgs = new VARIANT[cArgs + 1];
  44.  
  45.     // Extract arguments...
  46.     for (int i = 0; i < cArgs; i++) {
  47.         pArgs[i] = va_arg(marker, VARIANT);
  48.     }
  49.  
  50.     // Build DISPPARAMS
  51.     dp.cArgs = cArgs;
  52.     dp.rgvarg = pArgs;
  53.  
  54.     // Handle special-case for property-puts!
  55.     if (autoType & DISPATCH_PROPERTYPUT) {
  56.         dp.cNamedArgs = 1;
  57.         dp.rgdispidNamedArgs = &dispidNamed;
  58.     }
  59.  
  60.     // Make the call!
  61.     hr = pDisp->Invoke(dispID, IID_NULL, LOCALE_SYSTEM_DEFAULT, autoType,
  62.         &dp, pvResult, NULL, NULL);
  63.     if (FAILED(hr)) {
  64.         sprintf(buf,
  65.             "IDispatch::Invoke(\"%s\"=%08lx) failed w/err 0x%08lx",
  66.             szName, dispID, hr);
  67.         MessageBox(NULL, TEXT("Click Me"), TEXT("AutoWrap()"), 0x10010);
  68.         _exit(0);
  69.         return hr;
  70.     }
  71.     // End variable-argument section...
  72.     va_end(marker);
  73.  
  74.     delete[] pArgs;
  75.  
  76.     return hr;
  77.  
  78. }
  79.  
  80. extern "C" _declspec(dllexport) void WorkWithExcel()
  81. {
  82.     DISPPARAMS NoArgs = { NULL,NULL,0,0 }; // This variable is used in easiest Invoke() call when the method has no parameters.  When
  83.     IDispatch* pXLApp = NULL;            // using the IDispatch interface in conjunction with Invoke() method parameters must be loaded
  84.     DISPPARAMS DispParams;             // into a DISPPARAMS struct.  The actual parameters are loaded into VARIANTs, and one of the
  85.     VARIANT CallArgs[1];               // members of the DISPPARAMS struct is a pointer to the array of VARIANT.  The other members
  86.     VARIANT vResult;                   // of the DISPARAMS struct tell Invoke() how many parameters are being passed, as well as other
  87.     DISPID dispid;                     // specifics such as the type of the call (propput, propget, etc.).
  88.     HRESULT hr;
  89.  
  90.     CoInitialize(NULL);
  91.     hr = CoCreateInstance(CLSID_XLApplication, NULL, CLSCTX_LOCAL_SERVER, IID_Application, (void**)&pXLApp);
  92.     if (SUCCEEDED(hr))
  93.     {
  94.         OLECHAR* szVisible = (OLECHAR*)L"Visible";
  95.         hr = pXLApp->GetIDsOfNames(IID_NULL, &szVisible, 1, GetUserDefaultLCID(), &dispid);
  96.         if (SUCCEEDED(hr))
  97.         {
  98.             VariantInit(&CallArgs[0]);
  99.             CallArgs[0].vt = VT_BOOL;
  100.             CallArgs[0].boolVal = TRUE;
  101.             DISPID dispidNamed = DISPID_PROPERTYPUT;
  102.             DispParams.rgvarg = CallArgs;
  103.             DispParams.rgdispidNamedArgs = &dispidNamed;
  104.             DispParams.cArgs = 1;
  105.             DispParams.cNamedArgs = 1;
  106.             VariantInit(&vResult);       //  Call or Invoke _Application::Visible(true);
  107.             hr = pXLApp->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYPUT, &DispParams, &vResult, NULL, NULL);
  108.             OLECHAR* szWorkbooks = (OLECHAR*)L"Workbooks";
  109.             hr = pXLApp->GetIDsOfNames(IID_NULL, &szWorkbooks, 1, GetUserDefaultLCID(), &dispid);
  110.             if (SUCCEEDED(hr))
  111.             {
  112.                 IDispatch* pXLBooks = NULL;    //  Get Workbooks Collection
  113.                 VariantInit(&vResult);       //  Invoke _Application::Workbooks(&pXLBooks) << returns IDispatch** of Workbooks Collection
  114.                 hr = pXLApp->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET, &NoArgs, &vResult, NULL, NULL);
  115.                 if (SUCCEEDED(hr))
  116.                 {
  117.                     pXLBooks = vResult.pdispVal;
  118.                     IDispatch* pXLBook = NULL;  //  Try to add Workbook
  119.                     OLECHAR* szAdd = (OLECHAR*)L"Add";
  120.                     hr = pXLBooks->GetIDsOfNames(IID_NULL, &szAdd, 1, GetUserDefaultLCID(), &dispid);
  121.                     if (SUCCEEDED(hr))
  122.                     {
  123.                         VariantInit(&vResult);    //  Invoke Workbooks::Add(&Workbook)  << returns IDispatch** of Workbook Object
  124.                         hr = pXLBooks->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD | DISPATCH_PROPERTYGET, &NoArgs, &vResult, NULL, NULL);
  125.                         if (SUCCEEDED(hr))
  126.                         {
  127.                             pXLBook = vResult.pdispVal;
  128.                             OLECHAR* szActiveSheet = (OLECHAR*)L"ActiveSheet";
  129.                             hr = pXLApp->GetIDsOfNames(IID_NULL, &szActiveSheet, 1, GetUserDefaultLCID(), &dispid);
  130.                             if (SUCCEEDED(hr))
  131.                             {
  132.                                 IDispatch* pXLSheet = NULL;  // Try To Get ActiveSheet
  133.                                 VariantInit(&vResult);     // Invoke _Application::ActiveSheet(&pXLSheet);  << ret IDispatch** to Worksheet (Worksheet)
  134.                                 hr = pXLApp->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET, &NoArgs, &vResult, NULL, NULL);
  135.                                 if (SUCCEEDED(hr))
  136.                                 {
  137.                                     pXLSheet = vResult.pdispVal;
  138.                                     OLECHAR* szRange = (OLECHAR*)L"Range";
  139.                                     hr = pXLSheet->GetIDsOfNames(IID_NULL, &szRange, 1, GetUserDefaultLCID(), &dispid);
  140.                                     if (SUCCEEDED(hr))
  141.                                     {
  142.                                         IDispatch* pXLRange = NULL;
  143.                                         VariantInit(&vResult);
  144.                                         CallArgs[0].vt = VT_BSTR,
  145.                                             CallArgs[0].bstrVal = SysAllocString(L"A5");
  146.                                         DispParams.rgvarg = CallArgs;
  147.                                         DispParams.rgdispidNamedArgs = 0;
  148.                                         DispParams.cArgs = 1;  // Try to get Range
  149.                                         DispParams.cNamedArgs = 0;  // Invoke _Worksheet::Range("A1")  << returns IDispatch** to dispinterface Range
  150.                                         hr = pXLSheet->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET, &DispParams, &vResult, NULL, NULL);
  151.                                         if (SUCCEEDED(hr))
  152.                                         {
  153.                                             IDispatch* pXLRange = vResult.pdispVal;
  154.                                             VARIANT result;
  155.                                             VariantInit(&result);
  156.                                             hr = AutoWrap(DISPATCH_PROPERTYGET, &result, pXLRange, (wchar_t*)L"Font", 0);
  157.                                             if (SUCCEEDED(hr))
  158.                                             {
  159.                                                 IDispatch* pXLFont = result.pdispVal;
  160.                                                 VARIANT x;
  161.                                                 x.vt = VT_BOOL;
  162.                                                 x.boolVal = TRUE;
  163.                                                 //x.lVal = RGB(123, 123, 0);
  164.                                                 hr = AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXLFont, (wchar_t*)L"Bold", 1, x);
  165.                                                 VARIANT y;
  166.                                                 y.vt = VT_INT;
  167.                                                 y.intVal = 20;
  168.                                                 //y.lVal = RGB(255, 255, 0);
  169.                                                 hr = AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXLFont, (wchar_t*)L"Size", 1, y);
  170.                                                 VARIANT z;
  171.                                                 z.vt = VT_I4;
  172.                                                 z.lVal = RGB(255, 123, 0);
  173.                                                 hr = AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXLFont, (wchar_t*)L"Color", 1, z);
  174.                                             }
  175.  
  176.                                             //OLECHAR* szValue = (OLECHAR*)L"Value";
  177.                                             VARIANT x;
  178.                                             x.vt = VT_BSTR;
  179.                                             x.bstrVal = SysAllocString(L"Поставьте лабу пожалуйста ♥");
  180.                                             hr = AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXLRange, (wchar_t*)L"Value", 1, x);
  181.                                             pXLRange->Release();
  182.                                         }
  183.                                     }
  184.  
  185.                                     if (SUCCEEDED(hr))
  186.                                     {
  187.                                         IDispatch* pXLRange = NULL;
  188.                                         VariantInit(&vResult);
  189.                                         CallArgs[0].vt = VT_BSTR,
  190.                                             CallArgs[0].bstrVal = SysAllocString(L"A6");
  191.                                         DispParams.rgvarg = CallArgs;
  192.                                         DispParams.rgdispidNamedArgs = 0;
  193.                                         DispParams.cArgs = 1;  // Try to get Range
  194.                                         DispParams.cNamedArgs = 0;  // Invoke _Worksheet::Range("A1")  << returns IDispatch** to dispinterface Range
  195.                                         hr = pXLSheet->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET, &DispParams, &vResult, NULL, NULL);
  196.                                         if (SUCCEEDED(hr))
  197.                                         {
  198.                                             IDispatch* pXLRange = vResult.pdispVal;
  199.                                             VARIANT result;
  200.                                             VariantInit(&result);
  201.                                             hr = AutoWrap(DISPATCH_PROPERTYGET, &result, pXLRange, (wchar_t*)L"Font", 0);
  202.                                             if (SUCCEEDED(hr))
  203.                                             {
  204.                                                 IDispatch* pXLFont = result.pdispVal;
  205.                                                 VARIANT x;
  206.                                                 x.vt = VT_BOOL;
  207.                                                 x.boolVal = TRUE;
  208.                                                 //x.lVal = RGB(123, 123, 0);
  209.                                                 hr = AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXLFont, (wchar_t*)L"Bold", 1, x);
  210.                                                 VARIANT y;
  211.                                                 y.vt = VT_INT;
  212.                                                 y.intVal = 20;
  213.                                                 //y.lVal = RGB(255, 255, 0);
  214.                                                 hr = AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXLFont, (wchar_t*)L"Size", 1, y);
  215.                                                 VARIANT z;
  216.                                                 z.vt = VT_I4;
  217.                                                 z.lVal = RGB(123, 123, 0);
  218.                                                 hr = AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXLFont, (wchar_t*)L"Color", 1, z);
  219.                                             }
  220.  
  221.                                             //OLECHAR* szValue = (OLECHAR*)L"Value";
  222.                                             VARIANT x;
  223.                                             x.vt = VT_BSTR;
  224.                                             x.bstrVal = SysAllocString(L"Пожалуйста ♥!!!");
  225.                                             hr = AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXLRange, (wchar_t*)L"Value", 1, x);
  226.                                             pXLRange->Release();
  227.                                         }
  228.                                     }
  229.  
  230.                                     if (SUCCEEDED(hr))
  231.                                     {
  232.                                         IDispatch* pXLRange = NULL;
  233.                                         VariantInit(&vResult);
  234.                                         CallArgs[0].vt = VT_BSTR,
  235.                                             CallArgs[0].bstrVal = SysAllocString(L"A6");
  236.                                         DispParams.rgvarg = CallArgs;
  237.                                         DispParams.rgdispidNamedArgs = 0;
  238.                                         DispParams.cArgs = 1;  // Try to get Range
  239.                                         DispParams.cNamedArgs = 0;  // Invoke _Worksheet::Range("A1")  << returns IDispatch** to dispinterface Range
  240.                                         hr = pXLSheet->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET, &DispParams, &vResult, NULL, NULL);
  241.                                         if (SUCCEEDED(hr))
  242.                                         {
  243.                                             IDispatch* pXLRange = vResult.pdispVal;
  244.                                             VARIANT result;
  245.                                             VariantInit(&result);
  246.                                             hr = AutoWrap(DISPATCH_PROPERTYGET, &result, pXLRange, (wchar_t*)L"Font", 0);
  247.                                             if (SUCCEEDED(hr))
  248.                                             {
  249.                                                 IDispatch* pXLFont = result.pdispVal;
  250.                                                 VARIANT x;
  251.                                                 x.vt = VT_BOOL;
  252.                                                 x.boolVal = TRUE;
  253.                                                 //x.lVal = RGB(123, 123, 0);
  254.                                                 hr = AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXLFont, (wchar_t*)L"Bold", 1, x);
  255.                                                 VARIANT y;
  256.                                                 y.vt = VT_INT;
  257.                                                 y.intVal = 20;
  258.                                                 //y.lVal = RGB(255, 255, 0);
  259.                                                 hr = AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXLFont, (wchar_t*)L"Size", 1, y);
  260.                                                 VARIANT z;
  261.                                                 z.vt = VT_I4;
  262.                                                 z.lVal = RGB(123, 123, 123);
  263.                                                 hr = AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXLFont, (wchar_t*)L"Color", 1, z);
  264.                                             }
  265.  
  266.                                             //OLECHAR* szValue = (OLECHAR*)L"Value";
  267.                                             VARIANT x;
  268.                                             x.vt = VT_BSTR;
  269.                                             x.bstrVal = SysAllocString(L"Пожалуйста ♥!!!");
  270.                                             hr = AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXLRange, (wchar_t*)L"Value", 1, x);
  271.                                             pXLRange->Release();
  272.                                         }
  273.                                     }
  274.  
  275.                                     if (SUCCEEDED(hr))
  276.                                     {
  277.                                         IDispatch* pXLRange = NULL;
  278.                                         VariantInit(&vResult);
  279.                                         CallArgs[0].vt = VT_BSTR,
  280.                                             CallArgs[0].bstrVal = SysAllocString(L"I6");
  281.                                         DispParams.rgvarg = CallArgs;
  282.                                         DispParams.rgdispidNamedArgs = 0;
  283.                                         DispParams.cArgs = 1;  // Try to get Range
  284.                                         DispParams.cNamedArgs = 0;  // Invoke _Worksheet::Range("A1")  << returns IDispatch** to dispinterface Range
  285.                                         hr = pXLSheet->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET, &DispParams, &vResult, NULL, NULL);
  286.                                         if (SUCCEEDED(hr))
  287.                                         {
  288.                                             IDispatch* pXLRange = vResult.pdispVal;
  289.                                             VARIANT result;
  290.                                             VariantInit(&result);
  291.                                             hr = AutoWrap(DISPATCH_PROPERTYGET, &result, pXLRange, (wchar_t*)L"Font", 0);
  292.                                             if (SUCCEEDED(hr))
  293.                                             {
  294.                                                 IDispatch* pXLFont = result.pdispVal;
  295.                                                 VARIANT x;
  296.                                                 x.vt = VT_BOOL;
  297.                                                 x.boolVal = TRUE;
  298.                                                 //x.lVal = RGB(123, 123, 0);
  299.                                                 hr = AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXLFont, (wchar_t*)L"Bold", 1, x);
  300.                                                 VARIANT y;
  301.                                                 y.vt = VT_INT;
  302.                                                 y.intVal = 20;
  303.                                                 //y.lVal = RGB(255, 255, 0);
  304.                                                 hr = AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXLFont, (wchar_t*)L"Size", 1, y);
  305.                                                 VARIANT z;
  306.                                                 z.vt = VT_I4;
  307.                                                 z.lVal = RGB(123, 123, 0);
  308.                                                 hr = AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXLFont, (wchar_t*)L"Color", 1, z);
  309.                                             }
  310.  
  311.                                             //OLECHAR* szValue = (OLECHAR*)L"Value";
  312.                                             VARIANT x;
  313.                                             x.vt = VT_BSTR;
  314.                                             x.bstrVal = SysAllocString(L"Пожалуйста ♥!!!");
  315.                                             hr = AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXLRange, (wchar_t*)L"Value", 1, x);
  316.                                             pXLRange->Release();
  317.                                         }
  318.                                     }
  319.  
  320.                                     if (SUCCEEDED(hr))
  321.                                     {
  322.                                         IDispatch* pXLRange = NULL;
  323.                                         VariantInit(&vResult);
  324.                                         CallArgs[0].vt = VT_BSTR,
  325.                                             CallArgs[0].bstrVal = SysAllocString(L"B2");
  326.                                         DispParams.rgvarg = CallArgs;
  327.                                         DispParams.rgdispidNamedArgs = 0;
  328.                                         DispParams.cArgs = 1;  // Try to get Range
  329.                                         DispParams.cNamedArgs = 0;  // Invoke _Worksheet::Range("A1")  << returns IDispatch** to dispinterface Range
  330.                                         hr = pXLSheet->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET, &DispParams, &vResult, NULL, NULL);
  331.                                         if (SUCCEEDED(hr))
  332.                                         {
  333.                                             IDispatch* pXLRange = vResult.pdispVal;
  334.                                             VARIANT result;
  335.                                             VariantInit(&result);
  336.                                             hr = AutoWrap(DISPATCH_PROPERTYGET, &result, pXLRange, (wchar_t*)L"Font", 0);
  337.                                             if (SUCCEEDED(hr))
  338.                                             {
  339.                                                 IDispatch* pXLFont = result.pdispVal;
  340.                                                 VARIANT x;
  341.                                                 x.vt = VT_BOOL;
  342.                                                 x.boolVal = TRUE;
  343.                                                 //x.lVal = RGB(123, 123, 0);
  344.                                                 hr = AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXLFont, (wchar_t*)L"Bold", 1, x);
  345.                                                 VARIANT y;
  346.                                                 y.vt = VT_INT;
  347.                                                 y.intVal = 20;
  348.                                                 //y.lVal = RGB(255, 255, 0);
  349.                                                 hr = AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXLFont, (wchar_t*)L"Size", 1, y);
  350.                                                 VARIANT z;
  351.                                                 z.vt = VT_I4;
  352.                                                 z.lVal = RGB(123, 123, 0);
  353.                                                 hr = AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXLFont, (wchar_t*)L"Color", 1, z);
  354.                                             }
  355.  
  356.                                             //OLECHAR* szValue = (OLECHAR*)L"Value";
  357.                                             VARIANT x;
  358.                                             x.vt = VT_BSTR;
  359.                                             x.bstrVal = SysAllocString(L"Пожалуйста ♥!!!");
  360.                                             hr = AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXLRange, (wchar_t*)L"Value", 1, x);
  361.                                             pXLRange->Release();
  362.                                         }
  363.                                     }
  364.  
  365.                                     if (SUCCEEDED(hr))
  366.                                     {
  367.                                         IDispatch* pXLRange = NULL;
  368.                                         VariantInit(&vResult);
  369.                                         CallArgs[0].vt = VT_BSTR,
  370.                                             CallArgs[0].bstrVal = SysAllocString(L"C3");
  371.                                         DispParams.rgvarg = CallArgs;
  372.                                         DispParams.rgdispidNamedArgs = 0;
  373.                                         DispParams.cArgs = 1;  // Try to get Range
  374.                                         DispParams.cNamedArgs = 0;  // Invoke _Worksheet::Range("A1")  << returns IDispatch** to dispinterface Range
  375.                                         hr = pXLSheet->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET, &DispParams, &vResult, NULL, NULL);
  376.                                         if (SUCCEEDED(hr))
  377.                                         {
  378.                                             IDispatch* pXLRange = vResult.pdispVal;
  379.                                             VARIANT result;
  380.                                             VariantInit(&result);
  381.                                             hr = AutoWrap(DISPATCH_PROPERTYGET, &result, pXLRange, (wchar_t*)L"Font", 0);
  382.                                             if (SUCCEEDED(hr))
  383.                                             {
  384.                                                 IDispatch* pXLFont = result.pdispVal;
  385.                                                 VARIANT x;
  386.                                                 x.vt = VT_BOOL;
  387.                                                 x.boolVal = TRUE;
  388.                                                 //x.lVal = RGB(123, 123, 0);
  389.                                                 hr = AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXLFont, (wchar_t*)L"Bold", 1, x);
  390.                                                 VARIANT y;
  391.                                                 y.vt = VT_INT;
  392.                                                 y.intVal = 20;
  393.                                                 //y.lVal = RGB(255, 255, 0);
  394.                                                 hr = AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXLFont, (wchar_t*)L"Size", 1, y);
  395.                                                 VARIANT z;
  396.                                                 z.vt = VT_I4;
  397.                                                 z.lVal = RGB(123, 123, 0);
  398.                                                 hr = AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXLFont, (wchar_t*)L"Color", 1, z);
  399.                                             }
  400.  
  401.                                             //OLECHAR* szValue = (OLECHAR*)L"Value";
  402.                                             VARIANT x;
  403.                                             x.vt = VT_BSTR;
  404.                                             x.bstrVal = SysAllocString(L"Пожалуйста ♥!!!");
  405.                                             hr = AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXLRange, (wchar_t*)L"Value", 1, x);
  406.                                             pXLRange->Release();
  407.                                         }
  408.                                     }
  409.  
  410.                                     if (SUCCEEDED(hr))
  411.                                     {
  412.                                         IDispatch* pXLRange = NULL;
  413.                                         VariantInit(&vResult);
  414.                                         CallArgs[0].vt = VT_BSTR,
  415.                                             CallArgs[0].bstrVal = SysAllocString(L"E6");
  416.                                         DispParams.rgvarg = CallArgs;
  417.                                         DispParams.rgdispidNamedArgs = 0;
  418.                                         DispParams.cArgs = 1;  // Try to get Range
  419.                                         DispParams.cNamedArgs = 0;  // Invoke _Worksheet::Range("A1")  << returns IDispatch** to dispinterface Range
  420.                                         hr = pXLSheet->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET, &DispParams, &vResult, NULL, NULL);
  421.                                         if (SUCCEEDED(hr))
  422.                                         {
  423.                                             IDispatch* pXLRange = vResult.pdispVal;
  424.                                             VARIANT result;
  425.                                             VariantInit(&result);
  426.                                             hr = AutoWrap(DISPATCH_PROPERTYGET, &result, pXLRange, (wchar_t*)L"Font", 0);
  427.                                             if (SUCCEEDED(hr))
  428.                                             {
  429.                                                 IDispatch* pXLFont = result.pdispVal;
  430.                                                 VARIANT x;
  431.                                                 x.vt = VT_BOOL;
  432.                                                 x.boolVal = TRUE;
  433.                                                 //x.lVal = RGB(123, 123, 0);
  434.                                                 hr = AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXLFont, (wchar_t*)L"Bold", 1, x);
  435.                                                 VARIANT y;
  436.                                                 y.vt = VT_INT;
  437.                                                 y.intVal = 20;
  438.                                                 //y.lVal = RGB(255, 255, 0);
  439.                                                 hr = AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXLFont, (wchar_t*)L"Size", 1, y);
  440.                                                 VARIANT z;
  441.                                                 z.vt = VT_I4;
  442.                                                 z.lVal = RGB(123, 123, 0);
  443.                                                 hr = AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXLFont, (wchar_t*)L"Color", 1, z);
  444.                                             }
  445.  
  446.                                             //OLECHAR* szValue = (OLECHAR*)L"Value";
  447.                                             VARIANT x;
  448.                                             x.vt = VT_BSTR;
  449.                                             x.bstrVal = SysAllocString(L"Пожалуйста ♥!!!");
  450.                                             hr = AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXLRange, (wchar_t*)L"Value", 1, x);
  451.                                             pXLRange->Release();
  452.                                         }
  453.                                     }
  454.  
  455.                                     if (SUCCEEDED(hr))
  456.                                     {
  457.                                         IDispatch* pXLRange = NULL;
  458.                                         VariantInit(&vResult);
  459.                                         CallArgs[0].vt = VT_BSTR,
  460.                                             CallArgs[0].bstrVal = SysAllocString(L"I6");
  461.                                         DispParams.rgvarg = CallArgs;
  462.                                         DispParams.rgdispidNamedArgs = 0;
  463.                                         DispParams.cArgs = 1;  // Try to get Range
  464.                                         DispParams.cNamedArgs = 0;  // Invoke _Worksheet::Range("A1")  << returns IDispatch** to dispinterface Range
  465.                                         hr = pXLSheet->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET, &DispParams, &vResult, NULL, NULL);
  466.                                         if (SUCCEEDED(hr))
  467.                                         {
  468.                                             IDispatch* pXLRange = vResult.pdispVal;
  469.                                             VARIANT result;
  470.                                             VariantInit(&result);
  471.                                             hr = AutoWrap(DISPATCH_PROPERTYGET, &result, pXLRange, (wchar_t*)L"Font", 0);
  472.                                             if (SUCCEEDED(hr))
  473.                                             {
  474.                                                 IDispatch* pXLFont = result.pdispVal;
  475.                                                 VARIANT x;
  476.                                                 x.vt = VT_BOOL;
  477.                                                 x.boolVal = TRUE;
  478.                                                 //x.lVal = RGB(123, 123, 0);
  479.                                                 hr = AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXLFont, (wchar_t*)L"Bold", 1, x);
  480.                                                 VARIANT y;
  481.                                                 y.vt = VT_INT;
  482.                                                 y.intVal = 20;
  483.                                                 //y.lVal = RGB(255, 255, 0);
  484.                                                 hr = AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXLFont, (wchar_t*)L"Size", 1, y);
  485.                                                 VARIANT z;
  486.                                                 z.vt = VT_I4;
  487.                                                 z.lVal = RGB(123, 123, 0);
  488.                                                 hr = AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXLFont, (wchar_t*)L"Color", 1, z);
  489.                                             }
  490.  
  491.                                             //OLECHAR* szValue = (OLECHAR*)L"Value";
  492.                                             VARIANT x;
  493.                                             x.vt = VT_BSTR;
  494.                                             x.bstrVal = SysAllocString(L"Пожалуйста ♥!!!Поставьте лабу пожалуйста ♥");
  495.                                             hr = AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXLRange, (wchar_t*)L"Value", 1, x);
  496.                                             pXLRange->Release();
  497.                                         }
  498.                                     }
  499.  
  500.                                     pXLSheet->Release();
  501.                                 }
  502.                             }
  503.                             pXLBook->Release();
  504.                         }
  505.                     }
  506.                     pXLBooks->Release();
  507.                 }
  508.             }
  509.             getchar();
  510.         }
  511.         VariantInit(&vResult);  // Try to do _Application::Close()
  512.         hr = pXLApp->Invoke(0x0000012e, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &NoArgs, &vResult, NULL, NULL);
  513.         pXLApp->Release();
  514.     }
  515.     CoUninitialize();
  516.  
  517.     return;
  518. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!