ConnectTool Class Reference

#include <ConnectTool.hh>

Inheritance diagram for ConnectTool:

Collaboration diagram for ConnectTool:

Public Member Functions
	ConnectTool (ChildFrame *frame, MDFView *view)
virtual	~ConnectTool ()
virtual void	activate ()
virtual void	deactivate ()
virtual void	onMouseEvent (wxMouseEvent &event, wxDC &dc)
virtual Figure *	figure ()
Public Member Functions inherited from MachineCanvasTool
virtual	~MachineCanvasTool ()

Private Member Functions
void	updateStatusline (EditPart *part)
void	leftClick (EditPart *part)
void	rightClick (wxMouseEvent &event)

Private Attributes
ChildFrame *	frame_
	Parent frame of the canvas.
MDFView *	view_
	View displayed on the Canvas.
bool	active_
	Tells if the tool is active or not.
EditPart *	source_
	Source EditPart of the connection.
EditPart *	target_
	Target EditPart of the connection.
Figure *	figure_
	Connection figure.

Additional Inherited Members
Protected Member Functions inherited from MachineCanvasTool
	MachineCanvasTool (MachineCanvas *canvas)
Protected Attributes inherited from MachineCanvasTool
MachineCanvas *	canvas_
	Machine canvas where the tool is used.

Detailed Description

Mouse tool for creating and removing connections between ports, sockets and bus segments.

Definition at line 47 of file ConnectTool.hh.

Constructor & Destructor Documentation

ConnectTool()

ConnectTool::ConnectTool	(	ChildFrame *	frame,
		MDFView *	view
	)

The Constructor.

Definition at line 57 of file ConnectTool.cc.

                                                        :
    MachineCanvasTool(view->canvas()),
    frame_(frame),
    view_(view),
    active_(false),
    source_(NULL),
    target_(NULL),
    figure_(NULL) {
 
}

~ConnectTool()

ConnectTool::~ConnectTool ( )

virtual

The Destructor.

Definition at line 72 of file ConnectTool.cc.

                          {
    if (figure_ != NULL) {
        delete figure_;
        figure_ = NULL;
    }
}

References figure_.

Member Function Documentation

activate()

void ConnectTool::activate ( )

virtual

Activates the tool.

Implements MachineCanvasTool.

Definition at line 84 of file ConnectTool.cc.

                      {
    wxCursor connectCursor(wxCURSOR_CROSS);
    canvas_->SetCursor(connectCursor);
    active_ = true;
}

References active_, and MachineCanvasTool::canvas_.

deactivate()

void ConnectTool::deactivate ( )

virtual

Deactivates the tool.

Implements MachineCanvasTool.

Definition at line 95 of file ConnectTool.cc.

                        {
    canvas_->SetCursor(wxNullCursor);
    active_ = false;
}

References active_, and MachineCanvasTool::canvas_.

figure()

Figure * ConnectTool::figure ( )

virtual

Returns the tool Figure.

Returns

Tool figure.

Reimplemented from MachineCanvasTool.

Definition at line 269 of file ConnectTool.cc.

                    {
 
    // Delete old figure.
    if (figure_ != NULL) {
        delete figure_;
        figure_ = NULL;
    }
 
    if (!canvas_->hasEditPart(target_) || !canvas_->hasEditPart(source_)) {
        return NULL;
    }
 
    Socket* socket = NULL;
    Port* port = NULL;
    Segment* segment = NULL;
 
    // socket
    socket = dynamic_cast<Socket*>(source_->model());
    if (socket == NULL) {
        socket = dynamic_cast<Socket*>(target_->model());
    }
 
    // port
    port = dynamic_cast<Port*>(source_->model());
    if (port == NULL) {
        port = dynamic_cast<Port*>(target_->model());
    }
 
    // segment
    segment = dynamic_cast<Segment*>(source_->model());
    if (segment == NULL) {
        segment = dynamic_cast<Segment*>(target_->model());
    }
 
    // socket - port connection
    if (socket != NULL && port != NULL) {
        SocketPortConnToolFigure* figure = NULL;
        if (port->isConnectedTo(*socket)) {
            figure = new SocketPortConnToolFigure(false);
        } else {
            figure = new SocketPortConnToolFigure(true);
        }
        if (source_->model() == socket) {
            figure->setSource(target_->figure());
            figure->setTarget(source_->figure());
        } else {
            figure->setSource(source_->figure());
            figure->setTarget(target_->figure());
        }
        figure_ = figure;
        return figure_;
    }
 
    if (socket != NULL && segment != NULL) {
        // return SocketBusConnToolFigure
        SocketBusConnToolFigure* figure = NULL;
        if (socket->isConnectedTo(*segment)) {
            figure = new SocketBusConnToolFigure(false);
        } else {
            figure = new SocketBusConnToolFigure(true);
        }
        if (source_->model() == segment) {
            figure->setSource(target_->figure());
            figure->setTarget(source_->figure());
        } else {
            figure->setSource(source_->figure());
            figure->setTarget(target_->figure());
        }
        figure_ = figure;
        return figure;
    }
    target_ = NULL;
    return NULL;
}

