C / C++ / MFC

Getting a function Pointer

21-Jul-09 3:03

You had to post all of this code just for a linker error. Confused | :confused:

"Old age is like a bank account. You withdraw later in life what you have deposited along the way." - Unknown

"Fireproof doesn't mean the fire will never come. It means when the fire comes that you will be able to withstand it." - Michael Simmons

Need AMCap source code

Vaclav_20-Jul-09 11:36

Vaclav_

20-Jul-09 11:36

Please help me and send me - point me - to AMCap source code. I downloaded ( two hours) latest DXSDK_Mar09 to find out it does not run on WIN2000. Win2000 does not recognize the executable as WIn32 application!?
I tryed to run if on XP only to get cryptic message about need to use PACKER tool.
I have no clue what is this tool and where to get it.
Thanks for reading
Vaclav

San Saeteurn20-Jul-09 9:09

20-Jul-09 9:09

Hello,

Is there a way to get a pointer to the function you are in?
Like the "this" pointer for the object.

What I want to do is pass the function down to another function that I am calling.

void myFunction()
{
yourFunction("myFunction Reference");
}

void yourFunction(void (* myFunc)(void))
{
if(myFunc == m_myFunc)
{
cout << "Error: Possible infinite loop, calling me with this guy" << endl;
}
}

Thanks,
-San Saeteurn

David Crow20-Jul-09 9:20

20-Jul-09 9:20

San Saeteurn wrote:
if(myFunc == m_myFunc)

Well, at this point, the address of myFunction() is on the stack. I don't know how to peek at the stack without messing it up, however.

San Saeteurn20-Jul-09 10:26

20-Jul-09 10:26

Well, I guess it is possible to get this information manually. You could write a method that creates a variable on the stack, get the address of that, subtract the value by the size of the methods stack frame and the other method's stack frame to get to where the location of the method's address. But this is clearly very dangerous (both for stability and for security reasons), cause it will be possible to overwrite that section with the address of some malicious code.

I guess there prolly isn't any standard way of doing it then for this reason.

David Crow20-Jul-09 10:32

20-Jul-09 10:32

Can you not just use a global variable that denotes whether or not you've already been in yourFunction()?

San Saeteurn20-Jul-09 10:50

20-Jul-09 10:50

Nevermind, in fact, that won't work.
This assumes a single threaded environment. But I need it to work in a multi-threaded environment.

If two methods calls this function in parallel, it should work. Essentially, I don't want the same method called twice down in the call stack.

i.e. Call Stack:
MyFunction()
YourFunction()
MyFunction()
This is what I want tpo prevent.

But in two different threads

Thread One:
MyFunction()
YourFunction()

Thread Two:
MyFunction()
YourFunction()

It is OK. But in the solution above, this would fail, since thread one is inside MyFunction while thread Two is trying to call it.

Thanks though,
-San Saeteurn
Should work.

San Saeteurn20-Jul-09 12:14

20-Jul-09 12:14

Figured out an obvious way of getting a handle to the calling function, use the name!

void MyFunction()
{
MyFunction <--- This is the Function Pointer to MyFunction, DUH!
}

However, this doesn't solve my problem. I need to be able to get it in a generic way, like the 'this' keyword for the calling object.

-San Saeteurn

San Saeteurn20-Jul-09 13:00

20-Jul-09 13:00

I guess a modified version of this solution can work.
Instead of having a single variable to keep track of whether the method was called, use a table mapped with this status value and a thread_id.

So each thread has it's own context.

Stuart Dootson20-Jul-09 12:22

Stuart Dootson

20-Jul-09 12:22

San Saeteurn wrote:
Is there a way to get a pointer to the function you are in?

Not without using its name, no.

Java, Basic, who cares - it's all a bunch of tree-hugging hippy cr*p

krmed21-Jul-09 0:46

krmed

21-Jul-09 0:46

Perhaps you can use the __FUNCTION__ macro?

It works like the __FILE__ or __LINE__ macros.

