Solved

Using the IID_IUnknown in C program

Posted on 2000-02-29
1
1,423 Views
Last Modified: 2008-03-04
Hello,
I try to use CoCreateInstance in a C program in order to use an ActiveX control. I need to refer to IID_IUnknown as the riid of the object i want to use, but when I use IID_IUnknown I have a link error.

Does anyone can help me telling me where I could get a C program using an ActiveX control ?


Thanks.
0
Comment
Question by:mbensimo
1 Comment
 
LVL 14

Accepted Solution

by:
AlexVirochovsky earned 50 total points
ID: 2569323
Next is example of using
 IUnknown interface in C programm,
but in C++ it is more simple!

//  callpub.h
#define IDM_CREATE            1
#define IDM_DESTROY           2
#define IDM_IUNKNOWN          3
#define IDM_IMALLOC           4
#define IDM_IMARSHAL          5
#define IDM_ALLOCATE_CUSTOM   6
#define IDM_ALLOCATE_DEFAULT  7
#define IDM_FREE              8
#define IDM_CHECK             9

//pubmem.h
//-------------------------------------------------------------------
#define EXPORT extern "C" __declspec (dllexport)

EXPORT LPMALLOC CreateAllocator () ;

// {308D0430-1090-11cf-B92A-00AA006238F8}
DEFINE_GUID (CLSID_ALLOCATOR,
     0x308d0430, 0x1090, 0x11cf, 0xb9,
     0x2a, 0x0, 0xaa, 0x0, 0x62, 0x38, 0xf8) ;

//-------------------------------------------------------------------
// Implementation of allocator interface
//-------------------------------------------------------------------
#undef  INTERFACE
#define INTERFACE DAlloc

DECLARE_INTERFACE_ (DAlloc, IMalloc)
     {
     // *** IUnknown methods ***
     STDMETHOD  (QueryInterface) (THIS_ REFIID riid, LPVOID FAR *ppv) ;
     STDMETHOD_ (ULONG, AddRef)  (THIS) ;
     STDMETHOD_ (ULONG, Release) (THIS) ;

     // *** IMalloc methods ***
     STDMETHOD_ (void *, Alloc)        (THIS_ ULONG cb) ;
     STDMETHOD_ (void *, Realloc)      (THIS_ void *pv, ULONG cb) ;
     STDMETHOD_ (void,   Free)         (THIS_ void *pv) ;
     STDMETHOD_ (ULONG,  GetSize)      (THIS_ void *pv) ;
     STDMETHOD_ (int,    DidAlloc)     (THIS_ void *pv) ;
     STDMETHOD_ (void,   HeapMinimize) (THIS) ;

#ifndef CINTERFACE
public :
     DAlloc () ;
     ~DAlloc () ;
     BOOL Initialize () ;
private :
     ULONG RefCount ;
     HANDLE hHeap ;
#endif
     } ;

// Class Factory
#undef  INTERFACE
#define INTERFACE DClassFactory

DECLARE_INTERFACE_ (DClassFactory, IClassFactory)
     {
     // *** IUnknown methods ***
     STDMETHOD  (QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppv) ;
     STDMETHOD_ (ULONG, AddRef)  (THIS) ;
     STDMETHOD_ (ULONG, Release) (THIS) ;

     // *** IClassFactory methods ***
     STDMETHOD (CreateInstance) (THIS_ LPUNKNOWN pUnkOuter,
                         REFIID riid, LPVOID FAR *ppvObject) ;
     STDMETHOD (LockServer)     (THIS_ BOOL fLock) ;

#ifndef CINTERFACE
public :
     DClassFactory () ;
     ~DClassFactory () ;
private :
     ULONG RefCount ;
#endif
     } ;

/*---------------------------------------------
   CALLPUB.C -- Call into public OLE component
  ---------------------------------------------*/
#include <windows.h>
#include <initguid.h>
#include "pubmem.h"
#include "callpub.h"

LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;

char szWndClass[] = "CallerWindow" ;
char szAppName[]  = "Calls Public Malloc" ;

