MachineCanvas.cc

Go to the documentation of this file.

/*
 Copyright (c) 2002-2009 Tampere University.
 
 This file is part of TTA-Based Codesign Environment (TCE).
 
 Permission is hereby granted, free of charge, to any person obtaining a
 copy of this software and associated documentation files (the "Software"),
 to deal in the Software without restriction, including without limitation
 the rights to use, copy, modify, merge, publish, distribute, sublicense,
 and/or sell copies of the Software, and to permit persons to whom the
 Software is furnished to do so, subject to the following conditions:
 
 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 DEALINGS IN THE SOFTWARE.
 */
/**
 * @file MachineCanvas.cc
 *
 * Definition of MachineCanvas class.
 *
 * @author Veli-Pekka Jääskeläinen 2005 (vjaaskel-no.spam-cs.tut.fi)
 * @note rating: red
 */
 
#include <fstream>
#include <wx/dc.h>
#include <wx/dcclient.h>
#include <wx/event.h>
#include "Segment.hh"
#include "MachineCanvas.hh"
#include "MachineCanvasTool.hh"
#include "MachineEditPartFactory.hh"
#include "RootEditPart.hh"
#include "Figure.hh"
#include "SelectionFigure.hh"
#include "SequenceTools.hh"
#include "Bus.hh"
#include "Port.hh"
#include "MoveFigure.hh"
#include "EPSDC.hh"
#include "WxConversion.hh"
#include "BEMGenerator.hh"
#include "BinaryEncoding.hh"
#include "CanvasConstants.hh"
 
#if wxCHECK_VERSION(3, 0, 0)
#include <wx/dcsvg.h>   // wxSVGFileDC only available in wxwidgets 3.*
#endif
 
BEGIN_EVENT_TABLE(MachineCanvas, wxScrolledWindow)
EVT_MOUSE_EVENTS(MachineCanvas::onMouseEvent)
END_EVENT_TABLE()
 
using namespace TTAMachine;
 
/**
 * The Constructor, with a parameter for parent frame.
 * 
 * @param parent Parent frame of the canvas.
 * @param policyFactory EditPolicyFactory for creating edit policies.
 */
MachineCanvas::MachineCanvas(wxWindow* parent,
    EditPolicyFactory* policyFactory, ChildFrame* parentFrame) :
                wxScrolledWindow(parent), tool_(NULL), machine_(NULL), 
                    editPolicyFactory_(policyFactory),  parent_(parentFrame), 
                    zoomFactor_(1.0), dirty_(true), root_(NULL), 
                    selection_(NULL), toolBounds_(0, 0, 0, 0) {
 
    root_ = new RootEditPart();
 
    SetScrollRate(20, 20);
    SetVirtualSize(1000, 800);
}
 
 
 
/**
 * The Destructor.
 */
MachineCanvas::~MachineCanvas() {
    if (root_ != NULL) {
        delete root_;
    }
    clearMoves();
}
 
/**
 * Called when the window needs to be drawn again.
 *
 * @param dc The device context where to do the actual drawing.
 */
void
MachineCanvas::OnDraw(wxDC& dc) {
 
    wxBrush backgroundBrush(*wxLIGHT_GREY, wxSOLID);
    dc.SetBackground(backgroundBrush);
 
#if wxCHECK_VERSION(3, 0, 0)
    // Do not call Clear() for wxSVGFileDC object cause its not implemented
    try {
        (void)dynamic_cast<wxSVGFileDC&> (dc);
    } catch (const std::bad_cast& e) {
        dc.Clear();
    }
#else
    dc.Clear();
#endif
 
    // Set the canvas font.
    dc.SetFont(wxFont(10, wxDEFAULT, wxNORMAL, wxNORMAL));
 
    // Set scaling factor.
    dc.SetUserScale(zoomFactor_, zoomFactor_);
    // draw machine
    if (root_->contents() != NULL) {
        if (dirty_) {
            root_->contents()->figure()->layout(&dc);
            // Set Canvas virtual size according to the size needed by the
            // figures.
            wxRect bounds = root_->contents()->figure()->bounds();
            SetVirtualSize(int(bounds.GetWidth() * zoomFactor()),
                int(bounds.GetHeight() * zoomFactor()));
 
            dirty_ = false;
        }
        root_->contents()->figure()->draw(&dc);
 
    }
 
    // draw tool figure
    if (tool() != NULL) {
        Figure* toolFigure = tool()->figure();
        if (toolFigure != NULL) {
            toolFigure->layout(&dc);
            toolFigure->draw(&dc);
        }
    }
 
    // Draw moves.
    for (unsigned i = 0; i < moveFigures_.size(); i++) {
        moveFigures_[i]->draw(&dc);
    }
 
    // Draw selection rectangle.
    if (selection() != NULL) {
        SelectionFigure figure(selection()->figure());
        figure.layout(&dc);
        figure.draw(&dc);
    }
}
 
