C / C++ / MFC

Rajesh R Subramanian wrote:

I was I'm not able to find something like GetThreadCount() the thread pool API.

DWORD GetThreadCount()
{
    THREADENTRY32 stThreadEntry = {0};
    stThreadEntry.dwSize = sizeof( stThreadEntry );
    HANDLE hSnap = CreateToolhelp32Snapshot( TH32CS_SNAPTHREAD, 0 );
    if( !Thread32First( hSnap, &stThreadEntry ))
    {
        return 0;
    }
    int nCount = 0;
    DWORD dwCurrentProcessId = GetCurrentProcessId();
    do 
    {
        if( dwCurrentProcessId == stThreadEntry.th32OwnerProcessID )
        {
            nCount ++;
        }
    } while (Thread32Next(hSnap, &stThreadEntry ));
    return nCount;
}

Rajesh R Subramanian wrote:

On the other hand, it looks like this is going to return me the number of threads that my application is running

Rajesh R Subramanian wrote:

I want to be able to find the number of threads that specifically belong to the pool. I think I'll need to put in a bit more research.

Naveen wrote:

ya. I thought if the module is small, you know the count of other threads.

Naveen wrote:

BTW where is the option to find out the thread pool's thread count in process explorer?

#include <atlbase.h>
#include <atlcom.h>
// Reference the Excel object model
#import "libid:00020813-0000-0000-C000-000000000046" auto_search no_dual_interfaces rename("DialogBox", "excelDialogBox") rename("RGB", "excelRGB") rename("DocumentProperties", "excelDocumentProperties") rename("SearchPath", "excelSearchPath") rename("CopyFile", "excelCopyFile") rename("ReplaceText", "excelReplaceText")

// Define the AppEvents handler object.

// First define fucntion information for the events we want to handle
_ATL_FUNC_INFO SheetChangeInfo = { CC_CDECL, VT_EMPTY, 2, { VT_DISPATCH, VT_DISPATCH } };
_ATL_FUNC_INFO AfterCalculateInfo = { CC_CDECL, VT_EMPTY, 0, { } };

// And define an event handler object - note that this object just sets a boolean
// variable to true when a handled event is seen
class ExcelAppEventHandler : public IDispEventSimpleImpl<1, ExcelAppEventHandler, &__uuidof(Excel::AppEvents)>
{
public:
   ExcelAppEventHandler(bool& doneFlag) : done_(doneFlag) { done_ = false; }
   // The sink map maps event handler functions to the events they handle
   BEGIN_SINK_MAP(ExcelAppEventHandler)
      SINK_ENTRY_INFO(1, __uuidof(Excel::AppEvents), 0x0000061c, &ExcelAppEventHandler::SheetChange, &SheetChangeInfo)
      SINK_ENTRY_INFO(1, __uuidof(Excel::AppEvents), 0x00000a34, &ExcelAppEventHandler::AfterCalculate, &AfterCalculateInfo)
   END_SINK_MAP()

   // Event handling methods. These match the signatures given in the AppEvents
   // definition except for the return type and we've added in the _stdcall
   // calling convention.
   void _stdcall SheetChange(IDispatch *, struct Excel::Range *)
   {
      done_ = true;
   }
   void _stdcall AfterCalculate()
   {
      done_ = true;
   }
private:
   bool& done_;
};

int _tmain(int argc, _TCHAR* argv[])
{
   // Tell the system we're using COM
   CoInitializeEx(0, COINIT_MULTITHREADED);
   {
      //Declare an Excel object pointer
      Excel::_ApplicationPtr xl;
      // And get a reference to the currently running instance of Excel
      if (SUCCEEDED(xl.GetActiveObject(__uuidof(Excel::Application))))
      {
         // Make sure there's at least one workbook
         xl->Workbooks->Add();
         bool done = false;

         // Instantiate the event handler
         ExcelAppEventHandler handler(done);
         // Tell Excel about the handler
         if (SUCCEEDED(handler.DispEventAdvise(xl)))
         {
            // Run a Windows message loop to pump COM messages - this is needed
            // because that's how COM works...
            MSG msg;
            while (!done && GetMessage(&msg, NULL, 0, 0) > 0) {
               TranslateMessage(&msg);
               DispatchMessage(&msg);
            }            
            // Tell Excel we don't want to handle events any more.
            handler.DispEventUnadvise(xl);
         }
      }
   }
   // Tell the system we're done with COM
   CoUninitialize();
   return 0;
}

_ATL_FUNC_INFO SheetCalculateInfo = { CC_CDECL, VT_EMPTY, 1, { VT_DISPATCH } };

class ExcelBookEventHandler : public IDispEventSimpleImpl<1, ExcelBookEventHandler, &__uuidof(Excel::WorkbookEvents)>
{
public:
	BEGIN_SINK_MAP(ExcelBookEventHandler)
		SINK_ENTRY_INFO(1, __uuidof(Excel::WorkbookEvents), 0x0000061b, &ExcelBookEventHandler::SheetCalculate, &SheetCalculateInfo)
	END_SINK_MAP()

