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(keyTyped, _1));
// Make Torus Node (creates Torus in background of scene)
NodeRefPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRefPtr scene = OSG::Node::create();
scene->setCore(OSG::Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRefPtr TutorialGraphics = OSG::Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
/******************************************************
Create the Layers.
******************************************************/
ColorLayerRefPtr ExampleColorLayer = OSG::ColorLayer::create();
CompoundLayerRefPtr ExampleCompoundLayer = OSG::CompoundLayer::create();
EmptyLayerRefPtr ExampleEmptyLayer = OSG::EmptyLayer::create();
GradientLayerRefPtr ExampleGradientLayer = OSG::GradientLayer::create();
MaterialLayerRefPtr ExampleMaterialLayer = OSG::MaterialLayer::create();
TextureLayerRefPtr ExampleTextureLayer = OSG::TextureLayer::create();
PatternLayerRefPtr ExamplePatternLayer = OSG::PatternLayer::create();
GlassLayerRefPtr ExampleGlassLayer = OSG::GlassLayer::create();
CompoundLayerRefPtr ExampleGlassCompoundLayer = OSG::CompoundLayer::create();
/******************************************************
The ColorLayer is a simple Layer
having just a Color to it.
-setColor(Color4f): Determine the Color of
the Layer.
******************************************************/
ExampleColorLayer->setColor(Color4f(1.0,0.0,0.0,1.0));
/******************************************************
The CompoundLayer allows you to
combine multiple Backgrounds into one.
The Backgrounds are added sequentially;
so in this example the
ExampleTextureLayer would be added
first, and the ExampleGradientLayer
rendered on top of it.
-getBackgrounds().push_back(BackgroundName):
Adds a Background to the
CompoundBackground.
******************************************************/
ExampleCompoundLayer->pushToBackgrounds(ExampleTextureLayer);
ExampleCompoundLayer->pushToBackgrounds(ExampleGradientLayer);
/******************************************************
The EmptyLayer is a Background
with no attributes.
******************************************************/
// Nothing!
/******************************************************
The GradientLayer is a Background
which displays a gradient of Color.
-getColors().push_back(Color4f): Determines the
starting Color for the gradient.
-getColors().push_back(Color4f): Determines the
ending Color for the gradient.
-setOrientation(ENUM): Determines the
gradient alignment. Takes
HORIZONTAL_ORIENTATION or
VERTICAL_ORIENTATION arguments.
******************************************************/
ExampleGradientLayer->editMFColors()->push_back(Color4f(1.0, 0.0, 0.0, 1.0));
ExampleGradientLayer->editMFStops()->push_back(0.0);
ExampleGradientLayer->editMFColors()->push_back(Color4f(0.0, 1.0, 0.0, 0.75));
ExampleGradientLayer->editMFStops()->push_back(0.5);
ExampleGradientLayer->editMFColors()->push_back(Color4f(0.0, 0.0, 1.0, 0.5));
ExampleGradientLayer->editMFStops()->push_back(1.0);
ExampleGradientLayer->setStartPosition(Vec2f(0.2f,0.2f));
ExampleGradientLayer->setEndPosition(Vec2f(.6f,0.6f));
ExampleGradientLayer->setSpreadMethod(GradientLayer::SPREAD_REFLECT);
/******************************************************
The MaterialLayer is a Background
which is created using a Material (also
created here).
-setMaterial(MaterialName): Determine
which Material will be used to
create the Background.
******************************************************/
// Creates Material
ChunkMaterialRefPtr LayerMaterial = ChunkMaterial::create();
MaterialChunkRefPtr LayerMaterialChunk = MaterialChunk::create();
LayerMaterialChunk->setAmbient(Color4f(1.0,0.0,0.0,1.0));
LayerMaterialChunk->setDiffuse(Color4f(0.0,1.0,0.0,1.0));
LayerMaterialChunk->setSpecular(Color4f(0.0,0.0,1.0,1.0));
LayerMaterial->addChunk(LayerMaterialChunk);
// Edit MaterialLayer
ExampleMaterialLayer->setMaterial(LayerMaterial);
/******************************************************
The TextureLayer is a Background
which is created using a Texture (also
created here).
-setTexture(TextureName): Determine
which Texture will be used to
create the Background.
******************************************************/
// Creates Texture from Image
TextureObjChunkRefPtr LayerTextureObjChunk = TextureObjChunk::create();
ImageRefPtr LoadedImage = ImageFileHandler::the()->read("Data/Checker.jpg");
LayerTextureObjChunk->setImage(LoadedImage);
// Edit TextureLayer
ExampleTextureLayer->setTexture(LayerTextureObjChunk);
/******************************************************
The PatternLayer is a Background
which is created using a Texture (also
created here).
-setTexture(TextureName): Determine
which Texture will be used to
create the Background.
-setPatternSize(Vec2f):
-setVerticalAlignment():
-setHorizontalAlignment():
-setHorizontalRepeat():
-setVerticalRepeat():
-setHorizontalRepeatValue():
-setVerticalRepeatValue():
******************************************************/
TextureObjChunkRefPtr LayerPatternChunk = TextureObjChunk::create();
//ImageRefPtr LoadedImage = ImageFileHandler::the()->read("Data/Checker.jpg");
LayerPatternChunk->setImage(LoadedImage);
LayerPatternChunk->setWrapS(GL_REPEAT);
LayerPatternChunk->setWrapT(GL_CLAMP_TO_EDGE);
ExamplePatternLayer->setTexture(LayerPatternChunk);
ExamplePatternLayer->setPatternSize(Vec2f(50.0f,50.0f));
ExamplePatternLayer->setVerticalAlignment(0.5);
ExamplePatternLayer->setHorizontalAlignment(0.0);
ExamplePatternLayer->setHorizontalRepeat(PatternLayer::PATTERN_REPEAT_BY_POINT);
ExamplePatternLayer->setVerticalRepeat(PatternLayer::PATTERN_REPEAT_ABSOLUTE);
ExamplePatternLayer->setHorizontalRepeatValue(1.0);
ExamplePatternLayer->setVerticalRepeatValue(2.0);
/******************************************************
******************************************************/
ExampleGlassLayer->setCenterColor(Color4f(1.0f,1.0f,1.0f,0.0f));
ExampleGlassLayer->setEdgeColor(Color4f(1.0f,1.0f,1.0f,0.7f));
/******************************************************
******************************************************/
ExampleGlassCompoundLayer->pushToBackgrounds(ExampleColorLayer);
ExampleGlassCompoundLayer->pushToBackgrounds(ExampleGlassLayer);
/******************************************************
Create and edit Button Components to
display the Layers.
******************************************************/
ButtonRefPtr ExampleColorLayerButton = OSG::Button::create();
ButtonRefPtr ExampleCompoundLayerButton = OSG::Button::create();
ButtonRefPtr ExampleEmptyLayerButton = OSG::Button::create();
ButtonRefPtr ExampleGradientLayerButton = OSG::Button::create();
ButtonRefPtr ExampleMaterialLayerButton = OSG::Button::create();
ButtonRefPtr ExampleTextureLayerButton = OSG::Button::create();
ButtonRefPtr ExamplePatternLayerButton = OSG::Button::create();
ButtonRefPtr ExampleGlassLayerButton = OSG::Button::create();
ButtonRefPtr ExampleGlassCompoundLayerButton = OSG::Button::create();
ExampleColorLayerButton->setText("Color Layer");
ExampleColorLayerButton->setBackground(ExampleColorLayer);
ExampleColorLayerButton->setActiveBackground(ExampleColorLayer);
ExampleColorLayerButton->setRolloverBackground(ExampleColorLayer);
ExampleColorLayerButton->setPreferredSize(Vec2f(150,50));
ExampleCompoundLayerButton->setText("Compound Layer");
ExampleCompoundLayerButton->setBackground(ExampleCompoundLayer);
ExampleCompoundLayerButton->setActiveBackground(ExampleCompoundLayer);
ExampleCompoundLayerButton->setRolloverBackground(ExampleCompoundLayer);
ExampleCompoundLayerButton->setPreferredSize(Vec2f(150,50));
ExampleEmptyLayerButton->setText("Empty Layer");
ExampleEmptyLayerButton->setBackground(ExampleEmptyLayer);
ExampleEmptyLayerButton->setActiveBackground(ExampleEmptyLayer);
ExampleEmptyLayerButton->setRolloverBackground(ExampleEmptyLayer);
ExampleEmptyLayerButton->setPreferredSize(Vec2f(150,50));
ExampleGradientLayerButton->setText("Gradient Layer");
ExampleGradientLayerButton->setBackground(ExampleGradientLayer);
ExampleGradientLayerButton->setActiveBackground(ExampleGradientLayer);
ExampleGradientLayerButton->setRolloverBackground(ExampleGradientLayer);
ExampleGradientLayerButton->setPreferredSize(Vec2f(150,50));
ExampleMaterialLayerButton->setText("Material Layer");
ExampleMaterialLayerButton->setBackground(ExampleMaterialLayer);
ExampleMaterialLayerButton->setActiveBackground(ExampleMaterialLayer);
ExampleMaterialLayerButton->setRolloverBackground(ExampleMaterialLayer);
ExampleMaterialLayerButton->setPreferredSize(Vec2f(150,50));
ExampleMaterialLayerButton->setTextColor(Color4f(1.0,1.0,1.0,1.0));
ExampleMaterialLayerButton->setRolloverTextColor(Color4f(1.0,1.0,1.0,1.0));
ExampleMaterialLayerButton->setActiveTextColor(Color4f(1.0,1.0,1.0,1.0));
ExampleTextureLayerButton->setText("Texture Layer");
ExampleTextureLayerButton->setBackground(ExampleTextureLayer);
ExampleTextureLayerButton->setActiveBackground(ExampleTextureLayer);
ExampleTextureLayerButton->setRolloverBackground(ExampleTextureLayer);
ExampleTextureLayerButton->setPreferredSize(Vec2f(150,50));
ExampleTextureLayerButton->setTextColor(Color4f(0.0,1.0,0.0,1.0));
ExampleTextureLayerButton->setRolloverTextColor(Color4f(0.0,1.0,0.0,1.0));
ExampleTextureLayerButton->setActiveTextColor(Color4f(0.0,1.0,0.0,1.0));
ExamplePatternLayerButton->setText("Pattern Layer");
ExamplePatternLayerButton->setBackground(ExamplePatternLayer);
ExamplePatternLayerButton->setActiveBackground(ExamplePatternLayer);
ExamplePatternLayerButton->setRolloverBackground(ExamplePatternLayer);
ExamplePatternLayerButton->setPreferredSize(Vec2f(150,50));
ExamplePatternLayerButton->setTextColor(Color4f(0.0,1.0,0.0,1.0));
ExamplePatternLayerButton->setRolloverTextColor(Color4f(0.0,1.0,0.0,1.0));
ExamplePatternLayerButton->setActiveTextColor(Color4f(0.0,1.0,0.0,1.0));
ExampleGlassLayerButton->setText("Glass Layer");
ExampleGlassLayerButton->setBackground(ExampleGlassLayer);
ExampleGlassLayerButton->setActiveBackground(ExampleGlassLayer);
ExampleGlassLayerButton->setRolloverBackground(ExampleGlassLayer);
ExampleGlassLayerButton->setPreferredSize(Vec2f(150,50));
ExampleGlassLayerButton->setTextColor(Color4f(0.0,0.0,0.0,1.0));
ExampleGlassLayerButton->setRolloverTextColor(Color4f(0.0,0.0,0.0,1.0));
ExampleGlassLayerButton->setActiveTextColor(Color4f(0.0,0.0,0.0,1.0));
ExampleGlassCompoundLayerButton->setText("GlassCompound Layer");
ExampleGlassCompoundLayerButton->setBackground(ExampleGlassCompoundLayer);
ExampleGlassCompoundLayerButton->setActiveBackground(ExampleGlassCompoundLayer);
ExampleGlassCompoundLayerButton->setRolloverBackground(ExampleGlassCompoundLayer);
ExampleGlassCompoundLayerButton->setPreferredSize(Vec2f(150,50));
ExampleGlassCompoundLayerButton->setTextColor(Color4f(0.0,0.0,0.0,1.0));
ExampleGlassCompoundLayerButton->setRolloverTextColor(Color4f(0.0,0.0,0.0,1.0));
ExampleGlassCompoundLayerButton->setActiveTextColor(Color4f(0.0,0.0,0.0,1.0));
/******************************************************
Create a MainFrameBackground. For almost
all Tutorials, this is simply a
ColorLayer with a semi-transparent
white Background.
******************************************************/
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRefPtr MainInternalWindowBackground = OSG::ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
//InternalWindow Layout
LayoutRefPtr MainInternalWindowLayout = OSG::FlowLayout::create();
InternalWindowRefPtr MainInternalWindow = OSG::InternalWindow::create();
MainInternalWindow->pushToChildren(ExampleColorLayerButton);
MainInternalWindow->pushToChildren(ExampleCompoundLayerButton);
MainInternalWindow->pushToChildren(ExampleEmptyLayerButton);
MainInternalWindow->pushToChildren(ExampleGradientLayerButton);
MainInternalWindow->pushToChildren(ExampleMaterialLayerButton);
MainInternalWindow->pushToChildren(ExampleTextureLayerButton);
MainInternalWindow->pushToChildren(ExamplePatternLayerButton);
MainInternalWindow->pushToChildren(ExampleGlassLayerButton);
MainInternalWindow->pushToChildren(ExampleGlassCompoundLayerButton);
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
UIDrawingSurfaceRefPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRefPtr TutorialUIForeground = OSG::UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Create the SimpleSceneManager helper
sceneManager->setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRefPtr 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,
"04Background");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// Set up Window
TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
TutorialWindow->setDisplayCallback(display);
TutorialWindow->setReshapeCallback(reshape);
TutorialKeyListener TheKeyListener;
TutorialWindow->addKeyListener(&TheKeyListener);
// Make Torus Node (creates Torus in background of scene)
NodeRefPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRefPtr scene = OSG::Node::create();
scene->setCore(OSG::Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRefPtr TutorialGraphics = OSG::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
******************************************************/
MenuItemRefPtr MenuItem1 = MenuItem::create();
MenuItemRefPtr MenuItem2 = MenuItem::create();
MenuItemRefPtr MenuItem3 = MenuItem::create();
MenuItemRefPtr MenuItem4 = MenuItem::create();
MenuItemRefPtr SubMenuItem1 = MenuItem::create();
MenuItemRefPtr SubMenuItem2 = MenuItem::create();
MenuItemRefPtr SubMenuItem3 = MenuItem::create();
MenuRefPtr 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.
******************************************************/
PopupMenuRefPtr ExamplePopupMenu = PopupMenu::create();
ExamplePopupMenu->addItem(MenuItem1);
ExamplePopupMenu->addItem(MenuItem2);
ExamplePopupMenu->addItem(MenuItem3);
ExamplePopupMenu->addSeparator();
ExamplePopupMenu->addItem(ExampleSubMenu);
ExamplePopupMenu->addItem(MenuItem4);
// Create a Button and Font
UIFontRefPtr PopupMenuButtonFont = OSG::UIFont::create();
PopupMenuButtonFont->setSize(16);
ButtonRefPtr PopupMenuButton = OSG::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
ColorLayerRefPtr MainInternalWindowBackground = OSG::ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
LayoutRefPtr MainInternalWindowLayout = OSG::FlowLayout::create();
InternalWindowRefPtr MainInternalWindow = OSG::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
UIDrawingSurfaceRefPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRefPtr TutorialUIForeground = OSG::UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindow);
mgr->setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRefPtr TutorialViewport = mgr->getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
// Show the whole Scene
mgr->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
TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
TutorialWindow->setDisplayCallback(display);
TutorialWindow->setReshapeCallback(reshape);
TutorialKeyListener TheKeyListener;
TutorialWindow->addKeyListener(&TheKeyListener);
// Make Torus Node (creates Torus in background of scene)
NodeRefPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRefPtr scene = OSG::Node::create();
scene->setCore(OSG::Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRefPtr TutorialGraphics = OSG::Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
/******************************************************
Create and edit a few Button Components.
******************************************************/
ButtonRefPtr ExampleButton1 = OSG::Button::create();
ButtonRefPtr ExampleButton2 = OSG::Button::create();
ButtonRefPtr ExampleButton3 = OSG::Button::create();
ButtonRefPtr ExampleButton4 = OSG::Button::create();
ButtonRefPtr ExampleButton5 = OSG::Button::create();
ButtonRefPtr ExampleButton6 = OSG::Button::create();
ExampleButton1->setPreferredSize(Vec2f(200, 50));
ExampleButton4->setPreferredSize(Vec2f(50, 50));
/******************************************************
Create Flow Layout. Flow Layout arranges objects
automatically within the Frame, so that depending
on Frame size, the objects may appear in a vertical
line, horizontal line, or multiple lines. Objects
fill from the upper left hand corner of the Frame
across, then down (when the line becomes full) while
arranged Horizontally, or from the upper left hand
corner across when arranged Vertically, starting a
new column when necessary.
You can experiment with this by changing the window
size, changing the orientation, changing the
PreferredSize of the Buttons, or adding more
Buttons to the view.
Note that if the Frame is too small or resized
too much, the FlowLayout will become slightly
distorted. For Layouts which will often
be dynamically changed, FlowLayout is not
the best choice.
-setHorizontalGap(int): Determine the Horizontal
gap in pixels between Components in
FlowLayout.
-setVerticalGap(int): Determine the Vertical
gap in pixels between Components in
FlowLayout.
-setOrientation(ENUM): Determine whether the
Layout is arranged Vertically or
Horizontally. Takes HORIZONTAL_ORIENTATION
or VERTICAL_ORIENTATION arguments.
-setMajorAxisAlignment(ENUM): Determines
the alignment of the entire Layout
within its ComponentContainer. See below.
-setMinorAxistAlignment(ENUM): Determines
the alignment of Components within
the Layout. See below.
Both of the last two functions take the
following arguments: AXIS_MAX_ALIGNMENT,
AXIS_CENTER_ALIGNMENT, and AXIS_MIN_ALIGNMENT.
MAX puts it to the bottom/right, CENTER
centers it, and MIN puts it to the
top/left (for Vertical/Horizontal as
set above, respectively).
******************************************************/
FlowLayoutRefPtr MainInternalWindowLayout = OSG::FlowLayout::create();
MainInternalWindowLayout->setHorizontalGap(3.0f);
MainInternalWindowLayout->setVerticalGap(3.0f);
MainInternalWindowLayout->setOrientation(FlowLayout::VERTICAL_ORIENTATION);
MainInternalWindowLayout->setMajorAxisAlignment(0.5f);
MainInternalWindowLayout->setMinorAxisAlignment(1.0f);
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRefPtr MainInternalWindowBackground = OSG::ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
InternalWindowRefPtr MainInternalWindow = OSG::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);
// Add a 10 pixel "padding" inside the MainFrame
MainInternalWindow->setAllInsets(10);
//Create the Drawing Surface
UIDrawingSurfaceRefPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRefPtr TutorialUIForeground = OSG::UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindow);
mgr->setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRefPtr TutorialViewport = mgr->getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
// Show the whole Scene
mgr->showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"05FlowLayout");
//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(keyTyped, _1));
// Make Torus Node (creates Torus in background of scene)
NodeRefPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRefPtr scene = OSG::Node::create();
scene->setCore(OSG::Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRefPtr TutorialGraphics = OSG::Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
//Background
SolidBackgroundRefPtr TutorialBackground = SolidBackground::create();
TutorialBackground->setColor(Color3f(1.0,0.0,0.0));
UndoManagerPtr TheUndoManager = UndoManager::create();
CommandManagerPtr TheCommandManager = CommandManager::create(TheUndoManager);
//UndoList
DefaultListModelRecPtr UndoRedoListModel = DefaultListModel::create();
UndoRedoListModel->pushBack(boost::any(std::string("Top")));
ListRecPtr UndoRedoList = List::create();
UndoRedoList->setPreferredSize(Vec2f(250, 300));
UndoRedoList->setOrientation(List::VERTICAL_ORIENTATION);
UndoRedoList->setModel(UndoRedoListModel);
UndoRedoList->getSelectionModel()->connectSelectionChanged(boost::bind(&handleUndoRedoListSelectionChanged, _1, TheUndoManager));
ButtonRecPtr UndoButton = OSG::Button::create();
UndoButton->setText("Undo");
UndoButton->setEnabled(false);
UndoButton->connectActionPerformed(boost::bind(&handleUndoButtonAction, _1, TheUndoManager));
ButtonRecPtr RedoButton = OSG::Button::create();
RedoButton->setText("Redo");
RedoButton->setEnabled(false);
RedoButton->connectActionPerformed(boost::bind(&handleRedoButtonActionPerformed, _1, TheUndoManager));
TheUndoManager->connectStateChanged(boost::bind(&handleUndoManagerStateChanged, _1, UndoButton.get(), RedoButton.get(), UndoRedoListModel.get(), TheUndoManager));
// Create a ScrollPanel for easier viewing of the List (see 27ScrollPanel)
ScrollPanelRefPtr UndoRedoScrollPanel = ScrollPanel::create();
UndoRedoScrollPanel->setPreferredSize(Vec2f(200,200));
UndoRedoScrollPanel->setHorizontalResizePolicy(ScrollPanel::RESIZE_TO_VIEW);
UndoRedoScrollPanel->setViewComponent(UndoRedoList);
//Edited Label
LabelRecPtr EditedLabel = Label::create();
EditedLabel->setText("Can be edited");
EditedLabel->setPreferredSize(Vec2f(100.0f,18.0f));
//Editor Field
LabelRecPtr TheTextEditorLabel = Label::create();
TheTextEditorLabel->setText("Text");
TheTextEditorLabel->setPreferredSize(Vec2f(100.0f, 20.0f));
FieldEditorComponentRefPtr TheTextEditor = FieldEditorFactory::the()->createDefaultEditor(EditedLabel,
Label::TextFieldId,
TheCommandManager);
TheTextEditor->setPreferredSize(Vec2f(100.0f, 20.0f));
LabelRecPtr ThePreferredSizeEditorLabel = Label::create();
ThePreferredSizeEditorLabel->setText("PreferredSize");
ThePreferredSizeEditorLabel->setPreferredSize(Vec2f(100.0f, 20.0f));
FieldEditorComponentRefPtr ThePreferredSizeEditor =
FieldEditorFactory::the()->createDefaultEditor(EditedLabel,
Label::PreferredSizeFieldId,
TheCommandManager);
ThePreferredSizeEditor->setPreferredSize(Vec2f(150.0f, 20.0f));
//Editing Panel
LayoutRefPtr EditorPanelLayout = OSG::FlowLayout::create();
PanelRecPtr EditorPanel = Panel::create();
EditorPanel->setPreferredSize(Vec2f(200.0f,200.0f));
EditorPanel->pushToChildren(TheTextEditorLabel);
EditorPanel->pushToChildren(TheTextEditor);
EditorPanel->pushToChildren(ThePreferredSizeEditorLabel);
EditorPanel->pushToChildren(ThePreferredSizeEditor);
EditorPanel->setLayout(EditorPanelLayout);
//Undo Panel
LabelRecPtr UndoPanelLabel = Label::create();
UndoPanelLabel->setText("Undo Panel");
UndoPanelLabel->setPreferredSize(Vec2f(100.0f, 20.0f));
LayoutRefPtr UndoPanelLayout = OSG::FlowLayout::create();
PanelRecPtr UndoPanel = Panel::create();
UndoPanel->setPreferredSize(Vec2f(300.0f,300.0f));
UndoPanel->pushToChildren(UndoPanelLabel);
UndoPanel->pushToChildren(UndoRedoScrollPanel);
UndoPanel->pushToChildren(UndoButton);
UndoPanel->pushToChildren(RedoButton);
UndoPanel->setLayout(UndoPanelLayout);
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRefPtr MainInternalWindowBackground = OSG::ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
InternalWindowRefPtr MainInternalWindow = OSG::InternalWindow::create();
LayoutRefPtr MainInternalWindowLayout = OSG::FlowLayout::create();
MainInternalWindow->pushToChildren(EditedLabel);
MainInternalWindow->pushToChildren(EditorPanel);
MainInternalWindow->pushToChildren(UndoPanel);
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
UIDrawingSurfaceRefPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRefPtr TutorialUIForeground = OSG::UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
sceneManager.setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRefPtr TutorialViewport = sceneManager.getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
TutorialViewport->setBackground(TutorialBackground);
// 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,
"02GenericFieldEditor");
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// Set up Window
TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
TutorialWindow->setDisplayCallback(display);
TutorialWindow->setReshapeCallback(reshape);
TutorialKeyListener TheKeyListener;
TutorialWindow->addKeyListener(&TheKeyListener);
// Make Torus Node (creates Torus in background of scene)
NodeRefPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRefPtr scene = OSG::Node::create();
scene->setCore(OSG::Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRefPtr TutorialGraphics = OSG::Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
/******************************************************
Creates some Button components
******************************************************/
ButtonRefPtr ExampleButton1 = OSG::Button::create();
ButtonRefPtr ExampleButton2 = OSG::Button::create();
ButtonRefPtr ExampleButton3 = OSG::Button::create();
ButtonRefPtr ExampleButton4 = OSG::Button::create();
ButtonRefPtr ExampleButton5 = OSG::Button::create();
ButtonRefPtr ExampleButton6 = OSG::Button::create();
/******************************************************
Create SpringLayout. 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: SpringLayout has no options which
can be set.
******************************************************/
SpringLayoutRefPtr MainInternalWindowLayout = OSG::SpringLayout::create();
// OverlayLayout has no options to edit!
// NOTHING : )
/******************************************************
Create and edit some Button Components.
******************************************************/
ExampleButton1->setPreferredSize(Vec2f(50,50));
ExampleButton1->setText("Button 1");
ExampleButton2->setPreferredSize(Vec2f(50,50));
ExampleButton2->setText("Button 2");
ExampleButton3->setPreferredSize(Vec2f(50,50));
ExampleButton3->setText("Button 3");
ExampleButton4->setPreferredSize(Vec2f(50,50));
ExampleButton4->setText("Button 4");
ExampleButton5->setPreferredSize(Vec2f(50,50));
ExampleButton5->setText("Button 5");
ExampleButton6->setPreferredSize(Vec2f(50,50));
ExampleButton6->setText("Button 6");
InternalWindowRefPtr MainInternalWindow = OSG::InternalWindow::create();
// SpringLayoutConstraints Information
// It is possible to set the constraint for the Y_EDGE, X_EDGE, BASELINE_EDGE, NORTH_EDGE, SOUTH_EDGE, EAST_EDGE, WEST_EDGE, HEIGHT_EDGE, and/or WIDTH_EDGE of a component.
// It is possible to constrain a component's edge x pixels above, below, to the right of, or to the left of the edges other components, frames, and/or the MainInternalWindow.
// It is possible to constrain a component to the Y_EDGE, X_EDGE, BASELINE_EDGE, NORTH_EDGE, SOUTH_EDGE, EAST_EDGE, WEST_EDGE, HORIZONTAL_CENTER_EDGE, VERTICAL_CENTER_EDGE, HEIGHT_EDGE, and/or WIDTH_EDGE of whatever component to which it is constrained.
//Example Button 1
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::NORTH_EDGE, ExampleButton1, 25, SpringLayoutConstraints::NORTH_EDGE, MainInternalWindow); // The North edge of ExampleButton1 is 25 pixels below the North edge of the MainInternalWindow.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::SOUTH_EDGE, ExampleButton1, -5, SpringLayoutConstraints::VERTICAL_CENTER_EDGE, MainInternalWindow); // The South edge of ExampleButton1 is 5 pixels above the Vertical Center of the MainInternalWindow.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::EAST_EDGE, ExampleButton1, -25, SpringLayoutConstraints::EAST_EDGE, MainInternalWindow); // The East edge of ExampleButton1 is 25 pixels to the left of the East edge of the MainInternalWindow.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::WEST_EDGE, ExampleButton1, 25, SpringLayoutConstraints::WEST_EDGE, MainInternalWindow); // The West edge of ExampleButton1 is 25 pixels to the right of the West edge of the MainInternalWindow.
//Example Button 2
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::HEIGHT_EDGE, ExampleButton2, LayoutSpring::height(ExampleButton2)); // The Height edge of ExampleButton2 is set to the height of ExampleButton2.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::SOUTH_EDGE, ExampleButton2, -25, SpringLayoutConstraints::SOUTH_EDGE, MainInternalWindow); // The South edge of ExampleButton2 is 25 pixels above the South edge of the MainInternalWindow.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::EAST_EDGE, ExampleButton2, -5, SpringLayoutConstraints::HORIZONTAL_CENTER_EDGE, MainInternalWindow); // The East edge of ExampleButton2 is 5 pixels to the left of the Horizontal Center of the MainInternalWindow.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::WEST_EDGE, ExampleButton2, 25, SpringLayoutConstraints::WEST_EDGE, MainInternalWindow); // The West edge of ExampleButton2 is 25 pixels to the right of the West edge of the MainInternalWindow.
//Example Button 3
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::HEIGHT_EDGE, ExampleButton3, LayoutSpring::height(ExampleButton3)); // The Height edge of ExampleButton3 is set to the height of ExampleButton3.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::SOUTH_EDGE, ExampleButton3, -25, SpringLayoutConstraints::SOUTH_EDGE, MainInternalWindow); // The South edge of ExampleButton3 is 25 pixels above the South edge of the MainInternalWindow.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::WEST_EDGE, ExampleButton3, 5, SpringLayoutConstraints::HORIZONTAL_CENTER_EDGE, MainInternalWindow); // The West edge of ExampleButton3 is 5 pixels to the right of the Horizontal Center of the MainInternalWindow.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::EAST_EDGE, ExampleButton3, -25, SpringLayoutConstraints::EAST_EDGE, MainInternalWindow); // The East edge of ExampleButton3 is 25 pixels to the left of the East edge of the MainInternalWindow.
//Example Button 4
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::NORTH_EDGE, ExampleButton4, 25, SpringLayoutConstraints::SOUTH_EDGE, ExampleButton1); // The North edge of ExampleButton4 is 25 pixels below the South edge of ExampleButton1.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::SOUTH_EDGE, ExampleButton4, -25, SpringLayoutConstraints::NORTH_EDGE, ExampleButton2); // The South edge of ExampleButton4 is 25 pixels above the North edge of ExampleButton2.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::WEST_EDGE, ExampleButton4, 25, SpringLayoutConstraints::WEST_EDGE, MainInternalWindow); // The West edge of ExampleButton4 is 25 pixels to the right of the West edge of the MainInternalWindow.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::EAST_EDGE, ExampleButton4, -100, SpringLayoutConstraints::HORIZONTAL_CENTER_EDGE, MainInternalWindow); // The East edge of ExampleButton4 is 100 pixels to the left of the Horizontal Center of the MainInternalWindow.
//Example Button 5
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::NORTH_EDGE, ExampleButton5, 25, SpringLayoutConstraints::SOUTH_EDGE, ExampleButton1); // The North edge of ExampleButton5 is 25 pixels below the South edge of ExampleButton1.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::HEIGHT_EDGE, ExampleButton5, 0, SpringLayoutConstraints::HEIGHT_EDGE, ExampleButton4); // The Height of ExampleButton5 is set to the Height of ExampleButton4.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::EAST_EDGE, ExampleButton5, 75, SpringLayoutConstraints::HORIZONTAL_CENTER_EDGE, MainInternalWindow); // The East edge of ExampleButton5 is 75 pixels to the right of the Horizontal Center of the MainInternalWindow.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::WEST_EDGE, ExampleButton5, -75, SpringLayoutConstraints::HORIZONTAL_CENTER_EDGE, MainInternalWindow); // The West edge of ExampleButton5 is 75 pixels to the left of the Horizontal Center of the MainInternalWindow.
//Example Button 6
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::NORTH_EDGE, ExampleButton6, 25, SpringLayoutConstraints::SOUTH_EDGE, ExampleButton1); // The North edge of ExampleButton6 is 25 pixels below the South edge of ExampleButton1.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::SOUTH_EDGE, ExampleButton6, -25, SpringLayoutConstraints::NORTH_EDGE, ExampleButton2); // The South edge of ExampleButton6 is 25 pixels above the North edge of ExampleButton2.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::WEST_EDGE, ExampleButton6, 100, SpringLayoutConstraints::HORIZONTAL_CENTER_EDGE, MainInternalWindow); // The West edge of ExampleButton6 is 100 pixels to the right of the Horizontal Center of the MainInternalWindow.
MainInternalWindowLayout->putConstraint(SpringLayoutConstraints::WIDTH_EDGE, ExampleButton6, 0, SpringLayoutConstraints::WIDTH_EDGE, ExampleButton4); // The Width of ExampleButton6 is set to the Width of ExampleButton4.
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRefPtr MainInternalWindowBackground = OSG::ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
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
UIDrawingSurfaceRefPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRefPtr TutorialUIForeground = OSG::UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindow);
mgr->setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRefPtr TutorialViewport = mgr->getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
// Show the whole Scene
mgr->showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"36SpringLayout");
//Enter main Loop
TutorialWindow->mainLoop();
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
TutorialWindow->setDisplayCallback(display);
TutorialWindow->setReshapeCallback(reshape);
TutorialKeyListener TheKeyListener;
TutorialWindow->addKeyListener(&TheKeyListener);
// Make Torus Node (creates Torus in background of scene)
NodeRefPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRefPtr scene = OSG::Node::create();
scene->setCore(OSG::Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRefPtr TutorialGraphics = OSG::Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
GradientBackgroundRefPtr TheBackground = GradientBackground::create();
TheBackground->addLine(Color3f(1.0,0.0,0.0), 0.0);
TheBackground->addLine(Color3f(0.0,1.0,0.0), 0.2);
TheBackground->addLine(Color3f(0.0,0.0,1.0), 0.4);
TheBackground->addLine(Color3f(0.0,1.0,1.0), 0.6);
TheBackground->addLine(Color3f(1.0,1.0,0.0), 0.8);
TheBackground->addLine(Color3f(1.0,1.0,1.0), 1.0);
/******************************************************
Create a List. A List has several
parts to it:
-ListModel: Contains the data which is to be
displayed in the List. Data is added
as shown below
-ListCellRenderer: Creates the Components to
be used within the List (the default
setting is to create Labels using
the desired text).
-ListSelectionModel: Determines how
the List may be selected.
To add values to the list:
First, create SFStrings and use the
.setValue("Value") function to set their
values. Then, use the .pushBack(&SFStringName)
to add them to the List.
Next, create the CellRenderer and ListSelectionModel
defaults.
Finally, actually create the List. Set
its Model, CellRenderer, and SelectionModel
as shown below. Finally, choose the
type of display for the List (choices outlined
below).
******************************************************/
// Add data to it
ExampleListModel = MFieldListModel::create();
ExampleListModel->setContainer(TheBackground);
ExampleListModel->setFieldId(GradientBackground::ColorFieldId);
/******************************************************
Create ListCellRenderer and
ListSelectionModel. Most
often the defauls will be used.
Note: the ListSelectionModel was
created above and is referenced
by the ActionListeners.
******************************************************/
/******************************************************
Create List itself and assign its
Model, CellRenderer, and SelectionModel
to it.
-setOrientation(ENUM): Determine the
Layout of the cells (Horizontal
or Vertical). Takes List::VERTICAL_ORIENTATION
and List::HORIZONTAL_ORIENTATION arguments.
******************************************************/
ExampleList = List::create();
ExampleList->setPreferredSize(Vec2f(200, 300));
ExampleList->setOrientation(List::VERTICAL_ORIENTATION);
//ExampleList->setOrientation(List::HORIZONTAL_ORIENTATION);
ExampleList->setModel(ExampleListModel);
ExampleList->setSelectionModel(ExampleListSelectionModel);
/******************************************************
Determine the SelectionModel
-SINGLE_SELECTION lets you select ONE item
via a single mouse click
-SINGLE_INTERVAL_SELECTION lets you select
one interval via mouse and SHIFT key
-MULTIPLE_INTERVAL_SELECTION lets you select
via mouse, and SHIFT and CONTRL keys
Note: this tutorial is currently set up
to allow for this to be changed via
TogggleButtons with ActionListeners attached
to them so this code is commented out.
******************************************************/
//SelectionModel.setMode(DefaultListSelectionModel::SINGLE_SELECTION);
//SelectionModel.setMode(DefaultListSelectionModel::SINGLE_INTERVAL_SELECTION);
//SelectionModel.setMode(DefaultListSelectionModel::MULTIPLE_INTERVAL_SELECTION);
// Create a ScrollPanel for easier viewing of the List (see 27ScrollPanel)
ScrollPanelRefPtr ExampleScrollPanel = ScrollPanel::create();
ExampleScrollPanel->setPreferredSize(Vec2f(200,300));
ExampleScrollPanel->setHorizontalResizePolicy(ScrollPanel::RESIZE_TO_VIEW);
//ExampleScrollPanel->setVerticalResizePolicy(ScrollPanel::RESIZE_TO_VIEW);
ExampleScrollPanel->setViewComponent(ExampleList);
// Create MainFramelayout
FlowLayoutRefPtr MainInternalWindowLayout = OSG::FlowLayout::create();
MainInternalWindowLayout->setOrientation(FlowLayout::VERTICAL_ORIENTATION);
MainInternalWindowLayout->setMajorAxisAlignment(0.5f);
MainInternalWindowLayout->setMinorAxisAlignment(0.5f);
LabelRefPtr ListLabel = Label::create();
ListLabel->setText("Background Colors List");
ListLabel->setPreferredSize(Vec2f(200.0f, ListLabel->getPreferredSize().y()));
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRefPtr MainInternalWindowBackground = OSG::ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
InternalWindowRefPtr MainInternalWindow = OSG::InternalWindow::create();
MainInternalWindow->pushToChildren(ListLabel);
MainInternalWindow->pushToChildren(ExampleScrollPanel);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.7f,0.5f));
MainInternalWindow->setDrawTitlebar(false);
MainInternalWindow->setResizable(false);
// Create the Drawing Surface
UIDrawingSurfaceRefPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRefPtr TutorialUIForeground = OSG::UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindow);
mgr->setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRefPtr TutorialViewport = mgr->getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
TutorialViewport->setBackground(TheBackground);
// Show the whole Scene
mgr->showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"44MFieldList");
//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
TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
TutorialWindow->setDisplayCallback(display);
TutorialWindow->setReshapeCallback(reshape);
//TutorialKeyListener TheKeyListener;
//TutorialWindow->addKeyListener(&TheKeyListener);
// Make Torus Node (creates Torus in background of scene)
NodeRefPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRefPtr scene = OSG::Node::create();
scene->setCore(OSG::Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRefPtr graphics = OSG::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.
******************************************************/
DefaultMutableComboBoxModelRefPtr ExampleComboBoxModel = DefaultMutableComboBoxModel::create();
ExampleComboBoxModel->addElement(boost::any(Color4f(1.0,0.0,0.0,1.0)));
ExampleComboBoxModel->addElement(boost::any(Color4f(0.0,1.0,0.0,1.0)));
ExampleComboBoxModel->addElement(boost::any(Color4f(0.0,0.0,1.0,1.0)));
ExampleComboBoxModel->addElement(boost::any(Color4f(0.0,0.0,0.0,1.0)));
ExampleComboBoxModel->addElement(boost::any(Color4f(1.0,1.0,1.0,1.0)));
ExampleComboBoxModel->addElement(boost::any(std::string("More Colors")));
/******************************************************
Create an editable ComboBox. A ComboBox
has a Model just like various other
Components.
******************************************************/
ColorChooserComboBoxComponentGeneratorRefPtr TheColorChooserComboBoxComponentGenerator = ColorChooserComboBoxComponentGenerator::create();
//Create the ComboBox
ComboBoxRefPtr ExampleComboBox = ComboBox::create();
// Set the Model created above to the ComboBox
ExampleComboBox->setModel(ExampleComboBoxModel);
ExampleComboBox->setCellGenerator(TheColorChooserComboBoxComponentGenerator);
ExampleComboBox->setEditable(false);
// Determine where the ComboBox starts
ExampleComboBox->setSelectedIndex(0);
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRefPtr MainInternalWindowBackground = OSG::ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
LayoutRefPtr MainInternalWindowLayout = OSG::FlowLayout::create();
InternalWindowRefPtr MainInternalWindow = OSG::InternalWindow::create();
MainInternalWindow->pushToChildren(ExampleComboBox);
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
UIDrawingSurfaceRefPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(graphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRefPtr foreground = OSG::UIForeground::create();
foreground->setDrawingSurface(TutorialDrawingSurface);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the manager what to manage
mgr->setWindow(TutorialWindow);
mgr->setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRefPtr viewport = mgr->getWindow()->getPort(0);
viewport->addForeground(foreground);
// Show the whole scene
mgr->showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"33_2_ColorComboBox");
//Enter main Loop
TutorialWindow->mainLoop();
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// Set up Window
TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
TutorialWindow->setDisplayCallback(display);
TutorialWindow->setReshapeCallback(reshape);
TutorialKeyListener TheKeyListener;
TutorialWindow->addKeyListener(&TheKeyListener);
// Make Torus Node (creates Torus in background of scene)
NodeRefPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRefPtr scene = OSG::Node::create();
scene->setCore(OSG::Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRefPtr TutorialGraphics = OSG::Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
// Create a simple Font to be used with the TextField
UIFontRefPtr sampleFont = OSG::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
TextFieldRefPtr ExampleTextField = OSG::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
TextFieldRefPtr ExampleTextField2 = OSG::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
ColorLayerRefPtr MainInternalWindowBackground = OSG::ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
LayoutRefPtr MainInternalWindowLayout = OSG::FlowLayout::create();
InternalWindowRefPtr MainInternalWindow = OSG::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
UIDrawingSurfaceRefPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRefPtr TutorialUIForeground = OSG::UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindow);
mgr->setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRefPtr TutorialViewport = mgr->getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
// Show the whole Scene
mgr->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);
TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
TutorialWindow->setDisplayCallback(display);
TutorialWindow->setReshapeCallback(reshape);
TutorialKeyListener TheKeyListener;
TutorialWindow->addKeyListener(&TheKeyListener);
// Make Torus Node (creates Torus in background of scene)
NodeRefPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRefPtr scene = OSG::Node::create();
scene->setCore(OSG::Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRefPtr TutorialGraphics = OSG::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).
******************************************************/
CheckboxButtonRefPtr ExampleCheckboxButton = OSG::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
ColorLayerRefPtr MainInternalWindowBackground = OSG::ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
LayoutRefPtr MainInternalWindowLayout = OSG::FlowLayout::create();
InternalWindowRefPtr MainInternalWindow = OSG::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
UIDrawingSurfaceRefPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRefPtr TutorialUIForeground = OSG::UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindow);
mgr->setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRefPtr TutorialViewport = mgr->getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
// Show the whole Scene
mgr->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
TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
TutorialWindow->setDisplayCallback(display);
TutorialWindow->setReshapeCallback(reshape);
TutorialKeyListener TheKeyListener;
TutorialWindow->addKeyListener(&TheKeyListener);
// Make Torus Node (creates Torus in background of scene)
NodeRefPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRefPtr scene = OSG::Node::create();
scene->setCore(OSG::Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRefPtr TutorialGraphics = OSG::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.
******************************************************/
GridLayoutRefPtr MainInternalWindowLayout = OSG::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).
******************************************************/
ButtonRefPtr ExampleButton1 = OSG::Button::create();
ButtonRefPtr ExampleButton2 = OSG::Button::create();
ButtonRefPtr ExampleButton3 = OSG::Button::create();
ButtonRefPtr ExampleButton4 = OSG::Button::create();
ButtonRefPtr ExampleButton5 = OSG::Button::create();
ButtonRefPtr ExampleButton6 = OSG::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
ColorLayerRefPtr MainInternalWindowBackground = OSG::ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
InternalWindowRefPtr MainInternalWindow = OSG::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
UIDrawingSurfaceRefPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRefPtr TutorialUIForeground = OSG::UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindow);
mgr->setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRefPtr TutorialViewport = mgr->getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
// Show the whole Scene
mgr->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
TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
TutorialWindow->setDisplayCallback(display);
TutorialWindow->setReshapeCallback(reshape);
/******************************************************
Add MouseListeners and WindowListeners
to the WindowEvent.
******************************************************/
TutorialMouseListener TheTutorialMouseListener;
TutorialMouseListener1 BasicListener;
TutorialMouseMotionListener TheTutorialMouseMotionListener;
TutorialWindow->addMouseListener(&TheTutorialMouseListener);
TutorialWindow->addMouseMotionListener(&TheTutorialMouseMotionListener);
TutorialKeyListener TheKeyListener;
TutorialWindow->addKeyListener(&TheKeyListener);
// Make Torus Node (creates Torus in background of scene)
NodeRefPtr TorusGeometryNode = makeTorus(90, 270, 16, 16);
// Make Main Scene Node and add the Torus
NodeRefPtr scene = OSG::Node::create();
scene->setCore(OSG::Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRefPtr TutorialGraphics = OSG::Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
LoadButton = Button::create();
LoadButton->setMinSize(Vec2f(50, 25));
LoadButton->setMaxSize(Vec2f(200, 100));
LoadButton->setPreferredSize(Vec2f(100, 50));
LoadButton->setToolTipText("Click to open a file browser window");
LoadButton->setText("Load File");
LoadButton->addActionListener(&BasicListener);
SaveButton = Button::create();
SaveButton->setMinSize(Vec2f(50, 25));
SaveButton->setMaxSize(Vec2f(200, 100));
SaveButton->setPreferredSize(Vec2f(100, 50));
SaveButton->setToolTipText("Click to save the currently opened file");
SaveButton->setText("Save File");
SaveButton->addActionListener(&BasicListener);
theTextEditor = TextEditor::create();
theTextEditor->setPreferredSize(Vec2f(600,400));
/*
UIFontRefPtr _Font = UIFont::create();
_Font->setFamily("SANS");
_Font->setGap(3);
_Font->setGlyphPixelSize(46);
_Font->setSize(15);
_Font->setTextureWidth(0);
_Font->setStyle(TextFace::STYLE_PLAIN);
ExampleTextDomArea->setPreferredSize(Vec2f(600, 400));
ExampleTextDomArea->setWrapStyleWord(false);
ExampleTextDomArea->setMinSize(Vec2f(600,400));
ExampleTextDomArea->setFont(_Font);
ExampleAdvancedTextDomArea = OSG::AdvancedTextDomArea::create();
ExampleAdvancedTextDomArea->setPreferredSize(Vec2f(600,400));
ExampleAdvancedTextDomArea->setMinSize(Vec2f(600,400));
ExampleAdvancedTextDomArea->setGutterVisible(true);
ExampleAdvancedTextDomArea->pushToChildren(ExampleTextDomArea);
ExampleAdvancedTextDomArea->setLayout(LayoutRefPtr(OSG::FlowLayout::create()));
ExampleAdvancedTextDomArea->setPreferredSize(Vec2f(600,400));
ExampleAdvancedTextDomArea->setMinSize(Vec2f(600,400));
ScrollPanelRefPtr TextAreaScrollPanel = ScrollPanel::create();
TextAreaScrollPanel->setPreferredSize(Vec2f(600,400));
TextAreaScrollPanel->setMinSize(Vec2f(600,400));
TextAreaScrollPanel->setViewComponent(ExampleAdvancedTextDomArea);
*/
ColorLayerRefPtr MainInternalWindowBackground = OSG::ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
LayoutRefPtr MainInternalWindowLayout = OSG::FlowLayout::create();
InternalWindowRefPtr MainInternalWindow = OSG::InternalWindow::create();
MainInternalWindow->pushToChildren(theTextEditor);
MainInternalWindow->pushToChildren(LoadButton);
MainInternalWindow->pushToChildren(SaveButton);
MainInternalWindow->setLayout(MainInternalWindowLayout);
MainInternalWindow->setBackgrounds(MainInternalWindowBackground);
MainInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
MainInternalWindow->setScalingInDrawingSurface(Vec2f(0.85f,0.85f));
MainInternalWindow->setDrawTitlebar(true);
MainInternalWindow->setResizable(false);
/******************************************************
The Drawing Surface is created the
same as with previous Tutorials
(however the MainInternalWindow is created
in a function below).
******************************************************/
UIDrawingSurfaceRefPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
/******************************************************
Create the 3D UIRectangle. This allows
the DrawingSurface to be rotated relative
to the screen, allowing a 3D aspect to
the DrawingSurface. The Surface
can still be interacted with, so Buttons,
Menus, etc. all will still function
normally.
-setPoint(Pnt3f): Determine the location
of the UIRectangle in 3D space. Keep
in mind that (0,0,0) is located
directly in the center of the sceen.
(For our purposes it is the center
of the tori.) The point is located
on the lower left corner of the
rectangle.
-setWidth(float): Determine the Width
of the UIRectangle. This may
physically appear different depending
on where the UIRectangle is placed
as above (due to it being located
further away, etc).
-setHeight(float): Determine the Height
of the UIRectangle. This may
physically appear different depending
on where the UIRectangle is placed
as above (due to it being located
further away, etc).
-setDrawingSurface(DrawingSurface):
Determine what DrawingSurface is
drawn on the UIRectangle. This
will typically be the main
DrawingSurface, however, multiple
DrawingSurfaces can be used with
multiple UIRectangles.
******************************************************/
//Make A 3D Rectangle to draw the UI on
UIRectangleRefPtr ExampleUIRectangle = UIRectangle::create();
ExampleUIRectangle->setPoint(Pnt3f(-400,-400,200));
ExampleUIRectangle->setWidth(800.0);
ExampleUIRectangle->setHeight(800.0);
ExampleUIRectangle->setDrawingSurface(TutorialDrawingSurface);
/******************************************************
Because the previous Tutorials used a
Viewport to view the scene, which is
no longer being used, the UIRectangle
must be added to the scene for it to
be displayed (identical to how the
Torus is added).
First, create a Node, and set its
core to be the UIRectangle. Then,
add that to the scene Node which
is created above. This scene is
then set as the Root for the view.
It is possible to change this Root
to be just the UIRectangle (as
commented out below).
******************************************************/
NodeRefPtr ExampleUIRectangleNode = OSG::Node::create();
ExampleUIRectangleNode->setCore(ExampleUIRectangle);
// Add the UIRectangle as a child to the scene
scene->addChild(ExampleUIRectangleNode);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindow);
mgr->setRoot(scene);
//mgr->setRoot(ExampleUIRectangleNode);
// Show the whole Scene
mgr->showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"3DNotepad!!");
//Enter main Loop
TutorialWindow->mainLoop();
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// Set up Window
TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
TutorialWindow->setDisplayCallback(display);
TutorialWindow->setReshapeCallback(reshape);
TutorialMouseListener mouseListener;
TutorialMouseMotionListener mouseMotionListener;
TutorialWindow->addMouseListener(&mouseListener);
TutorialWindow->addMouseMotionListener(&mouseMotionListener);
TutorialKeyListener TheKeyListener;
TutorialWindow->addKeyListener(&TheKeyListener);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindow);
// Set up Window
//Load in File
NodeRefPtr LoadedFile = SceneFileHandler::the()->read("C:\\Documents and Settings\\All Users\\Documents\\Cell.osb");
// Make Main Scene Node
create3DObjects();
scene = OSG::Node::create();
scene->setCore(OSG::Group::create());
scene->addChild(LoadedFile);
// Create the Graphics
GraphicsRefPtr TutorialGraphics = OSG::Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
/******************************************************
Create a Background
******************************************************/
ColorLayerRefPtr GreyBackground = OSG::ColorLayer::create();
GreyBackground->setColor(Color4f(.93,.93,.93,1.0));
/******************************************************
Create some Borders
******************************************************/
LineBorderRefPtr PanelBorder = OSG::LineBorder::create();
EmptyBorderRefPtr Panel1Border = OSG::EmptyBorder::create();
EmptyBorderRefPtr Panel2Border = OSG::EmptyBorder::create();
EmptyBorderRefPtr emptyBorder = OSG::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
******************************************************/
LabelRefPtr LeftPanelLabel1 = OSG::Label::create();
UIFontRefPtr LeftPanelLabel1Font = OSG::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
******************************************************/
BoxLayoutRefPtr MainInternalWindowLayout = OSG::BoxLayout::create();
FlowLayoutRefPtr LeftPanelLayout = OSG::FlowLayout::create();
BoxLayoutRefPtr RightPanelLayout = OSG::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
******************************************************/
PanelRefPtr LeftPanel = OSG::Panel::create();
PanelRefPtr RightPanel = OSG::Panel::create();
// LeftPanel stuff
LeftPanel->setPreferredSize(Vec2f(400, 500));
LeftPanel->pushToChildren(LeftPanelLabel1);
LeftPanel->pushToChildren(createLeftPanelButtonPanel());
LeftPanel->pushToChildren(createLeftPanelRadioTextPanel());
LeftPanel->setLayout(LeftPanelLayout);
LeftPanel->setBackgrounds(GreyBackground);
LeftPanel->setBorders(Panel1Border);
//RightPanel stuff
RightPanel->setPreferredSize(Vec2f(200, 620));
RightPanel->pushToChildren(createRightPanelButtonPanel());
RightPanel->pushToChildren(createRightPanelCheckPanel());
RightPanel->setLayout(RightPanelLayout);
RightPanel->setBackgrounds(GreyBackground);
RightPanel->setBorders(Panel2Border);
// Create The Main InternalWindow
InternalWindowRefPtr MainInternalWindow = OSG::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);
// Create the Drawing Surface
UIDrawingSurfaceRefPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Make A 3D Rectangle to draw the UI on
UIRectangleRefPtr UIRectCore = UIRectangle::create();
UIRectCore->setPoint(Pnt3f(-310.0,-310.0,370.0));
UIRectCore->setWidth(620);
UIRectCore->setHeight(620);
UIRectCore->setDrawingSurface(TutorialDrawingSurface);
NodeRefPtr UIRectNode = OSG::Node::create();
UIRectNode->setCore(UIRectCore);
// add the UIRect as a child
scene->addChild(UIRectNode);
mgr->setRoot(scene);
// Show the whole Scene
mgr->showAll();
//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;
}
// Initialize WIN32 & OpenSG and set up the scene
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// Set up Window
TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
TutorialWindow->setDisplayCallback(display);
TutorialWindow->setReshapeCallback(reshape);
TutorialKeyListener TheKeyListener;
TutorialWindow->addKeyListener(&TheKeyListener);
// Make Torus Node (creates Torus in background of scene)
NodeRefPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRefPtr scene = OSG::Node::create();
scene->setCore(OSG::Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRefPtr graphics = OSG::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.
******************************************************/
DefaultMutableComboBoxModelRefPtr 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
ComboBoxRefPtr 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
ComboBoxRefPtr 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
ColorLayerRefPtr MainInternalWindowBackground = OSG::ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
LayoutRefPtr MainInternalWindowLayout = OSG::FlowLayout::create();
InternalWindowRefPtr MainInternalWindow = OSG::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
UIDrawingSurfaceRefPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(graphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRefPtr foreground = OSG::UIForeground::create();
foreground->setDrawingSurface(TutorialDrawingSurface);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the manager what to manage
mgr->setWindow(TutorialWindow);
mgr->setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRefPtr viewport = mgr->getWindow()->getPort(0);
viewport->addForeground(foreground);
// Show the whole scene
mgr->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;
}
ForegroundRefPtr ApplicationStartScreen::createInterface(void)
{
// Create the Graphics
GraphicsRefPtr StartScreenUIGraphics = OSG::Graphics2D::create();
UIFontRefPtr ButtonFont = OSG::UIFont::create();
ButtonFont->setSize(32);
ButtonRefPtr BuilderButton = ::OSG::Button::create();
BuilderButton->setPreferredSize(Vec2f(200, 75));
BuilderButton->setText("Builder");
BuilderButton->setFont(ButtonFont);
BuilderButton->addActionListener(&_BuilderButtonActionListener);
ButtonRefPtr PlayerButton = ::OSG::Button::create();
PlayerButton->setPreferredSize(Vec2f(200, 75));
PlayerButton->setText("Player");
PlayerButton->setFont(ButtonFont);
PlayerButton->addActionListener(&_PlayerButtonActionListener);
ButtonRefPtr ExitButton = ::OSG::Button::create();
ExitButton->setPreferredSize(Vec2f(200, 75));
ExitButton->setText("Exit");
ExitButton->setFont(ButtonFont);
ExitButton->addActionListener(&_ExitButtonActionListener);
//ButtonPanel
PanelRefPtr ButtonPanel = Panel::createEmpty();
LayoutRefPtr ButtonPanelLayout = OSG::FlowLayout::create();
ButtonPanel->pushToChildren(BuilderButton);
ButtonPanel->pushToChildren(PlayerButton);
ButtonPanel->pushToChildren(ExitButton);
ButtonPanel->setLayout(ButtonPanelLayout);
//Font
UIFontRefPtr LabelFont = UIFont::create();
LabelFont->setSize(16);
//Version Label
LabelRefPtr VersionLabel = OSG::Label::create();
VersionLabel->setText("Version:");
VersionLabel->setAlignment(Vec2f(1.0f,0.5f));
VersionLabel->setPreferredSize(Vec2f(100,20));
VersionLabel->setTextColors(Color4f(1.0f,1.0f,1.0f,1.0f));
VersionLabel->setBackgrounds(NULL);
VersionLabel->setBorders(NULL);
VersionLabel->setFont(LabelFont);
//Version Value Label
LabelRefPtr VersionValueLabel = OSG::Label::create();
VersionValueLabel->setText(getKabalaEngineVersion() + " - " + getKabalaEngineBuildType());
VersionValueLabel->setPreferredSize(Vec2f(110,20));
VersionValueLabel->setTextColors(Color4f(1.0f,1.0f,1.0f,1.0f));
VersionValueLabel->setBackgrounds(NULL);
VersionValueLabel->setBorders(NULL);
VersionValueLabel->setFont(LabelFont);
//Author Value Label
LabelRefPtr AuthorValueLabel = OSG::Label::create();
AuthorValueLabel->setText(getKabalaEngineAuthors());
AuthorValueLabel->setPreferredSize(Vec2f(300,20));
AuthorValueLabel->setTextColors(Color4f(1.0f,1.0f,1.0f,1.0f));
AuthorValueLabel->setBackgrounds(NULL);
AuthorValueLabel->setBorders(NULL);
AuthorValueLabel->setFont(LabelFont);
// Create The Main InternalWindow
InternalWindowRefPtr StartScreenInternalWindow = OSG::InternalWindow::create();
//Layout
SpringLayoutRefPtr StartScreenInternalWindowLayout = OSG::SpringLayout::create();
//::OSG::Button Panel
StartScreenInternalWindowLayout->putConstraint(SpringLayoutConstraints::WEST_EDGE, ButtonPanel, 0, SpringLayoutConstraints::WEST_EDGE, StartScreenInternalWindow);
StartScreenInternalWindowLayout->putConstraint(SpringLayoutConstraints::EAST_EDGE, ButtonPanel, 0, SpringLayoutConstraints::EAST_EDGE, StartScreenInternalWindow);
StartScreenInternalWindowLayout->putConstraint(SpringLayoutConstraints::NORTH_EDGE, ButtonPanel, 0, SpringLayoutConstraints::NORTH_EDGE, StartScreenInternalWindow);
StartScreenInternalWindowLayout->putConstraint(SpringLayoutConstraints::SOUTH_EDGE, ButtonPanel, 0, SpringLayoutConstraints::SOUTH_EDGE, StartScreenInternalWindow);
//Version Label
StartScreenInternalWindowLayout->putConstraint(SpringLayoutConstraints::EAST_EDGE, VersionLabel, 0, SpringLayoutConstraints::WEST_EDGE, VersionValueLabel);
StartScreenInternalWindowLayout->putConstraint(SpringLayoutConstraints::SOUTH_EDGE, VersionLabel, 0, SpringLayoutConstraints::SOUTH_EDGE, StartScreenInternalWindow);
StartScreenInternalWindowLayout->putConstraint(SpringLayoutConstraints::HEIGHT_EDGE, VersionLabel, LayoutSpring::height(VersionLabel));
StartScreenInternalWindowLayout->putConstraint(SpringLayoutConstraints::WIDTH_EDGE, VersionLabel, LayoutSpring::width(VersionLabel));
//Version Value Label
StartScreenInternalWindowLayout->putConstraint(SpringLayoutConstraints::EAST_EDGE, VersionValueLabel, 0, SpringLayoutConstraints::EAST_EDGE, StartScreenInternalWindow);
StartScreenInternalWindowLayout->putConstraint(SpringLayoutConstraints::SOUTH_EDGE, VersionValueLabel, 0, SpringLayoutConstraints::SOUTH_EDGE, StartScreenInternalWindow);
StartScreenInternalWindowLayout->putConstraint(SpringLayoutConstraints::HEIGHT_EDGE, VersionValueLabel, LayoutSpring::height(VersionValueLabel));
StartScreenInternalWindowLayout->putConstraint(SpringLayoutConstraints::WIDTH_EDGE, VersionValueLabel, LayoutSpring::width(VersionValueLabel));
//Author Value Label
StartScreenInternalWindowLayout->putConstraint(SpringLayoutConstraints::WEST_EDGE, AuthorValueLabel, 0, SpringLayoutConstraints::WEST_EDGE, StartScreenInternalWindow);
StartScreenInternalWindowLayout->putConstraint(SpringLayoutConstraints::SOUTH_EDGE, AuthorValueLabel, 0, SpringLayoutConstraints::SOUTH_EDGE, StartScreenInternalWindow);
StartScreenInternalWindowLayout->putConstraint(SpringLayoutConstraints::HEIGHT_EDGE, AuthorValueLabel, LayoutSpring::height(AuthorValueLabel));
StartScreenInternalWindowLayout->putConstraint(SpringLayoutConstraints::WIDTH_EDGE, AuthorValueLabel, LayoutSpring::width(AuthorValueLabel));
StartScreenInternalWindow->pushToChildren(ButtonPanel);
StartScreenInternalWindow->pushToChildren(AuthorValueLabel);
StartScreenInternalWindow->pushToChildren(VersionLabel);
StartScreenInternalWindow->pushToChildren(VersionValueLabel);
StartScreenInternalWindow->setLayout(StartScreenInternalWindowLayout);
StartScreenInternalWindow->setAlignmentInDrawingSurface(Vec2f(0.5f,0.5f));
StartScreenInternalWindow->setScalingInDrawingSurface(Vec2f(1.0f,1.0f));
StartScreenInternalWindow->setDrawTitlebar(false);
StartScreenInternalWindow->setDrawDecorations(false);
StartScreenInternalWindow->setResizable(false);
// Create the Drawing Surface
_TheUIDrawingSurface = UIDrawingSurface::create();
_TheUIDrawingSurface->setGraphics(StartScreenUIGraphics);
_TheUIDrawingSurface->openWindow(StartScreenInternalWindow);
// Create the UI Foreground Object
UIForegroundRefPtr StartScreenUIForeground = OSG::UIForeground::create();
StartScreenUIForeground->setDrawingSurface(_TheUIDrawingSurface);
return StartScreenUIForeground;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// Set up Window
TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
TutorialWindow->setDisplayCallback(display);
TutorialWindow->setReshapeCallback(reshape);
TutorialKeyListener TheKeyListener;
TutorialWindow->addKeyListener(&TheKeyListener);
// Make Torus Node (creates Torus in background of scene)
NodeRefPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRefPtr scene = OSG::Node::create();
scene->setCore(OSG::Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRefPtr TutorialGraphics = OSG::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.
******************************************************/
BorderLayoutRefPtr MainInternalWindowLayout = OSG::BorderLayout::create();
BorderLayoutConstraintsRefPtr ExampleButton1Constraints = OSG::BorderLayoutConstraints::create();
BorderLayoutConstraintsRefPtr ExampleButton2Constraints = OSG::BorderLayoutConstraints::create();
BorderLayoutConstraintsRefPtr ExampleButton7Constraints = OSG::BorderLayoutConstraints::create();
BorderLayoutConstraintsRefPtr ExampleButton8Constraints = OSG::BorderLayoutConstraints::create();
BorderLayoutConstraintsRefPtr ExampleCardPanelConstraints = OSG::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
ActionListeners, 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.
******************************************************/
ExampleCardLayout = OSG::CardLayout::create();
ExampleCardPanel = OSG::Panel::create();
/******************************************************
Create Button Components to be used with
CardLayout to allow for interactivity.
******************************************************/
ButtonRefPtr ExampleButton1 = OSG::Button::create();
ButtonRefPtr ExampleButton2 = OSG::Button::create();
ButtonRefPtr ExampleButton3 = OSG::Button::create();
ButtonRefPtr ExampleButton4 = OSG::Button::create();
ButtonRefPtr ExampleButton5 = OSG::Button::create();
ButtonRefPtr ExampleButton6 = OSG::Button::create();
ButtonRefPtr ExampleButton7 = OSG::Button::create();
ButtonRefPtr ExampleButton8 = OSG::Button::create();
ExampleButton1->setText("Next Card");
ExampleButton1->setConstraints(ExampleButton1Constraints);
// Add ActionListener
NextCardActionListener TheNextCardActionListener;
ExampleButton1->addActionListener( &TheNextCardActionListener);
ExampleButton2->setText("Previous Card");
ExampleButton2->setConstraints(ExampleButton2Constraints);
// Add ActionListener
BackCardActionListener TheBackCardActionListener;
ExampleButton2->addActionListener( &TheBackCardActionListener);
ExampleButton3->setText("This");
ExampleButton4->setText("is");
ExampleButton5->setText("Card");
ExampleButton6->setText("Layout");
ExampleButton7->setText("First Card");
ExampleButton7->setConstraints(ExampleButton7Constraints);
// Add ActionListener
FirstCardActionListener TheFirstCardActionListener;
ExampleButton7->addActionListener( &TheFirstCardActionListener);
ExampleButton8->setText("Last Card");
ExampleButton8->setConstraints(ExampleButton8Constraints);
// Add ActionListener
LastCardActionListener TheLastCardActionListener;
ExampleButton8->addActionListener( &TheLastCardActionListener);
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
ColorLayerRefPtr MainInternalWindowBackground = OSG::ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
InternalWindowRefPtr MainInternalWindow = OSG::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
UIDrawingSurfaceRefPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRefPtr TutorialUIForeground = OSG::UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindow);
mgr->setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRefPtr TutorialViewport = mgr->getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
// Show the whole Scene
mgr->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
TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
TutorialWindow->setDisplayCallback(display);
TutorialWindow->setReshapeCallback(reshape);
TutorialKeyListener TheKeyListener;
TutorialWindow->addKeyListener(&TheKeyListener);
// Make Torus Node (creates Torus in background of scene)
NodeRefPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRefPtr scene = OSG::Node::create();
scene->setCore(OSG::Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRefPtr TutorialGraphics = OSG::Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
/******************************************************
Create some Backgrounds
******************************************************/
ColorLayerRefPtr MainFrameBackground = OSG::ColorLayer::create();
ColorLayerRefPtr ExamplePanelBackground = OSG::ColorLayer::create();
ColorLayerRefPtr ExampleSmallPanelBackground = OSG::ColorLayer::create();
ColorLayerRefPtr ExampleLabel1ColorBackground = OSG::ColorLayer::create();
GradientLayerRefPtr ExampleLabel1GradientBackground = OSG::GradientLayer::create();
CompoundLayerRefPtr ExampleLabel1CompoundBackground = OSG::CompoundLayer::create();
MainFrameBackground->setColor(Color4f(0,0,1.0,0.5));
ExamplePanelBackground->setColor(Color4f(0.0,0.0,0.0,0.5));
ExampleSmallPanelBackground->setColor(Color4f(0.0,0.5,0.7,1.0));
ExampleLabel1ColorBackground->setColor(Color4f(0.0, 0.0, 0.0, 1.0));
ExampleLabel1GradientBackground->editMFColors()->push_back(Color4f(1.0, 0.0, 1.0, 0.8));
ExampleLabel1GradientBackground->editMFStops()->push_back(0.0);
ExampleLabel1GradientBackground->editMFColors()->push_back(Color4f(0.0, 0.0, 1.0, 0.3));
ExampleLabel1GradientBackground->editMFStops()->push_back(1.0);
ExampleLabel1GradientBackground->setStartPosition(Vec2f(0.0f,0.0f));
ExampleLabel1GradientBackground->setEndPosition(Vec2f(1.0f,0.0f));
ExampleLabel1CompoundBackground->pushToBackgrounds(ExampleLabel1ColorBackground);
ExampleLabel1CompoundBackground->pushToBackgrounds(ExampleLabel1GradientBackground);
/******************************************************
Create some Borders
******************************************************/
EtchedBorderRefPtr ExamplePanelBorder = OSG::EtchedBorder::create();
EmptyBorderRefPtr ExampleLabel1Border = OSG::EmptyBorder::create();
ExamplePanelBorder->setHighlight(Color4f(1.0, 1.0, 1.0, 1.0));
ExamplePanelBorder->setShadow(Color4f(0.8, 0.8, 0.8, 1.0));
ExamplePanelBorder->setWidth(6);
/******************************************************
Creates some Button components
******************************************************/
LabelRefPtr ExampleLabel1 = OSG::Label::create();
ButtonRefPtr ExampleButton1 = OSG::Button::create();
ButtonRefPtr ExampleButton2 = OSG::Button::create();
ButtonRefPtr ExampleButton3 = OSG::Button::create();
ButtonRefPtr ExampleButton4 = OSG::Button::create();
ButtonRefPtr ExampleButton5 = OSG::Button::create();
ButtonRefPtr ExampleButton6 = OSG::Button::create();
ButtonRefPtr ExampleButton7 = OSG::Button::create();
ButtonRefPtr ExampleButton8 = OSG::Button::create();
ButtonRefPtr ExampleButton9 = OSG::Button::create();
ButtonRefPtr ExampleButton10 = OSG::Button::create();
ButtonRefPtr ExampleButton11 = OSG::Button::create();
ExampleLabel1->setPreferredSize(Vec2f(800, 50));
ExampleLabel1->setBackground(ExampleLabel1CompoundBackground);
ExampleLabel1->setBorder(ExampleLabel1Border);
ExampleButton1->setPreferredSize(Vec2f(800, 50));
ExampleButton1->setMaxSize(Vec2f(50, 50));
ExampleButton1->setText("Resize the Window to Show Diificulties with Using Just One Layout");
ExampleButton2->setPreferredSize(Vec2f(50, 50));
ExampleButton2->setMaxSize(Vec2f(50, 50));
ExampleButton3->setPreferredSize(Vec2f(50, 50));
ExampleButton3->setMaxSize(Vec2f(50, 50));
ExampleButton4->setPreferredSize(Vec2f(100, 50));
ExampleButton4->setMaxSize(Vec2f(100, 50));
ExampleButton5->setPreferredSize(Vec2f(100, 50));
ExampleButton5->setMaxSize(Vec2f(100, 50));
ExampleButton6->setPreferredSize(Vec2f(100, 50));
ExampleButton6->setMaxSize(Vec2f(100, 50));
ExampleButton7->setPreferredSize(Vec2f(100, 50));
ExampleButton7->setMaxSize(Vec2f(100, 50));
ExampleButton8->setPreferredSize(Vec2f(100, 50));
ExampleButton8->setMaxSize(Vec2f(100, 50));
ExampleButton9->setPreferredSize(Vec2f(100, 50));
ExampleButton9->setMaxSize(Vec2f(100, 50));
ExampleButton10->setPreferredSize(Vec2f(100, 50));
ExampleButton10->setMaxSize(Vec2f(100, 50));
ExampleButton11->setPreferredSize(Vec2f(100, 50));
ExampleButton11->setMaxSize(Vec2f(100, 50));
/******************************************************
Create some Layouts
******************************************************/
FlowLayoutRefPtr MainInternalWindowLayout = OSG::FlowLayout::create();
BoxLayoutRefPtr ExamplePanel1Layout = OSG::BoxLayout::create();
BoxLayoutRefPtr ExamplePanel2Layout = OSG::BoxLayout::create();
BoxLayoutRefPtr ExamplePanel3Layout = OSG::BoxLayout::create();
BoxLayoutRefPtr ExamplePanel4Layout = OSG::BoxLayout::create();
BoxLayoutRefPtr ExamplePanel5Layout = OSG::BoxLayout::create();
BoxLayoutRefPtr ExamplePanel6Layout = OSG::BoxLayout::create();
ExamplePanel1Layout->setOrientation(BoxLayout::VERTICAL_ORIENTATION);
ExamplePanel2Layout->setOrientation(BoxLayout::VERTICAL_ORIENTATION);
ExamplePanel3Layout->setOrientation(BoxLayout::VERTICAL_ORIENTATION);
ExamplePanel4Layout->setOrientation(BoxLayout::VERTICAL_ORIENTATION);
ExamplePanel5Layout->setOrientation(BoxLayout::VERTICAL_ORIENTATION);
ExamplePanel6Layout->setOrientation(BoxLayout::VERTICAL_ORIENTATION);
MainInternalWindowLayout->setOrientation(BoxLayout::HORIZONTAL_ORIENTATION);
MainInternalWindowLayout->setMinorAxisAlignment(0.5f);
/******************************************************
Create MainFrame and some Panels
******************************************************/
PanelRefPtr ExamplePanel1 = OSG::Panel::create();
PanelRefPtr ExamplePanel2 = OSG::Panel::create();
PanelRefPtr ExamplePanel3 = OSG::Panel::create();
PanelRefPtr ExamplePanel4 = OSG::Panel::create();
PanelRefPtr ExamplePanel5 = OSG::Panel::create();
PanelRefPtr ExamplePanel6 = OSG::Panel::create();
// Edit Panel1, Panel2
ExamplePanel1->setPreferredSize(Vec2f(400, 400));
ExamplePanel1->pushToChildren(ExampleButton2);
ExamplePanel1->pushToChildren(ExamplePanel3);
ExamplePanel1->pushToChildren(ExamplePanel4);
ExamplePanel1->setLayout(ExamplePanel1Layout);
ExamplePanel1->setBackgrounds(ExamplePanelBackground);
ExamplePanel1->setBorders(ExamplePanelBorder);
ExamplePanel2->setPreferredSize(Vec2f(400, 400));
ExamplePanel2->pushToChildren(ExampleButton3);
ExamplePanel2->pushToChildren(ExamplePanel5);
ExamplePanel2->pushToChildren(ExamplePanel6);
ExamplePanel2->setLayout(ExamplePanel2Layout);
ExamplePanel2->setBackgrounds(ExamplePanelBackground);
ExamplePanel2->setBorders(ExamplePanelBorder);
ExamplePanel3->pushToChildren(ExampleButton4);
ExamplePanel3->pushToChildren(ExampleButton5);
ExamplePanel3->setLayout(ExamplePanel3Layout);
ExamplePanel3->setPreferredSize(Vec2f(125, 130));
ExamplePanel3->setBackgrounds(ExampleSmallPanelBackground);
ExamplePanel4->pushToChildren(ExampleButton6);
ExamplePanel4->pushToChildren(ExampleButton7);
ExamplePanel4->setLayout(ExamplePanel4Layout);
ExamplePanel4->setPreferredSize(Vec2f(125, 130));
ExamplePanel4->setBackgrounds(ExampleSmallPanelBackground);
ExamplePanel5->pushToChildren(ExampleButton8);
ExamplePanel5->pushToChildren(ExampleButton9);
ExamplePanel5->setLayout(ExamplePanel5Layout);
ExamplePanel5->setPreferredSize(Vec2f(125, 130));
ExamplePanel5->setBackgrounds(ExampleSmallPanelBackground);
ExamplePanel6->pushToChildren(ExampleButton10);
ExamplePanel6->pushToChildren(ExampleButton11);
ExamplePanel6->setLayout(ExamplePanel6Layout);
ExamplePanel6->setPreferredSize(Vec2f(125, 130));
ExamplePanel6->setBackgrounds(ExampleSmallPanelBackground);
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRefPtr MainInternalWindowBackground = OSG::ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
InternalWindowRefPtr MainInternalWindow = OSG::InternalWindow::create();
MainInternalWindow->setBorder(ExamplePanelBorder);
MainInternalWindow->pushToChildren(ExampleLabel1);
MainInternalWindow->pushToChildren(ExampleButton1);
MainInternalWindow->pushToChildren(ExamplePanel1);
MainInternalWindow->pushToChildren(ExamplePanel2);
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
UIDrawingSurfaceRefPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRefPtr TutorialUIForeground = OSG::UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindow);
mgr->setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRefPtr TutorialViewport = mgr->getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
// Show the whole Scene
mgr->showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"12ComplexLayout");
//Enter main Loop
TutorialWindow->mainLoop();
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// Set up Window
TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
TutorialWindow->setDisplayCallback(display);
TutorialWindow->setReshapeCallback(reshape);
TutorialKeyListener TheKeyListener;
TutorialWindow->addKeyListener(&TheKeyListener);
// Make Torus Node (creates Torus in background of scene)
NodeRefPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRefPtr scene = OSG::Node::create();
scene->setCore(OSG::Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRefPtr TutorialGraphics = OSG::Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
/******************************************************
Create and edit some Button Components
******************************************************/
ButtonRefPtr ExampleButton1 = OSG::Button::create();
ButtonRefPtr ExampleButton2 = OSG::Button::create();
ButtonRefPtr ExampleButton3 = OSG::Button::create();
ButtonRefPtr ExampleButton4 = OSG::Button::create();
ButtonRefPtr ExampleButton5 = OSG::Button::create();
ButtonRefPtr ExampleButton6 = OSG::Button::create();
ExampleButton1->setPreferredSize(Vec2f(200, 50));
ExampleButton4->setPreferredSize(Vec2f(50, 50));
/******************************************************
Create two Panels to be used with
SplitPanel.
******************************************************/
PanelRefPtr ExampleSplitPanelPanel1 = OSG::Panel::create();
PanelRefPtr ExampleSplitPanelPanel2 = OSG::Panel::create();
FlowLayoutRefPtr PanelFlowLayout = OSG::FlowLayout::create();
PanelFlowLayout->setHorizontalGap(3);
PanelFlowLayout->setVerticalGap(3);
ExampleSplitPanelPanel1->pushToChildren(ExampleButton1);
ExampleSplitPanelPanel1->pushToChildren(ExampleButton2);
ExampleSplitPanelPanel1->pushToChildren(ExampleButton3);
ExampleSplitPanelPanel1->setLayout(PanelFlowLayout);
ExampleSplitPanelPanel2->pushToChildren(ExampleButton4);
ExampleSplitPanelPanel2->pushToChildren(ExampleButton5);
ExampleSplitPanelPanel2->pushToChildren(ExampleButton6);
ExampleSplitPanelPanel2->setLayout(PanelFlowLayout);
// Creates a BorderLayout and Constraints (causing the SplitPanel
// to automatically fill entire center Frame)
BorderLayoutRefPtr MainInternalWindowLayout = OSG::BorderLayout::create();
BorderLayoutConstraintsRefPtr ExampleSplitPanelConstraints = OSG::BorderLayoutConstraints::create();
ExampleSplitPanelConstraints->setRegion(BorderLayoutConstraints::BORDER_CENTER);
/******************************************************
Creates and sets up SplitPanel
-setMinComponent/setMaxComponent(Component): Add
up to two Components to the SplitPanel. Note
that if you do not add both an empty Panel
will be added automatically.
-setOrientation(ENUM): Determines the alignment
of the split aspect. The default is
Horizontal with an east/west split. The
minComponent set previously is the west or
north Component of the Panel (depending
on the alignment) and the max is the east
or west Component. Takes VERTICAL_ORIENTATION
and HORIZONTAL_ORIENTATION arguments.
-setDividerPosition("smart" REAL): Determines the initial
location of the divider. Note that this REAL is
a percentage if between 0.0 and 1.0 (inclusive)
and absolute is greater than 1.0. Also note that
when resizing a window with a percentage, the
divider will move, but with absolute, it does
not until it no longer fits in the panel.
-setDividerSize(SIZE): Determine divider Size
in pixels.
-setExpandable(bool): Determine whether
divider can be moved by user. Default is
TRUE (is movable) while FALSE removes
the users ability to move the divider.
-setMaxDividerPosition("smart" REAL): Determine
the Maximum position for the divider.
-setMinDividerPosition("smart" REAL): Determine
the Minimum position for the divider. Note
that for both Max/Min, the "smart" REAL
follows same format as in setDividerPosition;
it is a percentage if between 0.0 and 1.0
and absolute when > 1.0
******************************************************/
SplitPanelRefPtr ExampleSplitPanel = OSG::SplitPanel::create();
ExampleSplitPanel->setConstraints(ExampleSplitPanelConstraints);
ExampleSplitPanel->setMinComponent(ExampleSplitPanelPanel1);
ExampleSplitPanel->setMaxComponent(ExampleSplitPanelPanel2);
// ExampleSplitPanel->setOrientation(SplitPanel::VERTICAL_ORIENTATION);
// ExampleSplitPanel->setDividerPosition(.25); // this is a percentage
ExampleSplitPanel->setDividerPosition(300); // this is an absolute (300 > 1.0)
// location from the left/top
ExampleSplitPanel->setDividerSize(5);
// ExampleSplitPanel->setExpandable(false);
ExampleSplitPanel->setMaxDividerPosition(.9);
ExampleSplitPanel->setMinDividerPosition(220);
// also, if you want to change the way the divider looks, you can always set a
// DrawObjectCanvas in place of the default divider
// ExampleSplitPanel->setDividerDrawObject(drawObjectName);
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRefPtr MainInternalWindowBackground = OSG::ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
InternalWindowRefPtr MainInternalWindow = OSG::InternalWindow::create();
MainInternalWindow->pushToChildren(ExampleSplitPanel);
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
UIDrawingSurfaceRefPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRefPtr TutorialUIForeground = OSG::UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindow);
mgr->setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRefPtr TutorialViewport = mgr->getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
// Show the whole Scene
mgr->showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"23SplitPanel");
//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));
TutorialWindow->connectKeyTyped(boost::bind(keyTyped, _1));
// Tell the Manager what to manage
sceneManager.setWindow(TutorialWindow);
// Make Torus Node (creates Torus in background of scene)
NodeRefPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRefPtr scene = OSG::Node::create();
scene->setCore(OSG::Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRefPtr TutorialGraphics = OSG::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.
******************************************************/
ButtonRefPtr ExampleButton = OSG::Button::create();
UIFontRefPtr ExampleFont = OSG::UIFont::create();
ExampleFont->setSize(16);
/******************************************************
Edit the Button's characteristics.
Note: the first 4 functions can
be used with any Component and
are not specific to Button.
-setMinSize(Vec2f): Determine the
Minimum Size of the Component.
Some Layouts will automatically
resize Components; this prevents
the Size from going below a
certain value.
-setMaxSize(Vec2f): Determine the
Maximum Size of the Component.
-setPreferredSize(Vec2f): Determine
the Preferred Size of the Component.
This is what the Component will
be displayed at unless changed by
another Component (such as a
Layout).
-setToolTipText("Text"): Determine
what text is displayed while
Mouse is hovering above Component.
The word Text will be displayed
in this case.
Functions specfic to Button:
-setText("DesiredText"): Determine
the Button's text. It will read
DesiredText in this case.
-setFont(FontName): Determine the
Font to be used on the Button.
-setTextColor(Color4f): Determine the
Color for the text.
-setRolloverTextColor(Color4f): Determine
what the text Color will be when
the Mouse Cursor is above the
Button.
-setActiveTextColor(Color4f): Determine
what the text Color will be when
the Button is pressed (denoted by
Active).
-setAlignment(Vec2f):
Determine the Vertical Alignment
of the text. The value is
in [0.0, 1.0].
******************************************************/
ExampleButton->setMinSize(Vec2f(50, 25));
ExampleButton->setMaxSize(Vec2f(200, 100));
ExampleButton->setPreferredSize(Vec2f(100, 50));
ExampleButton->setToolTipText("Button 1 ToolTip");
ExampleButton->setText("Button 1");
ExampleButton->setFont(ExampleFont);
ExampleButton->setTextColor(Color4f(1.0, 0.0, 0.0, 1.0));
ExampleButton->setRolloverTextColor(Color4f(1.0, 0.0, 1.0, 1.0));
ExampleButton->setActiveTextColor(Color4f(1.0, 0.0, 0.0, 1.0));
ExampleButton->setAlignment(Vec2f(1.0,0.0));
// Create an Action and assign it to ExampleButton
// This Class is defined above, and will cause the output
// window to display "Button 1 Action" when pressed
ExampleButton->connectActionPerformed(boost::bind(actionPerformed, _1));
/******************************************************
Create a ToggleButton and determine its
characteristics. ToggleButton inherits
off of Button, so all characteristsics
used above can be used with ToggleButtons
as well.
The only difference is that when pressed,
ToggleButton remains pressed until pressed
again.
-setSelected(bool): Determine whether the
ToggleButton is Selected (true) or
deselected (false).
******************************************************/
ToggleButtonRefPtr ExampleToggleButton = OSG::ToggleButton::create();
ExampleToggleButton->setSelected(false);
ExampleToggleButton->setText("ToggleMe");
ExampleToggleButton->setToolTipText("Toggle Button ToolTip");
//Button with Image
ButtonRefPtr ExampleDrawObjectButton = OSG::Button::create();
ExampleDrawObjectButton->setDrawObjectToTextAlignment(Button::ALIGN_DRAW_OBJECT_RIGHT_OF_TEXT);
ExampleDrawObjectButton->setText("Icon");
ExampleDrawObjectButton->setImage(std::string("./Data/Icon.png"));
ExampleDrawObjectButton->setActiveImage(std::string("./Data/Icon.png"));
ExampleDrawObjectButton->setFocusedImage(std::string("./Data/Icon.png"));
ExampleDrawObjectButton->setRolloverImage(std::string("./Data/Icon.png"));
ExampleDrawObjectButton->setDisabledImage(std::string("./Data/Icon.png"));
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRefPtr MainInternalWindowBackground = OSG::ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
InternalWindowRefPtr MainInternalWindow = OSG::InternalWindow::create();
LayoutRefPtr MainInternalWindowLayout = OSG::FlowLayout::create();
MainInternalWindow->pushToChildren(ExampleButton);
MainInternalWindow->pushToChildren(ExampleToggleButton);
MainInternalWindow->pushToChildren(ExampleDrawObjectButton);
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
UIDrawingSurfaceRefPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRefPtr TutorialUIForeground = OSG::UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
sceneManager.setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRefPtr 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();
//Attach key controls
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"01Button");
commitChanges();
//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(keyTyped, _1));
// Make Torus Node (creates Torus in background of scene)
NodeRefPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRefPtr scene = OSG::Node::create();
scene->setCore(OSG::Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRefPtr TutorialGraphics = OSG::Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
ButtonRefPtr ExampleButton = OSG::Button::create();
ExampleButton->setMinSize(Vec2f(50, 25));
ExampleButton->setMaxSize(Vec2f(200, 100));
ExampleButton->setPreferredSize(Vec2f(100, 50));
ExampleButton->setText("Button 1");
// Create an ActionListener and assign it to ExampleButton
// This Class is defined above, and will cause the output
// window to display "Button 1 Action" when pressed
ExampleButton->connectActionPerformed(boost::bind(actionPerformed, _1));
//Toggle Button
ToggleButtonRefPtr ExampleToggleButton = OSG::ToggleButton::create();
ExampleToggleButton->setSelected(false);
ExampleToggleButton->setText("ToggleMe");
//Text Field
TextFieldRefPtr ExampleTextField = OSG::TextField::create();
//Password Field
PasswordFieldRefPtr ExamplePasswordField = OSG::PasswordField::create();
LayoutRefPtr MainLayout = OSG::FlowLayout::create();
//Panel
PanelRecPtr ExamplePanel = Panel::create();
ExamplePanel->setPreferredSize(Vec2f(200.0f,200.0f));
ExamplePanel->setLayout(MainLayout);
ExamplePanel->pushToChildren(ExampleTextField);
ExamplePanel->pushToChildren(ExamplePasswordField);
//Text Field 2
TextFieldRefPtr ExampleTextField2 = OSG::TextField::create();
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRefPtr MainInternalWindowBackground = OSG::ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
InternalWindowRefPtr MainInternalWindow = OSG::InternalWindow::create();
MainInternalWindow->pushToChildren(ExampleButton);
MainInternalWindow->pushToChildren(ExampleToggleButton);
MainInternalWindow->pushToChildren(ExamplePanel);
MainInternalWindow->pushToChildren(ExampleTextField2);
MainInternalWindow->setLayout(MainLayout);
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
UIDrawingSurfaceRefPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRefPtr TutorialUIForeground = OSG::UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
sceneManager.setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRefPtr 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.5f);
TutorialWindow->openWindow(WinPos,
WinSize,
"54FocusProgession");
commitChanges();
//Enter main Loop
TutorialWindow->mainLoop();
}
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// Set up Window
TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
TutorialWindow->setDisplayCallback(display);
TutorialWindow->setReshapeCallback(reshape);
TutorialKeyListener TheKeyListener;
TutorialWindow->addKeyListener(&TheKeyListener);
// Make Torus Node (creates Torus in background of scene)
NodeRefPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRefPtr scene = OSG::Node::create();
scene->setCore(OSG::Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRefPtr TutorialGraphics = OSG::Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
//Background
TutorialBackground = GradientBackground::create();
TutorialBackground->addLine(Color3f(1.0,0.0,0.0), 0.0);
TutorialBackground->addLine(Color3f(0.0,1.0,0.0), 0.2);
TutorialBackground->addLine(Color3f(0.0,0.0,1.0), 0.4);
TutorialBackground->addLine(Color3f(0.0,1.0,1.0), 0.6);
TutorialBackground->addLine(Color3f(1.0,1.0,0.0), 0.8);
TutorialBackground->addLine(Color3f(1.0,1.0,1.0), 1.0);
TheUndoManager = UndoManager::create();
UndoManagerChangeListener TheUndoManagerChangeListener;
TheUndoManager->addChangeListener(&TheUndoManagerChangeListener);
LabelRefPtr SingleFieldLabel = OSG::Label::create();
SingleFieldLabel->setText("Single Field");
SingleFieldLabel->setBorders(NULL);
SingleFieldLabel->setBackgrounds(NULL);
LabelRefPtr MultiFieldLabel = OSG::Label::create();
MultiFieldLabel->setText("Multi Field");
MultiFieldLabel->setBorders(NULL);
MultiFieldLabel->setBackgrounds(NULL);
LabelRefPtr SinglePtrFieldLabel = OSG::Label::create();
SinglePtrFieldLabel->setText("Single Ptr Field");
SinglePtrFieldLabel->setBorders(NULL);
SinglePtrFieldLabel->setBackgrounds(NULL);
LabelRefPtr MultiPtrFieldLabel = OSG::Label::create();
MultiPtrFieldLabel->setText("Multi Ptr Field");
MultiPtrFieldLabel->setBorders(NULL);
MultiPtrFieldLabel->setBackgrounds(NULL);
TabPanelRefPtr ExampleTabPanel = OSG::TabPanel::create();
ExampleTabPanel->setPreferredSize(Vec2f(600,600));
ExampleTabPanel->addTab(SingleFieldLabel, createSingleFieldPanel());
ExampleTabPanel->addTab(MultiFieldLabel, createMultiFieldPanel());
ExampleTabPanel->addTab(SinglePtrFieldLabel, createSinglePtrFieldPanel());
ExampleTabPanel->addTab(MultiPtrFieldLabel, createMultiPtrFieldPanel());
ExampleTabPanel->setTabAlignment(0.5f);
ExampleTabPanel->setTabPlacement(TabPanel::PLACEMENT_NORTH);
ExampleTabPanel->setSelectedIndex(0);
//UndoList
UndoRedoListModel = DefaultListModel::create();
UndoRedoListModel->pushBack(boost::any(std::string("Top")));
ListSelectionModelPtr UndoRedoListSelectionModel(new DefaultListSelectionModel());
UndoRedoList = List::create();
UndoRedoList->setPreferredSize(Vec2f(200, 300));
UndoRedoList->setOrientation(List::VERTICAL_ORIENTATION);
UndoRedoList->setModel(UndoRedoListModel);
UndoRedoList->setSelectionModel(UndoRedoListSelectionModel);
UndoRedoListListener TheUndoRedoListListener;
UndoRedoList->getSelectionModel()->addListSelectionListener(&TheUndoRedoListListener);
UndoButton = OSG::Button::create();
UndoButton->setText("Undo");
UndoButton->setEnabled(TheUndoManager->numberOfUndos() != 0);
UndoButtonActionListener TheUndoButtonActionListener;
UndoButton->addActionListener(&TheUndoButtonActionListener);
RedoButton = OSG::Button::create();
RedoButton->setText("Redo");
RedoButton->setEnabled(TheUndoManager->numberOfRedos() != 0);
RedoButtonActionListener TheRedoButtonActionListener;
RedoButton->addActionListener(&TheRedoButtonActionListener);
// Create a ScrollPanel for easier viewing of the List (see 27ScrollPanel)
ScrollPanelRefPtr 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
ColorLayerRefPtr MainInternalWindowBackground = OSG::ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
InternalWindowRefPtr MainInternalWindow = OSG::InternalWindow::create();
LayoutRefPtr MainInternalWindowLayout = OSG::FlowLayout::create();
MainInternalWindow->pushToChildren(ExampleTabPanel);
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);
// Create the Drawing Surface
UIDrawingSurfaceRefPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRefPtr TutorialUIForeground = OSG::UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindow);
mgr->setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRefPtr TutorialViewport = mgr->getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
TutorialViewport->setBackground(TutorialBackground);
// Show the whole Scene
mgr->showAll();
//Open Window
Vec2f WinSize(TutorialWindow->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindow->getDesktopSize() - WinSize) *0.5);
TutorialWindow->openWindow(WinPos,
WinSize,
"01ChangeFieldCommands");
//Enter main Loop
TutorialWindow->mainLoop();
osgExit();
return 0;
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// Set up Window
TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
TutorialWindow->setDisplayCallback(display);
TutorialWindow->setReshapeCallback(reshape);
TutorialKeyListener TheKeyListener;
TutorialWindow->addKeyListener(&TheKeyListener);
NodeRefPtr Root(NULL);
if(argc == 2)
{
Root = SceneFileHandler::the()->read(argv[1]);
}
if(Root == NULL)
{
// Make Torus Node (creates Torus in background of Root)
NodeRefPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
setName(TorusGeometryNode, std::string("Torus"));
NodeRefPtr TorusNode = Node::create();
TorusNode->setCore(OSG::Transform::create());
TorusNode->addChild(TorusGeometryNode);
setName(TorusNode, std::string("Torus Transform"));
NodeRefPtr SphereGeometryNode = makeSphere(2,1.0f);
setName(SphereGeometryNode, std::string("Sphere"));
NodeRefPtr 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 = OSG::Node::create();
Root->setCore(OSG::Group::create());
Root->addChild(TorusNode);
Root->addChild(SphereGeometryNode);
Root->addChild(BoxGeometryNode);
setName(Root, std::string("Root"));
}
// Create the Graphics
GraphicsRefPtr TutorialGraphics = OSG::Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
//Tree Model
TheTreeModel = SceneGraphTreeModel::create();
TheTreeModel->setRoot(Root);
//TheFileSystemTreeModel = FileSystemTreeModel::create();
//TheFileSystemTreeModel->setRoot(BoostPath("C:\\"));
//TheFileSystemTreeModel->setRoot(BoostPath("/"));
//Create the Tree
TheTree = Tree::create();
TheTree->setPreferredSize(Vec2f(100, 500));
TheTree->setModel(TheTreeModel);
//TheTree->setModel(TheFileSystemTreeModel);
TutorialTreeSelectionListener TheTutorialTreeSelectionListener;
TheTree->getSelectionModel()->addTreeSelectionListener(&TheTutorialTreeSelectionListener);
// Create a ScrollPanel for easier viewing of the List (see 27ScrollPanel)
BorderLayoutConstraintsRefPtr SceneTreeConstraints = OSG::BorderLayoutConstraints::create();
SceneTreeConstraints->setRegion(BorderLayoutConstraints::BORDER_WEST);
ScrollPanelRefPtr 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
LabelRefPtr NodeNameLabel = Label::create();
NodeNameLabel->setText("Name");
NodeNameLabel->setPreferredSize(Vec2f(100.0f, 20.0f));
NodeNameValueLabel = Label::create();
NodeNameValueLabel->setPreferredSize(Vec2f(300.0f, 20.0f));
LabelRefPtr NodeCoreTypeLabel = Label::create();
NodeCoreTypeLabel->setText("Core Type");
NodeCoreTypeLabel->setPreferredSize(Vec2f(100.0f, 20.0f));
NodeCoreTypeValueLabel = Label::create();
NodeCoreTypeValueLabel->setPreferredSize(Vec2f(300.0f, 20.0f));
LabelRefPtr NodeMinLabel = Label::create();
NodeMinLabel->setText("Min");
NodeMinLabel->setPreferredSize(Vec2f(100.0f, 20.0f));
NodeMinValueLabel = Label::create();
NodeMinValueLabel->setPreferredSize(Vec2f(300.0f, 20.0f));
LabelRefPtr NodeMaxLabel = Label::create();
NodeMaxLabel->setText("Max");
NodeMaxLabel->setPreferredSize(Vec2f(100.0f, 20.0f));
NodeMaxValueLabel = Label::create();
NodeMaxValueLabel->setPreferredSize(Vec2f(300.0f, 20.0f));
LabelRefPtr NodeCenterLabel = Label::create();
NodeCenterLabel->setText("Center");
NodeCenterLabel->setPreferredSize(Vec2f(100.0f, 20.0f));
NodeCenterValueLabel = Label::create();
NodeCenterValueLabel->setPreferredSize(Vec2f(300.0f, 20.0f));
LabelRefPtr NodeTriCountLabel = Label::create();
NodeTriCountLabel->setText("TriCount");
NodeTriCountLabel->setPreferredSize(Vec2f(100.0f, 20.0f));
NodeTriCountValueLabel = Label::create();
NodeTriCountValueLabel->setPreferredSize(Vec2f(300.0f, 20.0f));
LabelRefPtr NodeTravMaskLabel = Label::create();
NodeTravMaskLabel->setText("Traversal Mask");
NodeTravMaskLabel->setPreferredSize(Vec2f(100.0f, 20.0f));
NodeTravMaskValueLabel = Label::create();
NodeTravMaskValueLabel->setPreferredSize(Vec2f(300.0f, 20.0f));
LabelRefPtr NodeOcclusionMaskLabel = Label::create();
NodeOcclusionMaskLabel->setText("Occlusion Mask");
NodeOcclusionMaskLabel->setPreferredSize(Vec2f(100.0f, 20.0f));
NodeOcclusionMaskValueLabel = Label::create();
NodeOcclusionMaskValueLabel->setPreferredSize(Vec2f(300.0f, 20.0f));
LabelRefPtr NodeActiveLabel = Label::create();
NodeActiveLabel->setText("Active");
NodeActiveLabel->setPreferredSize(Vec2f(100.0f, 20.0f));
NodeActiveValueLabel = Label::create();
NodeActiveValueLabel->setPreferredSize(Vec2f(300.0f, 20.0f));
//Details Panel
BorderLayoutConstraintsRefPtr NodeDetailPanelConstraints = OSG::BorderLayoutConstraints::create();
NodeDetailPanelConstraints->setRegion(BorderLayoutConstraints::BORDER_SOUTH);
GridLayoutRefPtr NodeDetailPanelLayout = OSG::GridLayout::create();
NodeDetailPanelLayout->setRows(9);
NodeDetailPanelLayout->setColumns(2);
NodeDetailPanelLayout->setHorizontalGap(2);
NodeDetailPanelLayout->setVerticalGap(2);
PanelRefPtr 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);
NodeDetailPanel->pushToChildren(NodeOcclusionMaskLabel);
NodeDetailPanel->pushToChildren(NodeOcclusionMaskValueLabel);
NodeDetailPanel->pushToChildren(NodeActiveLabel);
NodeDetailPanel->pushToChildren(NodeActiveValueLabel);
// Create The Main InternalWindow
// Create Background to be used with the Main InternalWindow
ColorLayerRefPtr MainInternalWindowBackground = OSG::ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
LayoutRefPtr MainInternalWindowLayout = OSG::BorderLayout::create();
InternalWindowRefPtr MainInternalWindow = OSG::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
UIDrawingSurfaceRefPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRefPtr TutorialUIForeground = OSG::UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindow);
mgr->setRoot(Root);
// Add the UI Foreground Object to the Scene
ViewportRefPtr TutorialViewport = mgr->getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
// Show the whole Scene
mgr->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
TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
TutorialWindow->setDisplayCallback(display);
TutorialWindow->setReshapeCallback(reshape);
TutorialKeyListener TheKeyListener;
TutorialWindow->addKeyListener(&TheKeyListener);
// Make Torus Node (creates Torus in background of scene)
NodeRefPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRefPtr scene = OSG::Node::create();
scene->setCore(OSG::Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRefPtr TutorialGraphics = OSG::Graphics2D::create();
// Initialize the LookAndFeelManager to enable default settings
LookAndFeelManager::the()->getLookAndFeel()->init();
// Create a simple Font to be used with the ExampleTextArea
UIFontRefPtr ExampleFont = OSG::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
TextAreaRefPtr ExampleTextArea = OSG::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
ScrollPanelRefPtr 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
ColorLayerRefPtr MainInternalWindowBackground = OSG::ColorLayer::create();
MainInternalWindowBackground->setColor(Color4f(1.0,1.0,1.0,0.5));
LayoutRefPtr MainInternalWindowLayout = OSG::FlowLayout::create();
InternalWindowRefPtr MainInternalWindow = OSG::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
UIDrawingSurfaceRefPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRefPtr TutorialUIForeground = OSG::UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindow);
mgr->setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRefPtr TutorialViewport = mgr->getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
// Show the whole Scene
mgr->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
TutorialWindow = createNativeWindow();
TutorialWindow->initWindow();
TutorialWindow->setDisplayCallback(display);
TutorialWindow->setReshapeCallback(reshape);
TutorialKeyListener TheKeyListener;
TutorialWindow->addKeyListener(&TheKeyListener);
// Make Torus Node (creates Torus in background of scene)
NodeRefPtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Main Scene Node and add the Torus
NodeRefPtr scene = OSG::Node::create();
scene->setCore(OSG::Group::create());
scene->addChild(TorusGeometryNode);
// Create the Graphics
GraphicsRefPtr TutorialGraphics = OSG::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(KeyEvent::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(KeyEvent::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(KeyEvent::KEY_****): sets the key
"****" to be underlined within the Menu
itself
******************************************************/
// Creates MenuItems as in 25PopupMenu
MenuItemRefPtr NewMenuItem = MenuItem::create();
MenuItemRefPtr OpenMenuItem = MenuItem::create();
MenuItemRefPtr CloseMenuItem = MenuItem::create();
MenuItemRefPtr ExitMenuItem = MenuItem::create();
MenuItemRefPtr UndoMenuItem = MenuItem::create();
MenuItemRefPtr RedoMenuItem = MenuItem::create();
//Edits MenuItems
NewMenuItem->setText("New ...");
NewMenuItem->setAcceleratorKey(KeyEvent::KEY_N);
NewMenuItem->setAcceleratorModifiers(KeyEvent::KEY_MODIFIER_COMMAND);
NewMenuItem->setMnemonicKey(KeyEvent::KEY_N);
OpenMenuItem->setText("Open ...");
OpenMenuItem->setAcceleratorKey(KeyEvent::KEY_P);
OpenMenuItem->setAcceleratorModifiers(KeyEvent::KEY_MODIFIER_COMMAND);
OpenMenuItem->setMnemonicKey(KeyEvent::KEY_P);
CloseMenuItem->setText("Close ...");
CloseMenuItem->setAcceleratorKey(KeyEvent::KEY_W);
CloseMenuItem->setAcceleratorModifiers(KeyEvent::KEY_MODIFIER_COMMAND);
CloseMenuItem->setMnemonicKey(KeyEvent::KEY_C);
ExitMenuItem->setText("Quit");
ExitMenuItem->setAcceleratorKey(KeyEvent::KEY_Q);
ExitMenuItem->setAcceleratorModifiers(KeyEvent::KEY_MODIFIER_COMMAND);
ExitMenuItem->setMnemonicKey(KeyEvent::KEY_Q);
UndoMenuItem->setText("Undo");
UndoMenuItem->setAcceleratorKey(KeyEvent::KEY_Z);
UndoMenuItem->setAcceleratorModifiers(KeyEvent::KEY_MODIFIER_COMMAND);
UndoMenuItem->setMnemonicKey(KeyEvent::KEY_U);
RedoMenuItem->setText("Redo");
RedoMenuItem->setEnabled(false);
RedoMenuItem->setMnemonicKey(KeyEvent::KEY_R);
// Create an ActionListener and assign it to ExitMenuItem
// This is defined above, and will cause the program to quit
// when that MenuItem is selected or Control + Q hit
QuitActionListener TheQuitActionListener;
ExitMenuItem->addActionListener( &TheQuitActionListener);
/******************************************************
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
MenuRefPtr 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(KeyEvent::KEY_F);
// Creates an Edit menu and adds its MenuItems
MenuRefPtr EditMenu = Menu::create();
EditMenu->addItem(UndoMenuItem);
EditMenu->addItem(RedoMenuItem);
// Labels the Edit Menu
EditMenu->setText("Edit");
EditMenu->setMnemonicKey(KeyEvent::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
MenuBarRefPtr MainMenuBar = MenuBar::create();
// Adds the two Menus to the MainMenuBar
MainMenuBar->addMenu(FileMenu);
MainMenuBar->addMenu(EditMenu);
// Create two Labels
LabelRefPtr ExampleLabel1 = OSG::Label::create();
LabelRefPtr ExampleLabel2 = OSG::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
EmptyLayerRefPtr MainInternalWindowBackground = OSG::EmptyLayer::create();
EmptyBorderRefPtr MainInternalWindowBorder = OSG::EmptyBorder::create();
LayoutRefPtr MainInternalWindowLayout = OSG::FlowLayout::create();
InternalWindowRefPtr MainInternalWindow = OSG::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
UIDrawingSurfaceRefPtr TutorialDrawingSurface = UIDrawingSurface::create();
TutorialDrawingSurface->setGraphics(TutorialGraphics);
TutorialDrawingSurface->setEventProducer(TutorialWindow);
TutorialDrawingSurface->openWindow(MainInternalWindow);
// Create the UI Foreground Object
UIForegroundRefPtr TutorialUIForeground = OSG::UIForeground::create();
TutorialUIForeground->setDrawingSurface(TutorialDrawingSurface);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindow);
mgr->setRoot(scene);
// Add the UI Foreground Object to the Scene
ViewportRefPtr TutorialViewport = mgr->getWindow()->getPort(0);
TutorialViewport->addForeground(TutorialUIForeground);
// Show the whole Scene
mgr->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;
}