Hope that helps.

Karl - WK5M
PP-ASEL-IA (N43CS)
PGP Key: 0xDB02E193
PGP Key Fingerprint: 8F06 5A2E 2735 892B 821C 871A 0411 94EA DB02 E193

San Saeteurn21-Jul-09 5:28

LRESULT question about beginner tutorial

21-Jul-09 5:28

That won't work because I need to be able to test against it before calling the method the second time to prevent calling it twice.
If I have to be in the method already, then that means the called method has to be specialized to always test this. However, it is a requirement that the called method be independent of this overhead.
A Function Pointer can work because I can simply compare the pointers before calling, whereas __FUNCTION__ only has the needed value if called from within the method.

Thanks for your input though,
-San Saeteurn

Adassus20-Jul-09 8:39

Adassus

20-Jul-09 8:39

Hello all,

Here's the tutorial:
The tutorial is here[^]

I noticed that in the callback wndproc, LRESULT functions (are those functions?) were used to perform the tasks. Is there a specific reason why the author decided to do that as opposed to using void functions to do the drawing?

/* Paint_beginner.cpp *********************************************************
Author:		Paul Watt
Date:		2/28/2002
Purpose:	Implementation file for a beginner's guide to painting with windows.
			
			Normally I like to create object oriented encapsulations of the 
			Main Window and data, however this program is very light.  There 
			are not any features that do not need to exist, in order to keep 
			the code clean, and to hopefully help the painting code stand out.

			Most of the data will be stored in global variables for clarity, not
			style.
******************************************************************************/
#include "stdafx.h"
#include "resource.h"

#define MAX_LOADSTRING 100

/* Global Variables **********************************************************/
HINSTANCE hInst;
TCHAR szTitle[MAX_LOADSTRING];
TCHAR szWindowClass[MAX_LOADSTRING];	

typedef struct tagShape
{
	RECT rect;
	UINT shapeID;
} Shape;


const UINT SHAPE_COUNT = 5;
Shape Shapes[SHAPE_COUNT]; 
UINT nCurrentIndex = 0;

bool  isRubberBand = false;
POINT ptStart;
POINT ptCurrent;

/* Forward Declarations ******************************************************/
ATOM				MyRegisterClass(HINSTANCE hInstance);
BOOL				InitInstance(HINSTANCE, int);
LRESULT CALLBACK	WndProc(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK	About(HWND, UINT, WPARAM, LPARAM);

/* Global *********************************************************************
Author:		Paul Watt
Date:		2/28/2002
Purpose:	Main entry point for this application.
******************************************************************************/
int APIENTRY WinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR     lpCmdLine,
                     int       nCmdShow)
{
	MSG msg;
	HACCEL hAccelTable;
			//C: Initialize the global strings.
	LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
	LoadString(hInstance, IDC_PAINT_BEGINNER, szWindowClass, MAX_LOADSTRING);
			//C: Register the class for the main window of this application.
	WNDCLASSEX wcex;

	wcex.cbSize = sizeof(WNDCLASSEX); 

	wcex.style			= CS_HREDRAW | CS_VREDRAW;
	wcex.lpfnWndProc	= (WNDPROC)WndProc;
	wcex.cbClsExtra		= 0;
	wcex.cbWndExtra		= 0;
	wcex.hInstance		= hInstance;
	wcex.hIcon			= LoadIcon(hInstance, (LPCTSTR)IDI_PAINT_BEGINNER);
	wcex.hCursor		= LoadCursor(NULL, IDC_ARROW);
	wcex.hbrBackground	= (HBRUSH)(COLOR_WINDOW+1);
	wcex.lpszMenuName	= (LPCSTR)IDC_PAINT_BEGINNER;
	wcex.lpszClassName	= szWindowClass;
	wcex.hIconSm		= LoadIcon(wcex.hInstance, (LPCTSTR)IDI_SMALL);

	RegisterClassEx(&wcex);
			//C: Perform application initialization.
	if (!InitInstance (hInstance, nCmdShow)) 
	{
		return FALSE;
	}

	hAccelTable = LoadAccelerators(hInstance, (LPCTSTR)IDC_PAINT_BEGINNER);
			//C: Main message pump.
	while (GetMessage(&msg, NULL, 0, 0)) 
	{
		if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg)) 
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
	}

	return msg.wParam;
}