//-------------------------------------------------------------------
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    PSTR lpszCmdLine, int cmdShow)      
     {
     HWND        hwnd ;
     MSG         msg ;
     WNDCLASSEX  wc ;

       wc.cbSize        = sizeof (wc) ;
     wc.lpszClassName = szWndClass ;
     wc.hInstance     = hInstance ;
     wc.lpfnWndProc   = WndProc ;
     wc.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
     wc.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
     wc.lpszMenuName  = "MAIN" ;
     wc.hbrBackground = (HBRUSH) (COLOR_WINDOW + 1) ;
     wc.style         = 0 ;
     wc.cbClsExtra    = 0 ;
     wc.cbWndExtra    = 0 ;
       wc.hIconSm       = LoadIcon (NULL, IDI_APPLICATION) ;

     RegisterClassEx (&wc) ;

     hwnd = CreateWindowEx (0L, szWndClass, szAppName,
                            WS_OVERLAPPEDWINDOW,  
                      CW_USEDEFAULT, CW_USEDEFAULT,
                            CW_USEDEFAULT, CW_USEDEFAULT,
                            NULL, NULL, hInstance, NULL) ;
     ShowWindow (hwnd, cmdShow) ;
     UpdateWindow (hwnd) ;

     // Connect to OLE libraries
     HRESULT hr = CoInitialize (NULL) ;
     if (FAILED (hr))
          {
          // Fail app initialization
          return FALSE ;
          }

     while (GetMessage (&msg, NULL, 0, 0))
          {
          TranslateMessage (&msg) ;
          DispatchMessage (&msg) ;  
          }

     // Disconnect from OLE libraries
     CoUninitialize () ;

     return msg.wParam ;
     }