References MachineCanvasTool::canvas_, figure(), EditPart::figure(), figure_, MachineCanvas::hasEditPart(), TTAMachine::Socket::isConnectedTo(), TTAMachine::Port::isConnectedTo(), EditPart::model(), source_, and target_.

Referenced by figure().

Here is the call graph for this function:

leftClick()

void ConnectTool::leftClick ( EditPart *  part )

private

Selects Component at cursor position, if there is a selectable EditPart at the coordinates.

Parameters

part	Component to select.

Definition at line 201 of file ConnectTool.cc.

                                     {
    EditPart* selection = view_->selection();
    ConnectRequest* request = new ConnectRequest(source_);
    if (part != NULL && part->canHandle(request)) {
        if (selection == NULL && source_ == NULL) {
            canvas_->select(part);
        } else if(source_ != NULL) {
            ComponentCommand* cmd = part->performRequest(request);
 
            if (cmd != NULL) {
                Model* model = dynamic_cast<MDFDocument*>(
                  wxGetApp().docManager()->GetCurrentDocument())->getModel();
                model->pushToStack();
                if (cmd->Do()) {
                    // conenction was modified
                    model->notifyObservers();
                    target_ = NULL;
                    source_ = NULL;
                } else {
                    // Modification failed.
                    model->popFromStack();
                }
            }
            delete cmd;
        }
    } else {
        view_->clearSelection();
    }
    delete request;
}

References EditPart::canHandle(), MachineCanvasTool::canvas_, MDFView::clearSelection(), ComponentCommand::Do(), Model::notifyObservers(), EditPart::performRequest(), Model::popFromStack(), Model::pushToStack(), MachineCanvas::select(), MDFView::selection(), source_, target_, and view_.

Referenced by onMouseEvent().

Here is the call graph for this function:

onMouseEvent()

void ConnectTool::onMouseEvent ( wxMouseEvent &  event, wxDC &  dc  )

virtual

Handles mouse events on the Canvas.

Parameters

event	Mouse event to handle.
dc	Device context.

Implements MachineCanvasTool.

Definition at line 108 of file ConnectTool.cc.

                                                       {
 
    if (!active_) {
        return;
    }
 
    // Get event position and translate "raw" coordinates to logical ones.
    wxPoint position = event.GetPosition();
    long logicalX = dc.DeviceToLogicalX(position.x);
    long logicalY = dc.DeviceToLogicalY(position.y);
 
    // Check if there is an EditPart directly at the cursor position.
    EditPart* toSelect = canvas_->findEditPart(logicalX, logicalY);
    // Check if there is an EditParts near at the cursor position.
    std::vector<EditPart*> nearbyParts;
    canvas_->findEditPartsInRange(logicalX, logicalY, 10, nearbyParts);
 
    EditPart* selection = canvas_->selection();
 
    vector<EditPart*> sources;
 
    source_ = NULL;
    if(toSelect != NULL) {
        target_ = toSelect;
        updateStatusline(target_);
 
        // This enables single click feature to edit connection between
        // socket and bus.
        if((selection == NULL || selection == target_)
                && !nearbyParts.empty()) {
            sources = nearbyParts;
        } else if(selection != target_) {
            sources.push_back(selection);
        }
 
        if(!sources.empty()) {
            for(unsigned int i = 0; i < sources.size(); i++) {
                ConnectRequest* request = new ConnectRequest(sources.at(i));
                if(target_->canHandle(request)) {
                    source_ = sources.at(i);
                    delete request;
                    break;
                }
                delete request;
            }
            if(source_ == NULL) {
                target_ = NULL;
            }
        } else {
            target_ = NULL;
            source_ = NULL;
        }
    }
 
    canvas_->refreshToolFigure();
 
    if (event.LeftUp()) {
        leftClick(toSelect);
    }
 
    if (event.RightUp()) {
        rightClick(event);
    }
}