/* Global *********************************************************************
Author:		Paul Watt
Date:		2/28/2002
Purpose:	Initializes global variables and creates the MainWindow.
Parameters:	hInstance[in]: The HINSTANCE of this application.
			nCmdShow[in]: The display mode to set for the main window when it 
				is created.
Return:		If this function succeeds then true will be returned otherwise false.
******************************************************************************/
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   HWND hWnd;
			//C: Store the instance handle in the global varaible.
   hInst = hInstance;
			//C: Initialize all of the shapes rectangles to -1.
   memset(&Shapes, -1, sizeof(Shapes));
			//C: Create the mainwindow.
   hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
   if (!hWnd)
   {
			//C: The main window creation failed.
      return FALSE;
   }
			//C: Display the main window.
   ShowWindow(hWnd, nCmdShow);
			//C: Force the main window to repaint itself.
   UpdateWindow(hWnd);

   return TRUE;
}


LRESULT OnCommand (HWND hWnd, int iID, int iEvent, HWND hWndControl, bool &isHandled);
LRESULT OnLButtonDown (HWND hWnd, UINT nCtrl, UINT x, UINT y);
LRESULT OnMouseMove   (HWND hWnd, UINT nCtrl, UINT x, UINT y);
LRESULT OnLButtonUp   (HWND hWnd, UINT nCtrl, UINT x, UINT y);
LRESULT OnPaint       (HWND hWnd);
void DrawRubberBand(HWND hWnd);


/* Global *********************************************************************
Author:		Paul Watt
Date:		2/28/2002
Purpose:	Window procedure for the main window.
Parameters:	hWnd[in]: Handle to the window that the message is intended for.
			message[in]: The message being sent.
			wParam[in]: Data
			lParam[in]: Data
Return:		
******************************************************************************/
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	switch (message) 
	{
	case WM_CREATE:
		{
			//C: Set the initial drawing mode.
			HMENU hMenu = ::GetMenu(hWnd);
			HMENU hMenuShapes = ::GetSubMenu(hMenu, 1);
			::CheckMenuRadioItem(hMenuShapes, ID_SHAPE_RECTANGLE, ID_SHAPE_CIRCLE, ID_SHAPE_RECTANGLE, MF_BYCOMMAND);
		}
	case WM_COMMAND:
		{
			int wmId    = LOWORD(wParam); 
			int wmEvent = HIWORD(wParam); 

			bool isHandled = true;
			LRESULT lResult = OnCommand(hWnd, wmId, wmEvent, (HWND)lParam, isHandled);
			if (!isHandled)
			{
				lResult = DefWindowProc(hWnd, message, wParam, lParam);
			}

			return lResult;
		}
		break;
	case WM_CHAR:
		{
			if (VK_ESCAPE == wParam && isRubberBand)
			{
			//C: Set rubberbanding to false.
				isRubberBand = false;
			//C: Erase the last rubber band rectangle that was drawn.
				DrawRubberBand(hWnd);
			}
		}
		break;
	case WM_LBUTTONDOWN:
		{
			return OnLButtonDown(hWnd, (UINT)wParam, LOWORD(lParam), HIWORD(lParam));
		}
		break;
	case WM_MOUSEMOVE:
		{
			return OnMouseMove(hWnd, (UINT)wParam, LOWORD(lParam), HIWORD(lParam));
		}
		break;
	case WM_LBUTTONUP:
		{
			return OnLButtonUp(hWnd, (UINT)wParam, LOWORD(lParam), HIWORD(lParam));
		}
		break;
	case WM_PAINT:
		{
			return OnPaint(hWnd);
		}
		break;
	case WM_DESTROY:
		{
			//C: Send a shutdown message to the message pump.
			PostQuitMessage(0);
			return 0;
		}
		break;
	}
			//C: Exit.
	return DefWindowProc(hWnd, message, wParam, lParam);
}


