Welcome to Experts Exchange

Add your voice to the tech community where 5M+ people, just like you, are talking about what matters.

  • Help others & share knowledge
  • Earn cash & points
  • Learn & ask questions
Solved

Using the IID_IUnknown in C program

Posted on 2000-02-29
1
1,459 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

What is SQL Server and how does it work?

The purpose of this paper is to provide you background on SQL Server. It’s your self-study guide for learning fundamentals. It includes both the history of SQL and its technical basics. Concepts and definitions will form the solid foundation of your future DBA expertise.

Question has a verified solution.

If you are experiencing a similar issue, please ask a related question

An Outlet in Cocoa is a persistent reference to a GUI control; it connects a property (a variable) to a control.  For example, it is common to create an Outlet for the text field GUI control and change the text that appears in this field via that Ou…
Summary: This tutorial covers some basics of pointer, pointer arithmetic and function pointer. What is a pointer: A pointer is a variable which holds an address. This address might be address of another variable/address of devices/address of fu…
The goal of this video is to provide viewers with basic examples to understand how to create, access, and change arrays in the C programming language.
The goal of this video is to provide viewers with basic examples to understand and use switch statements in the C programming language.

856 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