Re: How do I send a message to a Propery Page?

See below...
On Fri, 19 Dec 2008 14:08:01 -0800, Jimbo_Jimbob_Jiminator
<JimboJimbobJiminator@discussions.microsoft.com> wrote:


****
This is really a judgment call. I can easily argue in favor or against either approach.
As long as the sheet knows nothing about the implementation of the pages, and the
interface presented at the sheet level to the client of the sheet also hides the
organization and meaning of the pages, I consider the use of public members of the
property sheet a clean interface.

If you are using > VS6, note that the message handlers are erroneously declared as
'public' members; change this to 'protected'. Not in the entire history of MFC has it
made any logical sense to make handlers be public methods. The continuing failure to
declare them protected is a design error of the wizard. Also, no control member variables
should ever be public. Due again to a design error in the wizards, the "Add Variable"
defaults to marking these variables as 'public'. Mark them as 'protected'. The only
public members should be the IDD symbol, the constructor and destructor, and the methods
you wish to present as the interface.
                joe
****


*****
About here. Or four inches to the left.

Seriously, you get to draw it. The choice of methods vs. messages is largely an aesthetic
argument most of the time.
*****


****
Yes, but that's a different issue. You get to decide, for your interface, how you want to
implement it
****


****
It is up to you. I'd probably favor public methods most of the time, but it depends on a
lot of factors, such as whether or not I want to make any of the C++ interface visible.
For plug-ins, I tend to favor messaging. Your Mileage May Vary. Void Where Prohibited By
Law. Contains Small Parts, Not Suitable For Children Under The Age of 3. May Cause
Nausea, Headache, Or Constipation.

That is, there is no hard-and-fast criterion here. Each mechanism has its powers and
flaws. Messaging restricts what you can send, and enforces how you send it. If you use
public methods, their implementation will probably use SendMessage, or
SendMessageToDescendants. But then, you can change the nature of what is handled
transparently.
****


****
I favor SendMessageToDecendants. One simple approach is to specify a message type and a
WPARAM/LPARAM pair. Another I favor is to specify just one message type, WPARAM encodes
the type of the data, and LPARAM encodes the parameter to the notification, which can be a
pointer to a struct, e.g.,

/************************************************************************************
* UWM_NOTIFY_PAGE
* WPARAM: (WPARAM)(InfoType): THe type of the information
*
* LPARAM: (LPARAM)lParam: The value associated with the InfoType. See
* the defintion of InfoType
* LRESULT:
* Depends on the InfoType
************************************************************************************/

static const UINT UWM_NOTIFY_PAGE = ::RegisterWindowMessage(
                 _T("UWM_NOTIFY_PAGE") _T("guid here"));

class CMyPropertySheet : public CPropertySheet {
    protected:
        typedef enum {
             NAME, // (LPARAM)(const CString*) the name of the person
             HEIGHT, // (LPARAM) the height of the person in mm
             ...more definitions here
        } InfoType;
    public:
        void SetName(const CString & name) ;
        void SetHeight(UINT height);
        ...
};

void CMyPropertySheet::SetName(const CString & name)
    {
     SendMessageToDescendants(UWM_NOTIFY_PAGE,
                                                                      NAME,
                                                                      (LPARAM)&name);
   }

        joe

****
No, it is a SendMessage, it is synchronous, it is not "passing data from the sheet" it is
passing data. Nobody cares where the data is.

You would not pass 2000 bytes of "mixed data" which the control has to sort out, you would
pass either a pointer to a value (as I show above) or a pointer to a struct full of
values.

void CMyPropertySheet::SetEverything(const Everything & values)
    {
     SendMessageToDescendants(UWM_NOTIFY_PAGE,
                                                                EVERYTHING,
                                                                (LPARAM)&values);
    }

void CSomePage::OnNotifyPage(WPARAM wParam, LPARAM lParam)
    {
     switch(wParam)
         {
          case EVERYTHING:
                SetEverything( (const Everything *) lParam);
                break;
         }
    }

void CSomePage::SetEverything(const Everything * values)
    {
     c_Name.SetWindowText(values->name);
     c_Height.SetWIndowText(values->height);
     ...
   }

If you don't like the ugly switch statement, then you define messages like
UWM_SET_EVERYTHING, UWM_SET_NAME, UWM_SET_HEIGHT, etc.

These are just aesthetic decisions. Some people prefer one, some prefer another. I tend
to favor the lots-of-different-messages approach.
                joe

*****