/* Global *********************************************************************
Author:		Paul Watt
Date:		2/28/2002
Purpose:	WM_COMMAND message handler.  Basically parses the menu commands
			and either sets the current drawing shape, or exits the window.
Parameters:	iID[in]:
			iEvent[in]:
			hWndControl[in]:
			isHandled[out]: This value can be set to indicate if this function 
				handled the message or not.
Return:		The LRESULT of this handled message will be returned.
******************************************************************************/
LRESULT OnCommand (HWND hWnd, int iID, int iEvent, HWND hWndControl, bool &isHandled)
{
			//C: Parse the menu selections.
	switch (iID)
	{			
	case ID_SHAPE_RECTANGLE:
	case ID_SHAPE_ELLIPSE:
		{
			//C: Set the drawing mode.
			HMENU hMenu = ::GetMenu(hWnd);
			HMENU hMenuShapes = ::GetSubMenu(hMenu, 1);
			::CheckMenuRadioItem(hMenuShapes, ID_SHAPE_RECTANGLE, ID_SHAPE_ELLIPSE, iID, MF_BYCOMMAND);
		}
		break;
	case IDM_EXIT: 
		{
			//C: Destroy the window in order to exit the program.
			DestroyWindow(hWnd);
		}
		break;
	default:
		{
			//C: Flag this message as unhandled.
			isHandled = false;
		}
	}

	return 0;
}


/* Global *********************************************************************
Author:		Paul Watt
Date:		2/28/2002
Purpose:	Handles the WM_LBUTTONDOWN message.  This function will start the
			rubberbanding effect when the user drags the mouse until the
			left button is released.  If the Escape button is pressed before the 
			left button is released, then the action will be cancelled. 
Parameters:	hWnd[in]: The handle of the window where the mouse button was pressed.
			nCtrl[in]: A set of flags that indicates the control keys that 
				are currently pressed.
			x[in]: The X coordinate where the left button was pressed.
			y[in]: The Y coordinate where the left button was pressed.
Return:		0 will be returned.
******************************************************************************/
LRESULT OnLButtonDown (HWND hWnd, UINT nCtrl, UINT x, UINT y)
{
			//C: Set the start point.
	ptStart.x = x;
	ptStart.y = y;
			//C: Set the rubberband mode to true.
	isRubberBand = true;
			//C: Set the current point to the start point as well.
	ptCurrent.x = x;
	ptCurrent.y = y;
			//C: Draw the initial rubber band.
	DrawRubberBand(hWnd);
			//C: Return.
	return 0;	
}


/* Global *********************************************************************
Author:		Paul Watt
Date:		2/28/2002
Purpose:	Handles the WM_MOUSEMOVE message.  This function will continue the
			rubberbanding effect when the user drags the mouse until the
			left button is released.  If the Escape button is pressed before the 
			left button is released, then the action will be cancelled. 
Parameters:	hWnd[in]: The handle of the window where the mouse button was pressed.
			nCtrl[in]: A set of flags that indicates the control keys that 
				are currently pressed.
			x[in]: The X coordinate where the left button was pressed.
			y[in]: The Y coordinate where the left button was pressed.
Return:		0 will be returned.
******************************************************************************/
LRESULT OnMouseMove   (HWND hWnd, UINT nCtrl, UINT x, UINT y)
{
			//C: If the current mode is not rubber band, then exit.
	if (!isRubberBand)
	{
		return 0;
	}
			//C: Undo the last rectangle shape that was drawn.
	DrawRubberBand(hWnd);
			//C: Update the current position.
	ptCurrent.x = x;
	ptCurrent.y = y;
			//C: Draw the next rubberband position.
	DrawRubberBand(hWnd);
			//C: Exit with success.
	return 0;		
}


