FGFS-4.1/OpenSceneGraph
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Removed Qt dependency examples, osgQt NodeKit and qfont plugin as these are now provided by the separate osgQt project

Browse Source
This commit is contained in:
Robert Osfield 2016-09-26 09:31:22 +01:00
parent 13fa75fc12
commit 56a7208891
28 changed files with 0 additions and 4174 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
CMakeLists.txt
View File

@ -28,12 +28,6 @@ if(COMMAND cmake_policy)
cmake_policy(SET CMP0008 OLD)
endif()
# disable autolinking to qtmain as we have our own main() functions (new in Qt 5.1)
if(${CMAKE_MAJOR_VERSION} GREATER 2 OR
(${CMAKE_MAJOR_VERSION} EQUAL 2 AND ${CMAKE_MINOR_VERSION} GREATER 8) OR
(${CMAKE_MAJOR_VERSION} EQUAL 2 AND ${CMAKE_MINOR_VERSION} EQUAL 8 AND ${CMAKE_PATCH_VERSION} GREATER 10))
cmake_policy(SET CMP0020 OLD)
endif()
# nicer version check - but needs at least CMake 2.6.2? Worth upgrading the requirements?
#if("${CMAKE_VERSION}" VERSION_GREATER 2.8.10)
# or even easier (available in cmake-2.6)
@ -769,61 +763,6 @@ ENDIF()
# Include macro utilities here
INCLUDE(OsgMacroUtils)
OPTION(OSG_USE_QT "Enable to use Qt (build Qt-dependent libraries, plugins and examples)" ON)
IF(OSG_USE_QT AND NOT ANDROID)
# To select a specific version of QT define DESIRED_QT_VERSION
# via cmake -DDESIRED_QT_VERSION=5
# QUIET option disables messages if the package cannot be found.
IF (DESIRED_QT_VERSION)
IF (DESIRED_QT_VERSION MATCHES 5)
FIND_PACKAGE(Qt5Widgets)
ELSEIF (DESIRED_QT_VERSION MATCHES 4)
FIND_PACKAGE(Qt4)
ELSE()
FIND_PACKAGE(Qt3)
ENDIF()
ELSE()
FIND_PACKAGE(Qt5Widgets QUIET)
IF ( Qt5Widgets_FOUND )
# CMake 2.8.8 or greater required
BUILDER_VERSION_GREATER(2 8 7)
IF(NOT VALID_BUILDER_VERSION)
MESSAGE(
SEND_ERROR
"Qt5 requires CMake version 2.8.8 or greater!\n"
"Update CMake or set DESIRED_QT_VERSION to less than 5
or disable OSG_USE_QT."
)
ENDIF( )
ENDIF( )
IF ( NOT Qt5Widgets_FOUND )
FIND_PACKAGE(Qt4)
IF (NOT QT4_FOUND)
FIND_PACKAGE(Qt3)
ENDIF()
ENDIF()
ENDIF()
#If we have found Qt5, let's try to top off by getting the webkit as well
IF ( Qt5Widgets_FOUND )
FIND_PACKAGE(Qt5WebKitWidgets QUIET)
IF(COMMAND cmake_policy)
IF(${CMAKE_MAJOR_VERSION} GREATER 2)
# Qt5 qt5_use_modules usage was causing "Policy CMP0043 is not set: Ignore COMPILE_DEFINITIONS_<Config> properties." warnings
cmake_policy(SET CMP0043 NEW)
ENDIF()
ENDIF()
ENDIF()
ENDIF()
#optional example related dependencies
IF (BUILD_OSG_EXAMPLES AND NOT ANDROID)
@ -1327,10 +1266,6 @@ SET(PKGCONFIG_FILES
openscenegraph-osgVolume
)
IF(QT4_FOUND OR Qt5Widgets_FOUND )
SET(PKGCONFIG_FILES ${PKGCONFIG_FILES} openscenegraph-osgQt)
ENDIF()
FOREACH(PKGCONFIG_FILE ${PKGCONFIG_FILES})
CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/packaging/pkgconfig/${PKGCONFIG_FILE}.pc.in
${PROJECT_BINARY_DIR}/packaging/pkgconfig/${PKGCONFIG_FILE}.pc

1
CMakeModules/FindOSG.cmake
View File

@ -116,7 +116,6 @@ FIND_OSG_LIBRARY(OSGUTIL_LIBRARY osgUtil)
FIND_OSG_LIBRARY(OSGDB_LIBRARY osgDB)
FIND_OSG_LIBRARY(OSGTEXT_LIBRARY osgText)
FIND_OSG_LIBRARY(OSGWIDGET_LIBRARY osgWidget)
FIND_OSG_LIBRARY(OSGQT_LIBRARY osgQt)
FIND_OSG_LIBRARY(OSGTERRAIN_LIBRARY osgTerrain)
FIND_OSG_LIBRARY(OSGFX_LIBRARY osgFX)
FIND_OSG_LIBRARY(OSGVIEWER_LIBRARY osgViewer)

14
examples/CMakeLists.txt
View File

@ -208,20 +208,6 @@ IF(DYNAMIC_OPENSCENEGRAPH)
ENDIF()
ENDIF()
IF ( (QT4_FOUND OR Qt5Widgets_FOUND) AND NOT OSG_GLES1_AVAILABLE AND NOT OSG_GLES2_AVAILABLE AND NOT OSG_GL3_AVAILABLE)
IF ( QT4_FOUND OR Qt5Widgets_FOUND)
ADD_SUBDIRECTORY(osgviewerQt)
ADD_SUBDIRECTORY(osgqfont)
ENDIF()
IF ( (QT4_FOUND AND QT_QTWEBKIT_FOUND) OR Qt5WebKitWidgets_FOUND )
ADD_SUBDIRECTORY(osgQtWidgets)
ADD_SUBDIRECTORY(osgQtBrowser)
ENDIF()
ENDIF()
IF (FLTK_FOUND AND FLTK_GL_LIBRARY)
ADD_SUBDIRECTORY(osgviewerFLTK)
ENDIF()

25
examples/osgQtBrowser/CMakeLists.txt
View File