/**
 * Refreshes the tool figures on the canvas.
 */
void
MachineCanvas::refreshToolFigure() {
 
    if (toolBounds_.GetWidth() > 0 && toolBounds_.GetHeight() > 0) {
        // Clear previous tool figure.
        refreshLogicalRect(toolBounds_);
    }
 
    Figure* toolFigure = tool()->figure();
    if (toolFigure != NULL) {
        // Draw new tool figure.
        toolFigure->layout(NULL);
        toolBounds_ = toolFigure->bounds();
        refreshLogicalRect(toolBounds_);
    } else {
        toolBounds_ = wxRect(0, 0, 0, 0);
    }
}
 
/**
 * Sets the zoom factor of the canvas.
 *
 * @param factor New zoom factor of the canvas.
 */
void
MachineCanvas::setZoomFactor(double factor) {
 
    // Limit the min/max size of the zoom factor
    if (factor > CanvasConstants::MAX_ZOOM_FACTOR) {
        factor = CanvasConstants::MAX_ZOOM_FACTOR;
    } else if (factor < CanvasConstants::MIN_ZOOM_FACTOR) {
        factor = CanvasConstants::MIN_ZOOM_FACTOR;
    }
 
    // when scrolling, try to:
    // * On X direction, keep the middle pointing to same position in machine
    // * On Y direction, keep the upper edge of the windows pointer to
    //   same position in the machine.
    // This code calculates this and does the scrolling.
    int x, y;
    int xSize, ySize;
    int scrollUnitX, scrollUnitY;
    GetScrollPixelsPerUnit(&scrollUnitX, &scrollUnitY);
    GetViewStart(&x, &y);
    x *= scrollUnitX;
    y *= scrollUnitY;
    GetSize(&xSize, &ySize);
    double xPos = (x + (xSize >> 1)) / zoomFactor_;
    double yPos = y / zoomFactor_;
    x = std::max(static_cast<int>(xPos * factor) - (xSize >> 1), 0);
    y = static_cast<int>(yPos * factor);
    Scroll((x + (scrollUnitX >> 1)) / scrollUnitX,
        (y + (scrollUnitY >> 1)) / scrollUnitY);
 
    // then do the zooming
    zoomFactor_ = factor;
    dirty_ = true;
    Refresh();
}
 
 
/**
 * Returns the zoom factor of the canvas.
 *
 * @return Zoom factor of the canvas.
 */
double
MachineCanvas::zoomFactor() {
    return zoomFactor_;
}
 
 
/**
 * Zooms in the canvas by a predefined factor
 *
 */
void
MachineCanvas::zoomIn() {
    double factor = zoomFactor() + CanvasConstants::ZOOM_STEP;
    setZoomFactor(factor);
}
 
 
/**
 * Zooms out the canvas by a predefined factor
 *
 */
void
MachineCanvas::zoomOut() {
    double factor = zoomFactor() - CanvasConstants::ZOOM_STEP;
    setZoomFactor(factor);
}
 
 
/**
 * Handles mouse events on the canvas.
 *
 * Passes the mouse event to the active tool.
 * 
 * @param event Mouse event to pass to the active tool.
 */
void
MachineCanvas::onMouseEvent(wxMouseEvent& event) {
 
    wxClientDC dc(this);
    PrepareDC(dc);
    dc.SetUserScale(zoomFactor_, zoomFactor_);
 
    // Zoomin/out with mousewheel
    if (event.GetEventType() == wxEVT_MOUSEWHEEL) {
        double factor;
 
        if (event.GetWheelRotation() > 0) {
            factor = zoomFactor() + CanvasConstants::ZOOM_STEP;
        } else {
            factor = zoomFactor() - CanvasConstants::ZOOM_STEP;
        }
        setZoomFactor(factor);
    }
 
    if (tool_ != NULL) {
        tool_->onMouseEvent(event, dc);
    }
}
 
 
/**
 * Return the original size of the currently loaded Machine Figure
 *
 */
wxSize
MachineCanvas::getFigureSize() const {
    return root_->contents()->figure()->bounds().GetSize();
}
 
 
/**
 * Sets the active tool.
 * 
 * @param tool MachineCanvasTool to activate.
 */
void
MachineCanvas::setTool(MachineCanvasTool* tool) {
    if (tool_ != NULL) {
        tool_->deactivate();
        delete (tool_);
    }
    tool_ = tool;
    tool_->activate();
}
 
/**
 * Returns pointer to the current tool of the canvas.
 */
MachineCanvasTool*
MachineCanvas::tool() {
    return tool_;
}
 
/**
 * Refreshes area of the MachineCanvas bound by a logical coordinate
 * rectangle.
 *
 * @param rectangle Area to refresh.
 */