References active_, EditPart::canHandle(), MachineCanvasTool::canvas_, MachineCanvas::findEditPart(), MachineCanvas::findEditPartsInRange(), leftClick(), MachineCanvas::refreshToolFigure(), rightClick(), MachineCanvas::selection(), source_, target_, and updateStatusline().

Here is the call graph for this function:

rightClick()

void ConnectTool::rightClick ( wxMouseEvent &  event )

private

Pops a context menu when the right mouse button is clicked on the canvas.

Parameters

event

Mouse event containing the cursor location where to pop the menu.

Definition at line 240 of file ConnectTool.cc.

                                           {
    wxMenu* contextMenu = new wxMenu();
 
    // Create a context menu.
    CommandRegistry* registry = wxGetApp().commandRegistry();
    contextMenu->Append(ProDeConstants::COMMAND_UNDO, _T("&Undo"));
    contextMenu->Append(ProDeConstants::COMMAND_REDO, _T("&Redo"));
    contextMenu->Append(ProDeConstants::COMMAND_PASTE, _T("&Paste"));
    contextMenu->Enable(ProDeConstants::COMMAND_UNDO,
                        registry->isEnabled(ProDeConstants::CMD_NAME_UNDO));
    contextMenu->Enable(ProDeConstants::COMMAND_REDO,
                        registry->isEnabled(ProDeConstants::CMD_NAME_REDO));
    contextMenu->Enable(ProDeConstants::COMMAND_PASTE,
                        registry->isEnabled(ProDeConstants::CMD_NAME_PASTE));
    contextMenu->AppendSeparator();
    contextMenu->Append(ProDeConstants::COMMAND_SELECT, _T("&Select Tool"));
 
    // Pop the menu at cursor position.
    wxPoint position = event.GetPosition();
    view_->canvas()->PopupMenu(contextMenu, wxPoint(position.x, position.y));
}

References MDFView::canvas(), ProDeConstants::CMD_NAME_PASTE, ProDeConstants::CMD_NAME_REDO, ProDeConstants::CMD_NAME_UNDO, ProDeConstants::COMMAND_PASTE, ProDeConstants::COMMAND_REDO, ProDeConstants::COMMAND_SELECT, ProDeConstants::COMMAND_UNDO, CommandRegistry::isEnabled(), and view_.

Referenced by onMouseEvent().

Here is the call graph for this function:

updateStatusline()

void ConnectTool::updateStatusline ( EditPart *  part )

private

Sends a status request to the given EditPart and executes the returned command.

Definition at line 179 of file ConnectTool.cc.

                                            {
    string status = "";
    Request* request = new Request(Request::STATUS_REQUEST);
    if (part != NULL && part->canHandle(request)) {
        ComponentCommand* command = part->performRequest(request);
        if (command != NULL )
        {
            command->Do();
        }
    } else {
        frame_->setStatus(_T(""));
    }
}

References EditPart::canHandle(), ComponentCommand::Do(), frame_, EditPart::performRequest(), ChildFrame::setStatus(), and Request::STATUS_REQUEST.

Referenced by onMouseEvent().

Here is the call graph for this function:

Member Data Documentation

active_

bool ConnectTool::active_

private

Tells if the tool is active or not.

Definition at line 65 of file ConnectTool.hh.

Referenced by activate(), deactivate(), and onMouseEvent().

figure_

Figure* ConnectTool::figure_

private

Connection figure.

Definition at line 71 of file ConnectTool.hh.

Referenced by figure(), and ~ConnectTool().

frame_

ChildFrame* ConnectTool::frame_

private

Parent frame of the canvas.

Definition at line 61 of file ConnectTool.hh.

Referenced by updateStatusline().

source_

EditPart* ConnectTool::source_

private

Source EditPart of the connection.

Definition at line 67 of file ConnectTool.hh.

Referenced by figure(), leftClick(), and onMouseEvent().

target_

EditPart* ConnectTool::target_

private

Target EditPart of the connection.

Definition at line 69 of file ConnectTool.hh.

Referenced by figure(), leftClick(), and onMouseEvent().

view_

MDFView* ConnectTool::view_

private

View displayed on the Canvas.

Definition at line 63 of file ConnectTool.hh.

Referenced by leftClick(), and rightClick().

---

The documentation for this class was generated from the following files:

• ConnectTool.hh
• ConnectTool.cc