|
MAIN.CPP (LINES OLE Sample)
/*************************************************************************
-
- OLE Automation Lines Object.
-
- main.cpp
-
- Written by Microsoft Product Support Services, Windows Developer Support
- (c) Copyright Microsoft Corp. 1994 All Rights Reserved
-
- ***********************************************************************/
#include <windows.h>
#include <windowsx.h>
#ifdef WIN16
#include <ole2.h>
#include <compobj.h>
#include <dispatch.h>
#include <variant.h>
#include <olenls.h>
#include <commdlg.h>
#endif
#include <initguid.h>
#include "lines.h"
// Globals
CApplication FAR* g_pApplication;
SCODE g_scodes[SCODE_COUNT] = // Array of SCODEs for easy lookup
{ LINES_E_UNEXPECTED,
LINES_E_OUTOFMEMORY,
LINES_E_INVALIDINDEX,
LINES_E_COLLECTIONFULL,
LINES_E_LINEFROMOTHERINSTANCE,
LINES_E_CANTADDENDPOINTS,
LINES_E_POINTFROMOTHERINSTANCE,
LINES_E_NOVISIBLEXCOORDINATE,
LINES_E_NOVISIBLEYCOORDINATE,
LINES_E_NOSTARTPOINT,
LINES_E_NOENDPOINT
};
/*
* WinMain
*
* Purpose:
* Main entry point of application.
*
*/
int APIENTRY WinMain (HINSTANCE hinst, HINSTANCE hinstPrev, LPSTR pCmdLine,
int nCmdShow)
{
MSG msg;
DWORD dwRegisterCF;
DWORD dwRegisterActiveObject;
// It is recommended that all OLE applications set
// their message queue size to 96. This improves the capacity
// and performance of OLE's LRPC mechanism.
int cMsg = 96; // Recommend msg queue size for OLE
while (cMsg && !SetMessageQueue(cMsg)) // take largest size we can get.
cMsg -= 8;
if (!cMsg)
return -1; // ERROR: we got no message queue
if (!hinstPrev)
if (!InitApplication(hinst)) // Register window class
return FALSE;
if (!InitInstance(hinst)) // Initialize OLE and create Lines application
object
return (FALSE);
// Determine if /Automation was specified in command line and register
class
// factory and active object. Show window if application was started stand
alone.
if (!ProcessCmdLine(pCmdLine, &dwRegisterCF, &dwRegisterActiveObject,
nCmdShow))
{
Uninitialize(dwRegisterCF, dwRegisterActiveObject);
return (FALSE);
}
while (GetMessage(&msg, NULL, 0, 0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
Uninitialize(dwRegisterCF, dwRegisterActiveObject);
return (msg.wParam);
}
/*
* InitApplication
*
* Purpose:
* Registers window class
*
* Parameters:
* hinst hInstance of application
*
* Return Value:
* TRUE if initialization succeeded, FALSE otherwise.
*/
BOOL InitApplication (HINSTANCE hinst)
{
WNDCLASS wc;
wc.style = CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = MainWndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hinst;
wc.hIcon = LoadIcon(hinst, MAKEINTRESOURCE(IDI_ICON));
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
wc.lpszMenuName = TEXT("AppMenu");
wc.lpszClassName = TEXT("MainWndClass");
return RegisterClass(&wc);
}
/*
* InitInstance
*
* Purpose:
* Intializes OLE and creates Lines Application object
*
* Parameters:
* hinst hInstance of application
*
* Return Value:
* TRUE if initialization succeeded, FALSE otherwise.
*/
BOOL InitInstance (HINSTANCE hinst)
{
HRESULT hr;
// Intialize OLE
hr = OleInitialize(NULL);
if (FAILED(hr))
return FALSE;
// Create an instance of the Lines Application object. Object is
// created with refcount 0.
hr = CApplication::Create(hinst, &g_pApplication);
if (FAILED(hr))
return FALSE;
return TRUE;
}
/*
* ProcessCmdLine
*
* Purpose:
* Check if command line contains /Automation. If so, the class factory of
the
* application object is registered. If not, the application was started
stand-alone and
* so the window is shown. The application object is registered using
RegisterActiveObject.
*
* Parameters:
* pCmdLine Command line passed to application
* pdwRegisterCF Returns id returned after class factory registration. Can
be used to
* revoke class factory registration.
* pdwRegisterActiveObject Returns id returned after active object
registration. Can be used to
* revoke active object registration.
* nCmdShow Specifies how window is to be shown if application was
started stand alone.
*
* Return Value:
* TRUE if OLE initialization succeeded, FALSE otherwise.
*
*/
BOOL ProcessCmdLine(LPSTR pCmdLine, LPDWORD pdwRegisterCF, LPDWORD
pdwRegisterActiveObject, int nCmdShow)
{
LPCLASSFACTORY pcf = NULL;
HRESULT hr;
*pdwRegisterCF = 0;
*pdwRegisterActiveObject = 0;
// Expose class factory for application object if command line contains the
// Automation switch
if (_fstrstr(pCmdLine, "-Automation") != NULL
|| _fstrstr(pCmdLine, "/Automation") != NULL)
{
pcf = new CApplicationCF;
if (!pcf)
goto error;
pcf->AddRef();
hr = CoRegisterClassObject(CLSID_Lines, pcf,
CLSCTX_LOCAL_SERVER, REGCLS_SINGLEUSE,
pdwRegisterCF);
if (hr != NOERROR)
goto error;
pcf->Release();
}
else g_pApplication->ShowWindow(nCmdShow); // Show window if started
stand-alone
// Register Lines application object in the Running Object Table (ROT).
This
// allows controllers to connect to a running application object instead of
creating
// a new instance. Use weak registration so that the ROT releases it's
reference when
// all external references are released. If strong registration is used,
the ROT will not
// release it's reference until RevokeActiveObject is called and so will
keep
// the object alive even after all external references have been released.
RegisterActiveObject(g_pApplication, CLSID_Lines, ACTIVEOBJECT_WEAK,
pdwRegisterActiveObject);
return TRUE;
error:
if (pcf)
pcf->Release();
return FALSE;
}
/*
* Uninitialize
*
* Purpose:
* Revoke class factory and active object registration and uninitialize OLE.
*
* Parameters:
* dwRegisterCF ID returned after class factory registration.
* dwRegisterActiveObject ID returned after active object registration.
*
*/
- oid Uninitialize(DWORD dwRegisterCF, DWORD dwRegisterActiveObject)
{
if (dwRegisterCF != 0)
CoRevokeClassObject(dwRegisterCF);
if (dwRegisterActiveObject != 0)
RevokeActiveObject(dwRegisterActiveObject, NULL);
OleUninitialize();
}
/*
* MainWndProc
*
* Purpose:
* Window procedure for main window
*
*/
LRESULT CALLBACK MainWndProc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM
lParam)
{
switch (msg)
{
case WM_PAINT:
g_pApplication->Draw();
break;
case WM_SIZE:
g_pApplication->OnSize(LOWORD(lParam), HIWORD(lParam));
break;
case WM_COMMAND:
{
switch(GET_WM_COMMAND_ID(wParam,lParam))
{
case IDM_DRAWLINE:
g_pApplication->CreateAndDrawLine();
break;
case IDM_CLEAR:
g_pApplication->ClearPane();
break;
case IDM_EXIT:
PostMessage(hwnd, WM_CLOSE, 0, 0L);
break;
}
}
break;
case WM_CLOSE:
// Hide the window to release the refcount added by
CoLockObjectExternal
// (See CLines::ShowWindow)
g_pApplication->m_bUserClosing = TRUE;
g_pApplication->ShowWindow(SW_HIDE);
DestroyWindow(hwnd);
return 0L;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hwnd, msg, wParam, lParam);
}
return NULL;
}
/*
* DrawLineDialogFunc
*
* Purpose:
* Dialog function of DrawLine dialog. Prompts user and returns information
to draw a line.
*
*/
BOOL CALLBACK DrawLineDialogFunc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM
lParam)
{
static LPLINEINFO plineinfo;
BOOL b;
CHOOSECOLOR cc;
COLORREF clrCustom[16];
int n;
switch (msg)
{
case WM_INITDIALOG:
plineinfo = (LPLINEINFO)lParam;
// Initialize edit controls. Units are twips.
SetDlgItemText(hwndDlg, IDC_STARTPOINT_X, TEXT("4500"));
SetDlgItemText(hwndDlg, IDC_STARTPOINT_Y, TEXT("4500"));
SetDlgItemText(hwndDlg, IDC_ENDPOINT_X, TEXT("8000"));
SetDlgItemText(hwndDlg, IDC_ENDPOINT_Y, TEXT("8000"));
SetDlgItemText(hwndDlg, IDC_THICKNESS, TEXT("100"));
plineinfo->colorref = 0;
return TRUE;
case WM_COMMAND:
switch(GET_WM_COMMAND_ID(wParam,lParam))
{
case IDOK:
plineinfo->ptStart.x = GetDlgItemInt(hwndDlg,
IDC_STARTPOINT_X, &b, TRUE);
plineinfo->ptStart.y = GetDlgItemInt(hwndDlg,
IDC_STARTPOINT_Y, &b, TRUE);
plineinfo->ptEnd.x = GetDlgItemInt(hwndDlg, IDC_ENDPOINT_X,
&b, TRUE);
plineinfo->ptEnd.y = GetDlgItemInt(hwndDlg, IDC_ENDPOINT_Y,
&b, TRUE);
plineinfo->nThickness = GetDlgItemInt(hwndDlg, IDC_THICKNESS,
&b, TRUE);
EndDialog(hwndDlg, IDOK);
return TRUE;
case IDCANCEL:
EndDialog(hwndDlg, IDCANCEL);
return TRUE;
case IDC_CHOOSECOLOR:
memset(&cc, 0, sizeof(CHOOSECOLOR));
cc.lStructSize = sizeof(CHOOSECOLOR);
cc.hwndOwner = hwndDlg;
cc.rgbResult = RGB(0, 0, 0);
cc.Flags = CC_RGBINIT;
for (n=0; n<16; n++)
clrCustom[n] = RGB(255, 255, 255);
cc.lpCustColors = clrCustom;
if (ChooseColor(&cc))
plineinfo->colorref = cc.rgbResult;
}
break;
}
return FALSE;
}
/*
* LoadTypeInfo
*
* Purpose:
* Gets type information of an object's interface from type library.
*
* Parameters:
* ppunkStdDispatch Returns type information.
* clsid Interface id of object in type library.
*
* Return Value:
* HRESULT
*
*/
HRESULT LoadTypeInfo(ITypeInfo FAR* FAR* pptinfo, REFCLSID clsid)
{
HRESULT hr;
LPTYPELIB ptlib = NULL;
LPTYPEINFO ptinfo = NULL;
*pptinfo = NULL;
// Load Type Library.
hr = LoadRegTypeLib(LIBID_Lines, 1, 0, 0x0409, &ptlib);
if (FAILED(hr))
{
// if it wasn't registered, try to load it from the path
// if this succeeds, it will have registered the type library for us
// for the next time.
hr = LoadTypeLib(OLESTR("lines.tlb"), &ptlib);
if(FAILED(hr))
return hr;
}
// Get type information for interface of the object.
hr = ptlib->GetTypeInfoOfGuid(clsid, &ptinfo);
if (FAILED(hr))
{
ptlib->Release();
return hr;
}
ptlib->Release();
*pptinfo = ptinfo;
return NOERROR;
}
#ifdef WIN32
#ifndef UNICODE
char* ConvertToAnsi(OLECHAR FAR* szW)
{
static char achA[STRCONVERT_MAXLEN];
WideCharToMultiByte(CP_ACP, 0, szW, -1, achA, STRCONVERT_MAXLEN, NULL,
NULL);
return achA;
}
OLECHAR* ConvertToUnicode(char FAR* szA)
{
static OLECHAR achW[STRCONVERT_MAXLEN];
MultiByteToWideChar(CP_ACP, 0, szA, -1, achW, STRCONVERT_MAXLEN);
return achW;
}
#endif
#endif
| Last news from Greatis Software |
 |