void
MachineCanvas::refreshLogicalRect(const wxRect& rectangle) {
 
    int x = 0;
    int y = 0;
    CalcScrolledPosition(int(rectangle.x * zoomFactor_),
        int(rectangle.y * zoomFactor_), &x, &y);
    wxRect zoomed(x, y, int(rectangle.width * zoomFactor_),
        int(rectangle.height * zoomFactor_));
 
    RefreshRect(zoomed);
}
 
/**
 * Updates the machine from the machine object model.
 */
void
MachineCanvas::updateMachine() {
 
    clearSelection();
    clearMoves();
    dirty_ = true;
 
    if (machine_ == NULL) {
        root_->setContents(NULL);
        return;
    }
 
    MachineEditPartFactory factory(*editPolicyFactory_);
    EditPart* contents = factory.createEditPart(machine_);
    assert(root_ != NULL);
    root_->setContents(contents);
    contents->figure()->setOptions(&options_);
 
    if (parent_ != nullptr) {
 
        wxString text(_T(""));
        BinaryEncoding* bem(nullptr);
        try {
            bem = BEMGenerator(*machine_).generate();
            int width = bem->width();
            text = wxString::Format(_T("Instruction width: %u"), width);
        } catch (...) {
            text = _T("BEM could not be generated");
        }
        delete bem;
        parent_->setStatus(text, 1);
    }
 
    Refresh();
}
 
/**
 * Sets the machine which is dispalyed on the canvas.
 *
 * @param machine Machine to display on the canvas.
 */
void
MachineCanvas::setMachine(TTAMachine::Machine* machine) {
    machine_ = machine;
    updateMachine();
}
 
/**
 * Clears component selection.
 */
void
MachineCanvas::clearSelection() {
    if (selection_ != NULL) {
        selection_->setSelected(false);
    }
    selection_ = NULL;
    Refresh();
}
 
/**
 * Returns pointer to the EditPart of the selected component.
 *
 * @return Pointer to the selected EditPart, or null if selection is empty.
 */
EditPart*
MachineCanvas::selection() {
    return selection_;
}
 
/**
 * Finds an edit part at the given coordinates on the canvas.
 *
 * @param x X-coordinate of the position to search.
 * @param y Y-coordinate of the position to search.
 * @return Pointer to the found edit part, or NULL if no edit part was found.
 */
EditPart*
MachineCanvas::findEditPart(int x, int y) {
    EditPart* part = NULL;
    if (root_ != NULL && root_->contents() != NULL) {
        part = root_->contents()->find(wxPoint(x, y));
    }
    return part;
}
 
/**
 * Finds an edit part corresponding the given machine part.
 *
 * @param model MachinePart to find
 * @return Pointer to the found edit part, or NULL if no edit part was found.
 */
EditPart*
MachineCanvas::findEditPart(const TTAMachine::MachinePart* model) {
    EditPart* part = NULL;
    if (root_ != NULL && root_->contents() != NULL) {
        part = root_->contents()->find(model);
    }
    return part;
}
 
/**
 * Finds EditParts around coordinates that are in given range.
 *
 * @param x X-coordinate of the position to search.
 * @param y Y-coordinate of the position to search.
 * @param range Search range from position (x, y).
 * @param found Found EditParts after call.
 * @return Number of found EditParts. Zero if found nothing.
 */
int
MachineCanvas::findEditPartsInRange(int x, int y, int range,
    std::vector<EditPart*>& found) {
    if (root_ != NULL && root_->contents() != NULL) {
        return root_->contents()->findInRange(wxPoint(x, y),
            static_cast<float>(range), found);
    }
    return 0;
}
 
/**
 * Looks for given EditPart recursively.
 *
 * @param part Part to look up.
 * @return True if canvas has given EditPart.
 */
bool
MachineCanvas::hasEditPart(const EditPart* part) const {
    if (root_ != NULL && root_->contents() != NULL) {
        return root_->contents()->hasEditPartRecursive(part);
    }
    return false;
}
 
/**
 * Marks an edit part selected.
 *
 * Previous selection is cleared.
 *
 * @param part Edit part to select.
 */
void
MachineCanvas::select(EditPart* part) {
    if (selection_ != NULL) {
        selection_->setSelected(false);
    }
 
    // segments are not supported so we should select the parent
    // bus instead the segment (a very long standing irritating bug)
    TTAMachine::Segment* segment =
                    dynamic_cast<TTAMachine::Segment*>(part->model());
    if (segment != NULL) {
        // clicked segment, selecting parent bus instead
        part = part->parent();
    }
 
    selection_ = part;
    if (selection_ != NULL) {
        selection_->setSelected(true);
    }
    Refresh();
}
 