	void _stdcall SheetCalculate(IDispatch *)
	{
		std::cout << "ExcelBookEventHandler::SheetCalculate\n";
	}
};

 Excel::_WorkbookPtr wb = xl->Workbooks->Add();
ExcelBookEventHandler calc;
calc.DispEventAdvise(wb);

NarVish wrote:

it would be great if you can point me to complete documentation on interfacing Excel

#include <iostream>
#include <atlbase.h>
#include <atlcom.h>
// Reference the Excel object model
#import "libid:00020813-0000-0000-C000-000000000046" auto_search no_dual_interfaces rename("DialogBox", "excelDialogBox") rename("RGB", "excelRGB") rename("DocumentProperties", "excelDocumentProperties") rename("SearchPath", "excelSearchPath") rename("CopyFile", "excelCopyFile") rename("ReplaceText", "excelReplaceText")

// Define the AppEvents handler object.

// First define function information for the events we want to handle
_ATL_FUNC_INFO SheetChangeInfo = { CC_CDECL, VT_EMPTY, 2, { VT_DISPATCH, VT_DISPATCH } };
_ATL_FUNC_INFO AfterCalculateInfo = { CC_CDECL, VT_EMPTY, 0, { } };

// And define an event handler object - note that this object just sets a boolean
// variable to true when a handled event is seen
class ExcelAppEventHandler : public IDispEventSimpleImpl<1, ExcelAppEventHandler, &__uuidof(Excel::AppEvents)>
{
public:
   ExcelAppEventHandler(bool& doneFlag) : done_(doneFlag) { done_ = false; }
   // The sink map maps event handler functions to the events they handle
   BEGIN_SINK_MAP(ExcelAppEventHandler)
      SINK_ENTRY_INFO(1, __uuidof(Excel::AppEvents), 0x0000061c, &ExcelAppEventHandler::SheetChange, &SheetChangeInfo)
      SINK_ENTRY_INFO(1, __uuidof(Excel::AppEvents), 0x00000a34, &ExcelAppEventHandler::AfterCalculate, &AfterCalculateInfo)
   END_SINK_MAP()

   // Event handling methods. These match the signatures given in the AppEvents
   // definition except for the return type and we've added in the _stdcall
   // calling convention.
   void _stdcall SheetChange(IDispatch *, struct Excel::Range *)
   {
      std::cout << "ExcelAppEventHandler::SheetChange\n";
   }
   void _stdcall AfterCalculate()
   {
      std::cout << "ExcelAppEventHandler::AfterCalculate\n";
   }
private:
   bool& done_;
};

_ATL_FUNC_INFO SheetCalculateInfo = { CC_CDECL, VT_EMPTY, 1, { VT_DISPATCH } };

class ExcelBookEventHandler : public IDispEventSimpleImpl<1, ExcelBookEventHandler, &__uuidof(Excel::WorkbookEvents)>
{
public:
   BEGIN_SINK_MAP(ExcelBookEventHandler)
      SINK_ENTRY_INFO(1, __uuidof(Excel::WorkbookEvents), 0x0000061b, &ExcelBookEventHandler::SheetCalculate, &SheetCalculateInfo)
   END_SINK_MAP()

   void _stdcall SheetCalculate(IDispatch *)
   {
      std::cout << "ExcelBookEventHandler::SheetCalculate\n";
   }
};

int _tmain(int argc, _TCHAR* argv[])
{
   // Tell the system we're using COM
   CoInitializeEx(0, COINIT_MULTITHREADED);
   {
      //Declare an Excel object pointer
      Excel::_ApplicationPtr xl;
      // And get a reference to the currently running instance of Excel
      if (SUCCEEDED(xl.GetActiveObject(__uuidof(Excel::Application))))
      {
         // Make sure there's at least one workbook
         Excel::_WorkbookPtr wb = xl->Workbooks->Add();
         ExcelBookEventHandler bookHandler;
         bookHandler.DispEventAdvise(wb);
         Excel::_WorksheetPtr ws = wb->Worksheets->Item[1];
         if (ws)
            std::cout << ws->Name << std::endl;
         bool done = false;

         // Instantiate teh event handler
         ExcelAppEventHandler handler(done);
         // Tell Excel about the handler
         if (SUCCEEDED(handler.DispEventAdvise(xl)))
         {
            // Run a Windows message loop to pump COM messages - this is needed
            // because that's how COM works...
            MSG msg;
            while (!done && GetMessage(&msg, NULL, 0, 0) > 0) {
               TranslateMessage(&msg);
               DispatchMessage(&msg);
            }            
            // Tell Excel we don't want to handle events any more.
            handler.DispEventUnadvise(xl);
         }
      }
   }
   CoUninitialize();
   return 0;
}