@ -1,25 +0,0 @@
SET(TARGET_SRC
osgQtBrowser.cpp
)
IF(CMAKE_COMPILER_IS_GNUCXX)
# Remove -pedantic flag as it barfs on Qt headers
STRING(REGEX REPLACE "-pedantic" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
ENDIF()
if ( QT4_FOUND )
SET(TARGET_EXTERNAL_LIBRARIES ${QT_QTCORE_LIBRARY} ${QT_QTGUI_LIBRARY} ${QT_QTOPENGL_LIBRARY} ${QT_QTWEBKIT_LIBRARY})
INCLUDE_DIRECTORIES(${QT_INCLUDE_DIR} ${QT_QTCORE_INCLUDE_DIR} ${QT_QTOPENGL_INCLUDE_DIR} ${QT_QTGUI_INCLUDE_DIR} ${QT_QTWEBKIT_INCLUDE_DIR} )
endif( QT4_FOUND )
SET(TARGET_ADDED_LIBRARIES osgWidget osgQt)
#### end var setup ###
SET ( EXAMPLE_NAME osgQtBrowser )
SETUP_EXAMPLE(${EXAMPLE_NAME})
IF ( Qt5Widgets_FOUND )
qt5_use_modules( example_${EXAMPLE_NAME} Widgets OpenGL WebKitWidgets )
ENDIF( Qt5Widgets_FOUND )

145
examples/osgQtBrowser/osgQtBrowser.cpp
View File

@ -1,145 +0,0 @@
/* OpenSceneGraph example, osgcompositeviewer.
*
* 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 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.
*/
#include <iostream>
#include <osg/Notify>
#include <osg/io_utils>
#include <osg/ArgumentParser>
#include <osgDB/WriteFile>
#include <osgGA/TrackballManipulator>
#include <osgGA/StateSetManipulator>
#include <osgViewer/Viewer>
#include <osgViewer/ViewerEventHandlers>
#include <osgWidget/Browser>
#include <QtGlobal>
#if QT_VERSION >= 0x050000
# include <QtWebKitWidgets>
#else
# include <QtWebKit>
#endif
#include <QWebSettings>
#include <QGraphicsScene>
#include <QGraphicsView>
#include <QApplication>
#include <QPainter>
#include <QtEvents>
#include <osgQt/QGraphicsViewAdapter>
#include <osgQt/QWebViewImage>
// Thread that runs the viewer's frame loop as we can't run Qt in the background...
class ViewerFrameThread : public OpenThreads::Thread
{
public:
ViewerFrameThread(osgViewer::ViewerBase* viewerBase, bool doQApplicationExit):
_viewerBase(viewerBase),
_doQApplicationExit(doQApplicationExit) {}
~ViewerFrameThread()
{
if (isRunning())
{
cancel();
join();
}
}
int cancel()
{
_viewerBase->setDone(true);
return 0;
}
void run()
{
int result = _viewerBase->run();
if (_doQApplicationExit) QApplication::exit(result);
}
osg::ref_ptr<osgViewer::ViewerBase> _viewerBase;
bool _doQApplicationExit;
};
int main(int argc, char **argv)
{
// Qt requires that we construct the global QApplication before creating any widgets.
QApplication app(argc, argv);
// use an ArgumentParser object to manage the program arguments.
osg::ArgumentParser arguments(&argc,argv);
bool useFrameLoopThread = false;
if (arguments.read("--no-frame-thread")) useFrameLoopThread = false;
if (arguments.read("--frame-thread")) useFrameLoopThread = true;
osg::ref_ptr<osgQt::QWebViewImage> image = new osgQt::QWebViewImage;
if (arguments.argc()>1) image->navigateTo((arguments[1]));
else image->navigateTo("http://www.youtube.com/");
osgWidget::GeometryHints hints(osg::Vec3(0.0f,0.0f,0.0f),
osg::Vec3(1.0f,0.0f,0.0f),
osg::Vec3(0.0f,0.0f,1.0f),
osg::Vec4(1.0f,1.0f,1.0f,1.0f),
osgWidget::GeometryHints::RESIZE_HEIGHT_TO_MAINTAINCE_ASPECT_RATIO);
osg::ref_ptr<osgWidget::Browser> browser = new osgWidget::Browser;
browser->assign(image.get(), hints);
// image->focusBrowser(true);
osg::ref_ptr<osgViewer::Viewer> viewer = new osgViewer::Viewer(arguments);
viewer->setSceneData(browser.get());
viewer->setCameraManipulator(new osgGA::TrackballManipulator());
viewer->addEventHandler(new osgViewer::StatsHandler);
viewer->addEventHandler(new osgViewer::WindowSizeHandler);
if (useFrameLoopThread)
{
// create a thread to run the viewer's frame loop
ViewerFrameThread viewerThread(viewer.get(), true);
viewerThread.startThread();
// now start the standard Qt event loop, then exists when the viewerThead sends the QApplication::exit() signal.
return QApplication::exec();
}
else
{
// run the frame loop, interleaving Qt and the main OSG frame loop
while(!viewer->done())
{
// process Qt events - this handles both events and paints the browser image
QCoreApplication::processEvents(QEventLoop::AllEvents, 100);
viewer->frame();
}
return 0;
}
}

23
examples/osgQtWidgets/CMakeLists.txt
View File

@ -1,23 +0,0 @@
SET(TARGET_SRC
osgQtWidgets.cpp
)
IF(CMAKE_COMPILER_IS_GNUCXX)
# Remove -pedantic flag as it barfs on Qt headers
STRING(REGEX REPLACE "-pedantic" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
ENDIF()
if ( QT4_FOUND )
SET(TARGET_EXTERNAL_LIBRARIES ${QT_QTCORE_LIBRARY} ${QT_QTGUI_LIBRARY} ${QT_QTOPENGL_LIBRARY} ${QT_QTWEBKIT_LIBRARY})
INCLUDE_DIRECTORIES(${QT_INCLUDE_DIR} ${QT_QTCORE_INCLUDE_DIR} ${QT_QTOPENGL_INCLUDE_DIR} ${QT_QTGUI_INCLUDE_DIR} ${QT_QTWEBKIT_INCLUDE_DIR} )
endif( QT4_FOUND )
SET(TARGET_ADDED_LIBRARIES osgWidget osgQt)
#### end var setup ###
SET ( EXAMPLE_NAME osgQtWidgets )
SETUP_EXAMPLE(${EXAMPLE_NAME})
IF ( Qt5Widgets_FOUND )
qt5_use_modules( example_${EXAMPLE_NAME} OpenGL WebKitWidgets )
ENDIF( Qt5Widgets_FOUND )

512
examples/osgQtWidgets/osgQtWidgets.cpp
View File

File diff suppressed because one or more lines are too long

18
examples/osgqfont/CMakeLists.txt
View File

@ -1,18 +0,0 @@
#this file is automatically generated
ADD_DEFINITIONS(-DUSE_QT4)
SET(TARGET_SRC osgqfont.cpp )
SET(TARGET_ADDED_LIBRARIES osgQt osgText)
IF ( NOT Qt5Widgets_FOUND )
INCLUDE_DIRECTORIES( ${QT_INCLUDE_DIR} ${QT_QTCORE_INCLUDE_DIR} ${QT_QTGUI_INCLUDE_DIR} ${QT_QTOPENGL_INCLUDE_DIR} )
SET(TARGET_EXTERNAL_LIBRARIES ${QT_QTCORE_LIBRARY_RELEASE} ${QT_QTGUI_LIBRARY_RELEASE} ${QT_QTOPENGL_LIBRARY_RELEASE} )
ENDIF()
#### end var setup ###
SET ( EXAMPLE_NAME osgqfont )
SETUP_EXAMPLE(${EXAMPLE_NAME})
IF ( Qt5Widgets_FOUND )
qt5_use_modules( example_${EXAMPLE_NAME} Widgets OpenGL )
ENDIF( Qt5Widgets_FOUND )

564
examples/osgqfont/osgqfont.cpp
View File

@ -1,564 +0,0 @@
/* OpenSceneGraph example, osgtext.
*
* 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 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.
*/
#include <QApplication>
#include <QGridLayout>
#include <QWidget>
#include <osgQt/GraphicsWindowQt>
#include <osgQt/QFontImplementation>
#include <osgDB/ReadFile>
#include <osgDB/WriteFile>
#include <osgDB/Registry>
#include <osgGA/StateSetManipulator>
#include <osgGA/TrackballManipulator>
#include <osgViewer/CompositeViewer>
#include <osgViewer/ViewerEventHandlers>
#include <osg/Geode>
#include <osg/Camera>
#include <osg/ShapeDrawable>
#include <osg/Sequence>
#include <osg/PolygonMode>
#include <osgText/Font>
#include <osgText/Text>
osg::Group* createHUDText()
{
osg::Group* rootNode = new osg::Group;
osgText::Font* font = new osgText::Font(new osgQt::QFontImplementation(QFont("Arial")));
osg::Geode* geode = new osg::Geode;
rootNode->addChild(geode);
float windowHeight = 1024.0f;
float windowWidth = 1280.0f;
float margin = 50.0f;
////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Examples of how to set up different text layout
//
osg::Vec4 layoutColor(1.0f,1.0f,0.0f,1.0f);
float layoutCharacterSize = 20.0f;
{
osgText::Text* text = new osgText::Text;
text->setFont(font);
text->setColor(layoutColor);
text->setCharacterSize(layoutCharacterSize);
text->setPosition(osg::Vec3(margin,windowHeight-margin,0.0f));
// the default layout is left to right, typically used in languages
// originating from europe such as English, French, German, Spanish etc..
text->setLayout(osgText::Text::LEFT_TO_RIGHT);
text->setText("text->setLayout(osgText::Text::LEFT_TO_RIGHT);");
geode->addDrawable(text);
}
{
osgText::Text* text = new osgText::Text;
text->setFont(font);
text->setColor(layoutColor);
text->setCharacterSize(layoutCharacterSize);
text->setPosition(osg::Vec3(windowWidth-margin,windowHeight-margin,0.0f));
// right to left layouts would be used for hebrew or arabic fonts.
text->setLayout(osgText::Text::RIGHT_TO_LEFT);
text->setAlignment(osgText::Text::RIGHT_BASE_LINE);
text->setText("text->setLayout(osgText::Text::RIGHT_TO_LEFT);");
geode->addDrawable(text);
}
{
osgText::Text* text = new osgText::Text;
text->setFont(font);
text->setColor(layoutColor);
text->setPosition(osg::Vec3(margin,windowHeight-margin,0.0f));
text->setCharacterSize(layoutCharacterSize);
// vertical font layout would be used for asian fonts.
text->setLayout(osgText::Text::VERTICAL);
text->setText("text->setLayout(osgText::Text::VERTICAL);");
geode->addDrawable(text);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Examples of how to set up different font resolution
//
osg::Vec4 fontSizeColor(0.0f,1.0f,1.0f,1.0f);
float fontSizeCharacterSize = 30;
osg::Vec3 cursor = osg::Vec3(margin*2,windowHeight-margin*2,0.0f);
{
osgText::Text* text = new osgText::Text;
text->setFont(font);
text->setColor(fontSizeColor);
text->setCharacterSize(fontSizeCharacterSize);
text->setPosition(cursor);
// use text that uses 10 by 10 texels as a target resolution for fonts.
text->setFontResolution(10,10); // blocky but small texture memory usage
text->setText("text->setFontResolution(10,10); // blocky but small texture memory usage");
geode->addDrawable(text);
}
cursor.y() -= fontSizeCharacterSize;
{
osgText::Text* text = new osgText::Text;
text->setFont(font);
text->setColor(fontSizeColor);
text->setCharacterSize(fontSizeCharacterSize);
text->setPosition(cursor);
// use text that uses 20 by 20 texels as a target resolution for fonts.
text->setFontResolution(20,20); // smoother but higher texture memory usage (but still quite low).
text->setText("text->setFontResolution(20,20); // smoother but higher texture memory usage (but still quite low).");
geode->addDrawable(text);
}
cursor.y() -= fontSizeCharacterSize;
{
osgText::Text* text = new osgText::Text;
text->setFont(font);
text->setColor(fontSizeColor);
text->setCharacterSize(fontSizeCharacterSize);
text->setPosition(cursor);
// use text that uses 40 by 40 texels as a target resolution for fonts.
text->setFontResolution(40,40); // even smoother but again higher texture memory usage.
text->setText("text->setFontResolution(40,40); // even smoother but again higher texture memory usage.");
geode->addDrawable(text);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Examples of how to set up different sized text
//
osg::Vec4 characterSizeColor(1.0f,0.0f,1.0f,1.0f);
cursor.y() -= fontSizeCharacterSize*2.0f;
{
osgText::Text* text = new osgText::Text;
text->setFont(font);
text->setColor(characterSizeColor);
text->setFontResolution(20,20);
text->setPosition(cursor);
// use text that is 20 units high.
text->setCharacterSize(20); // small
text->setText("text->setCharacterSize(20.0f); // small");
geode->addDrawable(text);
}
cursor.y() -= 30.0f;
{
osgText::Text* text = new osgText::Text;
text->setFont(font);
text->setColor(characterSizeColor);
text->setFontResolution(30,30);
text->setPosition(cursor);
// use text that is 30 units high.
text->setCharacterSize(30.0f); // medium
text->setText("text->setCharacterSize(30.0f); // medium");
geode->addDrawable(text);
}
cursor.y() -= 50.0f;
{
osgText::Text* text = new osgText::Text;
text->setFont(font);
text->setColor(characterSizeColor);
text->setFontResolution(40,40);
text->setPosition(cursor);
// use text that is 60 units high.
text->setCharacterSize(60.0f); // large
text->setText("text->setCharacterSize(60.0f); // large");
geode->addDrawable(text);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Examples of how to set up different alignments
//
osg::Vec4 alignmentSizeColor(0.0f,1.0f,0.0f,1.0f);
float alignmentCharacterSize = 25.0f;
cursor.x() = 640;
cursor.y() = margin*4.0f;
typedef std::pair<osgText::Text::AlignmentType,std::string> AlignmentPair;
typedef std::vector<AlignmentPair> AlignmentList;
AlignmentList alignmentList;
alignmentList.push_back(AlignmentPair(osgText::Text::LEFT_TOP,"text->setAlignment(\nosgText::Text::LEFT_TOP);"));
alignmentList.push_back(AlignmentPair(osgText::Text::LEFT_CENTER,"text->setAlignment(\nosgText::Text::LEFT_CENTER);"));
alignmentList.push_back(AlignmentPair(osgText::Text::LEFT_BOTTOM,"text->setAlignment(\nosgText::Text::LEFT_BOTTOM);"));
alignmentList.push_back(AlignmentPair(osgText::Text::CENTER_TOP,"text->setAlignment(\nosgText::Text::CENTER_TOP);"));
alignmentList.push_back(AlignmentPair(osgText::Text::CENTER_CENTER,"text->setAlignment(\nosgText::Text::CENTER_CENTER);"));
alignmentList.push_back(AlignmentPair(osgText::Text::CENTER_BOTTOM,"text->setAlignment(\nosgText::Text::CENTER_BOTTOM);"));
alignmentList.push_back(AlignmentPair(osgText::Text::RIGHT_TOP,"text->setAlignment(\nosgText::Text::RIGHT_TOP);"));
alignmentList.push_back(AlignmentPair(osgText::Text::RIGHT_CENTER,"text->setAlignment(\nosgText::Text::RIGHT_CENTER);"));
alignmentList.push_back(AlignmentPair(osgText::Text::RIGHT_BOTTOM,"text->setAlignment(\nosgText::Text::RIGHT_BOTTOM);"));
alignmentList.push_back(AlignmentPair(osgText::Text::LEFT_BASE_LINE,"text->setAlignment(\nosgText::Text::LEFT_BASE_LINE);"));
alignmentList.push_back(AlignmentPair(osgText::Text::CENTER_BASE_LINE,"text->setAlignment(\nosgText::Text::CENTER_BASE_LINE);"));
alignmentList.push_back(AlignmentPair(osgText::Text::RIGHT_BASE_LINE,"text->setAlignment(\nosgText::Text::RIGHT_BASE_LINE);"));
alignmentList.push_back(AlignmentPair(osgText::Text::LEFT_BOTTOM_BASE_LINE,"text->setAlignment(\nosgText::Text::LEFT_BOTTOM_BASE_LINE);"));
alignmentList.push_back(AlignmentPair(osgText::Text::CENTER_BOTTOM_BASE_LINE,"text->setAlignment(\nosgText::Text::CENTER_BOTTOM_BASE_LINE);"));
alignmentList.push_back(AlignmentPair(osgText::Text::RIGHT_BOTTOM_BASE_LINE,"text->setAlignment(\nosgText::Text::RIGHT_BOTTOM_BASE_LINE);"));
osg::Sequence* sequence = new osg::Sequence;
{
for(AlignmentList::iterator itr=alignmentList.begin();
itr!=alignmentList.end();
++itr)
{
osg::Geode* alignmentGeode = new osg::Geode;
sequence->addChild(alignmentGeode);
sequence->setTime(sequence->getNumChildren(), 1.0f);
osgText::Text* text = new osgText::Text;
text->setFont(font);
text->setColor(alignmentSizeColor);
text->setCharacterSize(alignmentCharacterSize);
text->setPosition(cursor);
text->setDrawMode(osgText::Text::TEXT|osgText::Text::ALIGNMENT|osgText::Text::BOUNDINGBOX);
text->setAlignment(itr->first);
text->setText(itr->second);
alignmentGeode->addDrawable(text);
}
}
sequence->setMode(osg::Sequence::START);
sequence->setInterval(osg::Sequence::LOOP, 0, -1);
sequence->setDuration(1.0f, -1);
rootNode->addChild(sequence);
////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Examples of how to set up different fonts...
//
cursor.x() = margin*2.0f;
cursor.y() = margin*2.0f;
osg::Vec4 fontColor(1.0f,0.5f,0.0f,1.0f);
float fontCharacterSize = 20.0f;
float spacing = 40.0f;
{
osgText::Text* text = new osgText::Text;
text->setColor(fontColor);
text->setPosition(cursor);
text->setCharacterSize(fontCharacterSize);
text->setFont(0);
text->setText("text->setFont(0); // inbuilt font.");
geode->addDrawable(text);
cursor.x() = text->getBoundingBox().xMax() + spacing ;
}
{
osgText::Font* arial = new osgText::Font(new osgQt::QFontImplementation(QFont("Arial")));
osgText::Text* text = new osgText::Text;
text->setColor(fontColor);
text->setPosition(cursor);
text->setCharacterSize(fontCharacterSize);
text->setFont(arial);
text->setText(arial!=0?
"text->setFont(\"fonts/arial.ttf\");":
"unable to load \"fonts/arial.ttf\"");
geode->addDrawable(text);
cursor.x() = text->getBoundingBox().xMax() + spacing ;
}
{
osgText::Font* times = new osgText::Font(new osgQt::QFontImplementation(QFont("Times")));
osgText::Text* text = new osgText::Text;
text->setColor(fontColor);
text->setPosition(cursor);
text->setCharacterSize(fontCharacterSize);
geode->addDrawable(text);
text->setFont(times);
text->setText(times!=0?
"text->setFont(\"fonts/times.ttf\");":
"unable to load \"fonts/times.ttf\"");
cursor.x() = text->getBoundingBox().xMax() + spacing ;
}
cursor.x() = margin*2.0f;
cursor.y() = margin;
{
osgText::Font* dirtydoz = new osgText::Font(new osgQt::QFontImplementation(QFont("Times")));
osgText::Text* text = new osgText::Text;
text->setColor(fontColor);
text->setPosition(cursor);
text->setCharacterSize(fontCharacterSize);
text->setFont(dirtydoz);
text->setText(dirtydoz!=0?
"text->setFont(\"fonts/dirtydoz.ttf\");":
"unable to load \"fonts/dirtydoz.ttf\"");
geode->addDrawable(text);
cursor.x() = text->getBoundingBox().xMax() + spacing ;
}
{
osgText::Font* fudd = new osgText::Font(new osgQt::QFontImplementation(QFont("Times")));
osgText::Text* text = new osgText::Text;
text->setColor(fontColor);
text->setPosition(cursor);
text->setCharacterSize(fontCharacterSize);
text->setFont(fudd);
text->setText(fudd!=0?
"text->setFont(\"fonts/fudd.ttf\");":
"unable to load \"fonts/fudd.ttf\"");
geode->addDrawable(text);
cursor.x() = text->getBoundingBox().xMax() + spacing ;
}
return rootNode;
}
// create text which sits in 3D space such as would be inserted into a normal model
osg::Group* create3DText(const osg::Vec3& center,float radius)
{
osg::Geode* geode = new osg::Geode;
////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Examples of how to set up axis/orientation alignments
//
float characterSize=radius*0.2f;
osg::Vec3 pos(center.x()-radius*.5f,center.y()-radius*.5f,center.z()-radius*.5f);
osgText::Text* text1 = new osgText::Text;
text1->setFont(new osgText::Font(new osgQt::QFontImplementation(QFont("Times"))));
text1->setCharacterSize(characterSize);
text1->setPosition(pos);
text1->setAxisAlignment(osgText::Text::XY_PLANE);
text1->setText("XY_PLANE");
geode->addDrawable(text1);
osgText::Text* text2 = new osgText::Text;
text2->setFont(new osgText::Font(new osgQt::QFontImplementation(QFont("Times"))));
text2->setCharacterSize(characterSize);
text2->setPosition(pos);
text2->setAxisAlignment(osgText::Text::YZ_PLANE);
text2->setText("YZ_PLANE");
geode->addDrawable(text2);
osgText::Text* text3 = new osgText::Text;
text3->setFont(new osgText::Font(new osgQt::QFontImplementation(QFont("Times"))));
text3->setCharacterSize(characterSize);
text3->setPosition(pos);
text3->setAxisAlignment(osgText::Text::XZ_PLANE);
text3->setText("XZ_PLANE");
geode->addDrawable(text3);
osgText::Text* text4 = new osgText::Text;
text4->setFont(new osgText::Font(new osgQt::QFontImplementation(QFont("Times"))));
text4->setCharacterSize(characterSize);
text4->setPosition(center);
text4->setAxisAlignment(osgText::Text::SCREEN);
osg::Vec4 characterSizeModeColor(1.0f,0.0f,0.5f,1.0f);
osgText::Text* text5 = new osgText::Text;
text5->setColor(characterSizeModeColor);
text5->setFont(new osgText::Font(new osgQt::QFontImplementation(QFont("Times"))));
//text5->setCharacterSize(characterSize);
text5->setCharacterSize(32.0f); // medium
text5->setPosition(center - osg::Vec3(0.0, 0.0, 0.2));
text5->setAxisAlignment(osgText::Text::SCREEN);
text5->setCharacterSizeMode(osgText::Text::SCREEN_COORDS);
text5->setText("CharacterSizeMode SCREEN_COORDS(size 32.0)");
geode->addDrawable(text5);
osgText::Text* text6 = new osgText::Text;
text6->setColor(characterSizeModeColor);
text6->setFont(new osgText::Font(new osgQt::QFontImplementation(QFont("Times"))));
text6->setCharacterSize(characterSize);
text6->setPosition(center - osg::Vec3(0.0, 0.0, 0.4));
text6->setAxisAlignment(osgText::Text::SCREEN);
text6->setCharacterSizeMode(osgText::Text::OBJECT_COORDS_WITH_MAXIMUM_SCREEN_SIZE_CAPPED_BY_FONT_HEIGHT);
text6->setText("CharacterSizeMode OBJECT_COORDS_WITH_MAXIMUM_SCREEN_SIZE_CAPPED_BY_FONT_HEIGHT");
geode->addDrawable(text6);
osgText::Text* text7 = new osgText::Text;
text7->setColor(characterSizeModeColor);
text7->setFont(new osgText::Font(new osgQt::QFontImplementation(QFont("Times"))));
text7->setCharacterSize(characterSize);
text7->setPosition(center - osg::Vec3(0.0, 0.0, 0.6));
text7->setAxisAlignment(osgText::Text::SCREEN);
text7->setCharacterSizeMode(osgText::Text::OBJECT_COORDS);
text7->setText("CharacterSizeMode OBJECT_COORDS (default)");
geode->addDrawable(text7);
#if 1
// reproduce outline bounding box compute problem with backdrop on.
text4->setBackdropType(osgText::Text::OUTLINE);
text4->setDrawMode(osgText::Text::TEXT | osgText::Text::BOUNDINGBOX);
#endif
text4->setText("SCREEN");
geode->addDrawable(text4);
osg::ShapeDrawable* shape = new osg::ShapeDrawable(new osg::Sphere(center,characterSize*0.2f));
shape->getOrCreateStateSet()->setMode(GL_LIGHTING,osg::StateAttribute::ON);
geode->addDrawable(shape);
osg::Group* rootNode = new osg::Group;
rootNode->addChild(geode);
return rootNode;
}
class MainWindow : public QWidget {
public:
MainWindow()
{
osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits(osg::DisplaySettings::instance().get());
traits->width = width();
traits->height = height();
traits->doubleBuffer = true;
osgQt::GraphicsWindowQt* graphicsWindow = new osgQt::GraphicsWindowQt(traits.get());
QGridLayout* grid = new QGridLayout;
grid->setMargin(0);
grid->addWidget(graphicsWindow->getGLWidget(), 0, 0);
setLayout(grid);
_viewer.setThreadingModel(osgViewer::Viewer::SingleThreaded);
osg::Camera* camera = _viewer.getCamera();
camera->setGraphicsContext(graphicsWindow);
camera->setViewport(new osg::Viewport(0, 0, width(), height()));
startTimer(10);
}
virtual void paintEvent(QPaintEvent* /*event*/)
{
_viewer.frame();
}
virtual void timerEvent(QTimerEvent* /*event*/)
{
_viewer.frame();
}
void setSceneData(osg::Node* node)
{
_viewer.setSceneData(node);
}
void setCameraManipulator(osgGA::CameraManipulator* manipulator, bool resetPosition = true)
{
_viewer.setCameraManipulator(manipulator, resetPosition);
}
private:
osgViewer::Viewer _viewer;
};
int main(int argc, char** argv)
{
QApplication app(argc, argv);
// prepare scene.
osg::Vec3 center(0.0f,0.0f,0.0f);
float radius = 1.0f;
// create the hud.
osg::ref_ptr<osg::Camera> camera = new osg::Camera;
camera->setReferenceFrame(osg::Transform::ABSOLUTE_RF);
camera->setProjectionMatrixAsOrtho2D(0,1280,0,1024);
camera->setViewMatrix(osg::Matrix::identity());
camera->setClearMask(GL_DEPTH_BUFFER_BIT);
camera->addChild(createHUDText());
camera->getOrCreateStateSet()->setMode(GL_LIGHTING,osg::StateAttribute::OFF);
// make sure the root node is group so we can add extra nodes to it.
osg::ref_ptr<osg::Group> group = new osg::Group;
group->addChild(camera.get());
group->addChild(create3DText(center, radius));
// The qt window
MainWindow widget;
// set the scene to render
widget.setSceneData(group.get());
widget.setCameraManipulator(new osgGA::TrackballManipulator);
widget.setGeometry(100, 100, 800, 600);
widget.show();
return app.exec();
}

27
examples/osgviewerQt/CMakeLists.txt
View File

@ -1,27 +0,0 @@
SET( TARGET_SRC
osgviewerQt.cpp
)
IF ( NOT Qt5Widgets_FOUND )
IF( QT4_FOUND )
SET(TARGET_EXTERNAL_LIBRARIES ${QT_QTCORE_LIBRARY_RELEASE} ${QT_QTGUI_LIBRARY_RELEASE}
${QT_QTOPENGL_LIBRARY_RELEASE} )
ADD_DEFINITIONS(-DUSE_QT4)
ELSE( QT4_FOUND )
SET(TARGET_EXTERNAL_LIBRARIES ${QT_LIBRARIES} )
ENDIF( QT4_FOUND )
INCLUDE_DIRECTORIES( ${QT_INCLUDE_DIR} ${QT_QTCORE_INCLUDE_DIR} ${QT_QTGUI_INCLUDE_DIR}
${QT_QTOPENGL_INCLUDE_DIR} )
ENDIF()
SET(TARGET_ADDED_LIBRARIES osgWidget osgQt)
SET( EXAMPLE_NAME osgviewerQt )
SETUP_EXAMPLE( ${EXAMPLE_NAME} )
IF ( Qt5Widgets_FOUND )
qt5_use_modules( example_${EXAMPLE_NAME} Widgets OpenGL )
ENDIF( Qt5Widgets_FOUND )

119
examples/osgviewerQt/osgviewerQt.cpp
View File

@ -1,119 +0,0 @@
#include <QTimer>
#include <QApplication>
#include <QGridLayout>
#include <osgViewer/CompositeViewer>
#include <osgViewer/ViewerEventHandlers>
#include <osgGA/MultiTouchTrackballManipulator>
#include <osgDB/ReadFile>
#include <osgQt/GraphicsWindowQt>
#include <iostream>
class ViewerWidget : public QWidget, public osgViewer::CompositeViewer
{
public:
ViewerWidget(QWidget* parent = 0, Qt::WindowFlags f = 0, osgViewer::ViewerBase::ThreadingModel threadingModel=osgViewer::CompositeViewer::SingleThreaded) : QWidget(parent, f)
{
setThreadingModel(threadingModel);
// disable the default setting of viewer.done() by pressing Escape.
setKeyEventSetsDone(0);
QWidget* widget1 = addViewWidget( createGraphicsWindow(0,0,100,100), osgDB::readRefNodeFile("cow.osgt") );
QWidget* widget2 = addViewWidget( createGraphicsWindow(0,0,100,100), osgDB::readRefNodeFile("glider.osgt") );
QWidget* widget3 = addViewWidget( createGraphicsWindow(0,0,100,100), osgDB::readRefNodeFile("axes.osgt") );
QWidget* widget4 = addViewWidget( createGraphicsWindow(0,0,100,100), osgDB::readRefNodeFile("fountain.osgt") );
QWidget* popupWidget = addViewWidget( createGraphicsWindow(900,100,320,240,"Popup window",true), osgDB::readRefNodeFile("dumptruck.osgt") );
popupWidget->show();
QGridLayout* grid = new QGridLayout;
grid->addWidget( widget1, 0, 0 );
grid->addWidget( widget2, 0, 1 );
grid->addWidget( widget3, 1, 0 );
grid->addWidget( widget4, 1, 1 );
setLayout( grid );
connect( &_timer, SIGNAL(timeout()), this, SLOT(update()) );
_timer.start( 10 );
}
QWidget* addViewWidget( osgQt::GraphicsWindowQt* gw, osg::ref_ptr<osg::Node> scene )
{
osgViewer::View* view = new osgViewer::View;
addView( view );
osg::Camera* camera = view->getCamera();
camera->setGraphicsContext( gw );
const osg::GraphicsContext::Traits* traits = gw->getTraits();
camera->setClearColor( osg::Vec4(0.2, 0.2, 0.6, 1.0) );
camera->setViewport( new osg::Viewport(0, 0, traits->width, traits->height) );
camera->setProjectionMatrixAsPerspective(30.0f, static_cast<double>(traits->width)/static_cast<double>(traits->height), 1.0f, 10000.0f );
view->setSceneData( scene );
view->addEventHandler( new osgViewer::StatsHandler );
view->setCameraManipulator( new osgGA::MultiTouchTrackballManipulator );
gw->setTouchEventsEnabled( true );
return gw->getGLWidget();
}
osgQt::GraphicsWindowQt* createGraphicsWindow( int x, int y, int w, int h, const std::string& name="", bool windowDecoration=false )
{
osg::DisplaySettings* ds = osg::DisplaySettings::instance().get();
osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits;
traits->windowName = name;
traits->windowDecoration = windowDecoration;
traits->x = x;
traits->y = y;
traits->width = w;
traits->height = h;
traits->doubleBuffer = true;
traits->alpha = ds->getMinimumNumAlphaBits();
traits->stencil = ds->getMinimumNumStencilBits();
traits->sampleBuffers = ds->getMultiSamples();
traits->samples = ds->getNumMultiSamples();
return new osgQt::GraphicsWindowQt(traits.get());
}
virtual void paintEvent( QPaintEvent* /*event*/ )
{ frame(); }
protected:
QTimer _timer;
};
int main( int argc, char** argv )
{
osg::ArgumentParser arguments(&argc, argv);
#if QT_VERSION >= 0x050000
// Qt5 is currently crashing and reporting "Cannot make QOpenGLContext current in a different thread" when the viewer is run multi-threaded, this is regression from Qt4
osgViewer::ViewerBase::ThreadingModel threadingModel = osgViewer::ViewerBase::SingleThreaded;
#else
osgViewer::ViewerBase::ThreadingModel threadingModel = osgViewer::ViewerBase::CullDrawThreadPerContext;
#endif
while (arguments.read("--SingleThreaded")) threadingModel = osgViewer::ViewerBase::SingleThreaded;
while (arguments.read("--CullDrawThreadPerContext")) threadingModel = osgViewer::ViewerBase::CullDrawThreadPerContext;
while (arguments.read("--DrawThreadPerContext")) threadingModel = osgViewer::ViewerBase::DrawThreadPerContext;
while (arguments.read("--CullThreadPerCameraDrawThreadPerContext")) threadingModel = osgViewer::ViewerBase::CullThreadPerCameraDrawThreadPerContext;
#if QT_VERSION >= 0x040800
// Required for multithreaded QGLWidget on Linux/X11, see http://blog.qt.io/blog/2011/06/03/threaded-opengl-in-4-8/
if (threadingModel != osgViewer::ViewerBase::SingleThreaded)
QApplication::setAttribute(Qt::AA_X11InitThreads);
#endif
QApplication app(argc, argv);
ViewerWidget* viewWidget = new ViewerWidget(0, Qt::Widget, threadingModel);
viewWidget->setGeometry( 100, 100, 800, 600 );
viewWidget->show();
return app.exec();
}

52
include/osgQt/Export
View File

@ -1,52 +0,0 @@
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
*
* This library is open source and may be redistributed and/or modified under
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
* (at your option) any later version. The full license is in LICENSE file
* included with this distribution, and on the openscenegraph.org website.
*
* This library 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
* OpenSceneGraph Public License for more details.
*/
// The following symbol has a underscore suffix for compatibility.
#ifndef OSGQT_EXPORT_
#define OSGQT_EXPORT_ 1
#include<osg/Config>
#if defined(_MSC_VER) && defined(OSG_DISABLE_MSVC_WARNINGS)
#pragma warning( disable : 4244 )
#pragma warning( disable : 4251 )
#pragma warning( disable : 4267 )
#pragma warning( disable : 4275 )
#pragma warning( disable : 4290 )
#pragma warning( disable : 4786 )
#pragma warning( disable : 4305 )
#pragma warning( disable : 4996 )
#endif
#if defined(_MSC_VER) || defined(__CYGWIN__) || defined(__MINGW32__) || defined( __BCPLUSPLUS__) || defined( __MWERKS__)
# if defined( OSG_LIBRARY_STATIC )
# define OSGQT_EXPORT
# elif defined( OSGQT_LIBRARY )
# define OSGQT_EXPORT __declspec(dllexport)
# else
# define OSGQT_EXPORT __declspec(dllimport)
#endif
#else
#define OSGQT_EXPORT
#endif
#endif
/**
\namespace osgQt
The osgQt utility library provides various classes to aid the integration of OpenSceneGraph and Qt.
*/

195
include/osgQt/GraphicsWindowQt
View File

@ -1,195 +0,0 @@
/* -*-c++-*- OpenSceneGraph - Copyright (C) 2009 Wang Rui
*
* This library is open source and may be redistributed and/or modified under
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
* (at your option) any later version. The full license is in LICENSE file
* included with this distribution, and on the openscenegraph.org website.
*
* This library 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
* OpenSceneGraph Public License for more details.
*/
#ifndef OSGVIEWER_GRAPHICSWINDOWQT
#define OSGVIEWER_GRAPHICSWINDOWQT
#include <osgViewer/GraphicsWindow>
#include <osgQt/Export>
#include <osgQt/Version>
#include <QMutex>
#include <QEvent>
#include <QQueue>
#include <QSet>
#include <QGLWidget>
class QInputEvent;
class QGestureEvent;
namespace osgViewer {
class ViewerBase;
}
namespace osgQt
{
// forward declarations
class GraphicsWindowQt;
#if 0
/// The function sets the WindowingSystem to Qt.
void OSGQT_EXPORT initQtWindowingSystem();
#endif
/** The function sets the viewer that will be used after entering
* the Qt main loop (QCoreApplication::exec()).
*
* The function also initializes internal structures required for proper
* scene rendering.
*
* The method must be called from main thread. */
void OSGQT_EXPORT setViewer( osgViewer::ViewerBase *viewer );
class OSGQT_EXPORT GLWidget : public QGLWidget
{
typedef QGLWidget inherited;
public:
GLWidget( QWidget* parent = NULL, const QGLWidget* shareWidget = NULL, Qt::WindowFlags f = 0, bool forwardKeyEvents = false );
GLWidget( QGLContext* context, QWidget* parent = NULL, const QGLWidget* shareWidget = NULL, Qt::WindowFlags f = 0, bool forwardKeyEvents = false );
GLWidget( const QGLFormat& format, QWidget* parent = NULL, const QGLWidget* shareWidget = NULL, Qt::WindowFlags f = 0, bool forwardKeyEvents = false );
virtual ~GLWidget();
inline void setGraphicsWindow( GraphicsWindowQt* gw ) { _gw = gw; }
inline GraphicsWindowQt* getGraphicsWindow() { return _gw; }
inline const GraphicsWindowQt* getGraphicsWindow() const { return _gw; }
inline bool getForwardKeyEvents() const { return _forwardKeyEvents; }
virtual void setForwardKeyEvents( bool f ) { _forwardKeyEvents = f; }
inline bool getTouchEventsEnabled() const { return _touchEventsEnabled; }
void setTouchEventsEnabled( bool e );
void setKeyboardModifiers( QInputEvent* event );
virtual void keyPressEvent( QKeyEvent* event );
virtual void keyReleaseEvent( QKeyEvent* event );
virtual void mousePressEvent( QMouseEvent* event );
virtual void mouseReleaseEvent( QMouseEvent* event );
virtual void mouseDoubleClickEvent( QMouseEvent* event );
virtual void mouseMoveEvent( QMouseEvent* event );
virtual void wheelEvent( QWheelEvent* event );
virtual bool gestureEvent( QGestureEvent* event );
protected:
int getNumDeferredEvents()
{
QMutexLocker lock(&_deferredEventQueueMutex);
return _deferredEventQueue.count();
}
void enqueueDeferredEvent(QEvent::Type eventType, QEvent::Type removeEventType = QEvent::None)
{
QMutexLocker lock(&_deferredEventQueueMutex);
if (removeEventType != QEvent::None)
{
if (_deferredEventQueue.removeOne(removeEventType))
_eventCompressor.remove(eventType);
}
if (_eventCompressor.find(eventType) == _eventCompressor.end())
{
_deferredEventQueue.enqueue(eventType);
_eventCompressor.insert(eventType);
}
}
void processDeferredEvents();
friend class GraphicsWindowQt;
GraphicsWindowQt* _gw;
QMutex _deferredEventQueueMutex;
QQueue<QEvent::Type> _deferredEventQueue;
QSet<QEvent::Type> _eventCompressor;
bool _touchEventsEnabled;
bool _forwardKeyEvents;
qreal _devicePixelRatio;
virtual void resizeEvent( QResizeEvent* event );
virtual void moveEvent( QMoveEvent* event );
virtual void glDraw();
virtual bool event( QEvent* event );
};
class OSGQT_EXPORT GraphicsWindowQt : public osgViewer::GraphicsWindow
{
public:
GraphicsWindowQt( osg::GraphicsContext::Traits* traits, QWidget* parent = NULL, const QGLWidget* shareWidget = NULL, Qt::WindowFlags f = 0 );
GraphicsWindowQt( GLWidget* widget );
virtual ~GraphicsWindowQt();
inline GLWidget* getGLWidget() { return _widget; }
inline const GLWidget* getGLWidget() const { return _widget; }
/// deprecated
inline GLWidget* getGraphWidget() { return _widget; }
/// deprecated
inline const GLWidget* getGraphWidget() const { return _widget; }
struct WindowData : public osg::Referenced
{
WindowData( GLWidget* widget = NULL, QWidget* parent = NULL ): _widget(widget), _parent(parent) {}
GLWidget* _widget;
QWidget* _parent;
};
bool init( QWidget* parent, const QGLWidget* shareWidget, Qt::WindowFlags f );
static QGLFormat traits2qglFormat( const osg::GraphicsContext::Traits* traits );
static void qglFormat2traits( const QGLFormat& format, osg::GraphicsContext::Traits* traits );
static osg::GraphicsContext::Traits* createTraits( const QGLWidget* widget );
virtual bool setWindowRectangleImplementation( int x, int y, int width, int height );
virtual void getWindowRectangle( int& x, int& y, int& width, int& height );
virtual bool setWindowDecorationImplementation( bool windowDecoration );
virtual bool getWindowDecoration() const;
virtual void grabFocus();
virtual void grabFocusIfPointerInWindow();
virtual void raiseWindow();
virtual void setWindowName( const std::string& name );
virtual std::string getWindowName();
virtual void useCursor( bool cursorOn );
virtual void setCursor( MouseCursor cursor );
inline bool getTouchEventsEnabled() const { return _widget->getTouchEventsEnabled(); }
virtual void setTouchEventsEnabled( bool e ) { _widget->setTouchEventsEnabled(e); }
virtual bool valid() const;
virtual bool realizeImplementation();
virtual bool isRealizedImplementation() const;
virtual void closeImplementation();
virtual bool makeCurrentImplementation();
virtual bool releaseContextImplementation();
virtual void swapBuffersImplementation();
virtual void runOperations();
virtual void requestWarpPointer( float x, float y );
protected:
friend class GLWidget;
GLWidget* _widget;
bool _ownsWidget;
QCursor _currentCursor;
bool _realized;
};
}
#endif

52
include/osgQt/QFontImplementation
View File

@ -1,52 +0,0 @@
/* -*-c++-*- OpenSceneGraph - Copyright (C) 2009-2010 Mathias Froehlich
*
* This library is open source and may be redistributed and/or modified under
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
* (at your option) any later version. The full license is in LICENSE file
* included with this distribution, and on the openscenegraph.org website.
*
* This library 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
* OpenSceneGraph Public License for more details.
*/
#ifndef QFontImplementation_H
#define QFontImplementation_H
#include <osgText/Font>
#include <osgQt/Export>
#include <osgQt/Version>
#include <QtGui/QFont>
#include <string>
namespace osgQt {
class OSGQT_EXPORT QFontImplementation : public osgText::Font::FontImplementation
{
public:
QFontImplementation(const QFont& font);
virtual ~QFontImplementation();
virtual std::string getFileName() const;
virtual bool supportsMultipleFontResolutions() const { return true; }
virtual osgText::Glyph* getGlyph(const osgText::FontResolution& fontRes, unsigned int charcode);
virtual osgText::Glyph3D* getGlyph3D(const osgText::FontResolution& /*fontRes*/, unsigned int /*charcode*/) { return 0; }
virtual osg::Vec2 getKerning(const osgText::FontResolution& fontRes, unsigned int leftcharcode, unsigned int rightcharcode, osgText::KerningType kerningType);
virtual bool hasVertical() const;
protected:
std::string _filename;
QFont _font;
};
}
#endif

124
include/osgQt/QGraphicsViewAdapter
View File

@ -1,124 +0,0 @@
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2009 Robert Osfield
*
* This library is open source and may be redistributed and/or modified under
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
* (at your option) any later version. The full license is in LICENSE file
* included with this distribution, and on the openscenegraph.org website.
*
* This library 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
* OpenSceneGraph Public License for more details.
*/
#ifndef QGRAPHICSVIEWADAPTER
#define QGRAPHICSVIEWADAPTER
#include <QGLWidget>
#include <osg/Image>
#include <osg/observer_ptr>
#include <osgQt/Export>
#include <osgQt/Version>
#include <QPointer>
#include <QGraphicsScene>
#include <QGraphicsView>
#include <QApplication>
#include <QPainter>
#include <QtEvents>
namespace osgQt
{
extern OSGQT_EXPORT QCoreApplication* getOrCreateQApplication();
class OSGQT_EXPORT QGraphicsViewAdapter : public QObject
{
Q_OBJECT
public:
QGraphicsViewAdapter(osg::Image* image, QWidget* widget);
void setUpKeyMap();
bool sendPointerEvent(int x, int y, int buttonMask);
bool sendKeyEvent(int key, bool keyDown);
void setFrameLastRendered(const osg::FrameStamp* frameStamp);
void clearWriteBuffer();
bool requiresRendering() const { return _requiresRendering; }
void render();
void assignImage(unsigned int i);
void resize(int width, int height);
void setBackgroundColor(QColor color) { _backgroundColor = color; }
QColor getBackgroundColor() const { return _backgroundColor; }
/** The 'background widget' will ignore mouse/keyboard events and let following handlers handle them
It is mainly used for integrating scene graph and full-screen UIs
*/
void setBackgroundWidget(QWidget* w) { _backgroundWidget = w; }
QWidget* getBackgroundWidget() { return _backgroundWidget; }
QGraphicsView* getQGraphicsView() { return _graphicsView; }
QGraphicsScene* getQGraphicsScene() { return _graphicsScene; }
protected:
bool handlePointerEvent(int x, int y, int buttonMask);
bool handleKeyEvent(int key, bool keyDown);
QWidget* getWidgetAt(const QPoint& pos);
osg::observer_ptr<osg::Image> _image;
QWidget* _backgroundWidget;
int _previousButtonMask;
int _previousMouseX;
int _previousMouseY;
int _previousQtMouseX;
int _previousQtMouseY;
bool _previousSentEvent;
bool _requiresRendering;
int _width;
int _height;
typedef std::map<int, Qt::Key> KeyMap;
KeyMap _keyMap;
Qt::KeyboardModifiers _qtKeyModifiers;
QColor _backgroundColor;
QPointer<QGraphicsView> _graphicsView;
QPointer<QGraphicsScene> _graphicsScene;
QPointer<QWidget> _widget;
OpenThreads::Mutex _qimagesMutex;
OpenThreads::Mutex _qresizeMutex;
unsigned int _previousFrameNumber;
bool _newImageAvailable;
unsigned int _currentRead;
unsigned int _currentWrite;
unsigned int _previousWrite;
QImage _qimages[3];
virtual void customEvent ( QEvent * event ) ;
private slots:
void repaintRequestedSlot(const QList<QRectF> &regions);
void repaintRequestedSlot(const QRectF &region);
};
}
#endif

109
include/osgQt/QWebViewImage
View File

@ -1,109 +0,0 @@
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2009 Robert Osfield
*
* This library is open source and may be redistributed and/or modified under
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
* (at your option) any later version. The full license is in LICENSE file
* included with this distribution, and on the openscenegraph.org website.
*
* This library 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
* OpenSceneGraph Public License for more details.
*/
#ifndef QWEBVIEWIMAGE
#define QWEBVIEWIMAGE
// make sure this header isn't built as par of osgQt, leaving it to applications to build
#if !defined(OSGQT_LIBRARY) && !defined(OSG_LIBRARY_STATIC)
#if QT_VERSION >= 0x050000
# include <QtWebKitWidgets>
#else
# include <QtWebKit>
#endif
#include <osgWidget/Browser>
#include <osgQt/QGraphicsViewAdapter>
#include <osgQt/Version>
namespace osgQt
{
class QWebViewImage : public osgWidget::BrowserImage
{
public:
QWebViewImage()
{
// make sure we have a valid QApplication before we start creating widgets.
getOrCreateQApplication();
_webView = new QWebView;
_webPage = new QWebPage;
_webPage->settings()->setAttribute(QWebSettings::JavascriptEnabled, true);
_webPage->settings()->setAttribute(QWebSettings::PluginsEnabled, true);
_webView->setPage(_webPage);
_adapter = new QGraphicsViewAdapter(this, _webView.data());
}
virtual void navigateTo(const std::string& url)
{
_webView->load(QUrl(url.c_str()));
}
QWebView* getQWebView() { return _webView; }
QWebPage* getQWebPage() { return _webPage; }
QGraphicsViewAdapter* getQGraphicsViewAdapter() { return _adapter; }
void clearWriteBuffer()
{
_adapter->clearWriteBuffer();
}
void render()
{
if (_adapter->requiresRendering()) _adapter->render();
}
virtual bool requiresUpdateCall() const { return true; }
virtual void update( osg::NodeVisitor* nv ) { render(); }
virtual bool sendFocusHint(bool focus)
{
QFocusEvent event(focus ? QEvent::FocusIn : QEvent::FocusOut, Qt::OtherFocusReason);
QCoreApplication::sendEvent(_webPage, &event);
return true;
}
virtual bool sendPointerEvent(int x, int y, int buttonMask)
{
return _adapter->sendPointerEvent(x,y,buttonMask);
}
virtual bool sendKeyEvent(int key, bool keyDown)
{
return QWebViewImage::_adapter->sendKeyEvent(key, keyDown);
}
virtual void setFrameLastRendered(const osg::FrameStamp* frameStamp)
{
_adapter->setFrameLastRendered(frameStamp);
}
protected:
QPointer<QGraphicsViewAdapter> _adapter;
QPointer<QWebView> _webView;
QPointer<QWebPage> _webPage;
};
}
#endif
#endif

60
include/osgQt/QWidgetImage
View File

@ -1,60 +0,0 @@
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2009 Robert Osfield
*
* This library is open source and may be redistributed and/or modified under
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
* (at your option) any later version. The full license is in LICENSE file
* included with this distribution, and on the openscenegraph.org website.
*
* This library 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
* OpenSceneGraph Public License for more details.
*/
#ifndef QWIDGETIMAGE
#define QWIDGETIMAGE
#include <osgQt/QGraphicsViewAdapter>
#include <osgQt/Version>
#include <osg/Image>
namespace osgQt
{
class OSGQT_EXPORT QWidgetImage : public osg::Image
{
public:
QWidgetImage( QWidget* widget=0 );
QWidget* getQWidget() { return _widget; }
QGraphicsViewAdapter* getQGraphicsViewAdapter() { return _adapter; }
virtual bool requiresUpdateCall() const { return true; }
virtual void update( osg::NodeVisitor* /*nv*/ ) { render(); }
void clearWriteBuffer();
void render();
/// Overridden scaleImage used to catch cases where the image is
/// fullscreen and the window is resized.
virtual void scaleImage(int s,int t,int r, GLenum newDataType);
virtual bool sendFocusHint(bool focus);
virtual bool sendPointerEvent(int x, int y, int buttonMask);
virtual bool sendKeyEvent(int key, bool keyDown);
virtual void setFrameLastRendered(const osg::FrameStamp* frameStamp);
protected:
QPointer<QGraphicsViewAdapter> _adapter;
QPointer<QWidget> _widget;
};
}
#endif

14
packaging/pkgconfig/openscenegraph-osgQt.pc.in
View File

@ -1,14 +0,0 @@
# pkg-config source file
prefix=@CMAKE_INSTALL_PREFIX@
exec_prefix=${prefix}
libdir=${exec_prefix}/lib@LIB_POSTFIX@
includedir=${prefix}/include
Name: openscenegraph-osgQt
Description: osgQt utility library.
Version: @OPENSCENEGRAPH_VERSION@
Requires: openscenegraph-osgWidget openscenegraph-osgDB openscenegraph-osgUtil openscenegraph-osg openthreads
Conflicts:
Libs: -L${libdir} -losgQt@CMAKE_BUILD_POSTFIX@
Cflags: -I${includedir}

4
src/CMakeLists.txt
View File

@ -35,8 +35,4 @@ FOREACH( mylibfolder
ENDFOREACH()
IF ((QT4_FOUND OR Qt5Widgets_FOUND) AND NOT ANDROID)
ADD_SUBDIRECTORY(osgQt)
ENDIF()

4
src/osgPlugins/CMakeLists.txt
View File

@ -234,10 +234,6 @@ IF(FREETYPE_FOUND)
ADD_SUBDIRECTORY(freetype)
ENDIF()
IF (QT4_FOUND)
ADD_SUBDIRECTORY(qfont)
ENDIF()
IF(ZLIB_FOUND)
ADD_SUBDIRECTORY(zip)
ENDIF()

7
src/osgPlugins/qfont/CMakeLists.txt
View File

@ -1,7 +0,0 @@
INCLUDE_DIRECTORIES(${QT_INCLUDE_DIR} ${QT_QTCORE_INCLUDE_DIR} )
SET(TARGET_SRC ReaderQFont.cpp)
SET(TARGET_ADDED_LIBRARIES osgText osgQt)
SET(TARGET_LIBRARIES_VARS ${QT_QTCORE_LIBRARY_RELEASE} ${QT_QTGUI_LIBRARY_RELEASE})
SETUP_PLUGIN(qfont)

66
src/osgPlugins/qfont/ReaderQFont.cpp
View File

@ -1,66 +0,0 @@
/* -*-c++-*- OpenSceneGraph - Copyright (C) 2009-2010 Mathias Froehlich
*
* This library is open source and may be redistributed and/or modified under
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
* (at your option) any later version. The full license is in LICENSE file
* included with this distribution, and on the openscenegraph.org website.
*
* This library 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
* OpenSceneGraph Public License for more details.
*/
#include <osgDB/FileNameUtils>
#include <osgDB/Registry>
#include <osgText/Font>
#include <QtCore/QThread>
#include <QtGui/QApplication>
#include <QtGui/QFont>
#include <QtGui/QFontDatabase>
#include <osgQt/QFontImplementation>
namespace osgQFont {
class ReaderQFont : public osgDB::ReaderWriter
{
public:
ReaderQFont()
{
supportsExtension("qfont", "Qt font meta loader");
}
virtual const char* className() const { return "QFont Font Reader"; }
virtual ReadResult readObject(const std::string& file, const osgDB::ReaderWriter::Options* /*options*/) const
{
if (!acceptsExtension(osgDB::getLowerCaseFileExtension(file)))
return ReadResult::FILE_NOT_HANDLED;
if (!QApplication::instance())
{
OSG_WARN << "Trying to load qfont \"" << file << "\" from within a non qt application!" << std::endl;
return ReadResult::FILE_NOT_FOUND;
}
if (!QFontDatabase::supportsThreadedFontRendering() && QApplication::instance()->thread() != QThread::currentThread())
{
OSG_WARN << "Trying to load qfont \"" << file << "\" from a non gui thread "
"within qt application without threaded font rendering!" << std::endl;
return ReadResult::FILE_NOT_FOUND;
}
QFont font;
if (!font.fromString(QString::fromStdString(osgDB::getNameLessExtension(file))))
return ReadResult::FILE_NOT_FOUND;
return new osgText::Font(new osgQt::QFontImplementation(font));
}
};
// now register with Registry to instantiate the above
// reader/writer.
REGISTER_OSGPLUGIN(qfont, ReaderQFont)
}

83
src/osgQt/CMakeLists.txt
View File

@ -1,83 +0,0 @@
IF(DYNAMIC_OPENSCENEGRAPH)
ADD_DEFINITIONS(-DOSGQT_LIBRARY)
ELSE()
ADD_DEFINITIONS(-DOSG_LIBRARY_STATIC)
ENDIF()
SET(LIB_NAME osgQt)
SET(HEADER_PATH ${OpenSceneGraph_SOURCE_DIR}/include/${LIB_NAME})
SET(SOURCES_H
${HEADER_PATH}/QGraphicsViewAdapter
)
IF ( Qt5Widgets_FOUND )
QT5_WRAP_CPP( SOURCES_H_MOC ${SOURCES_H} OPTIONS
"-fosgQt/QGraphicsViewAdapter" )
set(OSGQT_QT_VERSION 5)
ELSE()
QT4_WRAP_CPP( SOURCES_H_MOC ${SOURCES_H} OPTIONS "-f" )
set(OSGQT_QT_VERSION 4)
ENDIF()
SET(OSGQT_VERSION_HEADER "${PROJECT_BINARY_DIR}/include/osgQt/Version")
CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/Version.in" ${OSGQT_VERSION_HEADER})
SET(TARGET_H
${HEADER_PATH}/Export
${HEADER_PATH}/GraphicsWindowQt
${HEADER_PATH}/QFontImplementation
${HEADER_PATH}/QGraphicsViewAdapter
${HEADER_PATH}/QWidgetImage
${HEADER_PATH}/QWebViewImage
${OSGQT_VERSION_HEADER}
)
# FIXME: For OS X, need flag for Framework or dylib
SET(TARGET_SRC
GraphicsWindowQt.cpp
QFontImplementation.cpp
QGraphicsViewAdapter.cpp
QWidgetImage.cpp
${SOURCES_H_MOC}
${OPENSCENEGRAPH_VERSIONINFO_RC}
)
SET(TARGET_LIBRARIES
osgWidget
osgDB
osgUtil
osg
OpenThreads
)
IF(CMAKE_COMPILER_IS_GNUCXX)
# Remove -pedantic flag as it barfs on Qt headers
STRING(REGEX REPLACE "-pedantic" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
ENDIF()
# FIXME: This should work but something with the LINK_WITH_VARIABLES macro is not working
#SET(TARGET_LIBRARIES_VARS
# QT_QTCORE_LIBRARY
# QT_QTGUI_LIBRARY
# QT_QTOPENGL_LIBRARY
#)
IF( QT4_FOUND )
INCLUDE_DIRECTORIES( ${QT_INCLUDE_DIR} ${QT_QTCORE_INCLUDE_DIR} ${QT_QTGUI_INCLUDE_DIR} ${QT_QTOPENGL_INCLUDE_DIR} )
SET(TARGET_LIBRARIES
${TARGET_LIBRARIES}
${QT_QTCORE_LIBRARY}
${QT_QTGUI_LIBRARY}
${QT_QTOPENGL_LIBRARY}
)
ENDIF( QT4_FOUND )
SETUP_LIBRARY(${LIB_NAME})
IF ( Qt5Widgets_FOUND )
qt5_use_modules( ${LIB_NAME} Widgets OpenGL )
ENDIF ( Qt5Widgets_FOUND )

1064
src/osgQt/GraphicsWindowQt.cpp
View File

File diff suppressed because it is too large Load Diff

136
src/osgQt/QFontImplementation.cpp
View File

@ -1,136 +0,0 @@
/* -*-c++-*- OpenSceneGraph - Copyright (C) 2009-2010 Mathias Froehlich
*
* This library is open source and may be redistributed and/or modified under
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
* (at your option) any later version. The full license is in LICENSE file
* included with this distribution, and on the openscenegraph.org website.
*
* This library 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
* OpenSceneGraph Public License for more details.
*/
#include <osgQt/QFontImplementation>
#include <osgDB/FileNameUtils>
#include <osgDB/Registry>
#include <osgText/Font>
#include <QFont>
#include <QFontMetrics>
#include <QImage>
#include <QPainter>
namespace osgQt {
QFontImplementation::QFontImplementation(const QFont& font) :
_filename(font.toString().toStdString() + ".qfont"),
_font(font)
{
}
QFontImplementation::~QFontImplementation()
{
}
std::string
QFontImplementation::getFileName() const
{
return _filename;
}
osgText::Glyph*
QFontImplementation::getGlyph(const osgText::FontResolution& fontRes, unsigned int charcode)
{
unsigned int fontSize = fontRes.second;
_font.setPixelSize(fontSize);
float coord_scale = 1.0f/float(fontSize);
QFontMetrics fontMetrics(_font);
QFontMetricsF fontMetricsF(_font);
QRect rect = fontMetrics.boundingRect(QChar(charcode));
QRectF rectF = fontMetricsF.boundingRect(QChar(charcode));
int margin = 1;
int imageWidth = rect.width() + 2*margin;
int imageHeight = rect.height() + 2*margin;
// Now paint the glyph into the image
QImage image(imageWidth, imageHeight, QImage::Format_ARGB32);
image.fill(0);
QPainter painter(&image);
painter.setRenderHint(QPainter::TextAntialiasing);
painter.setFont(_font);
painter.setBackgroundMode(Qt::TransparentMode);
painter.setBrush(Qt::white);
painter.setPen(Qt::white);
painter.drawText(margin - rect.left(), imageHeight - 1 - (margin + rect.bottom()), QString(QChar(charcode)));
painter.end();
// Transfer the rendered image to osg
osg::ref_ptr<osgText::Glyph> glyph = new osgText::Glyph(_facade, charcode);
unsigned int dataSize = imageWidth*imageHeight;
unsigned char* data = new unsigned char[dataSize];
// copy the qimage into the texture memory
for (int x = 0; x < imageWidth; ++x)
{
for (int y = 0; y < imageHeight; ++y)
{
data[x + y*imageWidth] = qAlpha(image.pixel(x, imageHeight - 1 - y));
}
}
// the glyph texture in osg
glyph->setImage(imageWidth, imageHeight, 1,
OSGTEXT_GLYPH_INTERNALFORMAT,
OSGTEXT_GLYPH_FORMAT, GL_UNSIGNED_BYTE,
data,
osg::Image::USE_NEW_DELETE,
1);
glyph->setInternalTextureFormat(OSGTEXT_GLYPH_INTERNALFORMAT);
glyph->setWidth((float)imageWidth * coord_scale);
glyph->setHeight((float)imageHeight * coord_scale);
// Layout parameters
float leftBearing = fontMetricsF.leftBearing(QChar(charcode));
float rightBearing = fontMetricsF.rightBearing(QChar(charcode));
// for horizonal layout
osg::Vec2 bottomLeft(leftBearing - margin, - rectF.bottom() - margin);
glyph->setHorizontalBearing(bottomLeft * coord_scale);
glyph->setHorizontalAdvance(fontMetricsF.width(QChar(charcode)) * coord_scale);
// for vertical layout
osg::Vec2 topMiddle(- margin + 0.5*(leftBearing - rect.width() - rightBearing),
rectF.top() - margin);
glyph->setVerticalBearing(topMiddle * coord_scale);
glyph->setVerticalAdvance((rectF.height() + fontMetricsF.overlinePos() - fontMetricsF.xHeight()) * coord_scale);
// ... ready
//addGlyph(fontRes, charcode, glyph.get());
return glyph.release();
}
osg::Vec2
QFontImplementation::getKerning(const osgText::FontResolution& /*fontRes*/, unsigned int /*leftcharcode*/, unsigned int /*rightcharcode*/, osgText::KerningType /*kerningType*/)
{
return osg::Vec2(0, 0);
}
bool
QFontImplementation::hasVertical() const
{
return true;
}
}

613
src/osgQt/QGraphicsViewAdapter.cpp
View File

@ -1,613 +0,0 @@
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2009 Robert Osfield
*
* This library is open source and may be redistributed and/or modified under
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
* (at your option) any later version. The full license is in LICENSE file
* included with this distribution, and on the openscenegraph.org website.
*
* This library 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
* OpenSceneGraph Public License for more details.
*/
#include <osgQt/QGraphicsViewAdapter>
#include <osgQt/QWidgetImage>
#include <QtOpenGL/QGLWidget>
#include <osg/Version>
#include <osgGA/GUIEventAdapter>
#include <osg/NodeVisitor>
#include <osg/io_utils>
#include <QGraphicsItem>
#include <QGraphicsProxyWidget>
#define MYQKEYEVENT 2000
#define MYQPOINTEREVENT 2001
namespace osgQt
{
QCoreApplication* getOrCreateQApplication()
{
if (QApplication::instance()==0)
{
static char** argv = 0;
static int argc = 0;
static QApplication app(argc,argv);
}
return QApplication::instance();
}
class MyQKeyEvent : public QEvent
{
public:
MyQKeyEvent( int key, bool down ):
QEvent( QEvent::Type(MYQKEYEVENT) ),
_key(key), _down(down) {}
int _key;
bool _down;
};
struct MyQPointerEvent : public QEvent
{
MyQPointerEvent(int x, int y, unsigned int buttonMask):
QEvent( QEvent::Type(MYQPOINTEREVENT) ),
_x(x), _y(y),_buttonMask(buttonMask) {}
int _x, _y;
unsigned int _buttonMask;
};
const QImage::Format s_imageFormat = QImage::Format_ARGB32_Premultiplied;
QGraphicsViewAdapter::QGraphicsViewAdapter(osg::Image* image, QWidget* widget):
_image(image),
_backgroundWidget(0),
_previousButtonMask(0),
_previousMouseX(-1),
_previousMouseY(-1),
_previousQtMouseX(-1),
_previousQtMouseY(-1),
_previousSentEvent(false),
_requiresRendering(false),
_qtKeyModifiers(Qt::NoModifier),
_backgroundColor(255, 255, 255),
_widget(widget)
{
// make sure we have a valid QApplication before we start creating widgets.
getOrCreateQApplication();
setUpKeyMap();
_graphicsScene = new QGraphicsScene;
_graphicsScene->addWidget(widget);
_graphicsView = new QGraphicsView;
_graphicsView->setScene(_graphicsScene);
_graphicsView->viewport()->setParent(0);
#if (QT_VERSION_CHECK(4, 5, 0) <= QT_VERSION)
_graphicsScene->setStickyFocus(true);
#endif
_width = static_cast<int>(_graphicsScene->width());
_height = static_cast<int>(_graphicsScene->height());
_qimages[0] = QImage(QSize(_width, _height), s_imageFormat);
_qimages[1] = QImage(QSize(_width, _height), s_imageFormat);
_qimages[2] = QImage(QSize(_width, _height), s_imageFormat);
_currentRead = 0;
_currentWrite = 1;
_previousWrite = 2;
_previousFrameNumber = osg::UNINITIALIZED_FRAME_NUMBER;
_newImageAvailable = false;
connect(_graphicsScene, SIGNAL(changed(const QList<QRectF> &)),
this, SLOT(repaintRequestedSlot(const QList<QRectF> &)));
connect(_graphicsScene, SIGNAL(sceneRectChanged(const QRectF &)),
this, SLOT(repaintRequestedSlot(const QRectF &)));
assignImage(0);
}
void QGraphicsViewAdapter::repaintRequestedSlot(const QList<QRectF>&)
{
// OSG_NOTICE<<"QGraphicsViewAdapter::repaintRequestedSlot"<<std::endl;
_requiresRendering = true;
}
void QGraphicsViewAdapter::repaintRequestedSlot(const QRectF&)
{
// OSG_NOTICE<<"QGraphicsViewAdapter::repaintRequestedSlot"<<std::endl;
_requiresRendering = true;
}
void QGraphicsViewAdapter::customEvent ( QEvent * event )
{
if (event->type()==MYQKEYEVENT)
{
MyQKeyEvent* keyEvent = (MyQKeyEvent*)event;
handleKeyEvent(keyEvent->_key, keyEvent->_down);
}
else if (event->type()==MYQPOINTEREVENT)
{
MyQPointerEvent* pointerEvent = (MyQPointerEvent*)event;
handlePointerEvent(pointerEvent->_x, pointerEvent->_y, pointerEvent->_buttonMask);
}
}
void QGraphicsViewAdapter::setUpKeyMap()
{
_keyMap[osgGA::GUIEventAdapter::KEY_BackSpace] = Qt::Key_Backspace;
_keyMap[osgGA::GUIEventAdapter::KEY_Tab] = Qt::Key_Tab;
_keyMap[osgGA::GUIEventAdapter::KEY_Linefeed] = Qt::Key_Return; // No LineFeed in Qt!
_keyMap[osgGA::GUIEventAdapter::KEY_Clear] = Qt::Key_Clear;
_keyMap[osgGA::GUIEventAdapter::KEY_Return] = Qt::Key_Return;
_keyMap[osgGA::GUIEventAdapter::KEY_Pause] = Qt::Key_Pause;
_keyMap[osgGA::GUIEventAdapter::KEY_Scroll_Lock] = Qt::Key_ScrollLock;
_keyMap[osgGA::GUIEventAdapter::KEY_Sys_Req] = Qt::Key_SysReq;
_keyMap[osgGA::GUIEventAdapter::KEY_Escape] = Qt::Key_Escape;
_keyMap[osgGA::GUIEventAdapter::KEY_Delete] = Qt::Key_Delete;
_keyMap[osgGA::GUIEventAdapter::KEY_Home] = Qt::Key_Home;
_keyMap[osgGA::GUIEventAdapter::KEY_Left] = Qt::Key_Left;
_keyMap[osgGA::GUIEventAdapter::KEY_Up] = Qt::Key_Up;
_keyMap[osgGA::GUIEventAdapter::KEY_Right] = Qt::Key_Right;
_keyMap[osgGA::GUIEventAdapter::KEY_Down] = Qt::Key_Down;
_keyMap[osgGA::GUIEventAdapter::KEY_Prior] = Qt::Key_Left; // no Prior in Qt
_keyMap[osgGA::GUIEventAdapter::KEY_Page_Up] = Qt::Key_PageUp;
_keyMap[osgGA::GUIEventAdapter::KEY_Next] = Qt::Key_Right; // No Next in Qt
_keyMap[osgGA::GUIEventAdapter::KEY_Page_Down] = Qt::Key_PageDown;
_keyMap[osgGA::GUIEventAdapter::KEY_End] = Qt::Key_End;
_keyMap[osgGA::GUIEventAdapter::KEY_Begin] = Qt::Key_Home; // No Begin in Qt
_keyMap[osgGA::GUIEventAdapter::KEY_Select] = Qt::Key_Select;
_keyMap[osgGA::GUIEventAdapter::KEY_Print] = Qt::Key_Print;
_keyMap[osgGA::GUIEventAdapter::KEY_Execute] = Qt::Key_Execute;
_keyMap[osgGA::GUIEventAdapter::KEY_Insert] = Qt::Key_Insert;
//_keyMap[osgGA::GUIEventAdapter::KEY_Undo] = Qt::Key_; // no Undo
//_keyMap[osgGA::GUIEventAdapter::KEY_Redo] = Qt::Key_; // no Redo
_keyMap[osgGA::GUIEventAdapter::KEY_Menu] = Qt::Key_Menu;
_keyMap[osgGA::GUIEventAdapter::KEY_Find] = Qt::Key_Search; // no Qt Find
_keyMap[osgGA::GUIEventAdapter::KEY_Cancel] = Qt::Key_Cancel;
_keyMap[osgGA::GUIEventAdapter::KEY_Help] = Qt::Key_Help;
_keyMap[osgGA::GUIEventAdapter::KEY_Break] = Qt::Key_Escape; // no break
_keyMap[osgGA::GUIEventAdapter::KEY_Mode_switch] = Qt::Key_Mode_switch;
_keyMap[osgGA::GUIEventAdapter::KEY_Script_switch] = Qt::Key_Mode_switch; // no Script switch
_keyMap[osgGA::GUIEventAdapter::KEY_Num_Lock] = Qt::Key_NumLock;
_keyMap[osgGA::GUIEventAdapter::KEY_Shift_L] = Qt::Key_Shift;
_keyMap[osgGA::GUIEventAdapter::KEY_Shift_R] = Qt::Key_Shift;
_keyMap[osgGA::GUIEventAdapter::KEY_Control_L] = Qt::Key_Control;
_keyMap[osgGA::GUIEventAdapter::KEY_Control_R] = Qt::Key_Control;
_keyMap[osgGA::GUIEventAdapter::KEY_Caps_Lock] = Qt::Key_CapsLock;
_keyMap[osgGA::GUIEventAdapter::KEY_Shift_Lock] = Qt::Key_CapsLock;
_keyMap[osgGA::GUIEventAdapter::KEY_Meta_L] = Qt::Key_Meta; // Qt doesn't have a Meta L
_keyMap[osgGA::GUIEventAdapter::KEY_Meta_R] = Qt::Key_Meta; // Qt doesn't have a Meta R
_keyMap[osgGA::GUIEventAdapter::KEY_Alt_L] = Qt::Key_Alt; // Qt doesn't have a Alt L
_keyMap[osgGA::GUIEventAdapter::KEY_Alt_R] = Qt::Key_Alt; // Qt doesn't have a Alt R
_keyMap[osgGA::GUIEventAdapter::KEY_Super_L] = Qt::Key_Super_L;
_keyMap[osgGA::GUIEventAdapter::KEY_Super_R] = Qt::Key_Super_R;
_keyMap[osgGA::GUIEventAdapter::KEY_Hyper_L] = Qt::Key_Hyper_L;
_keyMap[osgGA::GUIEventAdapter::KEY_Hyper_R] = Qt::Key_Hyper_R;
_keyMap[osgGA::GUIEventAdapter::KEY_KP_Space] = Qt::Key_Space;
_keyMap[osgGA::GUIEventAdapter::KEY_KP_Tab] = Qt::Key_Tab;
_keyMap[osgGA::GUIEventAdapter::KEY_KP_Enter] = Qt::Key_Enter;
_keyMap[osgGA::GUIEventAdapter::KEY_KP_F1] = Qt::Key_F1;
_keyMap[osgGA::GUIEventAdapter::KEY_KP_F2] = Qt::Key_F2;
_keyMap[osgGA::GUIEventAdapter::KEY_KP_F3] = Qt::Key_F3;
_keyMap[osgGA::GUIEventAdapter::KEY_KP_F4] = Qt::Key_F4;
_keyMap[osgGA::GUIEventAdapter::KEY_KP_Home] = Qt::Key_Home;
_keyMap[osgGA::GUIEventAdapter::KEY_KP_Left] = Qt::Key_Left;
_keyMap[osgGA::GUIEventAdapter::KEY_KP_Up] = Qt::Key_Up;
_keyMap[osgGA::GUIEventAdapter::KEY_KP_Right] = Qt::Key_Right;
_keyMap[osgGA::GUIEventAdapter::KEY_KP_Down] = Qt::Key_Down;
_keyMap[osgGA::GUIEventAdapter::KEY_KP_Prior] = Qt::Key_Left;
_keyMap[osgGA::GUIEventAdapter::KEY_KP_Page_Up] = Qt::Key_PageUp;
_keyMap[osgGA::GUIEventAdapter::KEY_KP_Next] = Qt::Key_Right;
_keyMap[osgGA::GUIEventAdapter::KEY_KP_Page_Down] = Qt::Key_PageDown;
_keyMap[osgGA::GUIEventAdapter::KEY_KP_End] = Qt::Key_End;
// _keyMap[osgGA::GUIEventAdapter::KEY_KP_Begin] = Qt::Key_Begin;
_keyMap[osgGA::GUIEventAdapter::KEY_KP_Insert] = Qt::Key_Insert;
_keyMap[osgGA::GUIEventAdapter::KEY_KP_Delete] = Qt::Key_Delete;
_keyMap[osgGA::GUIEventAdapter::KEY_KP_Equal] = Qt::Key_Equal;
_keyMap[osgGA::GUIEventAdapter::KEY_KP_Multiply] = Qt::Key_Asterisk;
_keyMap[osgGA::GUIEventAdapter::KEY_KP_Add] = Qt::Key_Plus;
//_keyMap[osgGA::GUIEventAdapter::KEY_KP_Separator] = Qt::Key_;
_keyMap[osgGA::GUIEventAdapter::KEY_KP_Subtract] = Qt::Key_Minus;
_keyMap[osgGA::GUIEventAdapter::KEY_KP_Decimal] = Qt::Key_Period;
_keyMap[osgGA::GUIEventAdapter::KEY_KP_Divide] = Qt::Key_division;
_keyMap[osgGA::GUIEventAdapter::KEY_KP_0] = Qt::Key_0;
_keyMap[osgGA::GUIEventAdapter::KEY_KP_1] = Qt::Key_1;
_keyMap[osgGA::GUIEventAdapter::KEY_KP_2] = Qt::Key_2;
_keyMap[osgGA::GUIEventAdapter::KEY_KP_3] = Qt::Key_3;
_keyMap[osgGA::GUIEventAdapter::KEY_KP_4] = Qt::Key_4;
_keyMap[osgGA::GUIEventAdapter::KEY_KP_5] = Qt::Key_5;
_keyMap[osgGA::GUIEventAdapter::KEY_KP_6] = Qt::Key_6;
_keyMap[osgGA::GUIEventAdapter::KEY_KP_7] = Qt::Key_7;
_keyMap[osgGA::GUIEventAdapter::KEY_KP_8] = Qt::Key_8;
_keyMap[osgGA::GUIEventAdapter::KEY_KP_9] = Qt::Key_9;
_keyMap[osgGA::GUIEventAdapter::KEY_F1] = Qt::Key_F1;
_keyMap[osgGA::GUIEventAdapter::KEY_F2] = Qt::Key_F2;
_keyMap[osgGA::GUIEventAdapter::KEY_F3] = Qt::Key_F3;
_keyMap[osgGA::GUIEventAdapter::KEY_F4] = Qt::Key_F4;
_keyMap[osgGA::GUIEventAdapter::KEY_F5] = Qt::Key_F5;
_keyMap[osgGA::GUIEventAdapter::KEY_F6] = Qt::Key_F6;
_keyMap[osgGA::GUIEventAdapter::KEY_F7] = Qt::Key_F7;
_keyMap[osgGA::GUIEventAdapter::KEY_F8] = Qt::Key_F8;
_keyMap[osgGA::GUIEventAdapter::KEY_F9] = Qt::Key_F9;
_keyMap[osgGA::GUIEventAdapter::KEY_F10] = Qt::Key_F10;
_keyMap[osgGA::GUIEventAdapter::KEY_F11] = Qt::Key_F11;
_keyMap[osgGA::GUIEventAdapter::KEY_F12] = Qt::Key_F12;
_keyMap[osgGA::GUIEventAdapter::KEY_F13] = Qt::Key_F13;
_keyMap[osgGA::GUIEventAdapter::KEY_F14] = Qt::Key_F14;
_keyMap[osgGA::GUIEventAdapter::KEY_F15] = Qt::Key_F15;
_keyMap[osgGA::GUIEventAdapter::KEY_F16] = Qt::Key_F16;
_keyMap[osgGA::GUIEventAdapter::KEY_F17] = Qt::Key_F17;
_keyMap[osgGA::GUIEventAdapter::KEY_F18] = Qt::Key_F18;
_keyMap[osgGA::GUIEventAdapter::KEY_F19] = Qt::Key_F19;
_keyMap[osgGA::GUIEventAdapter::KEY_F20] = Qt::Key_F20;
_keyMap[osgGA::GUIEventAdapter::KEY_F21] = Qt::Key_F21;
_keyMap[osgGA::GUIEventAdapter::KEY_F22] = Qt::Key_F22;
_keyMap[osgGA::GUIEventAdapter::KEY_F23] = Qt::Key_F23;
_keyMap[osgGA::GUIEventAdapter::KEY_F24] = Qt::Key_F24;
_keyMap[osgGA::GUIEventAdapter::KEY_F25] = Qt::Key_F25;
_keyMap[osgGA::GUIEventAdapter::KEY_F26] = Qt::Key_F26;
_keyMap[osgGA::GUIEventAdapter::KEY_F27] = Qt::Key_F27;
_keyMap[osgGA::GUIEventAdapter::KEY_F28] = Qt::Key_F28;
_keyMap[osgGA::GUIEventAdapter::KEY_F29] = Qt::Key_F29;
_keyMap[osgGA::GUIEventAdapter::KEY_F30] = Qt::Key_F30;
_keyMap[osgGA::GUIEventAdapter::KEY_F31] = Qt::Key_F31;
_keyMap[osgGA::GUIEventAdapter::KEY_F32] = Qt::Key_F32;
_keyMap[osgGA::GUIEventAdapter::KEY_F33] = Qt::Key_F33;
_keyMap[osgGA::GUIEventAdapter::KEY_F34] = Qt::Key_F34;
_keyMap[osgGA::GUIEventAdapter::KEY_F35] = Qt::Key_F35;
}
QWidget* QGraphicsViewAdapter::getWidgetAt(const QPoint& pos)
{
QWidget* childAt = _graphicsView->childAt(pos);
if(childAt)
{
return childAt;
}
QGraphicsItem* item = _graphicsView->itemAt(pos);
if(item /*&& item->contains(item->mapFromScene(pos))*/)
{
QGraphicsProxyWidget* p = qgraphicsitem_cast<QGraphicsProxyWidget*>(item);
if(p)
{
childAt = p->widget();
QWidget* c;
while( (c = childAt->childAt(childAt->mapFromGlobal(pos)))!=0 )
{
childAt = c;
}
// Widgets like QTextEdit will automatically add child scroll area widgets
// that will be selected by childAt(), we have to change to parents at that moment
// Hardcoded by the internal widget's name 'qt_scrollarea_viewport' at present
if (childAt->objectName() == "qt_scrollarea_viewport")
{
childAt = childAt->parentWidget();
}
return childAt;
}
}
return NULL;
}
bool QGraphicsViewAdapter::sendPointerEvent(int x, int y, int buttonMask)
{
_previousQtMouseX = x;
_previousQtMouseY = _graphicsView->size().height() - y;
QPoint pos(_previousQtMouseX, _previousQtMouseY);
QWidget* targetWidget = getWidgetAt(pos);
OSG_INFO << "Get " << (targetWidget ? targetWidget->metaObject()->className() : std::string("NULL"))
<< " at global pos " << x << ", " << y << std::endl;
if (_backgroundWidget && _backgroundWidget == targetWidget)
{
// Mouse is at background widget, so ignore such events
return false;
}
if (targetWidget != NULL || (_previousSentEvent && buttonMask != 0))
{
QCoreApplication::postEvent(this, new MyQPointerEvent(x,y,buttonMask));
OSG_INFO<<"sendPointerEvent("<<x<<", "<<y<<") sent"<<std::endl;
_previousSentEvent = true;
return true;
}
OSG_INFO<<"sendPointerEvent("<<x<<", "<<y<<") not sent"<<std::endl;
_previousSentEvent = false;
return false;
}
bool QGraphicsViewAdapter::handlePointerEvent(int x, int y, int buttonMask)
{
OSG_INFO<<"dispatchPointerEvent("<<x<<", "<<y<<", "<<buttonMask<<")"<<std::endl;
y = _graphicsView->size().height()-y;
bool leftButtonPressed = (buttonMask & osgGA::GUIEventAdapter::LEFT_MOUSE_BUTTON)!=0;
bool middleButtonPressed = (buttonMask & osgGA::GUIEventAdapter::MIDDLE_MOUSE_BUTTON)!=0;
bool rightButtonPressed = (buttonMask & osgGA::GUIEventAdapter::RIGHT_MOUSE_BUTTON)!=0;
bool prev_leftButtonPressed = (_previousButtonMask & osgGA::GUIEventAdapter::LEFT_MOUSE_BUTTON)!=0;
bool prev_middleButtonPressed = (_previousButtonMask & osgGA::GUIEventAdapter::MIDDLE_MOUSE_BUTTON)!=0;
bool prev_rightButtonPressed = (_previousButtonMask & osgGA::GUIEventAdapter::RIGHT_MOUSE_BUTTON)!=0;
OSG_INFO<<"leftButtonPressed "<<leftButtonPressed<<std::endl;
OSG_INFO<<"middleButtonPressed "<<middleButtonPressed<<std::endl;
OSG_INFO<<"rightButtonPressed "<<rightButtonPressed<<std::endl;
Qt::MouseButtons qtMouseButtons =
(leftButtonPressed ? Qt::LeftButton : Qt::NoButton) |
(middleButtonPressed ? Qt::MidButton : Qt::NoButton) |
(rightButtonPressed ? Qt::RightButton : Qt::NoButton);
const QPoint globalPos(x, y);
QWidget* targetWidget = getWidgetAt(globalPos);
if (buttonMask != _previousButtonMask)
{
Qt::MouseButton qtButton = Qt::NoButton;
QEvent::Type eventType = QEvent::None;
if (leftButtonPressed != prev_leftButtonPressed)
{
qtButton = Qt::LeftButton;
eventType = leftButtonPressed ? QEvent::MouseButtonPress : QEvent::MouseButtonRelease ;
}
else if (middleButtonPressed != prev_middleButtonPressed)
{
qtButton = Qt::MidButton;
eventType = middleButtonPressed ? QEvent::MouseButtonPress : QEvent::MouseButtonRelease ;
}
else if (rightButtonPressed != prev_rightButtonPressed)
{
qtButton = Qt::RightButton;
eventType = rightButtonPressed ? QEvent::MouseButtonPress : QEvent::MouseButtonRelease ;
if(!rightButtonPressed)
{
if(targetWidget)
{
QPoint localPos = targetWidget->mapFromGlobal(globalPos);
QContextMenuEvent* cme = new QContextMenuEvent(QContextMenuEvent::Mouse, localPos, globalPos);
QCoreApplication::postEvent(targetWidget, cme);
}
}
}
if (eventType==QEvent::MouseButtonPress)
{
_image->sendFocusHint(true);
if (targetWidget) targetWidget->setFocus(Qt::MouseFocusReason);
}
QMouseEvent event(eventType, globalPos, qtButton, qtMouseButtons, 0);
QCoreApplication::sendEvent(_graphicsView->viewport(), &event);
_previousButtonMask = buttonMask;
}
else if (x != _previousMouseX || y != _previousMouseY)
{
QMouseEvent event(QEvent::MouseMove, globalPos, Qt::NoButton, qtMouseButtons, 0);
QCoreApplication::sendEvent(_graphicsView->viewport(), &event);
_previousMouseX = x;
_previousMouseY = y;
}
return true;
}
bool QGraphicsViewAdapter::sendKeyEvent(int key, bool keyDown)
{
QPoint pos(_previousQtMouseX, _previousQtMouseY);
QWidget* targetWidget = getWidgetAt(pos);
if (_backgroundWidget && _backgroundWidget == targetWidget)
{
// Mouse is at background widget, so ignore such events
return false;
}
if (targetWidget != NULL)
{
QCoreApplication::postEvent(this, new MyQKeyEvent(key,keyDown));
return true;
}
return false;
}
bool QGraphicsViewAdapter::handleKeyEvent(int key, bool keyDown)
{
QEvent::Type eventType = keyDown ? QEvent::KeyPress : QEvent::KeyRelease;
OSG_INFO<<"sendKeyEvent("<<key<<", "<<keyDown<<")"<<std::endl;
if (key==Qt::Key_Shift)
{
_qtKeyModifiers = (_qtKeyModifiers & ~Qt::ShiftModifier) | (keyDown ? Qt::ShiftModifier : Qt::NoModifier);
}
if (key==Qt::Key_Control)
{
_qtKeyModifiers = (_qtKeyModifiers & ~Qt::ControlModifier) | (keyDown ? Qt::ControlModifier : Qt::NoModifier);
}
if (key==Qt::Key_Alt || key==Qt::Key_AltGr)
{
_qtKeyModifiers = (_qtKeyModifiers & ~Qt::ControlModifier) | (keyDown ? Qt::ControlModifier : Qt::NoModifier);
}
if (key==Qt::Key_Meta)
{
_qtKeyModifiers = (_qtKeyModifiers & ~Qt::MetaModifier) | (keyDown ? Qt::MetaModifier : Qt::NoModifier);
}
Qt::Key qtkey;
QChar input;
KeyMap::iterator itr = _keyMap.find(key);
if (itr != _keyMap.end())
{
qtkey = itr->second;
}
else
{
qtkey = (Qt::Key)key;
input = QChar(key);
}
QKeyEvent event(eventType, qtkey, _qtKeyModifiers, input);
QCoreApplication::sendEvent(_graphicsScene.data(), &event);
return true;
}
void QGraphicsViewAdapter::setFrameLastRendered(const osg::FrameStamp* frameStamp)
{
OSG_INFO<<"setFrameLastRendered("<<frameStamp->getFrameNumber()<<")"<<std::endl;
if (_newImageAvailable && _previousFrameNumber!=frameStamp->getFrameNumber())
{
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_qimagesMutex);
// make sure that _previousFrameNumber hasn't been updated by another thread since we entered this branch.
if (_previousFrameNumber==frameStamp->getFrameNumber()) return;
_previousFrameNumber = frameStamp->getFrameNumber();
std::swap(_currentRead, _previousWrite);
_newImageAvailable = false;
}
assignImage(_currentRead);
}
}
void QGraphicsViewAdapter::clearWriteBuffer()
{
QImage& image = _qimages[_currentWrite];
image.fill(_backgroundColor.rgba ());
image = QGLWidget::convertToGLFormat(image);
// swap the write buffers in a thread safe way
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_qimagesMutex);
std::swap(_currentWrite, _previousWrite);
_newImageAvailable = true;
}
void QGraphicsViewAdapter::render()
{
OSG_INFO<<"Current write = "<<_currentWrite<<std::endl;
QImage& image = _qimages[_currentWrite];
_requiresRendering = false;
// If we got a resize, act on it, first by resizing the view, then the current image
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_qresizeMutex);
if (_graphicsView->size().width() != _width || _graphicsView->size().height() != _height)
{
_graphicsView->setGeometry(0, 0, _width, _height);
_graphicsView->viewport()->setGeometry(0, 0, _width, _height);
_widget->setGeometry(0, 0, _width, _height);
}
if (image.width() != _width || image.height() != _height)
{
_qimages[_currentWrite] = QImage(_width, _height, s_imageFormat);
image = _qimages[_currentWrite];
}
OSG_INFO << "render image " << _currentWrite << " with size (" << _width << "," << _height << ")" <<std::endl;
}
#if 1
// paint the image with the graphics view
QPainter painter(&image);
// Clear the image otherwise there are artifacts for some widgets that overpaint.
painter.setCompositionMode(QPainter::CompositionMode_Source);
painter.fillRect(0, 0, image.width(), image.height(), _backgroundColor);
painter.setCompositionMode(QPainter::CompositionMode_SourceOver);
QRectF destinationRect(0, 0, image.width(), image.height());
QRect sourceRect(0, 0, image.width(), image.height());
_graphicsView->render(&painter, destinationRect, sourceRect, Qt::IgnoreAspectRatio);
painter.end();
#elif 0
QPixmap pixmap(QPixmap::grabWidget(_graphicsView.data(), QRect(0, 0, image.width(), image.height())));
image = pixmap.toImage();
#else
// paint the image with the graphics view
QPixmap pixmap(image.width(), image.height());
// Clear the image otherwise there are artifacts for some widgets that overpaint.
pixmap.fill(Qt::transparent);
QPainter painter(&pixmap);
QRectF destinationRect(0, 0, image.width(), image.height());
QRect sourceRect(0, 0, image.width(), image.height());
_graphicsView->render(&painter, destinationRect, _graphicsView->viewport()->rect());
painter.end();
image = pixmap.toImage();
#endif
// convert into OpenGL format - flipping around the Y axis and swizzling the pixels
image = QGLWidget::convertToGLFormat(image);
// swap the write buffers in a thread safe way
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_qimagesMutex);
std::swap(_currentWrite, _previousWrite);
_newImageAvailable = true;
}
void QGraphicsViewAdapter::assignImage(unsigned int i)
{
QImage& image = _qimages[i];
unsigned char* data = image.bits();
OSG_INFO<<"assignImage("<<i<<") image = "<<&image<<" size = ("<<image.width()<<","<<image.height()<<") data = "<<(void*)data<<std::endl;
_image->setImage(image.width(), image.height(), 1,
4, GL_RGBA, GL_UNSIGNED_BYTE,
data, osg::Image::NO_DELETE, 1);
}
void QGraphicsViewAdapter::resize(int width, int height)
{
OSG_INFO << "resize to (" << width << "," << height << ")" <<std::endl;
// Save the new width and height which will take effect on the next render() (in the Qt thread).
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_qresizeMutex);
_width = width;
_height = height;
}
// Force an update so render() will be called.
_graphicsScene->update(_graphicsScene->sceneRect());
}
}

