从另一个嵌套窗口访问嵌套窗口的最佳方法

时间：2011-06-23 14:49:26

标签： c++ user-interface mfc gui-design

GUI应用程序具有以下窗口层次结构：

                   CMainWnd                      <---- main window
     CLeftPane                   CRightPane       <---- left and right panes (views)
CLDlg1       CLDlg2          CRDlg1     CRDlg2   <---- controls container windows (dialogs)
...          ...             ...        ...      <---|
CCtrl1       ...             ...        CCtrl2   <---|- controls
...          ...             ...        ...      <---|

父窗户在他们的孩子之上 每个子窗口都是父级wnd类的受保护成员 每个子窗口类都有一个指向其父窗口的引用/指针 窗格是自定义控件占位符（视图） 所有控件均为标准MFC控件。

某些CCtrl1的事件处理程序需要更改CCtrl2（例如设置其文本）。实现这一目标的最佳方法是什么？ 从另一个窗口访问嵌套在窗口层次结构的一个分支中的窗口的最佳方法是什么？嵌套在窗口层次结构的另一个分支中？

我在这里发布两个解决方案。

解决方案1 ​​

  • 所有儿童对话（控制容器）都有：​​
    • 返回父对话框并且
      • 的公共getter
    • 对其子控件执行某些操作的公共方法（因此隐藏了子控件）
  • 根窗口具有返回窗格的公共getter

MainWnd.h：

#include "LeftPane.h"
#include "RightPane.h"

class CMainWnd
{
public:
   CLeftPane& GetLeftPane(){return m_leftPane;}
   CRightPane& GetRightPane(){return m_rightPane;}
   ...
protected:
   CLeftPane m_leftPane;
   CRightPane m_rightPane;
   ...
};

LeftPane.h：

#include "MainWnd.h"
#include "LDlg1.h"
#include "LDlg2.h"

class CLeftPane
{
public:
   CLeftPane(CMainWnd& mainWnd) : m_mainWnd(mainWnd){};
   CMainWnd& GetMainWnd() {return m_mainWnd;}
   ...
protected:
   CMainWnd& m_mainWnd;
   CLDlg1 m_LDlg1;
   CLDlg2 m_LDlg2;
   ...
};

RightPane.h：

#include "MainWnd.h"
#include "RDlg1.h"
#include "RDlg2.h"

class CRightPane
{
public:
   CRightPane(CMainWnd& mainWnd) : m_mainWnd(mainWnd){};
   CMainWnd& GetMainWnd() {return m_mainWnd;}
   CRDlg2& GetRDlg2() {return m_RDlg2;}
   ...
protected:
   CMainWnd& m_mainWnd;
   CRDlg1 m_RDlg1;
   CRDlg2 m_RDlg2;
   ...
};

LDlg1.h：

#include "LeftPane.h"
#include "Ctrl1.h"

class CLDlg1
{
public:
   CLDlg1(CLeftPane& leftPane) : m_leftPane(leftPane){}
protected:
   CLeftPane& m_leftPane;
   CCtrl1 m_ctrl1;
   void OnCtrl1Event();
};

LDlg1.cpp：

#include "LDlg1.h"
#include "RDlg2.h"

void CLDlg1::OnCtrl1Event()
{
   ...
   CString strText("test");
   m_leftPane.GetMainWnd().GetRightPane().GetRDlg2().SetCtrl2Text(strText);
   ....
}

RDlg2.h：

#include "RightPane.h"
#include "Ctrl2.h"

class CRDlg2
{
public:
   CRDlg2(CRightPane& rightPane) : m_rightPane(rightPane){}
   void SetCtrl2Text(const CString& strText) {m_ctrl2.SetWindowText(strText);}
protected:
   CRightPane& m_rightPane;
   CCtrl2 m_ctrl2;       
};

我在这里的情况类似于this问题中描述的情况：一组公共getter（GetMainWnd().GetRightPane().GetRDlg2()...）用于访问所需的嵌套对象。 CLDlg1知道违反Law of Demeter的CRightPane和CRDlg2。

通过将SetCtrl2Text(...)方法移动到层次结构中的上层可以避免这种情况，如下所述：

解决方案2

在这种情况下，CMainWnd包含在深层嵌套控件中执行操作的所有必要方法。