//-------------------------------------------------------------------
LRESULT CALLBACK
WndProc (HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
     {
     static int       iCurLine = 0 ;
     static LPMALLOC  pMalloc = NULL ;
     static LPSTR     szLine[10] ;
     static RECT      rHit[10] ;

     switch (iMsg)
          {
          case WM_CREATE :
             // Initialize data pointer array
               ZeroMemory (szLine, sizeof (szLine)) ;
               return 0 ;

        case WM_COMMAND :
               switch (LOWORD (wParam))
                    {
                    case IDM_CREATE :
                         {
                         HRESULT hr =
                              CoCreateInstance (CLSID_ALLOCATOR,
                                                NULL,
                                                CLSCTX_INPROC_SERVER,
                                                IID_IMalloc,
                                                (void **) &pMalloc) ;
   
                         if (FAILED (hr))
                              {
                              MessageBox (hwnd, "Error: No allocator",
                                szAppName, MB_OK) ;
                              return 0 ;
                              }

                   InvalidateRect (hwnd, NULL, TRUE) ;
                         return 0 ;
                         }

                    case IDM_DESTROY :
                         {
                         int i ;

                         // Mark allocated blocks as invalid
                         for (i = 0 ; i < 10 ; i++)
                              {
                              if ((szLine[i] != NULL) &&
                                  (pMalloc->lpVtbl->DidAlloc (pMalloc,
                                                                              szLine[i])))
                                   {
                           szLine[i] = NULL ;
                                   }
                              }

                   // Disconnect from & free allocator
                         pMalloc->lpVtbl->Release (pMalloc) ;
                         pMalloc = NULL ;

                         InvalidateRect (hwnd, NULL, TRUE) ;
                         return 0 ;
                         }

                    case IDM_IUNKNOWN :
                         {
                         LPUNKNOWN pUnk ;
                         HRESULT hr =
                              pMalloc->lpVtbl->QueryInterface (pMalloc,
                                                                             IID_IUnknown,
                                                                             (void **) &pUnk) ;
                   if (SUCCEEDED (hr))
                              {
                              pUnk->lpVtbl->Release (pUnk) ;
                              MessageBox (hwnd, "IUnknown supported",
                                szAppName, MB_OK) ;
                              }
                         else
                              {
                              MessageBox (hwnd, "IUnknown not supported",
                                          szAppName, MB_OK) ;
                              }
                         return 0 ;
                         }

                    case IDM_IMALLOC :
                         {
                         LPUNKNOWN pUnk ;
                         HRESULT hr =
                              pMalloc->lpVtbl->QueryInterface (pMalloc,
                                                                     IID_IMalloc,
                                                                             (void **) &pUnk) ;
                                           
                         if (SUCCEEDED (hr))
                        {
                              pUnk->lpVtbl->Release (pUnk) ;
                              MessageBox (hwnd, "IMalloc supported",
                                          szAppName, MB_OK) ;
                              }
                         else
                              {
                              MessageBox (hwnd, "IMalloc not supported",
                                          szAppName, MB_OK) ;
                              }
                         return 0 ;
                         }

                     case IDM_IMARSHAL :
                          {
                    LPUNKNOWN pUnk ;
                          HRESULT hr =
                               pMalloc->lpVtbl->QueryInterface (pMalloc,
                                                                              IID_IMarshal,
                                                                      (void **) &pUnk) ;
                          if (SUCCEEDED (hr))
                               {
                               pUnk->lpVtbl->Release (pUnk) ;
                               MessageBox (hwnd, "IMarshal supported",
                                           szAppName, MB_OK) ;
                               }
                          else
                               {
                               MessageBox (hwnd, "IMarshal not supported",
                                           szAppName, MB_OK) ;
                               }
                          return 0 ;
                          }

                case IDM_ALLOCATE_CUSTOM :
                         if (szLine[iCurLine] != NULL)
                              {
                              MessageBox (hwnd, "Error: Free First",
                                szAppName, MB_OK) ;
                              return 0 ;
                              }

                         // Allocate from IMalloc interface
                         szLine[iCurLine] =
                                            (char *) pMalloc->lpVtbl->Alloc (pMalloc, 100) ;
                         lstrcpy (szLine[iCurLine], "*IMalloc memory*") ;

                         InvalidateRect (hwnd, NULL, TRUE) ;
                         return 0 ;

                    case IDM_ALLOCATE_DEFAULT :
                         if (szLine[iCurLine] != NULL)
                              {
                        MessageBox (hwnd, "Error: Free First",
                                          szAppName, MB_OK) ;
                              return 0 ;
                              }

                         // Allocate from default heap
                         szLine[iCurLine] = (char *) malloc (100) ;
                         lstrcpy (szLine[iCurLine], "-Malloc memory-") ;

                         InvalidateRect (hwnd, NULL, TRUE) ;
                         return 0 ;

                    case IDM_FREE :
                         if (szLine[iCurLine] == NULL)
                              {
                              MessageBox (hwnd, "Error: Nothing to free",
                                          szAppName, MB_OK) ;
                              return 0 ;
                              }

                         if (pMalloc == NULL)
                              {
                              goto FreeMalloc ;
                        }

                         // Free allocated object
                         if (pMalloc->lpVtbl->DidAlloc (pMalloc,
                                                                      szLine[iCurLine]))
                              {
                              pMalloc->lpVtbl->Free (pMalloc,
                                                                     szLine[iCurLine]) ;
                              }
                         else
                              {
               FreeMalloc:
                              free (szLine[iCurLine]) ;
                              }

                   szLine[iCurLine] = NULL ;

                         InvalidateRect (hwnd, NULL, TRUE) ;
                         return 0 ;
                }

          case WM_DESTROY :
               // Disconnect from & free allocator
               if (pMalloc)
                    {
                    pMalloc->lpVtbl->Release (pMalloc) ;
                    pMalloc = NULL ;
                    }

               PostQuitMessage (0) ;  // Handle application shutdown
               return 0 ;

          case WM_INITMENU :
               {
               HMENU hMenu = (HMENU) wParam ;
               if (pMalloc)
                    {
                    EnableMenuItem (hMenu, IDM_CREATE,          MF_GRAYED) ;
                EnableMenuItem (hMenu, IDM_DESTROY,         MF_ENABLED) ;
                    EnableMenuItem (hMenu, IDM_ALLOCATE_CUSTOM, MF_ENABLED) ;
                    EnableMenuItem (hMenu, IDM_IUNKNOWN,        MF_ENABLED) ;
                    EnableMenuItem (hMenu, IDM_IMALLOC,         MF_ENABLED) ;
                    EnableMenuItem (hMenu, IDM_IMARSHAL,        MF_ENABLED) ;
                    }
               else
                    {
                    EnableMenuItem(hMenu, IDM_CREATE,          MF_ENABLED) ;
                    EnableMenuItem(hMenu, IDM_DESTROY,         MF_GRAYED) ;
                    EnableMenuItem(hMenu, IDM_ALLOCATE_CUSTOM, MF_GRAYED) ;
                    EnableMenuItem(hMenu, IDM_IUNKNOWN,        MF_GRAYED) ;
                    EnableMenuItem(hMenu, IDM_IMALLOC,         MF_GRAYED) ;
                    EnableMenuItem(hMenu, IDM_IMARSHAL,        MF_GRAYED) ;
                    }
               return 0 ;
               }

          case WM_LBUTTONDOWN :
             {
               int i ;
               int x = LOWORD (lParam) ;
               int y = HIWORD (lParam) ;
               POINT pt = { x, y } ;

               for (i = 0 ; i < 10 ; i++)
                    {
                    if (PtInRect (&rHit[i], pt))
                         {
                         if (iCurLine != i)  // Minimize screen blink
                              {
                              InvalidateRect (hwnd, &rHit[iCurLine], TRUE) ;
                              InvalidateRect (hwnd, &rHit[i], TRUE) ;
                              iCurLine = i ;
                              }
                         break ;
                         }    
                    }
             return 0 ;
               }

          case WM_PAINT :
               {
               char         szBuff[10] ;
               COLORREF     crText, crBack ;
               HDC          hdc ;
               int          cc ;
               int          i ;
               int          XCount, XText, Y ;
               int          cyLineHeight ;
               PAINTSTRUCT  ps ;
               RECT         rOpaque ;
               TEXTMETRIC   tm ;

               hdc = BeginPaint (hwnd, &ps) ;

               // Fetch line height
             GetTextMetrics (ps.hdc, &tm) ;
               cyLineHeight = tm.tmHeight + tm.tmExternalLeading ;

               // Fetch current text colors
               crText = GetTextColor (ps.hdc) ;
               crBack = GetBkColor (ps.hdc) ;

               XCount = tm.tmAveCharWidth * 3 ;
               XText  = XCount + tm.tmAveCharWidth * 7 ;
               Y      = tm.tmHeight ;

               for (i = 0 ; i < 10 ; i++, Y += cyLineHeight)
                    {
                    // Set colors to highlight current line
                    if (i == iCurLine)
                         {
                         SetTextColor (ps.hdc, crBack) ;
                         SetBkColor (ps.hdc, crText) ;

                   SetRect (&rOpaque, 0, Y, 9999, Y + cyLineHeight) ;
                         ExtTextOut(ps.hdc, 0, 0, ETO_OPAQUE, &rOpaque,
                                    NULL, 0, NULL ) ;
                         }
                    else
                         {
                         SetTextColor (ps.hdc, crText) ;
                         SetBkColor (ps.hdc, crBack) ;
                         }

                    // Display line count
                    cc = wsprintf (szBuff, "Line %d", i) ;
                    TextOut (ps.hdc, XCount, Y, szBuff, cc) ;

                    // Display text if a string has been defined
                    if (szLine[i] != NULL)
                         {
                         cc = lstrlen (szLine[i]) ;
                         TextOut (ps.hdc, XText, Y, szLine[i], cc) ;
                   }

                    // Calculate hit test rectangle
                    SetRect (&rHit[i], 0, Y, 9999, Y + cyLineHeight) ;
                    }

               EndPaint (hwnd, &ps) ;
               return 0 ;
               }

          default :
               return DefWindowProc (hwnd, iMsg, wParam, lParam) ;
          }
     }

I hope, it helps. Alex
0

Featured Post

Highfive + Dolby Voice = No More Audio Complaints!

Poor audio quality is one of the top reasons people don’t use video conferencing. Get the crispest, clearest audio powered by Dolby Voice in every meeting. Highfive and Dolby Voice deliver the best video conferencing and audio experience for every meeting and every room.

Join & Write a Comment

This tutorial is posted by Aaron Wojnowski, administrator at SDKExpert.net.  To view more iPhone tutorials, visit www.sdkexpert.net. This is a very simple tutorial on finding the user's current location easily. In this tutorial, you will learn ho…
Windows programmers of the C/C++ variety, how many of you realise that since Window 9x Microsoft has been lying to you about what constitutes Unicode (http://en.wikipedia.org/wiki/Unicode)? They will have you believe that Unicode requires you to use…
The goal of this video is to provide viewers with basic examples to understand and use pointers in the C programming language.
The goal of this video is to provide viewers with basic examples to understand and use structures in the C programming language.

743 members asked questions and received personalized solutions in the past 7 days.

Join the community of 500,000 technology professionals and ask your questions.

Join & Ask a Question

Need Help in Real-Time?

Connect with top rated Experts

9 Experts available now in Live!

Get 1:1 Help Now