66
src/osgQt/QWidgetImage.cpp
View File

@ -1,66 +0,0 @@
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2009 Robert Osfield
*
* This library is open source and may be redistributed and/or modified under
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
* (at your option) any later version. The full license is in LICENSE file
* included with this distribution, and on the openscenegraph.org website.
*
* This library 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
* OpenSceneGraph Public License for more details.
*/
#include <osgQt/QWidgetImage>
#include <QLayout>
namespace osgQt
{
QWidgetImage::QWidgetImage( QWidget* widget )
{
// make sure we have a valid QApplication before we start creating widgets.
getOrCreateQApplication();
_widget = widget;
_adapter = new QGraphicsViewAdapter(this, _widget.data());
}
bool QWidgetImage::sendFocusHint(bool focus)
{
QFocusEvent event(focus ? QEvent::FocusIn : QEvent::FocusOut, Qt::OtherFocusReason);
QCoreApplication::sendEvent(_widget, &event);
return true;
}
void QWidgetImage::clearWriteBuffer()
{
_adapter->clearWriteBuffer();
}
void QWidgetImage::render()
{
if (_adapter->requiresRendering()) _adapter->render();
}
void QWidgetImage::scaleImage(int s,int t,int /*r*/, GLenum /*newDataType*/)
{
_adapter->resize(s, t);
}
void QWidgetImage::setFrameLastRendered(const osg::FrameStamp* frameStamp)
{
_adapter->setFrameLastRendered(frameStamp);
}
bool QWidgetImage::sendPointerEvent(int x, int y, int buttonMask)
{
return _adapter->sendPointerEvent(x,y,buttonMask);
}
bool QWidgetImage::sendKeyEvent(int key, bool keyDown)
{
return _adapter->sendKeyEvent(key, keyDown);
}
}

12
src/osgQt/Version.in
View File

@ -1,12 +0,0 @@
#ifndef OSGQT_VERSION
#define OSGQT_VERSION
#define OSGQT_QT_VERSION @OSGQT_QT_VERSION@
#include <QtGlobal>
#if (QT_VERSION < QT_VERSION_CHECK(OSGQT_QT_VERSION,0,0))
#error "Qt version mismatch detected! Make sure to compile applications using osgQt with the same major Qt version that osgQt has been compiled against."
#endif
#endif