MainWnd.h：

#include "LeftPane.h"
#include "RightPane.h"

class CMainWnd
{
public:
   void SetCtrl2Text(const CString& strText);
   ...
protected:
   CLeftPane m_leftPane;
   CRightPane m_rightPane;
   ...
};

MainWnd.cpp：

void CMainWnd::SetCtrl2Text(const CString& strText)
{
    m_rightPane.SetCtrl2Text(strText);
}

RightPane.h：

#include "MainWnd.h"
#include "RDlg1.h"
#include "RDlg2.h"

class CRightPane
{
public:
   CRightPane(CMainWnd& mainWnd) : m_mainWnd(mainWnd){};
   CMainWnd& GetMainWnd() {return m_mainWnd;}       
   void SetCtrl2Text(const CString& strText);
   ...
protected:
   CMainWnd& m_mainWnd;
   CRDlg1 m_RDlg1;
   CRDlg2 m_RDlg2;
   ...
};

RightPane.cpp：

void CRightPane::SetCtrl2Text(const CString& strText)
{
    m_RDlg2.SetCtrl2Text(strText);
}

LDlg1.cpp：

#include "LDlg1.h"

void CLDlg1::OnCtrl1Event()
{
   ...
   CString strText("test");
   m_leftPane.GetMainWnd().SetCtrl2Text(strText);
   ....
}

RDlg2.h：

#include "RightPane.h"
#include "Ctrl2.h"

class CRDlg2
{
public:
   CRDlg2(CRightPane& rightPane) : m_rightPane(rightPane){}
   void SetCtrl2Text(const CString& strText);
protected:
   CRightPane& m_rightPane;
   CCtrl2 m_ctrl2;       
};

RDlg2.cpp：

void CRDlg2::SetCtrl2Text(const CString& strText)
{
    m_ctrl2.SetWindowText(strText);
}

这隐藏了客户端的窗口层次结构，但这种方法：

  • 使CMainWnd类过度拥挤，使用公共方法对所有嵌套控件执行所有操作; CMainWnd就像是所有客户行动的主要开关板;
  • CMainWnd和每个嵌套对话框都在公共接口中重复这些方法

哪种方法更可取？或者，这个问题还有其他解决方案/模式吗？

解决方案3

另一种解决方案是使用包含特定事件源对象的事件处理程序的接口类。目标对象的类实现了这个接口，事件源和处理程序松散耦合。这可能是要走的路吗？这是GUI中的常见做法吗？

编辑：

解决方案4 - 发布者/订阅者模式

在以前的解决方案中，事件源对象保留对事件处理程序的引用，但如果有多个事件侦听器（需要在事件上更新两个或更多类），则会出现问题。发布者/订阅者（观察者）模式解决了这个问题。我对这个模式进行了一些研究，并提出了如何实现从源到处理程序传递事件数据的two versions。这里的代码基于第二个：

Observer.h 

template<class TEvent>
class CObserver
{
public:
   virtual void Update(TEvent& e) = 0;
};

Notifier.h 

#include "Observer.h"
#include <set>

template<class TEvent>
class CNotifier
{ 
   std::set<CObserver<TEvent>*> m_observers;

public:  
   void RegisterObserver(const CObserver<TEvent>& observer)
   {
      m_observers.insert(const_cast<CObserver<TEvent>*>(&observer));
   }

   void UnregisterObserver(const CObserver<TEvent>& observer)
   {
      m_observers.erase(const_cast<CObserver<TEvent>*>(&observer));
   }

   void Notify(TEvent& e)
   {
      std::set<CObserver<TEvent>*>::iterator it;

      for(it = m_observers.begin(); it != m_observers.end(); it++)
      {
         (*it)->Update(e);
      }
   }
};

EventTextChanged.h 

class CEventTextChanged
{
   CString m_strText;
public:
   CEventTextChanged(const CString& strText) : m_strText(strText){}
   CString& GetText(){return m_strText;}
};

LDlg1.h：

class CLDlg1
{ 
   CNotifier<CEventTextChanged> m_notifierEventTextChanged;

public:
   CNotifier<CEventTextChanged>& GetNotifierEventTextChanged()
   {
      return m_notifierEventTextChanged;
   }  
};

