Russian Qt Forum

class MediatorInterface : public QObject
{
    Q_OBJECT

public:

    MediatorInterface(QObject *parent = 0);
    virtual ~MediatorInterface();

    
    ComponentOneInterface *componentOne() const;
    ComponentTwoInterface *componentTwo() const;
    ComponentThreeInterface *componentThree() const;


    void setComponentOne(ComponentOneInterface *componentOne);
    void setComponentTwo(ComponentTwoInterface *componentTwo);
    
protected:
    void setComponentThree(ComponentThreeInterface *componentThree);

private:
    MediatorInterfacePrivate *d;

private:
    MediatorInterface(const MediatorInterface &other);
    void operator = (const MediatorInterface &other);
};

//конструктор
MediatorInterface::MediatorInterface(QObject *parent)
    : QObject(parent),
      d(new MediatorInterfacePrivate())
{
}

//деструктор
MediatorInterface::~MediatorInterface()
{
    delete d;
}

//возвращает интерфейс компонента
ComponentOneInterface *MediatorInterface::componentOne() const
{
    return d->m_componentOne;
}

//устанавливает компонент
void MediatorInterface::setComponentOne(ComponentOneInterface *componentOne)
{
    d->m_componentOne = componentOne;
}

class MediatorInterfacePrivate {

public:
    MediatorInterfacePrivate();
    ~MediatorInterfacePrivate();


    QPointer<ComponentOneInterface> m_componentOne;
    QPointer<ComponentTwoInterface> m_componentTwo;
    QPointer<ComponentThreeInterface> m_componentThree;
    
};

//конструктор
MediatorInterfacePrivate::MediatorInterfacePrivate() :
    m_componentOne(0),
    m_componentTwo(0),
    m_componentThree(0)
{
}

//деструктор
MediatorInterfacePrivate::~MediatorInterfacePrivate()
{
    delete m_componentOne;
    delete m_componentTwo;
    delete m_componentThree;
}

class Mediator : public MediatorInterface
{
    Q_OBJECT

public:
    Mediator(QObject *parent = 0);
    virtual ~Mediator();
};


Mediator::Mediator(QObject *parent)
    : MediatorInterface(parent)
{

    ComponentThree *componentThree = new ComponentThree(this);
    setComponentThree(componentThree);
    ............
    создание компонентов чья функция set находится в секции protected
}

class ComponentOne: public ComponentOneInterface
{
    Q_OBJECT

public:
    ComponentOne(MediatorInterface *core, QObject *parent = 0);
    virtual ~ComponentOne();

    .....
}

class ActionEditor: public QDesignerActionEditorInterface
{
    Q_OBJECT
public:
    explicit ActionEditor(QDesignerFormEditorInterface *core, QWidget *parent = 0, Qt::WindowFlags flags = 0);
    virtual ~ActionEditor();
....

class QDesignerActionEditorInterface: public QWidget
{
    Q_OBJECT
public:
    QDesignerActionEditorInterface(QWidget *parent, Qt::WindowFlags flags = 0);
    virtual ~QDesignerActionEditorInterface();

    virtual QDesignerFormEditorInterface *core() const;
...........
};

void ActionEditor::restoreSettings()
{
    QDesignerSettingsInterface *settings = m_core->settingsManager();
    m_actionView->setViewMode(settings->value(QLatin1String(actionEditorViewModeKey), 0).toInt());
    updateViewModeActions();
}
...
void ActionEditor::manageAction(QAction *action)
{
    .....
    core()->metaDataBase()->add(action);

   .......

    QDesignerPropertySheetExtension *sheet = qt_extension<QDesignerPropertySheetExtension*>(core()->extensionManager(), action);
    sheet->setChanged(sheet->indexOf(QLatin1String(objectNamePropertyC)), true);
    sheet->setChanged(sheet->indexOf(QLatin1String(textPropertyC)), true);
    refreshIconPropertyChanged(action, sheet);

   ...............
}

class Mediator;

class Button
{
public:
   Button(Mediator *mediator) {_mediator = mediator;}

   void click() {_mediator->buttonClicked(this);}

   void autoClick() {}

private:
   Mediator _mediator;

};


class Mediator
{
public:
   Mediator() {}

   void addButton(Button *button) {_buttons.append(button);}

   void buttonClicked(Button *button) {
      for(int i = 0, n = buttons.size(); i < n; ++i) {
         if(button == buttons.at(i)) continue;
         buttons.at(i)->autoClick();
      }
   }

private:
   List<Button*> _buttons;

};

class Mediator;

class Widget
{
public:
   Widget(Mediator *mediator, const String &caption)
      {_mediator = mediator; _caption = caption;}

   virtual Mediator::WidgetType type() const = 0;

   void click() {_mediator->widgetClicked(this);}

   void setCaption(const String &new_caption) {_caption = new_caption;}

private:
   Mediator *_mediator;

   String _caption;

};


class Button : public Widget
{
public:
   Button(const String &caption, Mediator *mediator) : Widget(mediator, caption) {}

   Mediator::WidgetType type() const {return Mediator::WT_BUTTON;}

};


class Label : public Widget
{
public:
   Label(const String &caption, Mediator *mediator) : Widget(mediator, caption) {}

   Mediator::WidgetType type() const {return Mediator::WT_LABEL;}

};


class Mediator
{
public:
   enum WidgetType {WT_BUTTON, WT_LABEL};

   Mediator() {}

   void addWidget(Widget *widget)
      {_widgets.insertMulti(widget->type(), widget);}

   void widgetClicked(Widget *widget) {
      QList<Widget*> widgets;

      String new_caption;

      switch(widget->type()) {
         case Mediator::WT_BUTTON: {
            widgets = _widgets.values(Mediator::WT_LABEL);
            new_caption = "button clicked";
         } break;

         case Mediator::WT_LABEL: {
            widgets = _widgets.values(Mediator::WT_BUTTON);
            new_caption = "label clicked";
         } break;
      }

      for(int i = 0, n = widgets.size(); i < n; ++i) {
         widgets.at(i)->setCaption(new_caption);
      }
   }

private:
   Hash<WidgetType, Widget*> _widgets;

};

.....
 virtual void Mediator::Send(std::string message, Colleague *colleague)
        {
                if (colleague==static_cast<Colleague*>(m_Colleague1))
                {
                        m_Colleague2->Notify(message);
                }
                else if (colleague==static_cast<Colleague*>(m_Colleague2))
                {
                        m_Colleague1->Notify(message);
                }
        }
....