int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManagerRefPtr sceneManager = SimpleSceneManager::create();
TutorialWindow->setDisplayCallback(boost::bind(display, sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, sceneManager));
// Tell the Manager what to manage
sceneManager->setWindow(TutorialWindow);
TutorialWindow->connectKeyTyped(boost::bind(keyPressed, _1));
// Make Torus Node (creates Torus in background of scene)
NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRecPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRecPtr TutorialGraphics = Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
/******************************************************
Create Components to add to MenuBar
Menus. Each MenuBar has multiple Menus
which contain multiple MenuItems.
-setAcceleratorKey(KeyEventDetails::KEY_*): This
links the key "*" as a shortcut to
selecting the item it is attached to.
An example of this would be Q with
Control+Q causing programs to quit.
-setAcceleratorModifiers(KeyEventDetails::KEY_MODIFIER_*):
This adds the "*" key as another
requirement to cause the item to be
selected. Things such as "CONTROL" are
likely to be used here (as mentioned
above, both Control and Q are specified).
Note: These shortcuts will be shown in the list
with the MenuItem they are attached to.
-setMnemonicKey(KeyEventDetails::KEY_****): sets the key
"****" to be underlined within the Menu
itself
******************************************************/
// Creates MenuItems as in 25PopupMenu
MenuItemRecPtr NewMenuItem = MenuItem::create();
MenuItemRecPtr OpenMenuItem = MenuItem::create();
MenuItemRecPtr CloseMenuItem = MenuItem::create();
MenuItemRecPtr ExitMenuItem = MenuItem::create();
MenuItemRecPtr UndoMenuItem = MenuItem::create();
MenuItemRecPtr RedoMenuItem = MenuItem::create();
//Edits MenuItems
NewMenuItem->setText("New ...");
NewMenuItem->setAcceleratorKey(KeyEventDetails::KEY_N);
NewMenuItem->setAcceleratorModifiers(KeyEventDetails::KEY_MODIFIER_COMMAND);
NewMenuItem->setMnemonicKey(KeyEventDetails::KEY_N);
OpenMenuItem->setText("Open ...");
OpenMenuItem->setAcceleratorKey(KeyEventDetails::KEY_P);
OpenMenuItem->setAcceleratorModifiers(KeyEventDetails::KEY_MODIFIER_COMMAND);
OpenMenuItem->setMnemonicKey(KeyEventDetails::KEY_P);
CloseMenuItem->setText("Close ...");
CloseMenuItem->setAcceleratorKey(KeyEventDetails::KEY_W);
CloseMenuItem->setAcceleratorModifiers(KeyEventDetails::KEY_MODIFIER_COMMAND);
CloseMenuItem->setMnemonicKey(KeyEventDetails::KEY_C);
ExitMenuItem->setText("Quit");
ExitMenuItem->setAcceleratorKey(KeyEventDetails::KEY_Q);
ExitMenuItem->setAcceleratorModifiers(KeyEventDetails::KEY_MODIFIER_COMMAND);
ExitMenuItem->setMnemonicKey(KeyEventDetails::KEY_Q);
UndoMenuItem->setText("Undo");
UndoMenuItem->setAcceleratorKey(KeyEventDetails::KEY_Z);
UndoMenuItem->setAcceleratorModifiers(KeyEventDetails::KEY_MODIFIER_COMMAND);
UndoMenuItem->setMnemonicKey(KeyEventDetails::KEY_U);
RedoMenuItem->setText("Redo");
RedoMenuItem->setEnabled(false);
RedoMenuItem->setMnemonicKey(KeyEventDetails::KEY_R);
// Create a function connection to ExitMenuItem
// This is defined above, and will cause the program to quit
// when that MenuItem is selected or Control + Q hit
ExitMenuItem->connectActionPerformed(boost::bind(handleQuitAction, _1,
TutorialWindow.get()));
/******************************************************
Create Menu Components to add to MenuBar
and adds above Components to them.
Note: setAcceleratorKey,
setAcceleratorModifiers, and setMnemnoicKey
all apply to Menus in addition to MenuItems.
******************************************************/
// Create a File menu and adds its MenuItems
MenuRecPtr FileMenu = Menu::create();
FileMenu->addItem(NewMenuItem);
FileMenu->addItem(OpenMenuItem);
FileMenu->addItem(CloseMenuItem);
FileMenu->addSeparator();
FileMenu->addItem(ExitMenuItem);
// Labels the File Menu
FileMenu->setText("File");
FileMenu->setMnemonicKey(KeyEventDetails::KEY_F);
// Creates an Edit menu and adds its MenuItems
MenuRecPtr EditMenu = Menu::create();
EditMenu->addItem(UndoMenuItem);
EditMenu->addItem(RedoMenuItem);
// Labels the Edit Menu
EditMenu->setText("Edit");
EditMenu->setMnemonicKey(KeyEventDetails::KEY_E);
/******************************************************
Create MainMenuBar and adds the Menus
created above to it.
Also creates several Backgrounds
to improve MenuBar overall look.
Both the MenuBar and Menu can have
Backgrounds; the set up currently
is to have EmptyBackgrounds in
each Menu allowing a single
overall MenuBar Background which
is given to the MenuBar itself.
This can be easily changed by adding
different Backgrounds to the
File and Edit Menus.
Note: The MenuBar is added to the
MainFrame below.
******************************************************/
// Creates two Backgrounds
MenuBarRecPtr MainMenuBar = MenuBar::create();
// Adds the two Menus to the MainMenuBar
MainMenuBar->addMenu(FileMenu);
MainMenuBar->addMenu(EditMenu);
// Create two Labels
LabelRecPtr ExampleLabel1 = Label::create();
LabelRecPtr ExampleLabel2 = Label::create();
ExampleLabel1->setText("Look up in the corner!");
ExampleLabel1->setPreferredSize(Vec2f(150, 25));
ExampleLabel2->setText("Hit Control + Z");
ExampleLabel2->setPreferredSize(Vec2f(150, 25));
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
EmptyLayerRecPtr MainInternalWindowBackground = EmptyLayer::create();
EmptyBorderRecPtr MainInternalWindowBorder = EmptyBorder::create();
LayoutRecPtr MainInternalWindowLayout = FlowLayout::create();
InternalWindowRecPtr MainInternalWindow = InternalWindow::create();
MainInternalWindow->pushToChildren(ExampleLabel1);
MainInternalWindow->pushToChildren(ExampleLabel2);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setMenuBar(MainMenuBar);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setBorders(MainInternalWindowBorder);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(1.0f,1.0f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
// Create the Drawing Surface
UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRecPtr TutorialUIForeground = UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Tell the Manager what to manage
sceneManager->setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRecPtr TutorialViewport = sceneManager->getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
//Create the Documentation Foreground and add it to the viewport
SimpleScreenDoc TheSimpleScreenDoc(sceneManager, TutorialWindow);
// Show the whole Scene
sceneManager->showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"26MenuBar");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
TutorialWindow->connectKeyTyped(boost::bind(keyPressed, _1));
// Make Torus Node (creates Torus in background of scene)
NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRecPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRecPtr TutorialGraphics = Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
/******************************************************
Create a Panel containing Buttons to
add to ScrollPanel using a function
(located at bottom of this file)
******************************************************/
PanelRecPtr ExampleViewablePanel = createPanelWithButtons();
/******************************************************
Create a UIViewport to use with the
ScrollPanel. This sets up a secondary
TutorialViewport inside the ScrollPanel.
Without this, the ScrollPanel would
not function correctly.
The Panel created above is added to be
viewed in the UIViewport and the size
and position are set.
******************************************************/
UIViewportRecPtr ScrollPanelUIViewport = UIViewport::create();
ScrollPanelUIViewport->setViewComponent(ExampleViewablePanel);
ScrollPanelUIViewport->setViewPosition(Pnt2f(150,150));
ScrollPanelUIViewport->setPreferredSize(Vec2f(200,200));
/******************************************************
Create the ScrollPanel itself.
-setHorizontalResizePolicy(ScrollPanel::
ENUM): Determines the Horizontal
resize policy. The ScrollPanel will
automatically resize itself to the
Size of its Component within for
RESIZE_TO_VIEW, or add a ScrollBar
as needed for NO_RESIZE. Takes
NO_RESIZE and RESIZE_TO_VIEW
arguments.
-setVerticalResizePolicy(ScrollPanel::
ENUM): Determines the Vertical
resize policy. The ScrollPanel will
automatically resize itself to the
Size of its Component within for
RESIZE_TO_VIEW, or add a ScrollBar
as needed for NO_RESIZE. Takes
NO_RESIZE and RESIZE_TO_VIEW
arguments.
-setViewComponent(Component): Determine
which Component will be added into
the ScrollPanel. Note that this
must be the same as the UIViewport
created above and does not require
a begin/endEditCP.
******************************************************/
ScrollPanelRecPtr ExampleScrollPanel = ScrollPanel::create();
ExampleScrollPanel->setPreferredSize(Vec2f(100,100));
ExampleScrollPanel->setVerticalScrollBarAlignment(ScrollPanel::SCROLLBAR_ALIGN_LEFT);
ExampleScrollPanel->setHorizontalScrollBarAlignment(ScrollPanel::SCROLLBAR_ALIGN_BOTTOM);
//ExampleScrollPanel->setHorizontalResizePolicy(ScrollPanel::RESIZE_TO_VIEW);
//ExampleScrollPanel->setVerticalResizePolicy(ScrollPanel::RESIZE_TO_VIEW);
ExampleScrollPanel->setViewComponent(ExampleViewablePanel);
/******************************************************
Create two ScrollBars.
First, create a DefaultBoundedRangeModel.
This determines some characteristics of
the Scrollbar. Note that you can link
several ScollBars to the same
DefaultBoundedRangeModel; this will
cause them to move at the same time.
-.setMinimum(int): Determine a numeric
value for the beginning of the
ScrollBar. Note that the visible
size will be set separately.
-.setMaximum(int): Determine a numeric
value for the end of the
ScrollBar.
-.setValue(int): Determine the
initial location of the Bar on the
ScrollBar. This is determined from
the Min/Max values.
-.setExtent(int): Determine the size
of the Bar on the ScrollBar as a
fraction of the total size (which is
determined from the Min/Max values)
as well.
Second, create the ScrollBar itself.
-setOrientation(ENUM): Determine
the orientation of the ScrollBar.
Takes VERTICAL_ORIENTATION
and HORIZONTAL_ORIENTATION arguments.
-setUnitIncrement(int): Determines how
much the Scoller moves per click
on its end arrows. References to the
Min/Max values as well.
-setBlockIncrement(int): Determine
how many units the ScrollBar moves
when the "non-scroller" is clicked.
This references the Min/Max values
above as well (so if the Min/Max
range was 0 to 100, and this was
100, then each click would move the
scoller to the opposite end). It
would also be impossible to directly
click the scroller to a middle location.
Note that while in this tutorial both
ScrollBars use the same BoundedRangeModel
(which causes them to be linked), each
ScrollBar individually has these last two
settings uniquely set. So while the
Scrollers move together (because they
use the same Model), using each
will cause them to move at different
speeds due to these settings being
different.
******************************************************/
// Create a DefaultBoundedRangeModel
DefaultBoundedRangeModelRecPtr TheBoundedRangeModel = DefaultBoundedRangeModel::create();
TheBoundedRangeModel->setMinimum(10);
TheBoundedRangeModel->setMaximum(100);
TheBoundedRangeModel->setValue(10);
TheBoundedRangeModel->setExtent(20);
ScrollBarRecPtr ExampleVerticalScrollBar = ScrollBar::create();
//ExampleScrollPanel->getHorizontalScrollBar()
ExampleVerticalScrollBar->setOrientation(ScrollBar::VERTICAL_ORIENTATION);
ExampleVerticalScrollBar->setPreferredSize(Vec2f(20,200));
ExampleVerticalScrollBar->setEnabled(false);
ExampleVerticalScrollBar->setUnitIncrement(10);
ExampleVerticalScrollBar->setBlockIncrement(100);
ExampleVerticalScrollBar->setRangeModel(TheBoundedRangeModel);
ScrollBarRecPtr ExampleHorizontalScrollBar = ScrollBar::create();
ExampleHorizontalScrollBar->setOrientation(ScrollBar::HORIZONTAL_ORIENTATION);
ExampleHorizontalScrollBar->setPreferredSize(Vec2f(400,20));
ExampleHorizontalScrollBar->setRangeModel(TheBoundedRangeModel);
// Creates another DefaultBoundedRangeModel to use
// for separating the two ScrollBars from each other.
// Make sure to comment out the addition of the
// previous setModel above.
/*
DefaultBoundedRangeModel TheBoundedRangeModel2;
TheBoundedRangeModel2.setMinimum(0);
TheBoundedRangeModel2.setMaximum(100);
TheBoundedRangeModel2.setValue(10);
TheBoundedRangeModel2.setExtent(20);
ExampleHorizontalScrollBar->setModel(&TheBoundedRangeModel2);
*/
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
LayoutRecPtr MainInternalWindowLayout = FlowLayout::create();
InternalWindowRecPtr MainInternalWindow = InternalWindow::create();
MainInternalWindow->pushToChildren(ExampleHorizontalScrollBar);
MainInternalWindow->pushToChildren(ExampleVerticalScrollBar);
MainInternalWindow->pushToChildren(ExampleScrollPanel);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
// Create the Drawing Surface
UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRecPtr TutorialUIForeground = UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Tell the Manager what to manage
sceneManager.setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
// Show the whole Scene
sceneManager.showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"27ScrollPanel");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
TutorialWindow->connectKeyTyped(boost::bind(keyPressed, _1));
// Make Torus Node (creates Torus in background of scene)
NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRecPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRecPtr TutorialGraphics = Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
//Create the nessicary parts for a viewport
Matrix TransformMatrix;
TransformMatrix.setTranslate(0.0f,0.0f, 0.0f);
TransformRecPtr CameraBeaconTransform = Transform::create();
CameraBeaconTransform->setMatrix(TransformMatrix);
NodeRecPtr CameraBeaconNode = Node::create();
CameraBeaconNode->setCore(CameraBeaconTransform);
// Make Torus Node (creates Torus in background of scene)
NodeRecPtr GeometryNode = makeTorus(.5, 2, 32, 32);
//Make a light Node
NodeRecPtr LightBeaconNode = makeCoredNode<Transform>();
DirectionalLightRecPtr SceneLight = DirectionalLight::create();
SceneLight->setAmbient(Color4f(0.3f,0.3f,0.3f,1.0f));
SceneLight->setDiffuse(Color4f(0.8f,0.8f,0.8f,1.0f));
SceneLight->setSpecular(Color4f(1.0f,1.0f,1.0f,1.0f));
SceneLight->setOn(true);
SceneLight->setBeacon(LightBeaconNode);
NodeRecPtr LightNode = makeNodeFor(SceneLight);
LightNode->addChild(GeometryNode);
// Make Main Scene Node and add the Torus
NodeRecPtr DefaultRootNode = Node::create();
DefaultRootNode->setCore(Group::create());
DefaultRootNode->addChild(LightNode);
DefaultRootNode->addChild(LightBeaconNode);
DefaultRootNode->addChild(CameraBeaconNode);
//Camera
PerspectiveCameraRecPtr DefaultCamera = PerspectiveCamera::create();
DefaultCamera->setBeacon(CameraBeaconNode);
DefaultCamera->setFov (osgDegree2Rad(60.f));
DefaultCamera->setNear (0.1f);
DefaultCamera->setFar (100.f);
//Background
GradientBackgroundRecPtr DefaultBackground = GradientBackground::create();
DefaultBackground->addLine(Color3f(0.0f,0.0f,0.0f), 0.0f);
DefaultBackground->addLine(Color3f(0.0f,0.0f,1.0f), 1.0f);
//Viewport
ViewportRecPtr DefaultViewport = Viewport::create();
DefaultViewport->setCamera (DefaultCamera);
DefaultViewport->setRoot (DefaultRootNode);
DefaultViewport->setSize (0.0f,0.0f, 1.0f,1.0f);
DefaultViewport->setBackground (DefaultBackground);
//GL Viewport Component
LineBorderRecPtr TheGLViewportBorder = LineBorder::create();
TheGLViewportBorder->setColor(Color4f(1.0,0.0,0.0,1.0));
TheGLViewportBorder->setWidth(3.0);
GLViewportRecPtr TheGLViewport = GLViewport::create();
TheGLViewport->setPort(DefaultViewport);
TheGLViewport->setPreferredSize(Vec2f(400.0f,400.0f));
TheGLViewport->setBorders(TheGLViewportBorder);
TheGLViewport->lookAt(Pnt3f(0.0f,0.0f,10.0f), //From
Pnt3f(0.0f,0.0f,0.0f), //At
Vec3f(0.0f,1.0f,0.0f)); //Up
ButtonRecPtr ExampleButton = Button::create();
ExampleButton->setText("Example");
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
InternalWindowRecPtr MainInternalWindow = InternalWindow::create();
LayoutRecPtr MainInternalWindowLayout = FlowLayout::create();
MainInternalWindow->pushToChildren(TheGLViewport);
MainInternalWindow->pushToChildren(ExampleButton);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.95f,0.95f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
// Create the Drawing Surface
UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRecPtr TutorialUIForeground = UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Tell the Manager what to manage
sceneManager.setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
//Create the Documentation Foreground and add it to the viewport
SimpleScreenDoc TheSimpleScreenDoc(&sceneManager, TutorialWindow);
// Show the whole Scene
sceneManager.showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"41GLViewportComponent");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
TutorialWindow->connectKeyTyped(boost::bind(keyPressed, _1));
// Make Torus Node (creates Torus in background of scene)
NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRecPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRecPtr TutorialGraphics = Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
// Create a simple Font to be used with the TextField
UIFontRecPtr sampleFont = UIFont::create();
sampleFont->setSize(16);
/******************************************************
Create and edit the TextField. A TextField is
a Component which allows a single line of text
to be displayed. Text can be entered via the
keyboard, and selected with arrow keys or
the Mouse.
-setTextColor(Color4f): Determine the
Text Color.
setSelectionBoxColor(Color4f): Determine
the Color of highlighting around
selected Text.
-setSelectionTextColor(Color4f): Determine
the Color of selected Text.
-setText("TextToBeDisplayed"): Determine
initial Text within TextField.
-setFont(FontName): Determine the Font
used within TextField.
-setSelectionStart(StartCharacterNumber):
Determine the character with which
the selection will initially start.
-setSelectionEnd(EndCharacterNumber):
Determine the character which the
selection ends before.
-setAlignment(float): Determine
the alignment of the text.
The float is a percentage is from the
top of the text [0.0-1.0]. Note: be
sure to visually verify this, as due
to font size and line size this does
not always place it exactly
at the percentage point.
******************************************************/
// Create a TextField component
TextFieldRecPtr ExampleTextField = TextField::create();
ExampleTextField->setPreferredSize(Vec2f(100, 50));
ExampleTextField->setTextColor(Color4f(0.0, 0.0, 0.0, 1.0));
ExampleTextField->setSelectionBoxColor(Color4f(0.0, 0.0, 1.0, 1.0));
ExampleTextField->setSelectionTextColor(Color4f(1.0, 1.0, 1.0, 1.0));
ExampleTextField->setText("What");
ExampleTextField->setFont(sampleFont);
// The next two functions will select the "a" from above
ExampleTextField->setSelectionStart(2);
ExampleTextField->setSelectionEnd(3);
ExampleTextField->setAlignment(Vec2f(0.0,0.5));
// Create another TextField Component
TextFieldRecPtr ExampleTextField2 = TextField::create();
ExampleTextField2->setText("");
ExampleTextField2->setEmptyDescText("Write in me, please");
ExampleTextField2->setPreferredSize(Vec2f(200.0f,ExampleTextField2->getPreferredSize().y()));
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
LayoutRecPtr MainInternalWindowLayout = FlowLayout::create();
InternalWindowRecPtr MainInternalWindow = InternalWindow::create();
MainInternalWindow->pushToChildren(ExampleTextField);
MainInternalWindow->pushToChildren(ExampleTextField2);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
// Create the Drawing Surface
UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRecPtr TutorialUIForeground = UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Tell the Manager what to manage
sceneManager.setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
// Show the whole Scene
sceneManager.showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"16TextField");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManagerRefPtr sceneManager = SimpleSceneManager::create();
TutorialWindow->setDisplayCallback(boost::bind(display, sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, sceneManager));
// Tell the Manager what to manage
sceneManager->setWindow(TutorialWindow);
TutorialWindow->connectKeyTyped(boost::bind(keyPressed, _1));
// Make Torus Node (creates Torus in background of scene)
NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRecPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRecPtr TutorialGraphics = Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
/******************************************************
Create PopupMenu Components
-MenuItem: These are items that are contained
within a Menu; they are the things you click
on to cause something to occur
-SeperatorMenuItem: These place a seperator
line between items in a Menu
-Menu: These are sub-menus within another Menu;
MenuItems and SeperatorMenuItems
are added to a Menu
******************************************************/
MenuItemRecPtr MenuItem1 = MenuItem::create();
MenuItemRecPtr MenuItem2 = MenuItem::create();
MenuItemRecPtr MenuItem3 = MenuItem::create();
MenuItemRecPtr MenuItem4 = MenuItem::create();
MenuItemRecPtr SubMenuItem1 = MenuItem::create();
MenuItemRecPtr SubMenuItem2 = MenuItem::create();
MenuItemRecPtr SubMenuItem3 = MenuItem::create();
MenuRecPtr ExampleSubMenu = Menu::create();
/******************************************************
Edit the MenuItems
-setText("TEXT"): Sets the text on the
item to be TEXT
-setEnabled(Boolean): sets the menu item
to be either enabled or disabled
******************************************************/
MenuItem1->setText("Menu Item 1");
MenuItem2->setText("Menu Item 2");
MenuItem3->setText("Menu Item 3");
MenuItem4->setText("Menu Item 4");
MenuItem4->setEnabled(false);
SubMenuItem1->setText("SubMenu Item 1");
SubMenuItem2->setText("SubMenu Item 2");
SubMenuItem3->setText("SubMenu Item 3");
ExampleSubMenu->setText("Sub Menu");
// This adds three MenuItems to the Menu,
// creating a submenu. Note this does not
// involve begin/endEditCPs to do
ExampleSubMenu->addItem(SubMenuItem1);
ExampleSubMenu->addItem(SubMenuItem2);
ExampleSubMenu->addItem(SubMenuItem3);
/******************************************************
Create the PopupMenu itself.
Items are added in the order in which
they will be displayed (top to bottom)
via addItem(ItemToBeAdded)
The PopupMenu is attached to a
Button below using
setPopupMenu(PopupMenuName).
Note: PopupMenus can be added to any
Component.
******************************************************/
PopupMenuRecPtr ExamplePopupMenu = PopupMenu::create();
ExamplePopupMenu->setMinSize(Vec2f(100.0f, 20.0f));
ExamplePopupMenu->setMaxSize(Vec2f(100.0f, 80.0f));
ExamplePopupMenu->addItem(MenuItem1);
ExamplePopupMenu->addItem(MenuItem2);
ExamplePopupMenu->addItem(MenuItem3);
ExamplePopupMenu->addSeparator();
ExamplePopupMenu->addItem(ExampleSubMenu);
ExamplePopupMenu->addItem(MenuItem4);
// Create a Button and Font
UIFontRecPtr PopupMenuButtonFont = UIFont::create();
PopupMenuButtonFont->setSize(16);
ButtonRecPtr PopupMenuButton = Button::create();
PopupMenuButton->setText("RightClickMe!");
// Add the PopupMenu to PopupMenuButton so that when right clicked,
// the PopupMenu will appear
PopupMenuButton->setPopupMenu(ExamplePopupMenu);
PopupMenuButton->setPreferredSize(Vec2f(200,100));
PopupMenuButton->setFont(PopupMenuButtonFont);
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
LayoutRecPtr MainInternalWindowLayout = FlowLayout::create();
InternalWindowRecPtr MainInternalWindow = InternalWindow::create();
MainInternalWindow->pushToChildren(PopupMenuButton);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
// Create the Drawing Surface
UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRecPtr TutorialUIForeground = UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Tell the Manager what to manage
sceneManager->setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRecPtr TutorialViewport = sceneManager->getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
//Create the Documentation Foreground and add it to the viewport
SimpleScreenDoc TheSimpleScreenDoc(sceneManager, TutorialWindow);
// Show the whole Scene
sceneManager->showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"01RubberBandCamera");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
TutorialWindow->connectKeyTyped(boost::bind(keyPressed, _1));
// Make Torus Node (creates Torus in background of scene)
NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRecPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRecPtr TutorialGraphics = Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
/******************************************************
Create a Spinner Model. This dictates
how the Spinner functions.
-setMaximum(int): Determine the Maximum
value the Spinner can have.
-setMinimum(int): Determine the Minimum
value the Spinner can have.
-setStepSize(int): Determine the
incremental step size.
-setValue(SharedFieldRecPtr(new SFInt32(int)):
Determine initial starting value
of the Spinner.
Note: the StepSize can be changed
dynamically as done in this
Tutorial with ButtonSelectedListeners.
******************************************************/
//Int32SpinnerModelPtr TheModel(new Int32SpinnerModel());
Int32SpinnerModelPtr TheModel(new Int32SpinnerModel());
TheModel->setMaximum(100);
TheModel->setMinimum(-100);
TheModel->setStepSize(1);
TheModel->setValue(boost::any(Int32(0)));
/******************************************************
Create a Spinner and and assign it a
Model.
******************************************************/
SpinnerRecPtr ExampleSpinner = Spinner::create();
ExampleSpinner->setModel(TheModel);
/******************************************************
Create a RadioButtonPanel to allow
for certain characteristics of the
Spinner to be changed dynamically.
See 14RadioButton for more
information about RadioButtons.
******************************************************/
RadioButtonRecPtr SingleIncrementButton = RadioButton::create();
RadioButtonRecPtr DoubleIncrementButton = RadioButton::create();
SingleIncrementButton->setText("Increment by 1");
SingleIncrementButton->setPreferredSize(Vec2f(100, 50));
SingleIncrementButton->connectButtonSelected(boost::bind(handleSingleIncbuttonSelected, _1,
TheModel));
DoubleIncrementButton->setText("Increment by 2");
DoubleIncrementButton->setPreferredSize(Vec2f(100, 50));
DoubleIncrementButton->connectButtonSelected(boost::bind(handleDoubleIncbuttonSelected, _1,
TheModel));
RadioButtonGroupRecPtr SelectionRadioButtonGroup = RadioButtonGroup::create();
SelectionRadioButtonGroup->addButton(SingleIncrementButton);
SelectionRadioButtonGroup->addButton(DoubleIncrementButton);
SingleIncrementButton->setSelected(true);
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
LayoutRecPtr MainInternalWindowLayout = FlowLayout::create();
InternalWindowRecPtr MainInternalWindow = InternalWindow::create();
MainInternalWindow->pushToChildren(SingleIncrementButton);
MainInternalWindow->pushToChildren(DoubleIncrementButton);
MainInternalWindow->pushToChildren(ExampleSpinner);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
// Create the Drawing Surface
UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRecPtr TutorialUIForeground = UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Tell the Manager what to manage
sceneManager.setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
// Show the whole Scene
sceneManager.showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"29Spinner");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManagerRefPtr sceneManager = SimpleSceneManager::create();
TutorialWindow->setDisplayCallback(boost::bind(display, sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, sceneManager));
// Tell the Manager what to manage
sceneManager->setWindow(TutorialWindow);
TutorialWindow->connectKeyTyped(boost::bind(keyPressed, _1));
// Make Torus Node (creates Torus in background of scene)
NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRecPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRecPtr TutorialGraphics = Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
/******************************************************
Creates RadioButton components and
edit them. The RadioButton class
inherits from the Button class.
Radio Buttons are special ToggleButtons.
When they are selected, any RadioButton in
the same group is deselected, so there can
only be one option selected.
Advanced options for RadioButton can
be found in the DefaultLookAndFeel.cpp
file found in OSGUserInterface/Source Files/
LookAndFeel (options for changing the
RadioButton style, etc).
******************************************************/
RadioButtonRecPtr ExampleRadioButton1 = RadioButton::create();
RadioButtonRecPtr ExampleRadioButton2 = RadioButton::create();
RadioButtonRecPtr ExampleRadioButton3 = RadioButton::create();
ExampleRadioButton1->setAlignment(Vec2f(0.0,0.5));
ExampleRadioButton1->setPreferredSize(Vec2f(100, 50));
ExampleRadioButton1->setText("Option 1");
ExampleRadioButton2->setAlignment(Vec2f(0.0,0.5));
ExampleRadioButton2->setPreferredSize(Vec2f(100, 50));
ExampleRadioButton2->setText("Option 2");
ExampleRadioButton3->setAlignment(Vec2f(0.0,0.5));
ExampleRadioButton3->setPreferredSize(Vec2f(100, 50));
ExampleRadioButton3->setText("Option 3");
/***************************************************
Create and populate a group of RadioButtons.
Defining the group allows you to pick which
RadioButtons are tied together so that only one
can be selected.
Each RadioButtonGroup can only have ONE
RadioButton selected at a time, and by
selecting this RadioButton, will deselect
all other RadioButtons in the RadioButtonGroup.
******************************************************/
RadioButtonGroupRecPtr ExampleRadioButtonGroup = RadioButtonGroup::create();
ExampleRadioButtonGroup->addButton(ExampleRadioButton1);
ExampleRadioButtonGroup->addButton(ExampleRadioButton2);
ExampleRadioButtonGroup->addButton(ExampleRadioButton3);
ExampleRadioButtonGroup->setSelectedButton(ExampleRadioButton2);
FlowLayoutRecPtr MainInternalWindowLayout = FlowLayout::create();
MainInternalWindowLayout->setOrientation(FlowLayout::VERTICAL_ORIENTATION);
MainInternalWindowLayout->setMajorAxisAlignment(0.5f);
MainInternalWindowLayout->setMinorAxisAlignment(0.5f);
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
InternalWindowRecPtr MainInternalWindow = InternalWindow::create();
MainInternalWindow->pushToChildren(ExampleRadioButton1);
MainInternalWindow->pushToChildren(ExampleRadioButton2);
MainInternalWindow->pushToChildren(ExampleRadioButton3);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
// Create the Drawing Surface
UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRecPtr TutorialUIForeground = UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Tell the Manager what to manage
sceneManager->setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRecPtr TutorialViewport = sceneManager->getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
//Create the Documentation Foreground and add it to the viewport
SimpleScreenDoc TheSimpleScreenDoc(sceneManager, TutorialWindow);
// Show the whole Scene
sceneManager->showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"14RadioButton");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
TutorialWindow->connectKeyTyped(boost::bind(keyPressed, _1));
NodeRecPtr Root(NULL);
if(argc == 2)
{
Root = SceneFileHandler::the()->read(argv[1]);
}
if(Root == NULL)
{
// Make Torus Node (creates Torus in background of Root)
NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
setName(TorusGeometryNode, std::string("Torus"));
NodeRecPtr TorusNode = Node::create();
TorusNode->setCore(Transform::create());
TorusNode->addChild(TorusGeometryNode);
setName(TorusNode, std::string("Torus Transform"));
NodeRecPtr SphereGeometryNode = makeSphere(2,1.0f);
setName(SphereGeometryNode, std::string("Sphere"));
NodeRecPtr BoxGeometryNode = makeBox(1.0,1.0,1.0,1,1,1);
setName(BoxGeometryNode, std::string("Box"));
// Make Main Scene Node and add the Torus
Root = Node::create();
Root->setCore(Group::create());
Root->addChild(TorusNode);
Root->addChild(SphereGeometryNode);
Root->addChild(BoxGeometryNode);
setName(Root, std::string("Root"));
}
// Create the Graphics
GraphicsRecPtr TutorialGraphics = Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
//Tree Model
SceneGraphTreeModelRecPtr TheTreeModel = SceneGraphTreeModel::create();
TheTreeModel->setRoot(Root);
//Create the Tree
TreeRecPtr TheTree = Tree::create();
TheTree->setPreferredSize(Vec2f(100, 500));
TheTree->setModel(TheTreeModel);
// Create a ScrollPanel for easier viewing of the List (see 27ScrollPanel)
BorderLayoutConstraintsRecPtr SceneTreeConstraints = BorderLayoutConstraints::create();
SceneTreeConstraints->setRegion(BorderLayoutConstraints::BORDER_WEST);
ScrollPanelRecPtr ExampleScrollPanel = ScrollPanel::create();
ExampleScrollPanel->setPreferredSize(Vec2f(350,300));
ExampleScrollPanel->setConstraints(SceneTreeConstraints);
//ExampleScrollPanel->setHorizontalResizePolicy(ScrollPanel::RESIZE_TO_VIEW);
//ExampleScrollPanel->setVerticalResizePolicy(ScrollPanel::RESIZE_TO_VIEW);
ExampleScrollPanel->setViewComponent(TheTree);
//Details Panel Labels
LabelRecPtr NodeNameLabel = Label::create();
NodeNameLabel->setText("Name");
NodeNameLabel->setPreferredSize(Vec2f(100.0f, 20.0f));
LabelRecPtr NodeNameValueLabel = Label::create();
NodeNameValueLabel->setPreferredSize(Vec2f(300.0f, 20.0f));
LabelRecPtr NodeCoreTypeLabel = Label::create();
NodeCoreTypeLabel->setText("Core Type");
NodeCoreTypeLabel->setPreferredSize(Vec2f(100.0f, 20.0f));
LabelRecPtr NodeCoreTypeValueLabel = Label::create();
NodeCoreTypeValueLabel->setPreferredSize(Vec2f(300.0f, 20.0f));
LabelRecPtr NodeMinLabel = Label::create();
NodeMinLabel->setText("Min");
NodeMinLabel->setPreferredSize(Vec2f(100.0f, 20.0f));
LabelRecPtr NodeMinValueLabel = Label::create();
NodeMinValueLabel->setPreferredSize(Vec2f(300.0f, 20.0f));
LabelRecPtr NodeMaxLabel = Label::create();
NodeMaxLabel->setText("Max");
NodeMaxLabel->setPreferredSize(Vec2f(100.0f, 20.0f));
LabelRecPtr NodeMaxValueLabel = Label::create();
NodeMaxValueLabel->setPreferredSize(Vec2f(300.0f, 20.0f));
LabelRecPtr NodeCenterLabel = Label::create();
NodeCenterLabel->setText("Center");
NodeCenterLabel->setPreferredSize(Vec2f(100.0f, 20.0f));
LabelRecPtr NodeCenterValueLabel = Label::create();
NodeCenterValueLabel->setPreferredSize(Vec2f(300.0f, 20.0f));
LabelRecPtr NodeTriCountLabel = Label::create();
NodeTriCountLabel->setText("TriCount");
NodeTriCountLabel->setPreferredSize(Vec2f(100.0f, 20.0f));
LabelRecPtr NodeTriCountValueLabel = Label::create();
NodeTriCountValueLabel->setPreferredSize(Vec2f(300.0f, 20.0f));
LabelRecPtr NodeTravMaskLabel = Label::create();
NodeTravMaskLabel->setText("Traversal Mask");
NodeTravMaskLabel->setPreferredSize(Vec2f(100.0f, 20.0f));
LabelRecPtr NodeTravMaskValueLabel = Label::create();
NodeTravMaskValueLabel->setPreferredSize(Vec2f(300.0f, 20.0f));
//Details Panel
BorderLayoutConstraintsRecPtr NodeDetailPanelConstraints = BorderLayoutConstraints::create();
NodeDetailPanelConstraints->setRegion(BorderLayoutConstraints::BORDER_SOUTH);
GridLayoutRecPtr NodeDetailPanelLayout = GridLayout::create();
NodeDetailPanelLayout->setRows(7);
NodeDetailPanelLayout->setColumns(2);
NodeDetailPanelLayout->setHorizontalGap(2);
NodeDetailPanelLayout->setVerticalGap(2);
PanelRecPtr NodeDetailPanel = Panel::create();
NodeDetailPanel->setConstraints(NodeDetailPanelConstraints);
NodeDetailPanel->setPreferredSize(Vec2f(100.0f, 200.0f));
NodeDetailPanel->setLayout(NodeDetailPanelLayout);
NodeDetailPanel->pushToChildren(NodeNameLabel);
NodeDetailPanel->pushToChildren(NodeNameValueLabel);
NodeDetailPanel->pushToChildren(NodeCoreTypeLabel);
NodeDetailPanel->pushToChildren(NodeCoreTypeValueLabel);
NodeDetailPanel->pushToChildren(NodeMinLabel);
NodeDetailPanel->pushToChildren(NodeMinValueLabel);
NodeDetailPanel->pushToChildren(NodeMaxLabel);
NodeDetailPanel->pushToChildren(NodeMaxValueLabel);
NodeDetailPanel->pushToChildren(NodeCenterLabel);
NodeDetailPanel->pushToChildren(NodeCenterValueLabel);
NodeDetailPanel->pushToChildren(NodeTriCountLabel);
NodeDetailPanel->pushToChildren(NodeTriCountValueLabel);
NodeDetailPanel->pushToChildren(NodeTravMaskLabel);
NodeDetailPanel->pushToChildren(NodeTravMaskValueLabel);
SelectionHandler TheTreeSelectionHandler(TheTree,
&sceneManager,
NodeNameValueLabel,
NodeCoreTypeValueLabel,
NodeMinValueLabel,
NodeMaxValueLabel,
NodeCenterValueLabel,
NodeTriCountValueLabel,
NodeTravMaskValueLabel);
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
LayoutRecPtr MainInternalWindowLayout = BorderLayout::create();
InternalWindowRecPtr MainInternalWindow = InternalWindow::create();
MainInternalWindow->pushToChildren(ExampleScrollPanel);
MainInternalWindow->pushToChildren(NodeDetailPanel);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(NULL);
MainInternalWindow->setBorders(NULL);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.0f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(1.0,1.0));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
// Create the Drawing Surface
UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRecPtr TutorialUIForeground = UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Tell the Manager what to manage
sceneManager.setRoot(Root);
// Add the UI Foreground Object to the Scene
ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
//Create the Documentation Foreground and add it to the viewport
SimpleScreenDoc TheSimpleScreenDoc(&sceneManager, TutorialWindow);
// Show the whole Scene
sceneManager.showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"52SceneGraphTree");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
TutorialWindow->connectKeyTyped(boost::bind(keyPressed, _1));
// Make Torus Node (creates Torus in background of scene)
NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRecPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRecPtr TutorialGraphics = Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
/******************************************************
Create some Button Components
******************************************************/
ButtonRecPtr ExampleButton1 = Button::create();
ButtonRecPtr ExampleButton2 = Button::create();
ButtonRecPtr ExampleButton3 = Button::create();
ButtonRecPtr ExampleButton4 = Button::create();
/******************************************************
Create Box Layout. Box Layout arranges objects
automatically within the Frame, so that the objects
are evenly spaced within the Frame.
Box Layout also causes all objects to have the same
height (if arranged Horizontally) or the same width
(if arranged Vertically) using the maximum width of the
objects in the Layout. This overrides the specified
dimensions of the object, unless the object has a
Maximum or Minimum size set. In this case, the object
size cannot be changed to greater than the Maximum size,
or less than the Minimum size (it will still be changed,
however it will not exceed the Max/Min size).
You can experiment with this by changing the window
size, changing the size of the Buttons as shown
in 01Button, editing the Buttons, or adding more
Buttons to the view.
Note that if the Frame is too small, the objects will
appear out of the Frame background.
-setOrientation(ENUM): Determine alignment of
Layout. Takes VERTICAL_ORIENTATION and
HORIZONTAL_ORIENTATION arguments.
******************************************************/
BoxLayoutRecPtr MainInternalWindowLayout = BoxLayout::create();
MainInternalWindowLayout->setOrientation(BoxLayout::VERTICAL_ORIENTATION); //Make the swap to see what happens Between Vertical and Horizontal!
//MainInternalWindowLayout->setOrientation(BoxLayout::HORIZONTAL_ORIENTATION);
/******************************************************
Edit some of the Button Components.
Because of how BoxLayout works, by
setting a MaxSize, even though other
Buttons within the Layout will be resized,
ExampleButton1 cannot be larger than
Vec2f(50,50). The default size for
all Buttons is Vec2f(100,50) [see
DefaultLookAndFeel.cpp], but because
ExampleButton2 is larger, each of
the other Buttons will be resized
to match ExampleButton2's larger
size.
Experiment by commenting out either
line and observing the results.
******************************************************/
ExampleButton1->setPreferredSize(Vec2f(50,50));
ExampleButton1->setMaxSize(Vec2f(50, 50)); //The max size determines how large this button can be even though the BoxLayout says otherwise.(comment out to see the difference)
ExampleButton2->setPreferredSize(Vec2f(200,100));
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
InternalWindowRecPtr MainInternalWindow = InternalWindow::create();
MainInternalWindow->pushToChildren(ExampleButton1);
MainInternalWindow->pushToChildren(ExampleButton2);
MainInternalWindow->pushToChildren(ExampleButton3);
MainInternalWindow->pushToChildren(ExampleButton4);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
// Create the Drawing Surface
UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRecPtr TutorialUIForeground = UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Tell the Manager what to manage
sceneManager.setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
// Show the whole Scene
sceneManager.showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"06BoxLayout");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
// Initialize WIN32 & OpenSG and set up the scene
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
TutorialWindow->connectKeyTyped(boost::bind(keyPressed, _1));
// Make Torus Node (creates Torus in background of scene)
NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRecPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRecPtr graphics = Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
/******************************************************
Create the DefaultMutableComboBoxModel and
add Elements to it (several Colors
in this case). These will be the data
values shown in the ComboBox.
******************************************************/
DefaultMutableComboBoxModelRecPtr ExampleComboBoxModel = DefaultMutableComboBoxModel::create();
ExampleComboBoxModel->addElement(boost::any(std::string("Red")));
ExampleComboBoxModel->addElement(boost::any(std::string("Green")));
ExampleComboBoxModel->addElement(boost::any(std::string("Blue")));
ExampleComboBoxModel->addElement(boost::any(std::string("Brown")));
ExampleComboBoxModel->addElement(boost::any(std::string("Yellow")));
ExampleComboBoxModel->addElement(boost::any(std::string("Orange")));
ExampleComboBoxModel->addElement(boost::any(std::string("Violet")));
ExampleComboBoxModel->addElement(boost::any(std::string("Black")));
/******************************************************
Create an editable ComboBox. A ComboBox
has a Model just like various other
Components.
******************************************************/
//Create the ComboBox
ComboBoxRecPtr ExampleComboBox = ComboBox::create();
// Set the Model created above to the ComboBox
ExampleComboBox->setModel(ExampleComboBoxModel);
// Determine where the ComboBox starts
ExampleComboBox->setSelectedIndex(0);
/******************************************************
Create a non-editable ComboBox.
-setEditable(bool): Determine whether
the user can type in the ComboBox
or if it is uneditable. In this
case, it is set to false.
When creating a non-editable ComboBox,
a Renderer must also be assigned. For
editable ComboBoxes, the ComboBox
automatically shows its text due to the
nature of the ComboBox. However, when
uneditable, this aspect of the ComboBox
is disabled, and so to display the
selection, a renderer must be created and
assigned to the ComboBox.
Note: as with Sliders and ScrollBars,
having the same Model assigned causes
the ComboBoxes to be tied together.
******************************************************/
// Create another ComboBox
ComboBoxRecPtr ExampleUneditableComboBox = ComboBox::create();
// Set it to be uneditable
ExampleUneditableComboBox->setEditable(false);
ExampleUneditableComboBox->setModel(ExampleComboBoxModel);
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
LayoutRecPtr MainInternalWindowLayout = FlowLayout::create();
InternalWindowRecPtr MainInternalWindow = InternalWindow::create();
MainInternalWindow->pushToChildren(ExampleComboBox);
MainInternalWindow->pushToChildren(ExampleUneditableComboBox);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
//Create the Drawing Surface
UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(graphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRecPtr foreground = UIForeground::create();
foreground->setDrawingSurface(TutorialDrawingSurface);
// Tell the manager what to manage
sceneManager.setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRecPtr viewport = sceneManager.getWindow()->getPort(0);
viewport->addForeground(foreground);
//Create the Documentation Foreground and add it to the viewport
SimpleScreenDoc TheSimpleScreenDoc(&sceneManager, TutorialWindow);
// Show the whole scene
sceneManager.showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"33ComboBox");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
// Initialize WIN32 & OpenSG and set up the scene
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManagerRefPtr sceneManager = SimpleSceneManager::create();
TutorialWindow->setDisplayCallback(boost::bind(display, sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, sceneManager));
// Tell the Manager what to manage
sceneManager->setWindow(TutorialWindow);
TutorialWindow->connectKeyTyped(boost::bind(keyPressed, _1));
// Make Torus Node (creates Torus in background of scene)
NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRecPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRecPtr TutorialGraphics = Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
// Create the DefaultBoundedRangeModel and
// set its values
DefaultBoundedRangeModelRecPtr TheBoundedRangeModel = DefaultBoundedRangeModel::create();
TheBoundedRangeModel->setMinimum(10);
TheBoundedRangeModel->setMaximum(110);
TheBoundedRangeModel->setValue(60);
TheBoundedRangeModel->setExtent(0);
//Create the slider
LabelRecPtr TempLabel;
SliderRecPtr TheSliderVertical = Slider::create();
TempLabel = dynamic_pointer_cast<Label>(TheSliderVertical->getLabelPrototype()->shallowCopy());
TheSliderVertical->editLabelMap()[TheBoundedRangeModel->getMinimum()] = TempLabel;
TempLabel = dynamic_pointer_cast<Label>(TheSliderVertical->getLabelPrototype()->shallowCopy());
TheSliderVertical->editLabelMap()[TheBoundedRangeModel->getMinimum() + (TheBoundedRangeModel->getMaximum() - TheBoundedRangeModel->getMinimum())/10] = TempLabel;
TempLabel = dynamic_pointer_cast<Label>(TheSliderVertical->getLabelPrototype()->shallowCopy());
TheSliderVertical->editLabelMap()[TheBoundedRangeModel->getMaximum()] = TempLabel;
TheSliderVertical->setPreferredSize(Vec2f(100, 300));
TheSliderVertical->setSnapToTicks(true);
TheSliderVertical->setMajorTickSpacing(10);
TheSliderVertical->setMinorTickSpacing(5);
TheSliderVertical->setOrientation(Slider::VERTICAL_ORIENTATION);
TheSliderVertical->setInverted(true);
TheSliderVertical->setDrawLabels(true);
TheSliderVertical->setRangeModel(TheBoundedRangeModel);
TheSliderVertical->setAlignment(0.1);
SliderRecPtr TheSliderHorizontal = Slider::create();
TheSliderHorizontal->setPreferredSize(Vec2f(300, 100));
TheSliderHorizontal->setSnapToTicks(false);
TheSliderHorizontal->setMajorTickSpacing(10);
TheSliderHorizontal->setMinorTickSpacing(5);
TheSliderHorizontal->setOrientation(Slider::HORIZONTAL_ORIENTATION);
TheSliderHorizontal->setInverted(false);
TheSliderHorizontal->setDrawLabels(true);
TheSliderHorizontal->setRangeModel(TheBoundedRangeModel);
TheSliderHorizontal->setTicksOnRightBottom(false);
// Create Background to be used with the MainFrame
ColorLayerRecPtr MainFrameBackground = ColorLayer::create();
MainFrameBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
LayoutRecPtr MainInternalWindowLayout = FlowLayout::create();
InternalWindowRecPtr MainInternalWindow = InternalWindow::create();
MainInternalWindow->pushToChildren(TheSliderVertical);
MainInternalWindow->pushToChildren(TheSliderHorizontal);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.75f,0.75f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
// Create the Drawing Surface
UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRecPtr TutorialUIForeground = UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Tell the Manager what to manage
sceneManager->setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRecPtr TutorialViewport = sceneManager->getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
//Create the Documentation Foreground and add it to the viewport
SimpleScreenDoc TheSimpleScreenDoc(sceneManager, TutorialWindow);
// Show the whole Scene
sceneManager->showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"32Slider");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
// Initialize WIN32 & OpenSG and set up the scene
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
TutorialWindow->connectKeyTyped(boost::bind(keyPressed, _1));
// Make Torus Node (creates Torus in background of scene)
NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRecPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRecPtr graphics = Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
/******************************************************
Create the DerivedFieldContainerComboBoxModel and
add Elements to it (derived FieldContainerTypes
). These will be the data
values shown in the ComboBox.
******************************************************/
DerivedFieldContainerComboBoxModelRecPtr ExampleComboBoxModel = DerivedFieldContainerComboBoxModel::create();
ExampleComboBoxModel->editMFDerivedFieldContainerTypes()->push_back(std::string(Component::getClassType().getCName()));
/******************************************************
Create an editable ComboBox. A ComboBox
has a Model just like various other
Components.
******************************************************/
//Create the ComboBox
ComboBoxRecPtr ExampleUneditableComboBox = ComboBox::create();
// Set it to be uneditable
ExampleUneditableComboBox->setEditable(false);
ExampleUneditableComboBox->setModel(ExampleComboBoxModel);
ExampleUneditableComboBox->setSelectedIndex(0);
ExampleUneditableComboBox->setPreferredSize(Vec2f(160.0f,ExampleUneditableComboBox->getPreferredSize().y()));
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
FlowLayoutRecPtr MainInternalWindowLayout = FlowLayout::create();
MainInternalWindowLayout->setMinorAxisAlignment(0.2f);
InternalWindowRecPtr MainInternalWindow = InternalWindow::create();
MainInternalWindow->pushToChildren(ExampleUneditableComboBox);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.8f,0.8f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
//Create the Drawing Surface
UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(graphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRecPtr foreground = UIForeground::create();
foreground->setDrawingSurface(TutorialDrawingSurface);
// Tell the manager what to manage
sceneManager.setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRecPtr viewport = sceneManager.getWindow()->getPort(0);
viewport->addForeground(foreground);
// Show the whole scene
sceneManager.showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"42FieldContainerComboBox");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
TutorialWindow->connectKeyTyped(boost::bind(keyPressed, _1));
// Make Torus Node (creates Torus in background of scene)
NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRecPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRecPtr TutorialGraphics = Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
/******************************************************
Creates some Button components
******************************************************/
ButtonRecPtr ExampleButton1 = Button::create();
ButtonRecPtr ExampleButton2 = Button::create();
ButtonRecPtr ExampleButton3 = Button::create();
ButtonRecPtr ExampleButton4 = Button::create();
ButtonRecPtr ExampleButton5 = Button::create();
ButtonRecPtr ExampleButton6 = Button::create();
/******************************************************
Create OverlayLayout. This layout simply
places all Components within it on top of
each other.
They are placed in reverse order of how they
are added to the MainFrame (Components added
first are rendered last, those added last are
rendered first).
Note: OverlayLayout has no options which
can be set.
******************************************************/
OverlayLayoutRecPtr MainInternalWindowLayout = OverlayLayout::create();
// OverlayLayout has no options to edit!
// NOTHING : )
/******************************************************
Create and edit some Button Components.
******************************************************/
ExampleButton1->setPreferredSize(Vec2f(50,50));
ExampleButton1->setMaxSize(Vec2f(50,50));
ExampleButton2->setPreferredSize(Vec2f(300,50));
ExampleButton3->setPreferredSize(Vec2f(50,300));
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
InternalWindowRecPtr MainInternalWindow = InternalWindow::create();
MainInternalWindow->pushToChildren(ExampleButton1);
MainInternalWindow->pushToChildren(ExampleButton2);
MainInternalWindow->pushToChildren(ExampleButton3);
MainInternalWindow->pushToChildren(ExampleButton4);
MainInternalWindow->pushToChildren(ExampleButton5);
MainInternalWindow->pushToChildren(ExampleButton6);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
// Create the Drawing Surface
UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRecPtr TutorialUIForeground = UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Tell the Manager what to manage
sceneManager.setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
// Show the whole Scene
sceneManager.showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"08OverlayLayout");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
TutorialWindow->connectKeyTyped(boost::bind(keyPressed, _1));
NodeRecPtr Root(NULL);
if(argc == 2)
{
Root = SceneFileHandler::the()->read(argv[1]);
}
if(Root == NULL)
{
// Make Torus Node (creates Torus in background of Root)
NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
NodeRecPtr TorusNode = Node::create();
TorusNode->setCore(Transform::create());
TorusNode->addChild(TorusGeometryNode);
NodeRecPtr SphereGeometryNode = makeSphere(2,1.0f);
NodeRecPtr BoxGeometryNode = makeBox(1.0,1.0,1.0,1,1,1);
// Make Main Scene Node and add the Torus
Root = Node::create();
Root->setCore(Group::create());
Root->addChild(TorusNode);
Root->addChild(SphereGeometryNode);
Root->addChild(BoxGeometryNode);
}
// Create the Graphics
GraphicsRecPtr TutorialGraphics = Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
LayoutRecPtr MainInternalWindowLayout = FlowLayout::create();
//Import InternalWindow(s) from XML file
std::vector<InternalWindowRecPtr> StoreWindows;
FCFileType::FCPtrStore NewContainers;
NewContainers = FCFileHandler::the()->read(BoostPath("./Data/55ComponentTree.xml"));
//Store each window found in the XML in the vector
FCFileType::FCPtrStore::iterator Itor;
for(Itor = NewContainers.begin(); Itor != NewContainers.end(); ++Itor)
{
if( (*Itor)->getType() == (InternalWindow::getClassType()))
{
StoreWindows.push_back(dynamic_pointer_cast<InternalWindow>(*Itor));
}
}
//Tree Model
FieldContainerTreeModelRecPtr TheTreeModel = FieldContainerTreeModel::create();
TheTreeModel->setRoot(StoreWindows.front());
//TheTreeModel->setShowPtrFields(false);
//TheTreeModel->setShowDataFields(false);
//TheTreeModel->setShowParentPtrFields(false);
//TheTreeModel->setShowChildPtrFields(false);
TheTreeModel->setShowAttachments(false);
//TheTreeModel->setShowCallbackFunctors(false);
//Tree Component Generator
FieldContainerFieldPathComponentGeneratorRecPtr TheTreeComponentGenerator = FieldContainerFieldPathComponentGenerator::create();
//Create the Tree
TreeRecPtr TheTree = Tree::create();
TheTree->setPreferredSize(Vec2f(100, 500));
TheTree->setRootVisible(true);
TheTree->setModel(TheTreeModel);
TheTree->setCellGenerator(TheTreeComponentGenerator);
setName(TheTree, std::string("TheTree"));
// Create a ScrollPanel for easier viewing of the List (see 27ScrollPanel)
ScrollPanelRecPtr ExampleScrollPanel = ScrollPanel::create();
ExampleScrollPanel->setPreferredSize(Vec2f(350,500));
//ExampleScrollPanel->setHorizontalResizePolicy(ScrollPanel::RESIZE_TO_VIEW);
//ExampleScrollPanel->setVerticalResizePolicy(ScrollPanel::RESIZE_TO_VIEW);
ExampleScrollPanel->setViewComponent(TheTree);
setName(ExampleScrollPanel, std::string("ExampleScrollPanel"));
//Show Buttons
CheckboxButtonRecPtr ShowMultiFieldsButton = CheckboxButton::create();
CheckboxButtonRecPtr ShowSingleFieldsButton = CheckboxButton::create();
CheckboxButtonRecPtr ShowPtrFieldsButton = CheckboxButton::create();
CheckboxButtonRecPtr ShowDataFieldsButton = CheckboxButton::create();
CheckboxButtonRecPtr ShowParentPtrFieldsButton = CheckboxButton::create();
CheckboxButtonRecPtr ShowChildPtrFieldsButton = CheckboxButton::create();
CheckboxButtonRecPtr ShowAttachmentsButton = CheckboxButton::create();
CheckboxButtonRecPtr ShowCallbackFunctorsButton = CheckboxButton::create();
CheckboxButtonRecPtr ShowInternalFieldsButton = CheckboxButton::create();
ShowMultiFieldsButton->setText("Multi Fields");
ShowMultiFieldsButton->setPreferredSize(Vec2f(120.0f,ShowMultiFieldsButton->getPreferredSize().y()));
ShowMultiFieldsButton->setAlignment(Vec2f(0.0f,0.5f));
ShowSingleFieldsButton->setText("Single Fields");
ShowSingleFieldsButton->setPreferredSize(Vec2f(120.0f,ShowSingleFieldsButton->getPreferredSize().y()));
ShowSingleFieldsButton->setAlignment(Vec2f(0.0f,0.5f));
ShowPtrFieldsButton->setText("Ptr Fields");
ShowPtrFieldsButton->setPreferredSize(Vec2f(120.0f,ShowPtrFieldsButton->getPreferredSize().y()));
ShowPtrFieldsButton->setAlignment(Vec2f(0.0f,0.5f));
ShowDataFieldsButton->setText("Data Fields");
ShowDataFieldsButton->setPreferredSize(Vec2f(120.0f,ShowDataFieldsButton->getPreferredSize().y()));
ShowDataFieldsButton->setAlignment(Vec2f(0.0f,0.5f));
ShowParentPtrFieldsButton->setText("ParentPtr Fields");
ShowParentPtrFieldsButton->setPreferredSize(Vec2f(120.0f,ShowParentPtrFieldsButton->getPreferredSize().y()));
ShowParentPtrFieldsButton->setAlignment(Vec2f(0.0f,0.5f));
ShowChildPtrFieldsButton->setText("ChildPtr Fields");
ShowChildPtrFieldsButton->setPreferredSize(Vec2f(120.0f,ShowChildPtrFieldsButton->getPreferredSize().y()));
ShowChildPtrFieldsButton->setAlignment(Vec2f(0.0f,0.5f));
ShowAttachmentsButton->setText("Attachments");
ShowAttachmentsButton->setPreferredSize(Vec2f(120.0f,ShowAttachmentsButton->getPreferredSize().y()));
ShowAttachmentsButton->setAlignment(Vec2f(0.0f,0.5f));
ShowCallbackFunctorsButton->setText("Callback Functors");
ShowCallbackFunctorsButton->setPreferredSize(Vec2f(120.0f,ShowCallbackFunctorsButton->getPreferredSize().y()));
ShowCallbackFunctorsButton->setAlignment(Vec2f(0.0f,0.5f));
ShowInternalFieldsButton->setText("Internal Fields");
ShowInternalFieldsButton->setPreferredSize(Vec2f(120.0f,ShowInternalFieldsButton->getPreferredSize().y()));
ShowInternalFieldsButton->setAlignment(Vec2f(0.0f,0.5f));
ShowCheckboxesController CheckboxesController(TheTreeModel,
ShowMultiFieldsButton,
ShowSingleFieldsButton,
ShowPtrFieldsButton,
ShowDataFieldsButton,
ShowParentPtrFieldsButton,
ShowChildPtrFieldsButton,
ShowAttachmentsButton,
ShowCallbackFunctorsButton,
ShowInternalFieldsButton);
PanelRecPtr OptionsPanel = Panel::create();
FlowLayoutRecPtr OptionsPanelLayout = FlowLayout::create();
OptionsPanel->setLayout(OptionsPanelLayout);
OptionsPanel->setPreferredSize(Vec2f(250.0f, 300.0f));
OptionsPanel->pushToChildren(ShowMultiFieldsButton);
OptionsPanel->pushToChildren(ShowSingleFieldsButton);
OptionsPanel->pushToChildren(ShowPtrFieldsButton);
OptionsPanel->pushToChildren(ShowDataFieldsButton);
OptionsPanel->pushToChildren(ShowInternalFieldsButton);
OptionsPanel->pushToChildren(ShowParentPtrFieldsButton);
OptionsPanel->pushToChildren(ShowChildPtrFieldsButton);
OptionsPanel->pushToChildren(ShowAttachmentsButton);
OptionsPanel->pushToChildren(ShowCallbackFunctorsButton);
InternalWindowRecPtr MainInternalWindow = InternalWindow::create();
MainInternalWindow->pushToChildren(ExampleScrollPanel);
MainInternalWindow->pushToChildren(OptionsPanel);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.85f,0.85f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
setName(MainInternalWindow, std::string("MainInternalWindow"));
// Create the Drawing Surface
UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
TutorialDrawingSurface->openWindow(StoreWindows.back());
// Create the UI Foreground Object
UIForegroundRecPtr TutorialUIForeground = UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Tell the Manager what to manage
sceneManager.setRoot(Root);
// Add the UI Foreground Object to the Scene
ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
// Show the whole Scene
sceneManager.showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"56FieldContainerTree");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
TutorialWindow->connectKeyTyped(boost::bind(keyPressed, _1));
// Make Torus Node (creates Torus in background of scene)
NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRecPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRecPtr TutorialGraphics = Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
// Create a simple Font to be used with the PasswordField
UIFontRecPtr ExampleFont = UIFont::create();
ExampleFont->setSize(16);
/******************************************************
Create and edit a PasswordField.
A PasswordField is a TextField
which allows for text to be
entered secretly.
-setEchoCar("char"): Determine
which character replaces text in the
PasswordField.
See 16TextField for more information.
******************************************************/
TextFieldRecPtr ExampleTextField = TextField::create();
ExampleTextField->setText("");
ExampleTextField->setEmptyDescText("username");
ExampleTextField->setPreferredSize(Vec2f(130.0f,ExampleTextField->getPreferredSize().y()));
PasswordFieldRecPtr ExamplePasswordField = PasswordField::create();
ExamplePasswordField->setPreferredSize(Vec2f(130, ExamplePasswordField->getPreferredSize().y()));
ExamplePasswordField->setTextColor(Color4f(0.0, 0.0, 0.0, 1.0));
ExamplePasswordField->setSelectionBoxColor(Color4f(0.0, 0.0, 1.0, 1.0));
ExamplePasswordField->setSelectionTextColor(Color4f(1.0, 1.0, 1.0, 1.0));
//ExamplePasswordField->setText("Text");
// "Text" will be replaced by "####" in the PasswordField
ExamplePasswordField->setEchoChar("#");
ExamplePasswordField->setEditable(true);
ExamplePasswordField->setFont(ExampleFont);
ExamplePasswordField->setSelectionStart(2);
ExamplePasswordField->setSelectionEnd(3);
ExamplePasswordField->setAlignment(Vec2f(0.0,0.5));
ExamplePasswordField->setEmptyDescText("password");
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
FlowLayoutRecPtr MainInternalWindowLayout = FlowLayout::create();
MainInternalWindowLayout->setOrientation(FlowLayout::VERTICAL_ORIENTATION);
InternalWindowRecPtr MainInternalWindow = InternalWindow::create();
MainInternalWindow->pushToChildren(ExampleTextField);
MainInternalWindow->pushToChildren(ExamplePasswordField);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
// Create the Drawing Surface
UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRecPtr TutorialUIForeground = UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Tell the Manager what to manage
sceneManager.setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
//Create the Documentation Foreground and add it to the viewport
SimpleScreenDoc TheSimpleScreenDoc(&sceneManager, TutorialWindow);
// Show the whole Scene
sceneManager.showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"24PasswordField");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManagerRefPtr sceneManager = SimpleSceneManager::create();
TutorialWindow->setDisplayCallback(boost::bind(display, sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, sceneManager));
// Tell the Manager what to manage
sceneManager->setWindow(TutorialWindow);
TutorialWindow->connectKeyTyped(boost::bind(keyPressed, _1));
// Make Torus Node (creates Torus in background of scene)
NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRecPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRecPtr TutorialGraphics = Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
/******************************************************
Create Grid Layout. Grid Layout arranges the
objects in a grid, with user specified rows,
columns, and gap size (conceptually imagine that
an invisible grid is drawn, and components are
placed into that grid one per "box").
Objects within the Grid Layout fill from left
to right, and top to bottom, filling in each space
sequentially. The Grid Layout "boxes" are each the
same size as the largest object within the Layout.
Smaller objects are automatically resized to fit
this size unless they have Max/Min sizes assigned
(similar to Box Layout).
You can experiment with this by changing the size of
the Buttons as shown in 01Button, editing the Max/Min
size of the Buttons, or adding more Buttons to the
scene.
Note that if the Frame is too small, the objects will
appear out of the Frame background.
-setRows(int): Determine the number of rows
in the Layout.
-setColumns(int): Determine the number of
columns in the Layout.
-setHorizontalGap(int): Determine the number
of pixels between each column.
setVerticalGap(int): Determine the number
of pixels between each row.
******************************************************/
GridLayoutRecPtr MainInternalWindowLayout = GridLayout::create();
MainInternalWindowLayout->setRows(3);
MainInternalWindowLayout->setColumns(2);
MainInternalWindowLayout->setHorizontalGap(4);
MainInternalWindowLayout->setVerticalGap(4);
/******************************************************
Create and edit some Button Components.
Note that as with BoxLayout, Components
are resized to fit their respective
grid boxes. Unless a MaxSize is set,
this will be the case. This will
override even PreferredSizes (see
ExampleButton3).
******************************************************/
ButtonRecPtr ExampleButton1 = Button::create();
ButtonRecPtr ExampleButton2 = Button::create();
ButtonRecPtr ExampleButton3 = Button::create();
ButtonRecPtr ExampleButton4 = Button::create();
ButtonRecPtr ExampleButton5 = Button::create();
ButtonRecPtr ExampleButton6 = Button::create();
ExampleButton1->setPreferredSize(Vec2f(50,50));
ExampleButton1->setMaxSize(Vec2f(50,50)); //if MaxSize is commented out, this button then will revert to being the same size as the others in the grid.
ExampleButton2->setPreferredSize(Vec2f(200,100)); //<----
// |
ExampleButton3->setPreferredSize(Vec2f(50,100)); //Notice that even though these two differ in size they appear the same on the grid
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
InternalWindowRecPtr MainInternalWindow = InternalWindow::create();
MainInternalWindow->pushToChildren(ExampleButton1);
MainInternalWindow->pushToChildren(ExampleButton2);
MainInternalWindow->pushToChildren(ExampleButton3);
MainInternalWindow->pushToChildren(ExampleButton4);
MainInternalWindow->pushToChildren(ExampleButton5);
MainInternalWindow->pushToChildren(ExampleButton6);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
// Create the Drawing Surface
UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRecPtr TutorialUIForeground = UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Tell the Manager what to manage
sceneManager->setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRecPtr TutorialViewport = sceneManager->getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
//Create the Documentation Foreground and add it to the viewport
SimpleScreenDoc TheSimpleScreenDoc(sceneManager, TutorialWindow);
// Show the whole Scene
sceneManager->showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"07GridLayout");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
TutorialWindow->connectKeyTyped(boost::bind(keyPressed, _1));
// Make Torus Node (creates Torus in background of scene)
NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRecPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRecPtr TutorialGraphics = Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
/******************************************************
Create BorderLayout and some
BorderLayoutConstraints to be used
to set up CardLayout.
******************************************************/
BorderLayoutRecPtr MainInternalWindowLayout = BorderLayout::create();
BorderLayoutConstraintsRecPtr ExampleButton1Constraints = BorderLayoutConstraints::create();
BorderLayoutConstraintsRecPtr ExampleButton2Constraints = BorderLayoutConstraints::create();
BorderLayoutConstraintsRecPtr ExampleButton7Constraints = BorderLayoutConstraints::create();
BorderLayoutConstraintsRecPtr ExampleButton8Constraints = BorderLayoutConstraints::create();
BorderLayoutConstraintsRecPtr ExampleCardPanelConstraints = BorderLayoutConstraints::create();
ExampleButton1Constraints->setRegion(BorderLayoutConstraints::BORDER_EAST);
ExampleButton2Constraints->setRegion(BorderLayoutConstraints::BORDER_WEST);
ExampleButton7Constraints->setRegion(BorderLayoutConstraints::BORDER_NORTH);
ExampleButton8Constraints->setRegion(BorderLayoutConstraints::BORDER_SOUTH);
ExampleCardPanelConstraints->setRegion(BorderLayoutConstraints::BORDER_CENTER);
/******************************************************
Create CardLayout. CardLayout shows
a single Component at a time, meaning
it is not exactly practical to use it
alone for a Layout. This tutorial uses
the BorderLayout to include a Panel in
the Center Region, and within that Panel
using a CardLayout. A single card is
displayed at one time within a
ComponentContainer using CardLayout.
CardLayout has four functions:
next, previous, first, and last.
->next(CardContainerName): Causes
CardLayout to display the next card.
->previous(CardContainerName): Causes
CardLayout to display the
previous card.
->first(CardContainerName): Causes
CardLayout to display the
first card.
->last(CardContainerName): Causes
CardLayout to display the
last card.
These are most useful when combined with
Action, as shown at the top of
this Tutorial, to assign actions to the
Buttons or Components to allow the user
to cycle through the Card Layout and
view different ExampleCards.
Note that CardContainerName is the name
of the ComponentContainer which is using the
CardLayout, while the begin/endEditCP
is performed on the CardLayout itself.
******************************************************/
CardLayoutRecPtr ExampleCardLayout = CardLayout::create();
PanelRecPtr ExampleCardPanel = Panel::create();
/******************************************************
Create Button Components to be used with
CardLayout to allow for interactivity.
******************************************************/
ButtonRecPtr ExampleButton1 = Button::create();
ButtonRecPtr ExampleButton2 = Button::create();
ButtonRecPtr ExampleButton3 = Button::create();
ButtonRecPtr ExampleButton4 = Button::create();
ButtonRecPtr ExampleButton5 = Button::create();
ButtonRecPtr ExampleButton6 = Button::create();
ButtonRecPtr ExampleButton7 = Button::create();
ButtonRecPtr ExampleButton8 = Button::create();
ExampleButton1->setText("Next Card");
ExampleButton1->setConstraints(ExampleButton1Constraints);
// Add Action
ExampleButton1->connectActionPerformed(boost::bind(handleNextCardAction, _1,
ExampleCardLayout.get(),
ExampleCardPanel.get()));
ExampleButton2->setText("Previous Card");
ExampleButton2->setConstraints(ExampleButton2Constraints);
// Add Action
ExampleButton2->connectActionPerformed(boost::bind(handleBackCardAction, _1,
ExampleCardLayout.get(),
ExampleCardPanel.get()));
ExampleButton3->setText("This");
ExampleButton4->setText("is");
ExampleButton5->setText("Card");
ExampleButton6->setText("Layout");
ExampleButton7->setText("First Card");
ExampleButton7->setConstraints(ExampleButton7Constraints);
// Add Action
ExampleButton7->connectActionPerformed(boost::bind(handleFirstCardAction, _1,
ExampleCardLayout.get(),
ExampleCardPanel.get()));
ExampleButton8->setText("Last Card");
ExampleButton8->setConstraints(ExampleButton8Constraints);
// Add Action
ExampleButton8->connectActionPerformed(boost::bind(handleLastCardAction, _1,
ExampleCardLayout.get(),
ExampleCardPanel.get()));
ExampleCardPanel->setLayout(ExampleCardLayout);
ExampleCardPanel->pushToChildren(ExampleButton3);
ExampleCardPanel->pushToChildren(ExampleButton4);
ExampleCardPanel->pushToChildren(ExampleButton5);
ExampleCardPanel->pushToChildren(ExampleButton6);
ExampleCardPanel->setConstraints(ExampleCardPanelConstraints);
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
InternalWindowRecPtr MainInternalWindow = InternalWindow::create();
MainInternalWindow->pushToChildren(ExampleButton1);
MainInternalWindow->pushToChildren(ExampleButton2);
MainInternalWindow->pushToChildren(ExampleButton7);
MainInternalWindow->pushToChildren(ExampleButton8);
MainInternalWindow->pushToChildren(ExampleCardPanel);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
// Create the Drawing Surface
UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRecPtr TutorialUIForeground = UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Tell the Manager what to manage
sceneManager.setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
//Create the Documentation Foreground and add it to the viewport
SimpleScreenDoc TheSimpleScreenDoc(&sceneManager, TutorialWindow);
// Show the whole Scene
sceneManager.showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"11CardLayout");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
TutorialWindow->connectKeyTyped(boost::bind(keyPressed, _1));
// Make Torus Node (creates Torus in background of scene)
NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRecPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRecPtr TutorialGraphics = Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
// Create a simple Font to be used with the ExampleTextArea
UIFontRecPtr ExampleFont = UIFont::create();
ExampleFont->setSize(16);
/******************************************************
Create and edit the TextArea and determine its
characteristics. A TextArea is a component
that allows you to enter text into the box via
keyboard input. You can select text by using
your mouse or pressing shift and the left and
right arrow keys.
The only difference between a TextArea and
TextField is that a TextArea can have
multiple lines of text
within it.
-setTextColor(Color4f): Determine color of
text within TextArea.
-setSelectionBoxColor(Color4f): Determine the
color that highlighting around the
selected text appears.
-setSelectionTextColor(Color4f): Determine the
color the selected text appears.
-setText("TextToBeDisplayed"): Determine
initial text within TextArea.
-setFont(FontName): Determine the Font
used within TextArea
-setSelectionStart(StartCharacterNumber):
Determine the character which the
selection will initially start after.
-setSelectionEnd(EndCharacterNumber):
Determine the character which the
selection will end before.
-setCaretPosition(Location): Determine the
location of the Caret within the TextArea.
Note: this does not do too much
currently because the only way
to cause the TextArea to gain focus is
to click within it, causing the
Caret to move.
******************************************************/
// Create a TextArea component
TextAreaRecPtr ExampleTextArea = TextArea::create();
ExampleTextArea->setPreferredSize(Vec2f(300, 200));
ExampleTextArea->setMinSize(Vec2f(300, 200));
ExampleTextArea->setTextColor(Color4f(0.0, 0.0, 0.0, 1.0));
ExampleTextArea->setSelectionBoxColor(Color4f(0.0, 0.0, 1.0, 1.0));
ExampleTextArea->setSelectionTextColor(Color4f(1.0, 1.0, 1.0, 1.0));
// Determine the font and initial text
ExampleTextArea->setText("What");
ExampleTextArea->setFont(ExampleFont);
// This will select the "a" from above
ExampleTextArea->setSelectionStart(2);
ExampleTextArea->setSelectionEnd(3);
ExampleTextArea->setCaretPosition(2);
//ExampleTextArea->setLineWrap(false);
// Create a ScrollPanel
ScrollPanelRecPtr TextAreaScrollPanel = ScrollPanel::create();
TextAreaScrollPanel->setPreferredSize(Vec2f(200,200));
TextAreaScrollPanel->setHorizontalResizePolicy(ScrollPanel::RESIZE_TO_VIEW);
// Add the TextArea to the ScrollPanel so it is displayed
TextAreaScrollPanel->setViewComponent(ExampleTextArea);
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
LayoutRecPtr MainInternalWindowLayout = FlowLayout::create();
InternalWindowRecPtr MainInternalWindow = InternalWindow::create();
MainInternalWindow->pushToChildren(TextAreaScrollPanel);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
// Create the Drawing Surface
UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRecPtr TutorialUIForeground = UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Tell the Manager what to manage
sceneManager.setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
// Show the whole Scene
sceneManager.showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"22TextArea");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
TutorialWindow->connectKeyTyped(boost::bind(keyPressed, _1));
// Make Torus Node (creates Torus in background of scene)
NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRecPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRecPtr TutorialGraphics = Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
/******************************************************
Create and edit a CheckboxButton.
Note: the only function call shown
specific to CheckboxButton is setSelected.
In DefaultLookAndFeel, the options
for changing the style of the CheckBox
are shown. CheckboxButton also
inherits off Button so all features
of Button may be used.
-setSelected(bool): Determines if the
CheckboxButton is checked(true) or
not checked(false).
******************************************************/
CheckboxButtonRecPtr ExampleCheckboxButton = CheckboxButton::create();
ExampleCheckboxButton->setMinSize(Vec2f(50, 25));
ExampleCheckboxButton->setMaxSize(Vec2f(300, 100));
ExampleCheckboxButton->setPreferredSize(Vec2f(200, 50));
ExampleCheckboxButton->setEnabled(true);
ExampleCheckboxButton->setText("Checkbox Button");
ExampleCheckboxButton->setAlignment(Vec2f(0.5,0.5));
ExampleCheckboxButton->setSelected(true);
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
LayoutRecPtr MainInternalWindowLayout = FlowLayout::create();
InternalWindowRecPtr MainInternalWindow = InternalWindow::create();
MainInternalWindow->pushToChildren(ExampleCheckboxButton);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
// Create the Drawing Surface
UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRecPtr TutorialUIForeground = UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Tell the Manager what to manage
sceneManager.setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
// Show the whole Scene
sceneManager.showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"13CheckboxButton");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
TutorialWindow->connectMousePressed(boost::bind(mousePressed, _1, &sceneManager));
TutorialWindow->connectMouseReleased(boost::bind(mouseReleased, _1, &sceneManager));
TutorialWindow->connectMouseDragged(boost::bind(mouseDragged, _1, &sceneManager));
TutorialWindow->connectMouseWheelMoved(boost::bind(mouseWheelMoved, _1, &sceneManager));
TutorialWindow->connectKeyTyped(boost::bind(keyPressed, _1));
// Make Main Scene Node
NodeRecPtr Scene = makeCoredNode<Group>();
NodeRecPtr TorusNode = createTorus();
NodeRecPtr SphereNode = createSphere();
NodeRecPtr ConeNode = createCone();
NodeRecPtr BoxNode = createBox();
Scene->addChild(TorusNode);
Scene->addChild(SphereNode);
Scene->addChild(ConeNode);
Scene->addChild(BoxNode);
// Create the Graphics
GraphicsRecPtr TutorialGraphics = Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
/******************************************************
Create a Background
******************************************************/
ColorLayerRecPtr GreyBackground = ColorLayer::create();
GreyBackground->setColor(Color4f(.93,.93,.93,1.0));
/******************************************************
Create some Borders
******************************************************/
LineBorderRecPtr PanelBorder = LineBorder::create();
EmptyBorderRecPtr Panel1Border = EmptyBorder::create();
EmptyBorderRecPtr Panel2Border = EmptyBorder::create();
EmptyBorderRecPtr emptyBorder = EmptyBorder::create();
PanelBorder->setColor(Color4f(0.0,0.0,0.0,1.0));
PanelBorder->setWidth(1);
Panel1Border->setTopWidth(0);
Panel1Border->setBottomWidth(6);
Panel1Border->setLeftWidth(0);
Panel1Border->setRightWidth(0);
Panel2Border->setTopWidth(0);
Panel2Border->setBottomWidth(0);
Panel2Border->setLeftWidth(0);
Panel2Border->setRightWidth(0);
/******************************************************
Create some Labels and stuff to go
with them
******************************************************/
LabelRecPtr LeftPanelLabel1 = Label::create();
UIFontRecPtr LeftPanelLabel1Font = UIFont::create();
LeftPanelLabel1Font->setSize(50);
LeftPanelLabel1->setBorders(emptyBorder);
LeftPanelLabel1->setBackgrounds(GreyBackground);
LeftPanelLabel1->setFont(LeftPanelLabel1Font);
LeftPanelLabel1->setText("OSG Gui");
LeftPanelLabel1->setPreferredSize(Vec2f(300, 100));
LeftPanelLabel1->setAlignment(Vec2f(0.0f, 0.5f));
/******************************************************
Create some Layouts
******************************************************/
BoxLayoutRecPtr MainInternalWindowLayout = BoxLayout::create();
FlowLayoutRecPtr LeftPanelLayout = FlowLayout::create();
BoxLayoutRecPtr RightPanelLayout = BoxLayout::create();
MainInternalWindowLayout->setOrientation(BoxLayout::HORIZONTAL_ORIENTATION);
LeftPanelLayout->setOrientation(FlowLayout::HORIZONTAL_ORIENTATION);
LeftPanelLayout->setMinorAxisAlignment(1.0f);
RightPanelLayout->setOrientation(BoxLayout::VERTICAL_ORIENTATION);
/******************************************************
Create MainFrame and Panels
******************************************************/
PanelRecPtr LeftPanel = Panel::createEmpty();
PanelRecPtr RightPanel = Panel::createEmpty();
// LeftPanel stuff
LeftPanel->setPreferredSize(Vec2f(400, 500));
LeftPanel->pushToChildren(LeftPanelLabel1);
PanelRecPtr LeftPanelButtonPanel = createLeftPanelButtonPanel();
LeftPanel->pushToChildren(LeftPanelButtonPanel);
PanelRecPtr LeftPanelRadioTextPanel = createLeftPanelRadioTextPanel();
LeftPanel->pushToChildren(LeftPanelRadioTextPanel);
LeftPanel->setLayout(LeftPanelLayout);
LeftPanel->setBackgrounds(GreyBackground);
LeftPanel->setBorders(Panel1Border);
//RightPanel stuff
RightPanel->setPreferredSize(Vec2f(200, 620));
PanelRecPtr RightPanelButtonPanel = createRightPanelButtonPanel();
RightPanel->pushToChildren(RightPanelButtonPanel);
PanelRecPtr RightPanelCheckPanel = createRightPanelCheckPanel(TorusNode,
SphereNode,
ConeNode,
BoxNode);
RightPanel->pushToChildren(RightPanelCheckPanel);
RightPanel->setLayout(RightPanelLayout);
RightPanel->setBackgrounds(GreyBackground);
RightPanel->setBorders(Panel2Border);
// Create The Main InternalWindow
InternalWindowRecPtr MainInternalWindow = InternalWindow::create();
MainInternalWindow->pushToChildren(LeftPanel);
MainInternalWindow->pushToChildren(RightPanel);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(GreyBackground);
MainInternalWindow->setBorders(PanelBorder);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(1.0f,1.0f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
//MainInternalWindow->setOpacity(0.7f);
// Create the Drawing Surface
UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Make A 3D Rectangle to draw the UI on
UIRectangleRecPtr UIRectCore = UIRectangle::create();
UIRectCore->setPoint(Pnt3f(-310.0,-310.0,370.0));
UIRectCore->setWidth(620);
UIRectCore->setHeight(620);
UIRectCore->setDrawingSurface(TutorialDrawingSurface);
NodeRecPtr UIRectNode = Node::create();
UIRectNode->setCore(UIRectCore);
// add the UIRect as a child
Scene->addChild(UIRectNode);
sceneManager.setRoot(Scene);
// Show the whole Scene
sceneManager.showAll();
//Create the Documentation Foreground and add it to the viewport
SimpleScreenDoc TheSimpleScreenDoc(&sceneManager, TutorialWindow);
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"21ExampleInterface");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
TutorialWindow->connectKeyTyped(boost::bind(keyPressed, _1));
// Make Torus Node (creates Torus in background of scene)
NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRecPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRecPtr TutorialGraphics = Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
/******************************************************
Creates some Button components
and edit their Text.
******************************************************/
ButtonRecPtr ExampleButton1 = Button::create();
ButtonRecPtr ExampleButton2 = Button::create();
ButtonRecPtr ExampleButton3 = Button::create();
ButtonRecPtr ExampleButton4 = Button::create();
ButtonRecPtr ExampleButton5 = Button::create();
ButtonRecPtr ExampleButton6 = Button::create();
ExampleButton1->setText("This");
ExampleButton2->setText("is a");
ExampleButton3->setText("sample");
ExampleButton4->setText("two");
ExampleButton5->setText("ExamplePanel");
ExampleButton6->setText("layout");
/******************************************************
Create some Flow and BoxLayouts to be
used with the Main Frame and two
Panels.
******************************************************/
FlowLayoutRecPtr MainInternalWindowLayout = FlowLayout::create();
FlowLayoutRecPtr ExamplePanel1Layout = FlowLayout::create();
FlowLayoutRecPtr ExamplePanel2Layout = FlowLayout::create();
ExamplePanel1Layout->setOrientation(FlowLayout::VERTICAL_ORIENTATION);
/******************************************************
Create two Backgrounds to be used with
Panels and MainInternalWindow.
******************************************************/
ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create();
ColorLayerRecPtr ExamplePanelBackground = ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
ExamplePanelBackground->setColor(Color4f(0.0,0.0,0.0,1.0));
/******************************************************
Create a Border to be used with
the two Panels.
******************************************************/
LineBorderRecPtr ExamplePanelBorder = LineBorder::create();
ExamplePanelBorder->setColor(Color4f(0.9, 0.9, 0.9, 1.0));
ExamplePanelBorder->setWidth(3);
/******************************************************
Create MainInternalWindow and two Panel Components and
edit their characteristics.
-setPreferredSize(Vec2f): Determine the
size of the Panel.
-pushToChildren(ComponentName):
Adds a Component to the
ComponentContainer as a Child (meaning it
will be displayed within it).
-setLayout(LayoutName): Determines the
Layout of the ComponentContainer.
******************************************************/
InternalWindowRecPtr MainInternalWindow = InternalWindow::create();
PanelRecPtr ExamplePanel1 = Panel::create();
PanelRecPtr ExamplePanel2 = Panel::create();
// Edit Panel1, Panel2
ExamplePanel1->setPreferredSize(Vec2f(200, 200));
ExamplePanel1->pushToChildren(ExampleButton1);
ExamplePanel1->pushToChildren(ExampleButton2);
ExamplePanel1->pushToChildren(ExampleButton3);
ExamplePanel1->setLayout(ExamplePanel1Layout);
ExamplePanel1->setBackgrounds(ExamplePanelBackground);
ExamplePanel1->setBorders(ExamplePanelBorder);
ExamplePanel2->setPreferredSize(Vec2f(200, 200));
ExamplePanel2->pushToChildren(ExampleButton4);
ExamplePanel2->pushToChildren(ExampleButton5);
ExamplePanel2->pushToChildren(ExampleButton6);
ExamplePanel2->setLayout(ExamplePanel2Layout);
ExamplePanel2->setBackgrounds(ExamplePanelBackground);
ExamplePanel2->setBorders(ExamplePanelBorder);
// Create The Main InternalWindow
MainInternalWindow->pushToChildren(ExamplePanel1);
MainInternalWindow->pushToChildren(ExamplePanel2);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
MainInternalWindow->setAllInsets(5);
// Create the Drawing Surface
UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRecPtr TutorialUIForeground = UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Tell the Manager what to manage
sceneManager.setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
// Show the whole Scene
sceneManager.showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"10Container");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
TutorialWindow->connectKeyTyped(boost::bind(keyPressed, _1));
// Make Torus Node (creates Torus in background of scene)
NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRecPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRecPtr TutorialGraphics = Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
/******************************************************
Create an Button Component and
a simple Font.
See 17Label_Font for more
information about Fonts.
******************************************************/
LineBorderRecPtr ChangableBorder = LineBorder::create();
ChangableBorder->setColor(Color4f(0.0,0.0,0.0,1.0));
ColorLayerRecPtr ChangableBackground = ColorLayer::create();
ChangableBackground->setColor(Color4f(1.0,1.0,1.0,1.0));
LabelRecPtr ChangableLabel = Label::create();
ChangableLabel->setText("Changable");
ChangableLabel->setBorders(ChangableBorder);
ChangableLabel->setBackgrounds(ChangableBackground);
//Command Buttons
UndoManagerPtr TheUndoManager = UndoManager::create();
CommandManagerPtr TheCommandManager = CommandManager::create(TheUndoManager);
ButtonRecPtr BorderRedButton = Button::create();
BorderRedButton->setText("Border Red");
BorderRedButton->setPreferredSize(Vec2f(85, 20));
BorderRedButton->connectActionPerformed(boost::bind(handleSetBorderColorAction,
_1,
TheCommandManager,
ChangableBorder.get(),
Color4f(1.0,0.0,0.0,1.0)));
ButtonRecPtr BorderGreenButton = Button::create();
BorderGreenButton->setText("Border Green");
BorderGreenButton->setPreferredSize(Vec2f(85, 20));
BorderGreenButton->connectActionPerformed(boost::bind(handleSetBorderColorAction,
_1,
TheCommandManager,
ChangableBorder.get(),
Color4f(0.0,1.0,0.0,1.0)));
ButtonRecPtr BorderBlueButton = Button::create();
BorderBlueButton->setText("Border Blue");
BorderBlueButton->setPreferredSize(Vec2f(85, 20));
BorderBlueButton->connectActionPerformed(boost::bind(handleSetBorderColorAction,
_1,
TheCommandManager,
ChangableBorder.get(),
Color4f(0.0,0.0,1.0,1.0)));
//Background
ButtonRecPtr BackgroundRedButton = Button::create();
BackgroundRedButton->setText("Background Red");
BackgroundRedButton->setPreferredSize(Vec2f(105, 20));
BackgroundRedButton->connectActionPerformed(boost::bind(handleSetBackgroundColorAction,
_1,
TheCommandManager,
ChangableBackground.get(),
Color4f(1.0,0.0,0.0,1.0)));
ButtonRecPtr BackgroundGreenButton = Button::create();
BackgroundGreenButton->setText("Background Green");
BackgroundGreenButton->setPreferredSize(Vec2f(105, 20));
BackgroundGreenButton->connectActionPerformed(boost::bind(handleSetBackgroundColorAction,
_1,
TheCommandManager,
ChangableBackground.get(),
Color4f(0.0,1.0,0.0,1.0)));
ButtonRecPtr BackgroundBlueButton = Button::create();
BackgroundBlueButton->setText("Background Blue");
BackgroundBlueButton->setPreferredSize(Vec2f(105, 20));
BackgroundBlueButton->connectActionPerformed(boost::bind(handleSetBackgroundColorAction,
_1,
TheCommandManager,
ChangableBackground.get(),
Color4f(0.0,0.0,1.0,1.0)));
//UndoList
DefaultListModelRecPtr UndoRedoListModel = DefaultListModel::create();
UndoRedoListModel->pushBack(boost::any(std::string("Top")));
ListRecPtr UndoRedoList = List::create();
UndoRedoList->setPreferredSize(Vec2f(200, 300));
UndoRedoList->setOrientation(List::VERTICAL_ORIENTATION);
UndoRedoList->setModel(UndoRedoListModel);
UndoRedoList->getSelectionModel()->connectSelectionChanged(boost::bind(handleUndoRedoListSelectionChanged,
_1,
UndoRedoList.get(),
TheUndoManager));
ButtonRecPtr UndoButton = Button::create();
UndoButton->setText("Undo");
UndoButton->setEnabled(TheUndoManager->numberOfUndos() != 0);
UndoButton->connectActionPerformed(boost::bind(handleUndoButtonAction,
_1,
TheUndoManager));
ButtonRecPtr RedoButton = Button::create();
RedoButton->setText("Redo");
RedoButton->setEnabled(TheUndoManager->numberOfRedos() != 0);
RedoButton->connectActionPerformed(boost::bind(handleRedoButtonAction,
_1,
TheUndoManager));
// Create a ScrollPanel for easier viewing of the List (see 27ScrollPanel)
ScrollPanelRecPtr UndoRedoScrollPanel = ScrollPanel::create();
UndoRedoScrollPanel->setPreferredSize(Vec2f(200,200));
UndoRedoScrollPanel->setHorizontalResizePolicy(ScrollPanel::RESIZE_TO_VIEW);
UndoRedoScrollPanel->setViewComponent(UndoRedoList);
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
InternalWindowRecPtr MainInternalWindow = InternalWindow::create();
LayoutRecPtr MainInternalWindowLayout = FlowLayout::create();
MainInternalWindow->pushToChildren(BorderRedButton);
MainInternalWindow->pushToChildren(BorderGreenButton);
MainInternalWindow->pushToChildren(BorderBlueButton);
MainInternalWindow->pushToChildren(BackgroundRedButton);
MainInternalWindow->pushToChildren(BackgroundGreenButton);
MainInternalWindow->pushToChildren(BackgroundBlueButton);
MainInternalWindow->pushToChildren(ChangableLabel);
MainInternalWindow->pushToChildren(UndoRedoScrollPanel);
MainInternalWindow->pushToChildren(UndoButton);
MainInternalWindow->pushToChildren(RedoButton);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.95f,0.95f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
TheUndoManager->connectStateChanged(boost::bind(handleUndoManagerStateChanged,
_1,
UndoRedoListModel.get(),
TheUndoManager,
UndoButton.get(),
RedoButton.get()));
// Create the Drawing Surface
UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRecPtr TutorialUIForeground = UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Tell the Manager what to manage
sceneManager.setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
//Create the Documentation Foreground and add it to the viewport
SimpleScreenDoc TheSimpleScreenDoc(&sceneManager, TutorialWindow);
// Show the whole Scene
sceneManager.showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"40UndoableCommand");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
{
// Set up Window
WindowEventProducerRecPtr TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
// Create the SimpleSceneManager helper
SimpleSceneManager sceneManager;
TutorialWindow->setDisplayCallback(boost::bind(display, &sceneManager));
TutorialWindow->setReshapeCallback(boost::bind(reshape, _1, &sceneManager));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
TutorialWindow->connectKeyTyped(boost::bind(keyPressed, _1));
// Make Torus Node (creates Torus in background of scene)
NodeRecPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRecPtr scene = Node::create();
scene->setCore(Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRecPtr TutorialGraphics = Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
/******************************************************
Create a RotatedComponent.
-setAngle(Angle, in radians): Determine
the angle the Component initially
is rotated.
-setInternalComponent(Component):
Determine what Component will
be rotated.
-setResizePolicy(RotatedComponent::ENUM):
Takes NO_RESIZING, RESIZE_TO_MIN, or
RESIZE_TO_MAX arguments.
******************************************************/
RotatedComponentRecPtr TheRotatedComponent = RotatedComponent::create();
// Define PI
Real32 PI(3.14159);
TheRotatedComponent->setAngle(PI/4);
ComponentRecPtr InnerPanel = createPanel();
TheRotatedComponent->setInternalComponent(InnerPanel);
TheRotatedComponent->setResizePolicy(RotatedComponent::RESIZE_TO_MIN);
/******************************************************
Create a ToggleButton which can
be used to start and stop the
Button from rotating.
Note: due to the way FlowLayout works
you will notice that this ToggleButton
will move as well. In cases where
a Rotating Component is used, an
alternate Layout may be preferred
to prevent other Components from
moving as well. This is
intentionally left this way to
illustrate why this might be the case.
A SplitPanel with fixed divider for
example would prevent the ToggleButton
from moving, while still allowing the
Panel to move freely.
******************************************************/
ToggleButtonRecPtr RotateControlButton = ToggleButton::create();
RotateControlButton->setText("Start Rotating");
RotateControlButton->setPreferredSize(Vec2f(100.0f, 29.0f));
RotateControlButton->connectButtonSelected(boost::bind(handleButtonSelected, _1,
TutorialWindow.get(),
TheRotatedComponent.get()));
RotateControlButton->connectButtonDeselected(boost::bind(handleButtonDeselected, _1,
TutorialWindow.get(),
TheRotatedComponent.get()));
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
LayoutRecPtr MainInternalWindowLayout = FlowLayout::create();
InternalWindowRecPtr MainInternalWindow = InternalWindow::create();
MainInternalWindow->pushToChildren(TheRotatedComponent);
MainInternalWindow->pushToChildren(RotateControlButton);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.8f,0.8f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
// Create the Drawing Surface
UIDrawingSurfaceRecPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRecPtr TutorialUIForeground = UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Tell the Manager what to manage
sceneManager.setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRecPtr TutorialViewport = sceneManager.getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
//Create the Documentation Foreground and add it to the viewport
SimpleScreenDoc TheSimpleScreenDoc(&sceneManager, TutorialWindow);
// Show the whole Scene
sceneManager.showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"30RotatedComponent");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
InternalWindowTransitPtr createMainInternalWindow(void)
{
/******************************************************
Create Button Components to be used with
TabPanel and specify their characteristics.
Note: Buttons are used for simplicity,
any Component can be used as Tab content
or as a Tab. A Panel with several
Buttons within it is also added.
******************************************************/
ButtonRecPtr ExampleTabButton1 = Button::create();
ButtonRecPtr ExampleTabButton2 = Button::create();
ButtonRecPtr ExampleTabButton3 = Button::create();
ButtonRecPtr ExampleTabButton4 = Button::create();
ButtonRecPtr ExampleTabButton5 = Button::create();
ButtonRecPtr ExampleTabButton6 = Button::create();
ButtonRecPtr ExampleTabContentA = Button::create();
ButtonRecPtr ExampleTabContentB = Button::create();
ButtonRecPtr ExampleTabContentC = Button::create();
ButtonRecPtr ExampleTabContentD = Button::create();
ButtonRecPtr ExampleTabContentE = Button::create();
ButtonRecPtr ExampleTabContentF = Button::create();
ExampleTabButton1->setText("Tab1");
ExampleTabButton2->setText("Tab2");
ExampleTabButton3->setText("To Rotate");
ExampleTabButton4->setText("Tab4");
ExampleTabButton5->setText("To Zoom");
ExampleTabButton6->setText("To Move");
ExampleTabContentA->setText("Add another Tab");
ExampleTabContentB->setText("Add a Tab in Tab1!");
ExampleTabContentC->setText("Enable CapsLock, then rotate scene using left Mouse button!");
ExampleTabContentD->setText("Enable CapsLock, then zoom in and out with right Mouse button and dragging");
ExampleTabContentE->setText("Enable CapsLock, then move using center Mouse button");
/******************************************************
Create a Panel to add to the TabPanel
******************************************************/
// Create and edit the Panel Buttons
ButtonRecPtr ExampleTabPanelButton1 = Button::create();
ButtonRecPtr ExampleTabPanelButton2 = Button::create();
ButtonRecPtr ExampleTabPanelButton3 = Button::create();
ButtonRecPtr ExampleTabPanelButton4 = Button::create();
ButtonRecPtr ExampleTabPanelButton5 = Button::create();
ButtonRecPtr ExampleTabPanelButton6 = Button::create();
ExampleTabPanelButton1->setText("This is a");
ExampleTabPanelButton2->setText("sample");
ExampleTabPanelButton3->setText("UIRectangle");
ExampleTabPanelButton4->setText("containing");
ExampleTabPanelButton5->setText("interactive");
ExampleTabPanelButton6->setText("components");
// Create and edit Panel Layout
BoxLayoutRecPtr TabPanelLayout = BoxLayout::create();
TabPanelLayout->setOrientation(BoxLayout::VERTICAL_ORIENTATION);
// Create and edit Panel
PanelRecPtr ExampleTabPanelPanel = Panel::create();
ExampleTabPanelPanel->setPreferredSize(Vec2f(180, 500));
ExampleTabPanelPanel->pushToChildren(ExampleTabPanelButton1);
ExampleTabPanelPanel->pushToChildren(ExampleTabPanelButton2);
ExampleTabPanelPanel->pushToChildren(ExampleTabPanelButton3);
ExampleTabPanelPanel->pushToChildren(ExampleTabPanelButton4);
ExampleTabPanelPanel->pushToChildren(ExampleTabPanelButton5);
ExampleTabPanelPanel->pushToChildren(ExampleTabPanelButton6);
ExampleTabPanelPanel->setLayout(TabPanelLayout);
TabPanelRecPtr ExampleTabPanel = TabPanel::create();
ExampleTabPanel->setPreferredSize(Vec2f(350,350));
ExampleTabPanel->addTab(ExampleTabButton1, ExampleTabContentA);
ExampleTabPanel->addTab(ExampleTabButton2, ExampleTabContentB);
ExampleTabPanel->addTab(ExampleTabButton3, ExampleTabContentC);
ExampleTabPanel->addTab(ExampleTabButton4, ExampleTabPanelPanel);
ExampleTabPanel->addTab(ExampleTabButton5, ExampleTabContentD);
ExampleTabPanel->addTab(ExampleTabButton6, ExampleTabContentE);
ExampleTabPanel->setTabAlignment(0.5f);
ExampleTabPanel->setTabPlacement(TabPanel::PLACEMENT_SOUTH);
ExampleTabPanel->setSelectedIndex(3);
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRecPtr MainInternalWindowBackground = ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
CardLayoutRecPtr MainInternalWindowLayout = CardLayout::create();
InternalWindowRecPtr MainInternalWindow = InternalWindow::create();
MainInternalWindow->pushToChildren(ExampleTabPanel);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(1.0f,1.0f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
ExampleTabContentB->connectActionPerformed(boost::bind(handleRemoveTabAction, _1,
ExampleTabPanel.get(),
ExampleTabContentA.get(),
ExampleTabContentB.get()));
ExampleTabContentA->connectActionPerformed(boost::bind(handleAddTabAction, _1,
ExampleTabPanel.get(),
ExampleTabContentA.get(),
ExampleTabContentB.get()));
return InternalWindowTransitPtr(MainInternalWindow);
}