LDlg1.cpp：

  // CEventTextChanged event source
  void CLDlg1::OnCtrl1Event()
  {
     ...
     CString strNewText("test");
     CEventTextChanged e(strNewText); 
     m_notifierEventTextChanged.Notify(e);
     ...
  }

RDlg2.h：

class CRDlg2
{ 
// use inner class to avoid multiple inheritance (in case when this class wants to observe multiple events)
   class CObserverEventTextChanged : public CObserver<CEventTextChanged>
   {
      CActualObserver& m_actualObserver;
   public:
      CObserverEventTextChanged(CActualObserver& actualObserver) : m_actualObserver(actualObserver){}

      void Update(CEventTextChanged& e)
      { 
         m_actualObserver.SetCtrl2Text(e.GetText());
      }
   } m_observerEventTextChanged;

public:

   CObserverEventTextChanged& GetObserverEventTextChanged()
   {
      return m_observerEventTextChanged;
   }

   void SetCtrl2Text(const CString& strText);
};

RDlg2.cpp：

void CRDlg2::SetCtrl2Text(const CString& strText)
{
    m_ctrl2.SetWindowText(strText);
}

LeftPane.h：

#include "LDlg1.h"
#include "LDlg2.h"

// forward declaration
class CMainWnd;

class CLeftPane
{
   friend class CMainWnd;
   ...
protected:
   CLDlg1 m_LDlg1;
   CLDlg2 m_LDlg2;
   ...
};

RightPane.h：

#include "RDlg1.h"
#include "RDlg2.h"

// forward declaration
class CMainWnd;

class CRightPane
{
   friend class CMainWnd; 
protected:
   CRDlg1 m_RDlg1;
   CRDlg2 m_RDlg2;
   ...
};

MainWnd.h：

class CMainWnd
{
   ...
protected:
   CLeftPane m_leftPane;
   CRightPane m_rightPane;
   ...
   void Init();
   ...
};

MainWnd.cpp：

// called after all child windows/dialogs had been created
void CMainWnd::Init()
{
   ...
   // link event source and listener
   m_leftPane.m_LDlg1.GetNotifierEventTextChanged().RegisterObserver(m_rightPane.m_RDlg2.GetObserverEventTextChanged());
   ...
}

此解决方案解耦事件源（CLDlg1）和处理程序（CRDlg2） - 他们彼此不了解。

考虑到上述解决方案和GUI的事件驱动特性，我的原始问题正演变为另一种形式：如何将事件从一个嵌套窗口发送到另一个窗口？

2 个答案:

答案 0 :(得分：1)

引用OP的评论：

  

另一种解决方案是使用   包含事件的接口类   特定事件源的处理程序   宾语。目标对象的类   实现此接口和事件   源和处理程序松散   再加。这可能是要走的路吗？   这是GUI中的常见做法吗？

我更喜欢这个解决方案。这在其他语言/平台（尤其是Java）中很常见，但在MFC中很少见。不是因为它很糟糕，而是因为MFC过于老式和C导向。

顺便说一下，更多面向MFC的解决方案将使用Windows消息和MFC Command Routing机制。使用OnCmdMsg覆盖可以非常快速轻松地完成此操作。

使用显式接口（特别是事件源和事件侦听器）需要更多的时间和精力，但提供更易读和可维护的源代码。

如果您对事件监听器不满意，基于Windows消息的设计将比解决方案1,2更有前途。

答案 1 :(得分：0)

也许你可以让控件公开或使用朋友方法来保存getter，setter写作。我认为这应该在ui类层次结构中被接受，因为您没有将自定义控件设计为可重用的，因此它们不应该被硬编码。它们特定于您正在设计的单个窗口。

因此，从层次结构顶部访问它可能就像这样（并且我认为将所有事件处理程序保存在顶部的一个类中会更好）：

class CMainWnd
{
private:
    CCtrl1 GetCtrl1();
    CCtrl2 GetCtrl2()
    {
        return m_leftPane.m_lDlg1.m_ctrl2;
    }
}

在CLeftPane和CDlg1类中声明GetCtrl2友元函数

class CDlg1
{
    friend CCtrl2 CMainWnd::GetCtrl2();
}

或者将所有控制成员公开

UPDATE：我的意思是自定义对话框类的朋友功能不是控件。

相关问题
最新问题