|
Nostalgia .Net |
|
.Net is powerful, but not all-powerful, so sometimes we need to use Win32 API for our .Net applications. It's simple enough with Platform Invoke if you have Win32 skill, but we do not always have time to dig the ancient documentation, declare the special types that are compatible with Win32, find the values of the Win32's constants and so on. Nostalgia .Net offers several simple-to-use classes, and components that will allow you to forget about the headache of Win32 and just use the power of Win32 in your application the same way as you use the native. Net classes. More » |
| Recommended software for developers |
 |
|
Ultimate Pack |
|
Component pack for Delphi and C++ Builder that contains runtime form designer, runtime object inspector, print suite and much more for the very special price. More » |
 |
|
Form Designer .Net |
|
Unique runtime form design solution that allows to edit any form in .Net WinForms application at runtime with full source codes for only 300 euro! More » |
 |
|
Print Suite .Net |
|
Print Suite .Net is a set of components for easy printing texts, images and grids from your WinForms applications. Full C# source codes are available More » |
 |
|
Gradient Controls .Net |
|
Gradient Controls .Net offers controls with gradient background feature. Labels, panels and so on... Full C# source codes are available More » |
 |
|
Greatis iGrid |
|
iGrid plots drawing grid right over your desktop, so you can use it everywhere, with any drawing application without any special plugins for different graphic editors. More » |
All the contacts and projectsDmitry Vasiliev (just.dmitry)
Related LinksSoftware for Visual Studio .NET developers
Software for Delphi and C++ Builder developers
Software for Visual Basic 6 developers
Delphi Tips&Tricks
MegaDetailed.NET More Online Helps Win32 Programmer's Reference
Win32 Multimedia Programmer's Reference
OLE Programmer's Reference
Microsoft Windows Pen API Programmer's Reference
Microsoft Windows Sockets 2 Reference
Microsoft Windows Telephony API (TAPI) Programmer's Reference
Unix Manual Pages
|
