void callGraphDisplay::resize(bool currentlyDisplayedAbstraction) {
const int newWindowWidth = Tk_Width(consts.theTkWindow);
// const int newWindowHeight = Tk_Height(consts.theTkWindow); [not used]
consts.resize(); // reallocates offscreen pixmap; rethinks
//listboxHeightWhereSBappears'
// Loop through EVERY listbox (gasp) and rethink whether or not it needs
// a scrollbar and (possibly) change listBoxActualHeight...
// _Must_ go _after_ the consts.resize()
(void)rootPtr->rethinkListboxAfterResize(consts);
// Now the more conventional resize code:
rootPtr->rethinkAfterResize(consts, newWindowWidth);
rethink_nominal_centerx();
// must go _after_ the rootPtr->rethinkAfterResize()
if (currentlyDisplayedAbstraction) {
// We have changed axis width and/or height. Let's inform tcl, so it may
// rethink the scrollbar ranges.
resizeScrollbars();
// Now, let's update our own stored horiz & vert scrollbar offset values
adjustHorizSBOffset(); // obtain FirstPix from the actual tk scrollbar
adjustVertSBOffset (); // obtain FirstPix from the actual tk scrollbar
}
}
void callGraphDisplay::rethinkEntireLayout(){
rootPtr->recursiveDoneAddingChildren(consts, false);
// false --> don't resort
rethink_nominal_centerx();
resizeScrollbars();
adjustHorizSBOffset();
adjustVertSBOffset();
}
bool callGraphDisplay::forciblyScrollToEndOfPath(const whereNodePosRawPath &thePath) {
// Forcibly expands path items as needed, then calls softScrollToEndOfPath()
const bool anyChanges = rootPtr->expandEntirePath(consts, thePath, 0);
if (anyChanges) {
rethink_nominal_centerx();
resizeScrollbars();
adjustHorizSBOffset();
adjustVertSBOffset();
}
softScrollToEndOfPath(thePath);
return anyChanges;
}
/**
* Change the box line size.
*
*/
void StatisticsTool::changeBoxLines() {
QString lines = p_linesEdit->text();
if(lines != "" && lines.toInt() != p_boxLines && lines.toInt() > 0) {
p_boxLines = lines.toInt();
QString samps;
samps.setNum(p_boxSamps);
p_boxLabel->setText(samps + "x" + lines);
p_visualDisplay->setLines(p_boxLines);
p_set = false;
resizeScrollbars();
}
}
bool callGraphDisplay::processDoubleClick(int x, int y) {
// returns true iff a complete redraw is called for
bool scrollToWhenDone = false; // for now...
whereNodeGraphicalPath<callGraphRootNode> thePath = point2path(x, y);
switch (thePath.whatDoesPathEndIn()) {
case whereNodeGraphicalPath<callGraphRootNode>::Nothing:
return false;
case whereNodeGraphicalPath<callGraphRootNode>::ListboxScrollbarUpArrow:
case whereNodeGraphicalPath<callGraphRootNode>::ListboxScrollbarDownArrow:
case whereNodeGraphicalPath<callGraphRootNode>::ListboxScrollbarPageup:
case whereNodeGraphicalPath<callGraphRootNode>::ListboxScrollbarPagedown:
// in this case, do the same as a single-click
processNonSliderButtonPress(thePath);
return false; // no need to redraw further
case whereNodeGraphicalPath<callGraphRootNode>::ListboxScrollbarSlider:
return false;
case whereNodeGraphicalPath<callGraphRootNode>::ExpandedNode: {
// double-click in a "regular" node (not in listbox): un-expand
if (thePath.getSize() == 0) {
return false;
}
if (!rootPtr->path2lbItemUnexpand(consts, thePath.getPath(), 0)) {
// probably an attempt to expand a leaf item (w/o a triangle next to it)
return false;
}
// Now let's scroll to the un-expanded item.
rethink_nominal_centerx();
resizeScrollbars();
adjustHorizSBOffset();
adjustVertSBOffset();
softScrollToEndOfPath(thePath.getPath());
where4tree<callGraphRootNode> *ptr = thePath.getLastPathNode(rootPtr);
bool ishighlight=ptr->isHighlighted();
map_to_WhereAxis(ptr->getNodeData().getUniqueId(),ishighlight);
return true;
}
case whereNodeGraphicalPath<callGraphRootNode>::ListboxItem: {
// double-click in a listbox item
// first thing's first: now that we know the user
//intended to do a double-click
// all along, we should undo the effects of the
//single-click which came earlier.
thePath.getLastPathNode(rootPtr)->toggle_highlight();
where4tree<callGraphRootNode> *ptr = thePath.getLastPathNode(rootPtr);
bool ishighlight=ptr->isHighlighted();
map_to_WhereAxis(ptr->getNodeData().getUniqueId(),ishighlight);
// doesn't redraw
const bool anyChanges = rootPtr->path2lbItemExpand(consts,
thePath.getPath(),0);
if (!anyChanges) {
// The only real change we made was the toggle_highlight(). This is
// a case where we can do the redrawing ourselves (and fast).
thePath.getParentOfLastPathNode(rootPtr)->
draw(consts.theTkWindow, consts, Tk_WindowId(consts.theTkWindow),
thePath.get_endpath_centerx(),
thePath.get_endpath_topy(),
false, // not root only
true // listbox only
);
return false;
}
else {
// expansion was successful...later, we'll scroll to the
// expanded item.
// NOTE: rootPtr->path2lbItemExpand will have modified "thePath"
// for us (by changing the last item from a listbox item to
// an expanded one, which is the proper thing to do).
scrollToWhenDone = true;
}
break;
}
default:
assert(false);
}
// expansion or un-expansion successful
rethink_nominal_centerx();
// We have changed axis width and/or height. Let's inform tcl, so it may
// rethink the scrollbar ranges.
resizeScrollbars();
// Now, let's update our own stored horiz & vert scrollbar offset values
adjustHorizSBOffset(); // obtain FirstPix from the actual tk scrollbar
adjustVertSBOffset (); // obtain FirstPix from the actual tk scrollbar
if (scrollToWhenDone) {
const int overallWindowBorderPix = 0;
whereNodeGraphicalPath<callGraphRootNode>
path_to_scroll_to(thePath.getPath(),
consts, rootPtr,
nominal_centerx,
// root centerx (abs. pos., regardless of sb [intentional])
overallWindowBorderPix
// topy of root (abs. pos., regardless of sb [intentional])
);
int newlyExpandedElemCenterX = path_to_scroll_to.get_endpath_centerx();
int newlyExpandedElemTopY = path_to_scroll_to.get_endpath_topy();
int newlyExpandedElemMiddleY = newlyExpandedElemTopY +
path_to_scroll_to.getLastPathNode(rootPtr)->getNodeData().getHeightAsRoot() / 2;
(void)set_scrollbars(newlyExpandedElemCenterX, x,
newlyExpandedElemMiddleY, y,
true);
}
return true;
}
bool callGraphDisplay::processShiftDoubleClick(int x, int y) {
// returns true iff a complete redraw is called for
whereNodeGraphicalPath<callGraphRootNode> thePath = point2path(x, y);
switch (thePath.whatDoesPathEndIn()) {
case whereNodeGraphicalPath<callGraphRootNode>::Nothing:
return false;
case whereNodeGraphicalPath<callGraphRootNode>::ListboxItem:
return false;
case whereNodeGraphicalPath<callGraphRootNode>::ExpandedNode:
break; // some breathing room for lots of code to follow...
case whereNodeGraphicalPath<callGraphRootNode>::ListboxScrollbarUpArrow:
case whereNodeGraphicalPath<callGraphRootNode>::ListboxScrollbarDownArrow:
case whereNodeGraphicalPath<callGraphRootNode>::ListboxScrollbarPageup:
case whereNodeGraphicalPath<callGraphRootNode>::ListboxScrollbarPagedown:
// in this case, do the same as a single-click
processNonSliderButtonPress(thePath);
return false; // no need to redraw further
case whereNodeGraphicalPath<callGraphRootNode>::ListboxScrollbarSlider:
return false;
default:
assert(false);
}
// How do we know whether to expand-all or un-expand all?
// Well, if there is no listbox up, then we should _definitely_ unexpand.
// And, if there is a listbox up containing all items
// (no explicitly expanded items), then we should _definitely_ expand.
// But, if there is a listbox up with _some_ explicitly expanded items,
// then are we supposed to expand out the remaining ones; or un-expand
// the expanded ones? It could go either way. For now, we'll say
// that we should un-expand.
bool anyChanges = false; // so far...
where4tree<callGraphRootNode> *ptr = thePath.getLastPathNode(rootPtr);
ptr->toggle_highlight(); // doesn't redraw
if (ptr->getListboxPixWidth() > 0) {
bool noExplicitlyExpandedChildren = true; // so far...
for (unsigned childlcv=0; childlcv < ptr->getNumChildren(); childlcv++)
if (ptr->getChildIsExpandedFlag(childlcv)) {
noExplicitlyExpandedChildren = false;
break;
}
if (noExplicitlyExpandedChildren)
// There is a listbox up, and it contains ALL children.
// So, obviously, we want to expand them all...
anyChanges = rootPtr->path2ExpandAllChildren(consts,
thePath.getPath(), 0);
else
// There is a listbox up, but there are also some expanded children.
// This call (whether to expand the remaining listbox items, or whether
// to un-expand the expanded items) could go either way; we choose the
// latter (for now, at least)
anyChanges = rootPtr->path2UnExpandAllChildren(consts,
thePath.getPath(), 0);
}
else
// No listbox is up; hence, all children are expanded.
// So obviously, we wish to un-expand all the children.
anyChanges = rootPtr->path2UnExpandAllChildren(consts, thePath.getPath(), 0);
if (!anyChanges)
return false;
rethink_nominal_centerx();
// We have changed axis width and/or height. Let's inform tcl, so it may
// rethink the scrollbar ranges.
resizeScrollbars();
// Now, let's update our own stored horiz & vert scrollbar offset values
adjustHorizSBOffset(); // obtain FirstPix from the actual tk scrollbar
adjustVertSBOffset (); // obtain FirstPix from the actual tk scrollbar
return true;
}
/**
* Retrieve the statistics based on the box size
* and point on the cube.
*
* @param p
*/
void StatisticsTool::getStatistics(QPoint p) {
MdiCubeViewport *cvp = cubeViewport();
if(cvp == NULL) return;
double sample, line;
cvp->viewportToCube(p.x(), p.y(), sample, line);
// If we are outside of the cube, do nothing
if((sample < 0.5) || (line < 0.5) ||
(sample > cvp->cubeSamples() + 0.5) || (line > cvp->cubeLines() + 0.5)) {
return;
}
int isamp = (int)(sample + 0.5);
int iline = (int)(line + 0.5);
Statistics stats;
Brick *brick = new Brick(1, 1, 1, cvp->cube()->pixelType());
QVector<QVector<double> > pixelData(p_boxLines, QVector<double>(p_boxSamps, Null));
double lineDiff = p_boxLines / 2.0;
double sampDiff = p_boxSamps / 2.0;
p_ulSamp = isamp - (int)floor(sampDiff);
p_ulLine = iline - (int)floor(lineDiff);
int x, y;
y = p_ulLine;
for(int i = 0; i < p_boxLines; i++) {
x = p_ulSamp;
if(y < 1 || y > cvp->cubeLines()) {
y++;
continue;
}
for(int j = 0; j < p_boxSamps; j++) {
if(x < 1 || x > cvp->cubeSamples()) {
x++;
continue;
}
brick->SetBasePosition(x, y, cvp->grayBand());
cvp->cube()->read(*brick);
stats.AddData(brick->at(0));
pixelData[i][j] = brick->at(0);
x++;
}
y++;
}
p_visualDisplay->setPixelData(pixelData, p_ulSamp, p_ulLine);
if (stats.ValidPixels()) {
p_minLabel->setText(QString("Minimum: %1").arg(stats.Minimum()));
p_maxLabel->setText(QString("Maximum: %1").arg(stats.Maximum()));
p_avgLabel->setText(QString("Average: %1").arg(stats.Average()));
p_stdevLabel->setText(QString("Standard Dev: %1").arg(stats.StandardDeviation(), 0, 'f', 6));
}
else {
p_minLabel->setText(QString("Minimum: n/a"));
p_maxLabel->setText(QString("Maximum: n/a"));
p_avgLabel->setText(QString("Average: n/a"));
p_stdevLabel->setText(QString("Standard Dev: n/a"));
}
p_set = true;
resizeScrollbars();
}
Viewport::Viewport(int scale, int autoUpdateInterval, bool openGL, QWidget *parent) : QWidget(parent)
{
// Init
this->scale = scale;
sliderZoom = NULL;
maps = new QList<Map*>();
mapMetas = new QList<MapMeta*>();
antiAlias = true;
selectedAction = NULL;
timerAutoUpdate = new QTimer();
timerAutoUpdate->setInterval(autoUpdateInterval);
this->setAttribute(Qt::WA_DeleteOnClose, true);
this->setWindowIcon(QIcon(":eye"));
this->setWindowTitle("emss Viewport");
maxMapWidth = 0.0;
maxMapHeight = 0.0;
// Toolbar
this->setLayout(new QVBoxLayout());
this->layout()->setContentsMargins(0,0,0,0);
toolbar = new QToolBar();
toolbar->setAutoFillBackground(true);
this->layout()->addWidget(toolbar);
// Add scrollbars...
gridLayout = new QGridLayout();
gridLayout->setContentsMargins(0,0,0,0);
QWidget *gridHolder = new QWidget();
gridHolder->setLayout(gridLayout);
this->layout()->addWidget(gridHolder);
scrollHorizontal = new QScrollBar(Qt::Horizontal);
scrollHorizontal->setMinimum(0);
scrollHorizontal->setMaximum(1000);
scrollHorizontal->setSingleStep(10);
scrollVertical = new QScrollBar(Qt::Vertical);
scrollVertical->setMinimum(0);
scrollVertical->setMaximum(1000);
scrollVertical->setSingleStep(10);
gridLayout->addWidget(scrollHorizontal,3,1);
gridLayout->addWidget(scrollVertical,0,2);
// Canvas
if(openGL) canvas = new DrawCanvasGL();
else canvas = new DrawCanvas();
gridLayout->addWidget(canvas, 0,1);
// Zoom
if(openGL) {
// Only allow zooming if open gl. Software render is just not built for this...
sliderZoom = new QSlider(Qt::Horizontal);
setNaturalZoom();
gridLayout->addWidget(sliderZoom,2,1);
}
// Build menu
menuMain = new QMenu(this);
QAction *actionLabelNativeOrGL = new QAction( (openGL ? "openGL Render" : "Native Render"), menuMain);
actionLabelNativeOrGL->setEnabled(false);
menuMain->addAction(actionLabelNativeOrGL);
actionAntiAlias = new QAction("Anti Alias", menuMain);
actionAntiAlias->setCheckable(true);
actionAntiAlias->setChecked(antiAlias);
menuMain->addAction(actionAntiAlias);
actionAutoUpdate = new QAction("Auto Update", menuMain);
actionAutoUpdate->setCheckable(true);
actionAutoUpdate->setChecked(true);
menuMain->addAction(actionAutoUpdate);
actionAutoFocus = new QAction("Auto Focus", menuMain);
actionAutoFocus->setCheckable(true);
actionAutoFocus->setChecked(true);
menuMain->addAction(actionAutoFocus);
menuMaps = new QMenu("Maps");
menuMain->addMenu(menuMaps);
// Register events
this->setFocusPolicy(Qt::StrongFocus);
this->setMouseTracking(true);
// Connections
connect(menuMain, SIGNAL(triggered(QAction*)), this, SLOT(menuAction(QAction*)));
connect(menuMaps, SIGNAL(triggered(QAction*)), this, SLOT(menuAction(QAction*)));
connect(toolbar, SIGNAL(actionTriggered(QAction*)), this, SLOT(toolbarAction(QAction*)));
connect(timerAutoUpdate, SIGNAL(timeout()), this, SLOT(paintAndShow()));
connect(canvas,SIGNAL(draw(QPainter*)), this, SLOT(drawMaps(QPainter*)));
connect(canvas,SIGNAL(mouseClick(QMouseEvent*)), this, SLOT(canvasClicked(QMouseEvent*)));
if(sliderZoom) connect(sliderZoom, SIGNAL(valueChanged(int)), this, SLOT(zoomChanged()));
// Start timers...
resizeScrollbars();
timerAutoUpdate->start();
}