/* Global *********************************************************************
Author:		Paul Watt
Date:		2/28/2002
Purpose:	Handles the WM_LBUTTONDOWN message.  This function will end the
			rubberbanding effect and add a new shape to the current set of shapes.
			If the Escape button is pressed before the left button is released, 
			then the action will be cancelled. 
Parameters:	hWnd[in]: The handle of the window where the mouse button was pressed.
			nCtrl[in]: A set of flags that indicates the control keys that 
				are currently pressed.
			x[in]: The X coordinate where the left button was pressed.
			y[in]: The Y coordinate where the left button was pressed.
Return:		0 will be returned.
******************************************************************************/
LRESULT OnLButtonUp   (HWND hWnd, UINT nCtrl, UINT x, UINT y)
{
			//C: If the current mode is not rubber band, then exit.
	if (!isRubberBand)
	{
		return 0;
	}
			//C: Undo the last rectangle shape that was drawn.
	DrawRubberBand(hWnd);
			//C: Update the dimensions of the current shape.
			//C: Get the current shape mode.
	HMENU hMenu			= ::GetMenu(hWnd);
	HMENU hShapeMenu	= ::GetSubMenu(hMenu, 1);

	if (::GetMenuState(hShapeMenu, ID_SHAPE_RECTANGLE, MF_BYCOMMAND) & MF_CHECKED)
	{
		Shapes[nCurrentIndex].shapeID = ID_SHAPE_RECTANGLE;
	}
	else
	{
		Shapes[nCurrentIndex].shapeID = ID_SHAPE_ELLIPSE;
	}
	
	Shapes[nCurrentIndex].rect.left		= ptStart.x;
	Shapes[nCurrentIndex].rect.top		= ptStart.y;
	Shapes[nCurrentIndex].rect.right	= ptCurrent.x;
	Shapes[nCurrentIndex].rect.bottom	= ptCurrent.y;
			//C: Increment the index.
	nCurrentIndex = (++nCurrentIndex)%SHAPE_COUNT;
			//C: Disable the rubberband mode.
	isRubberBand = false;
			//C: Update the window.
	InvalidateRect(hWnd, NULL, TRUE);
	UpdateWindow(hWnd);
			//C: Return with success.
	return 0;		
}


/* Global *********************************************************************
Author:		Paul Watt
Date:		2/28/2002
Purpose:	Paints the five shapes that have been set on this window.
Parameters:	hWnd[in]:
Return:		
******************************************************************************/
LRESULT OnPaint       (HWND hWnd)
{
	PAINTSTRUCT ps;
	HDC			hdc;
	hdc = ::BeginPaint(hWnd, &ps);

	UINT index;
	for (index = 0; index < SHAPE_COUNT; index++)
	{
		if (ID_SHAPE_RECTANGLE == Shapes[index].shapeID)
		{
			::Rectangle	(	
						hdc, 
						Shapes[index].rect.left, 
						Shapes[index].rect.top, 
						Shapes[index].rect.right,
						Shapes[index].rect.bottom
						);
		}
		else
		{
			::Ellipse	(	
						hdc, 
						Shapes[index].rect.left, 
						Shapes[index].rect.top, 
						Shapes[index].rect.right,
						Shapes[index].rect.bottom
						);
		}
	}

	::EndPaint(hWnd, &ps);

	return 0;	
}