/**
 * Highlights figure of a machine component.
 */
void
MachineCanvas::highlight(TTAMachine::MachinePart* component,
    const wxColour& colour) {
 
    if (root_->contents() == NULL) {
        return;
    }
 
    EditPart* editPart = root_->contents()->find(component);
    if (editPart != NULL && editPart->figure() != NULL) {
        editPart->figure()->highlight(colour);
    }
}
 
/**
 * Clears highlighting of all machine components.
 */
void
MachineCanvas::clearHighlights() {
    if (root_ != NULL && root_->contents() != NULL) {
        root_->contents()->figure()->clearHighlight();
    }
}
 
/**
 * Adds a move to be drawn on the canvas.
 *
 * @param bus Transport bus of the move.
 * @param source Source port of the move.
 * @param target Target port of the move.
 */
void
MachineCanvas::addMove(const Bus* bus, const Port* source, const Port* target) {
    std::string procName = "MachineCanvas::addMove";
    EditPart* busEditPart = findEditPart(bus);
 
    if (busEditPart == NULL) {
        throw InstanceNotFound(__FILE__, __LINE__, procName);
    }
 
    Figure* busFigure = busEditPart->figure();
    Figure* sourceFigure = NULL;
    Figure* targetFigure = NULL;
 
    if (source != NULL) {
        EditPart* sourceEditPart = findEditPart(source);
        if (sourceEditPart == NULL) {
            throw InstanceNotFound(__FILE__, __LINE__, procName);
        }
        sourceFigure = sourceEditPart->figure();
    }
 
    if (target != NULL) {
        EditPart* targetEditPart = findEditPart(target);
        if (targetEditPart == NULL) {
            throw InstanceNotFound(__FILE__, __LINE__, procName);
        }
        targetFigure = targetEditPart->figure();
    }
 
    moveFigures_.push_back(
        new MoveFigure(busFigure, sourceFigure, targetFigure));
}
 
/**
 * Clears list of moves to be drawn on the canvas.
 */
void
MachineCanvas::clearMoves() {
    SequenceTools::deleteAllItems(moveFigures_);
}
 
#if wxCHECK_VERSION(3, 0, 0)
/**
 * Saves the machine figure to a .svg file.
 *
 * @param filename Name of the .svg file.
 * @return True, if the svg was succesfully saved.
 */
bool
MachineCanvas::saveSVG(const std::string& filename) {
    // Refresh machine figure to get the canvas size.
    wxClientDC clientDC(this);
    OnDraw(clientDC);
 
    // Add minimum coordinates to maximum coordinates to create margins
    // of equal width.
    int width = clientDC.MaxX() + clientDC.MinX();
    int height = clientDC.MaxY() + clientDC.MinY();
 
    wxSVGFileDC svg(filename, width, height);
    svg.StartPage();
    OnDraw(svg);
    svg.EndPage();
 
    return true;
}
 
#else
/**
 * Saves the machine figure to an eps file.
 *
 * @param filename Name of the eps file.
 * @param title Title of the eps document.
 * @param creator Creator of the eps document.
 * @return True, if the eps was succesfully saved.
 */
bool
MachineCanvas::saveEPS(const std::string& filename, const std::string& title,
    const std::string& creator) {
 
    EPSDC dc;
    dc.setCreator(creator);
 
    dc.setTitle(title);
    dc.StartPage();
    OnDraw(dc);
    dc.EndPage();
 
    std::ofstream file(filename.c_str());
 
    if (file.bad()) {
        return false;
    }
 
    dc.writeToStream(file);
    file.close();
 
    return true;
}
#endif
 
/**
 * Saves the machine figure to a .png file.
 *
 * @param filename Name of the .png file.
 * @return True, if the png was succesfully saved.
 */
bool
MachineCanvas::savePNG(const std::string& filename) {
 
    // Refresh machine figure to get the canvas size.
    wxClientDC clientDC(this);
    OnDraw(clientDC);
 
    // Add minimum coordinates to maximum coordinates to create margins
    // of equal width.
    int width = clientDC.MaxX() + clientDC.MinX();
    int height = clientDC.MaxY() + clientDC.MinY();
 
    // Create bitmap and a MemoryDC which writes the bitmap.
    wxMemoryDC bitmapDC;
    wxBitmap bitmap(width, height);
    bitmapDC.SelectObject(bitmap);
    OnDraw(bitmapDC);
 
    wxString file = WxConversion::toWxString(filename);
 
    // Save bitmap.
    if (bitmap.SaveFile(file, wxBITMAP_TYPE_PNG)) {
        return true;
    }
 
    return false;
}
 
/**
 * Returns the current options used by machine canvas figures.
 *
 * @return Current machine canvas options.
 */
MachineCanvasOptions&
MachineCanvas::options() {
    return options_;
}