-
Josh Siegle authoredJosh Siegle authored
GraphViewer.cpp 11.13 KiB
/*
------------------------------------------------------------------
This file is part of the Open Ephys GUI
Copyright (C) 2014 Open Ephys
------------------------------------------------------------------
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "GraphViewer.h"
static const Font FONT_LABEL ("Paragraph", 50, Font::plain);
static const Font FONT_VERSION ("Small Text", 14, Font::plain);
GraphViewer::GraphViewer()
{
JUCEApplication* app = JUCEApplication::getInstance();
currentVersionText = "GUI version " + app->getApplicationVersion();
rootNum = 0;
}
GraphViewer::~GraphViewer()
{
}
void GraphViewer::addNode (GenericEditor* editor)
{
GraphNode* gn = new GraphNode (editor, this);
addAndMakeVisible (gn);
availableNodes.add (gn);
gn->setBounds (20, 20, 150, 50);
updateNodeLocations();
}
void GraphViewer::removeNode (GenericEditor* editor)
{
availableNodes.remove (getIndexOfEditor (editor));
updateNodeLocations();
}
void GraphViewer::removeAllNodes()
{
availableNodes.clear();
updateNodeLocations();
}
// void GenericEditor::updateNodeName(GenericEditor* editor)
// {
// GraphNode* n = getNodeForEditor(editor);
// n->repaint();
// }
void GraphViewer::updateNodeLocations()
{
const int numAvailableNodes = availableNodes.size();
// If this was made just for future purpose it would be better to execute this only in debug mode
#if JUCE_DEBUG
// set the initial locations
for (int i = 0; i < numAvailableNodes; ++i)
{
}
#endif
rootNum = 0;
// do initial layout
for (int i = 0; i < numAvailableNodes; ++i)
{
checkLayout (availableNodes[i]);
}
// check for overlap
for (int i = 0; i < numAvailableNodes; ++i)
{
for (int j = 0; j < numAvailableNodes; ++j)
{
if (j != i)
{
if (availableNodes[j]->getLevel() == availableNodes[i]->getLevel()
&& availableNodes[j]->getHorzShift() == availableNodes[i]->getHorzShift())
{
availableNodes[j]->setHorzShift (availableNodes[j]->getHorzShift() + 1);
}
}
}
}
repaint();
}
void GraphViewer::checkLayout (GraphNode* gn)
{
if (gn != nullptr)
{
GraphNode* sourceNode = nullptr;
if (gn->isMerger())
{
Array<GenericEditor*> editors = gn->getConnectedEditors();
int level1 = 0;
int level2 = 0;
if (editors[0] != nullptr)
{
level1 = getNodeForEditor (editors[0])->getLevel();
}
if (editors[1] != nullptr)
{
level2 = getNodeForEditor (editors[1])->getLevel();
}
// std::cout << "LEVEL1 = " << level1 << " LEVEL2 = " << level2 << std::endl;
sourceNode = level1 > level2 ? getNodeForEditor (editors[0])
: getNodeForEditor (editors[1]); // choose the higher source
}
else
{
sourceNode = getNodeForEditor (gn->getSource());
}
if (! sourceNode)
{
gn->setLevel (0);
gn->setHorzShift (rootNum);
++rootNum;
}
else if (sourceNode->isSplitter())
{
Array<GenericEditor*> editors = sourceNode->getConnectedEditors();
const int newHorizontalShift = gn->hasEditor (editors[1])
? sourceNode->getHorzShift() + 1
: sourceNode->getHorzShift();
// increase level
gn->setLevel (sourceNode->getLevel() + 1);
// increase horizontal shift
gn->setHorzShift (newHorizontalShift);
}
else
{
// increase level
gn->setLevel (sourceNode->getLevel() + 1);
// use the same horizontal shift
gn->setHorzShift (sourceNode->getHorzShift());
}
checkLayout (getNodeForEditor (gn->getDest()));
}
}
int GraphViewer::getIndexOfEditor (GenericEditor* editor) const
{
int index = -1;
const int numAvailableNodes = availableNodes.size();
for (int i = 0; i < numAvailableNodes; ++i)
{
if (availableNodes[i]->hasEditor (editor))
{
return i;
}
}
return index;
}
GraphNode* GraphViewer::getNodeForEditor (GenericEditor* editor) const
{
int indexOfEditor = getIndexOfEditor (editor);
if (indexOfEditor > -1)
return availableNodes[indexOfEditor];
else
return nullptr;
}
int GraphViewer::nodesAtLevel (int level) const
{
int numNodes = 0;
for (auto& node : availableNodes)
{
// Level value is not used.
// It seems we should check if current level of each node is equal to the passed as param level
// TODO : research this question and either delete this comment or fix the bug
if (node->getLevel() == numNodes)
++numNodes;
}
return numNodes;
}
int GraphViewer::getHorizontalShift (GraphNode* gn) const
{
int shift = 0;
for (auto& node : availableNodes)
{
if (node == gn)
break;
else
if (node->getLevel() == gn->getLevel())
++shift;
}
return shift;
}
void GraphViewer::paint (Graphics& g)
{
g.fillAll (Colours::darkgrey);
g.setFont (FONT_LABEL);
g.setColour (Colours::grey);
g.drawFittedText ("open ephys", 40, 40, getWidth()-50, getHeight()-60, Justification::bottomRight, 100);
g.setFont (FONT_VERSION);
g.drawFittedText (currentVersionText, 40, 40, getWidth()-50, getHeight()-45, Justification::bottomRight, 100);
// Draw connections
const int numAvailableNodes = availableNodes.size();
for (int i = 0; i < numAvailableNodes; ++i)
{
if (! availableNodes[i]->isSplitter())
{
if (availableNodes[i]->getDest() != nullptr)
{
int indexOfDest = getIndexOfEditor (availableNodes[i]->getDest());
if (indexOfDest > -1)
connectNodes (i, indexOfDest, g);
}
}
else
{
Array<GenericEditor*> editors = availableNodes[i]->getConnectedEditors();
for (int path = 0; path < 2; ++path)
{ int indexOfDest = getIndexOfEditor (editors[path]);
if (indexOfDest > -1)
connectNodes (i, indexOfDest, g);
}
}
}
}
void GraphViewer::connectNodes (int node1, int node2, Graphics& g)
{
Point<float> start = availableNodes[node1]->getCenterPoint();
Point<float> end = availableNodes[node2]->getCenterPoint();
Path linePath;
float x1 = start.getX();
float y1 = start.getY();
float x2 = end.getX();
float y2 = end.getY();
linePath.startNewSubPath (x1, y1);
linePath.cubicTo (x1, y1 + (y2 - y1) * 0.9f,
x2, y1 + (y2 - y1) * 0.1f,
x2, y2);
PathStrokeType stroke (2.0f);
g.strokePath (linePath, stroke);
}
/// ------------------------------------------------------
GraphNode::GraphNode (GenericEditor* ed, GraphViewer* g)
: editor (ed)
, gv (g)
, isMouseOver (false)
{
}
GraphNode::~GraphNode()
{
}
int GraphNode::getLevel() const
{
// int level = -1;
// GenericEditor* ed = editor;
// while (ed != nullptr)
// {
// level += 1;
// ed = ed->getSourceEditor();
// }
return vertShift;
}
void GraphNode::setLevel (int level)
{
setBounds (getX(), 20 + level * 40, getWidth(), getHeight());
vertShift = level;
}
int GraphNode::getHorzShift() const
{
return horzShift; //gv->getHorizontalShift(this);
}
void GraphNode::setHorzShift (int shift)
{
setBounds (20 + shift * 140, getY(), getWidth(), getHeight());
horzShift = shift;
}
void GraphNode::mouseEnter (const MouseEvent& m)
{
isMouseOver = true;
repaint();
}
void GraphNode::mouseExit (const MouseEvent& m)
{
isMouseOver = false;
repaint();
}
void GraphNode::mouseDown (const MouseEvent& m)
{
editor->makeVisible();
}
bool GraphNode::hasEditor (GenericEditor* ed) const
{
if (ed == editor)
return true;
else
return false;
}
bool GraphNode::isSplitter() const
{
return editor->isSplitter();
}
bool GraphNode::isMerger() const
{
return editor->isMerger();
}
GenericEditor* GraphNode::getDest() const
{
return editor->getDestEditor();
}
GenericEditor* GraphNode::getSource() const
{
return editor->getSourceEditor();
}
Array<GenericEditor*> GraphNode::getConnectedEditors() const{
return editor->getConnectedEditors();
}
const String GraphNode::getName() const
{
return editor->getDisplayName();
}
Point<float> GraphNode::getCenterPoint() const
{
Point<float> center = Point<float> (getX() + 10, getY() + 10);
return center;
}
void GraphNode::switchIO (int path)
{
}
void GraphNode::updateBoundaries()
{
int horzShift = gv->getHorizontalShift (this);
setBounds (20 + horzShift * 140, 20 + getLevel() * 40, 150, 50);
}
void GraphNode::paint (Graphics& g)
{
Array<bool> recordStatuses = editor->getRecordStatusArray();
Path recordPath;
const int numRecordStatuses = recordStatuses.size();
for (int i = 0; i < numRecordStatuses; ++i)
{
float stepSize = 2 * float_Pi / numRecordStatuses;
float startRadians = stepSize * i;
float endRadians = startRadians + stepSize;
if (recordStatuses[i])
recordPath.addPieSegment (0, 0, 20, 20, startRadians, endRadians, 0.5);
}
g.setColour (Colours::red);
g.fillPath (recordPath);
g.setColour (isMouseOver ? Colours::yellow : editor->getBackgroundColor());
g.fillEllipse (2, 2, 16, 16);
g.drawText (getName(), 25, 0, getWidth() - 25, 20, Justification::left, true);
}