long
GUISUMOAbstractView::onLeftBtnPress(FXObject*, FXSelector , void* data) {
destroyPopup();
setFocus();
FXEvent* e = (FXEvent*) data;
// check whether the selection-mode is activated
if ((e->state & CONTROLMASK) != 0) {
// try to get the object-id if so
if (makeCurrent()) {
unsigned int id = getObjectUnderCursor();
if (id != 0) {
gSelected.toggleSelection(id);
}
makeNonCurrent();
if (id != 0) {
// possibly, the selection-colouring is used,
// so we should update the screen again...
update();
}
}
}
myChanger->onLeftBtnPress(data);
grab();
return 1;
}
long
GUITLLogicPhasesTrackerWindow::GUITLLogicPhasesTrackerPanel::onPaint(
FXObject*, FXSelector, void*) {
if (!isEnabled()) {
return 1;
}
if (makeCurrent()) {
int widthInPixels = getWidth();
int heightInPixels = getHeight();
if (widthInPixels != 0 && heightInPixels != 0) {
glViewport(0, 0, widthInPixels - 1, heightInPixels - 1);
glClearColor(0, 0, 0, 1);
glDisable(GL_DEPTH_TEST);
glDisable(GL_LIGHTING);
glDisable(GL_LINE_SMOOTH);
glEnable(GL_BLEND);
glEnable(GL_ALPHA_TEST);
glDisable(GL_COLOR_MATERIAL);
glLineWidth(1);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
// draw
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
myParent->drawValues(*this);
swapBuffers();
}
makeNonCurrent();
}
return 1;
}
void
GUISUMOAbstractView::openObjectDialog() {
ungrab();
if (!isEnabled() || !myAmInitialised) {
return;
}
if (makeCurrent()) {
// initialise the select mode
unsigned int id = getObjectUnderCursor();
GUIGlObject* o = 0;
if (id != 0) {
o = GUIGlObjectStorage::gIDStorage.getObjectBlocking(id);
} else {
o = GUIGlObjectStorage::gIDStorage.getNetObject();
}
if (o != 0) {
myPopup = o->getPopUpMenu(*myApp, *this);
int x, y;
FXuint b;
myApp->getCursorPosition(x, y, b);
myPopup->setX(x + myApp->getX());
myPopup->setY(y + myApp->getY());
myPopup->create();
myPopup->show();
myChanger->onRightBtnRelease(0);
GUIGlObjectStorage::gIDStorage.unblockObject(id);
}
makeNonCurrent();
}
}
long
GUIParameterTracker::GUIParameterTrackerPanel::onPaint(FXObject*,
FXSelector,void*) {
if (!isEnabled()) {
return 1;
}
if (makeCurrent()) {
myWidthInPixels = getWidth();
myHeightInPixels = getHeight();
if (myWidthInPixels!=0&&myHeightInPixels!=0) {
glViewport(0, 0, myWidthInPixels-1, myHeightInPixels-1);
glClearColor(1.0, 1.0, 1.0, 1);
glDisable(GL_DEPTH_TEST);
glDisable(GL_LIGHTING);
glDisable(GL_LINE_SMOOTH);
glEnable(GL_BLEND);
glEnable(GL_ALPHA_TEST);
glDisable(GL_COLOR_MATERIAL);
glLineWidth(1);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
// draw
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
drawValues();
glFlush();
swapBuffers();
}
makeNonCurrent();
}
return 1;
}
long Viewport::onPaint(FXObject*,FXSelector,void*)
{
//---------------- inizializzo la finestra per il paint ------------
makeCurrent();
w = getWidth();
h = getHeight();
glViewport(0, 0, w, h);
// pulisco lo schermo
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if (reproject)
{
prepareProjection();
Pick.Reshape();
reproject = false;
}
prepareModelView();
//------------------------- disegna il mondo -----------------------
drawWorld();
//---------------------------- finalizza... ------------------------
glFlush();
swapBuffers();
makeNonCurrent();
return 1;
}
void FXVTKCanvas::render()
{
makeCurrent();
_fxrwi->GetRenderWindow()->SetWindowId(_id);
//_fxrwi->GetRenderWindow()->SetDisplayId(_display);
_fxrwi->Render();
makeNonCurrent();
}
long
GUISUMOAbstractView::onPaint(FXObject*, FXSelector, void*) {
if (!isEnabled() || !myAmInitialised) {
return 1;
}
if (makeCurrent()) {
paintGL();
makeNonCurrent();
}
return 1;
}
long
GUISUMOAbstractView::onConfigure(FXObject*, FXSelector, void*) {
if (makeCurrent()) {
glViewport(0, 0, getWidth() - 1, getHeight() - 1);
glClearColor(
myVisualizationSettings->backgroundColor.red() / 255.,
myVisualizationSettings->backgroundColor.green() / 255.,
myVisualizationSettings->backgroundColor.blue() / 255.,
myVisualizationSettings->backgroundColor.alpha() / 255.);
doInit();
myAmInitialised = true;
makeNonCurrent();
checkSnapshots();
}
return 1;
}
void Viewport::glInit()
{
// Esegue dei comandi opengl per rendere attive le impostazioni
// nella struct RenderMode.
makeCurrent();
(RenderMode.Texture) ? glEnable(GL_TEXTURE_2D) : glDisable(GL_TEXTURE_2D);
if (RenderMode.Solid)
{
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
}
else
{
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glDisable(GL_LIGHTING);
glDisable(GL_TEXTURE_2D);
glEnable(GL_COLOR_MATERIAL);
//glColor3ub(255,255,255);
}
(RenderMode.Cullface) ? glEnable(GL_CULL_FACE) : glDisable(GL_CULL_FACE);
(RenderMode.DepthTest) ? glEnable(GL_DEPTH_TEST) : glDisable(GL_DEPTH_TEST);
glClearColor(RenderMode.ClearColor[0],
RenderMode.ClearColor[1],
RenderMode.ClearColor[2],
RenderMode.ClearColor[3]);
glEnable(GL_POINT_SMOOTH);
glHint(GL_LINE_SMOOTH_HINT, GL_FASTEST);
glPointSize(5.0f);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//glBlendFunc(GL_SRC_ALPHA, GL_ONE);
glAlphaFunc(GL_GEQUAL, 0.5f);
makeNonCurrent();
}
long
GUIParameterTracker::GUIParameterTrackerPanel::onConfigure(FXObject*,
FXSelector,void*) {
if (makeCurrent()) {
myWidthInPixels = myParent->getWidth();
myHeightInPixels = myParent->getHeight();
if (myWidthInPixels!=0&&myHeightInPixels!=0) {
glViewport(0, 0, myWidthInPixels-1, myHeightInPixels-1);
glClearColor(1.0, 1.0, 1.0, 1);
glDisable(GL_DEPTH_TEST);
glDisable(GL_LIGHTING);
glDisable(GL_LINE_SMOOTH);
glEnable(GL_BLEND);
glEnable(GL_ALPHA_TEST);
glDisable(GL_COLOR_MATERIAL);
glLineWidth(1);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
makeNonCurrent();
}
return 1;
}
std::string
GUISUMOAbstractView::makeSnapshot(const std::string& destFile) {
std::string errorMessage;
FXString ext = FXPath::extension(destFile.c_str());
const bool useGL2PS = ext == "ps" || ext == "eps" || ext == "pdf" || ext == "svg" || ext == "tex" || ext == "pgf";
#ifdef HAVE_FFMPEG
const bool useVideo = destFile == "" || ext == "h264" || ext == "hevc";
#endif
for (int i = 0; i < 10 && !makeCurrent(); ++i) {
FXSingleEventThread::sleep(100);
}
// draw
glClearColor(
myVisualizationSettings->backgroundColor.red() / 255.,
myVisualizationSettings->backgroundColor.green() / 255.,
myVisualizationSettings->backgroundColor.blue() / 255.,
myVisualizationSettings->backgroundColor.alpha() / 255.);
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
if (myVisualizationSettings->dither) {
glEnable(GL_DITHER);
} else {
glDisable(GL_DITHER);
}
if (myVisualizationSettings->antialiase) {
glEnable(GL_BLEND);
glEnable(GL_POLYGON_SMOOTH);
glEnable(GL_LINE_SMOOTH);
} else {
glDisable(GL_BLEND);
glDisable(GL_POLYGON_SMOOTH);
glDisable(GL_LINE_SMOOTH);
}
applyGLTransform();
if (useGL2PS) {
GLint format = GL2PS_PS;
if (ext == "ps") {
format = GL2PS_PS;
} else if (ext == "eps") {
format = GL2PS_EPS;
} else if (ext == "pdf") {
format = GL2PS_PDF;
} else if (ext == "tex") {
format = GL2PS_TEX;
} else if (ext == "svg") {
format = GL2PS_SVG;
} else if (ext == "pgf") {
format = GL2PS_PGF;
} else {
return "Could not save '" + destFile + "'.\n Unrecognized format '" + std::string(ext.text()) + "'.";
}
FILE* fp = fopen(destFile.c_str(), "wb");
if (fp == 0) {
return "Could not save '" + destFile + "'.\n Could not open file for writing";
}
GLint buffsize = 0, state = GL2PS_OVERFLOW;
GLint viewport[4];
glGetIntegerv(GL_VIEWPORT, viewport);
while (state == GL2PS_OVERFLOW) {
buffsize += 1024 * 1024;
gl2psBeginPage(destFile.c_str(), "sumo-gui; http://sumo.dlr.de", viewport, format, GL2PS_SIMPLE_SORT,
GL2PS_DRAW_BACKGROUND | GL2PS_USE_CURRENT_VIEWPORT,
GL_RGBA, 0, NULL, 0, 0, 0, buffsize, fp, "out.eps");
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glDisable(GL_TEXTURE_2D);
glDisable(GL_ALPHA_TEST);
glDisable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
// compute lane width
// draw decals (if not in grabbing mode)
if (!myUseToolTips) {
drawDecals();
if (myVisualizationSettings->showGrid) {
paintGLGrid();
}
}
glLineWidth(1);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
Boundary viewPort = myChanger->getViewport();
float minB[2];
float maxB[2];
minB[0] = viewPort.xmin();
minB[1] = viewPort.ymin();
maxB[0] = viewPort.xmax();
maxB[1] = viewPort.ymax();
myVisualizationSettings->scale = m2p(SUMO_const_laneWidth);
glEnable(GL_POLYGON_OFFSET_FILL);
glEnable(GL_POLYGON_OFFSET_LINE);
myGrid->Search(minB, maxB, *myVisualizationSettings);
if (myVisualizationSettings->showSizeLegend) {
displayLegend();
}
state = gl2psEndPage();
glFinish();
}
fclose(fp);
} else {
doPaintGL(GL_RENDER, myChanger->getViewport());
if (myVisualizationSettings->showSizeLegend) {
displayLegend();
}
swapBuffers();
glFinish();
FXColor* buf;
FXMALLOC(&buf, FXColor, getWidth()*getHeight());
// read from the back buffer
glReadBuffer(GL_BACK);
// Read the pixels
glReadPixels(0, 0, getWidth(), getHeight(), GL_RGBA, GL_UNSIGNED_BYTE, (GLvoid*)buf);
makeNonCurrent();
update();
// mirror
size_t mwidth = getWidth();
size_t mheight = getHeight();
FXColor* paa = buf;
FXColor* pbb = buf + mwidth * (mheight - 1);
do {
FXColor* pa = paa;
paa += mwidth;
FXColor* pb = pbb;
pbb -= mwidth;
do {
FXColor t = *pa;
*pa++ = *pb;
*pb++ = t;
} while (pa < paa);
} while (paa < pbb);
try {
#ifdef HAVE_FFMPEG
if (useVideo) {
try {
saveFrame(destFile, buf);
errorMessage = "video";
} catch (std::runtime_error& err) {
errorMessage = err.what();
}
} else
#endif
if (!MFXImageHelper::saveImage(destFile, getWidth(), getHeight(), buf)) {
errorMessage = "Could not save '" + destFile + "'.";
}
} catch (InvalidArgument& e) {
errorMessage = "Could not save '" + destFile + "'.\n" + e.what();
}
FXFREE(&buf);
}
return errorMessage;
}