/* Global *********************************************************************
Author:		Paul Watt
Date:		3/1/2002
Purpose:	Draws the rubberband shape using the dimensions of the start
			and current point global variables.
Parameters:	NONE
Return:		-
******************************************************************************/
void DrawRubberBand(HWND hWnd)
{
	HDC hdc;
			//C: Get a client DC.
	hdc = ::GetDC(hWnd);
			//C: Set the current drawing mode to XOR, this will allow us
			//   to add the rubber band, and later remove it by sending the
			//   exact same drawing command.
	::SetROP2(hdc, R2_NOT);
			//C: Select a NULL Brush into the DC so that no fill is performed.
	::SelectObject(hdc, ::GetStockObject(NULL_BRUSH));
			//C: Get the current shape mode.
	HMENU hMenu			= ::GetMenu(hWnd);
	HMENU hShapeMenu	= ::GetSubMenu(hMenu, 1);

	if (::GetMenuState(hShapeMenu, ID_SHAPE_RECTANGLE, MF_BYCOMMAND) & MF_CHECKED)
	{
		::Rectangle	(	
					hdc, 
					ptStart.x, 
					ptStart.y, 
					ptCurrent.x,
					ptCurrent.y
					);
	}
	else
	{
		::Ellipse	(	
					hdc, 
					ptStart.x, 
					ptStart.y, 
					ptCurrent.x,
					ptCurrent.y
					);
	}
			//C: Release the DC.
	::ReleaseDC(hWnd, hdc);
}

Re: LRESULT question about beginner tutorial

Maximilien20-Jul-09 9:13

Maximilien

20-Jul-09 9:13

It's simply better coding "standards" to keep functions to a manageable size.

This signature was proudly tested on animals.

Re: LRESULT question about beginner tutorial

Stuart Dootson20-Jul-09 12:25

Stuart Dootson

20-Jul-09 12:25

Adassus wrote:
I noticed that in the callback wndproc, LRESULT functions (are those functions?) were used to perform the tasks. Is there a specific reason why the author decided to do that as opposed to using void functions to do the drawing?

So that you can return a status from those functions if you want to. That status can then be passed back by the WndProc to the messgae loop. You'll note the WndProc returns an LRESULT...

Java, Basic, who cares - it's all a bunch of tree-hugging hippy cr*p

want to access any windows input elements from a win32 or mfc program

Jayapal Chandran20-Jul-09 7:32

Jayapal Chandran

20-Jul-09 7:32

I want to access any windows input elements from a win32 or mfc program.
i want to open browser from a win32 program and want to manipulate the contents...
it is like accessing html dom using javascript. i want to do it in windows.
this is my idea and i want to know which of the concepts does this work either in win32 or in mfc?

Today's Beautiful Moments are
Tomorrow's Beautiful Memories

Re: want to access any windows input elements from a win32 or mfc program

Hari Mahadevan20-Jul-09 15:27

Hari Mahadevan

20-Jul-09 15:27

I presume you're talking about accessing the HTML UI elements in a page displayed in your own Window.

I remember looking at this briefly sometime back and unfortunately couldn't find any easy to use classes to achieve this (I was under severe time constraints to go about writing one of my own). Note that both MFC and WTL do provide a wrapper for you to host HTML pages within a window. And the MS-HTML renderer provides COM connection points into which can hook for receiving events. These events do include events generated by the UI elements in the page. There's an article in CP that provides a basic wrapper to trap these events but I can't seem to locate it.

Also, looks like there's an ActiveX wrapper for Mozilla, which means you can use Gecko as the renderer to display you HTML UI.

Link below discusses this:
http://nick.typepad.com/blog/2003/11/feeddemon_and_m.html[^]

Hope this helps. Good luck.

Hari

Re: want to access any windows input elements from a win32 or mfc program

Jayapal Chandran23-Jul-09 8:41

Jayapal Chandran

23-Jul-09 8:41

You are a little right but i want to access any windows controls. for example i can open (spawn) another application from my program and i want to access all of its UI controls like what we do in html.
anyway thanks for the reply i want that for another work and i have to try it.

Today's Beautiful Moments are
Tomorrow's Beautiful Memories

List focus setting problem

bhanu_reddy0920-Jul-09 6:08

bhanu_reddy09

20-Jul-09 6:08

Hello All,

In "ListCtrl" i need to set the focus of the Key Up&Down events,how can i set,please some one help me.

With kind regards,
Bhanu

Re: List focus setting problem

David Crow20-Jul-09 6:50