void myMouseMotionCB(int x, int y)
{
control.mouseMotionCB(x,y);
}
inline void set (const size_t n, bool value) {control.set (n, value);}
//
// NOTE: run this sample from the repo/tests directory.
//
int main(int argc, char** argv)
{
osg::ArgumentParser arguments(&argc,argv);
osgViewer::Viewer viewer(arguments);
s_viewer = &viewer;
// Start by creating the map:
s_mapNode = MapNode::load(arguments);
if ( !s_mapNode )
{
Map* map = new Map();
// Start with a basemap imagery layer; we'll be using the GDAL driver
// to load a local GeoTIFF file:
GDALOptions basemapOpt;
basemapOpt.url() = "../data/world.tif";
map->addImageLayer( new ImageLayer( ImageLayerOptions("basemap", basemapOpt) ) );
// That's it, the map is ready; now create a MapNode to render the Map:
MapNodeOptions mapNodeOptions;
mapNodeOptions.enableLighting() = false;
s_mapNode = new MapNode( map, mapNodeOptions );
}
s_mapNode->setNodeMask( 0x01 );
// Define a style for the feature data. Since we are going to render the
// vectors as lines, configure the line symbolizer:
StyleSheet* styleSheet = buildStyleSheet( Color::Yellow, 2.0f );
// create a feature list source with the map extents as the default extent.
s_source = new FeatureListSource( s_mapNode->getMap()->getProfile()->getExtent() );
LineString* line = new LineString();
line->push_back( osg::Vec3d(-60, 20, 0) );
line->push_back( osg::Vec3d(-120, 20, 0) );
line->push_back( osg::Vec3d(-120, 60, 0) );
line->push_back( osg::Vec3d(-60, 60, 0) );
Feature* feature = new Feature(line, s_mapNode->getMapSRS(), Style(), s_fid++);
s_source->insertFeature( feature );
s_activeFeature = feature;
s_root = new osg::Group;
s_root->addChild( s_mapNode.get() );
Session* session = new Session(s_mapNode->getMap(), styleSheet, s_source.get());
FeatureModelGraph* graph = new FeatureModelGraph(
session,
FeatureModelSourceOptions(),
new GeomFeatureNodeFactory() );
graph->getOrCreateStateSet()->setMode(GL_LIGHTING, osg::StateAttribute::OFF);
graph->getOrCreateStateSet()->setMode(GL_DEPTH_TEST, osg::StateAttribute::OFF);
s_root->addChild( graph );
//Setup the controls
ControlCanvas* canvas = ControlCanvas::get( &viewer );
s_root->addChild( canvas );
Grid *toolbar = createToolBar( );
canvas->addControl( toolbar );
canvas->setNodeMask( 0x1 << 1 );
int col = 0;
LabelControl* addVerts = new LabelControl("Add Verts");
toolbar->setControl(col++, 0, addVerts );
addVerts->addEventHandler( new AddVertsModeHandler( graph ));
LabelControl* edit = new LabelControl("Edit");
toolbar->setControl(col++, 0, edit );
edit->addEventHandler(new EditModeHandler( graph ));
unsigned int row = 0;
Grid *styleBar = createToolBar( );
styleBar->setPosition(0, 50);
canvas->addControl( styleBar );
//Make a list of styles
styleBar->setControl(0, row++, new LabelControl("Styles") );
unsigned int numStyles = 8;
for (unsigned int i = 0; i < numStyles; ++i)
{
float w = 50;
osg::Vec4 color = randomColor();
float widths[3] = {2, 4, 8};
unsigned int r = row++;
for (unsigned int j = 0; j < 3; j++)
{
Control* l = new Control();
l->setBackColor( color );
l->addEventHandler(new ChangeStyleHandler(graph, buildStyleSheet( color, widths[j] ) ));
l->setSize(w,5 * widths[j]);
styleBar->setControl(j, r, l);
}
}
viewer.setSceneData( s_root.get() );
viewer.setCameraManipulator( new EarthManipulator() );
if ( s_mapNode )
viewer.getCamera()->addCullCallback( new osgEarth::Util::AutoClipPlaneCullCallback(s_mapNode) );
// add some stock OSG handlers:
viewer.addEventHandler(new osgViewer::StatsHandler());
viewer.addEventHandler(new osgViewer::WindowSizeHandler());
viewer.addEventHandler(new osgGA::StateSetManipulator(viewer.getCamera()->getOrCreateStateSet()));
return viewer.run();
}
// 2. 加载骨骼数据
void M2Importer::importBoneObject()
{
// Bone Group Header Node
INode* groupHeadNode = createGroupHeaderNode();
groupHeadNode->SetGroupHead(TRUE);
groupHeadNode->SetGroupMember(FALSE);
if (m_modelHeader->nameLength > 1)
{
TCHAR* modelName = (TCHAR*)(m_m2FileData + m_modelHeader->nameOfs);
TCHAR boneGroupName[256];
sprintf(boneGroupName, "%s_bone", modelName);
groupHeadNode->SetName(boneGroupName);
}
else
groupHeadNode->SetName("BoneGroup");
// Bone
// 一个Bone构造一个Node, 并且加入到组中
ModelBoneDef* boneData = (ModelBoneDef*)(m_m2FileData + m_modelHeader->ofsBones);
m_boneNodeList.reserve(m_modelHeader->nBones);
for (unsigned int i = 0; i < m_modelHeader->nBones; ++i)
{
ModelBoneDef& boneDef = boneData[i];
// create bone node
HelperObject* obj = (HelperObject*)CreateInstance(HELPER_CLASS_ID, Class_ID(BONE_CLASS_ID, 0));
ImpNode* node = m_impInterface->CreateNode();
TCHAR boneName[256];
sprintf(boneName, "bone_%02d", i);
node->SetName(boneName);
node->SetPivot(*(Point3*)&(boneDef.pivot));
node->Reference(obj);
m_impInterface->AddNodeToScene(node);
// 设置变换矩阵
Matrix3 tm;
tm.IdentityMatrix();
tm.SetTrans(*(Point3*)&(boneDef.pivot));
node->SetTransform(0, tm);
// 添加到组
INode* realINode = node->GetINode();
realINode->SetGroupHead(FALSE);
realINode->SetGroupMember(TRUE);
groupHeadNode->AttachChild(realINode);
// 设置Bone父子关系
realINode->ShowBone(2);
m_boneNodeList.push_back(realINode);
if (boneDef.parent != -1)
{
INode* parentNode = m_boneNodeList[boneDef.parent];
parentNode->AttachChild(realINode);
}
realINode->EvalWorldState(0);
}
// 导入每根骨骼的关键桢数据
for (unsigned int i = 0; i < m_modelHeader->nBones; ++i)
{
ModelBoneDef& boneDef = boneData[i];
INode* realINode = m_boneNodeList[i];
Control* tmControl = realINode->GetTMController();
// Position
if (boneDef.translation.nKeys)
{
// 设置动画控制器为线性控制器
Control* posControl = createPositionController();
tmControl->SetPositionController(posControl);
unsigned int* timeData = (unsigned int*)(m_m2FileData + boneDef.translation.ofsTimes);
Point3* keyData = (Point3*)(m_m2FileData + boneDef.translation.ofsKeys);
// 设置动画时间范围
bool animRangeChanged = false;
Interval animRange = m_maxInterface->GetAnimRange();
for (unsigned int j = 0; j < boneDef.translation.nKeys; ++j)
{
if (timeData[j] < animRange.Start())
{
animRange.SetStart(timeData[j]);
animRangeChanged = true;
}
else if (timeData[j] > animRange.End())
{
animRange.SetEnd(timeData[j]);
animRangeChanged = true;
}
}
if (animRangeChanged)
m_maxInterface->SetAnimRange(animRange);
// 设置动画关键桢数据
Control* xControl = posControl->GetXController();
IKeyControl* xKeyControl = GetKeyControlInterface(xControl);
xKeyControl->SetNumKeys(boneDef.translation.nKeys);
Control* yControl = posControl->GetYController();
IKeyControl* yKeyControl = GetKeyControlInterface(yControl);
yKeyControl->SetNumKeys(boneDef.translation.nKeys);
Control* zControl = posControl->GetZController();
IKeyControl* zKeyControl = GetKeyControlInterface(zControl);
zKeyControl->SetNumKeys(boneDef.translation.nKeys);
for (unsigned int j = 0; j < boneDef.translation.nKeys; ++j)
{
// X
AnyKey bufX;
ILinFloatKey* keyX = reinterpret_cast<ILinFloatKey*>((IKey*)bufX);
keyX->time = timeData[j];
keyX->val = keyData[j].x;
xKeyControl->AppendKey(keyX);
// Y
AnyKey bufY;
ILinFloatKey* keyY = reinterpret_cast<ILinFloatKey*>((IKey*)bufY);
keyY->time = timeData[j];
keyY->val = keyData[j].y;
yKeyControl->AppendKey(keyY);
// Z
AnyKey bufZ;
ILinFloatKey* keyZ = reinterpret_cast<ILinFloatKey*>((IKey*)bufZ);
keyZ->time = timeData[j];
keyZ->val = keyData[j].z;
zKeyControl->AppendKey(keyZ);
}
}
/*
// Rotation
if (boneDef.rotation.nKeys)
{
Control* rotControl = createRotationController();
tmControl->SetRotationController(rotControl);
unsigned int* timeData = (unsigned int*)(m_m2FileData + boneDef.rotation.ofsTimes);
Quat* keyData = (Quat*)(m_m2FileData + boneDef.rotation.ofsKeys);
// 设置动画时间范围
bool animRangeChanged = false;
Interval animRange = m_maxInterface->GetAnimRange();
for (unsigned int j = 0; j < boneDef.rotation.nKeys; ++j)
{
if (timeData[j] < animRange.Start())
{
animRange.SetStart(timeData[j]);
animRangeChanged = true;
}
else if (timeData[j] > animRange.End())
{
animRange.SetEnd(timeData[j]);
animRangeChanged = true;
}
}
if (animRangeChanged)
m_maxInterface->SetAnimRange(animRange);
// 设置动画关键桢数据
IKeyControl* keyControl = GetKeyControlInterface(rotControl);
keyControl->SetNumKeys(boneDef.rotation.nKeys);
for (unsigned int j = 0; j < boneDef.rotation.nKeys; ++j)
{
AnyKey buf;
ILinRotKey* key = reinterpret_cast<ILinRotKey*>((IKey*)buf);
key->time = timeData[j];
key->val = keyData[j];
keyControl->AppendKey(key);
}
}
*/
// Scaling
if (boneDef.scaling.nKeys)
{
Control* scaControl = createScaleController();
tmControl->SetScaleController(scaControl);
unsigned int* timeData = (unsigned int*)(m_m2FileData + boneDef.scaling.ofsTimes);
Point3* keyData = (Point3*)(m_m2FileData + boneDef.scaling.ofsKeys);
// 设置动画时间范围
bool animRangeChanged = false;
Interval animRange = m_maxInterface->GetAnimRange();
for (unsigned int j = 0; j < boneDef.scaling.nKeys; ++j)
{
if (timeData[j] < animRange.Start())
{
animRange.SetStart(timeData[j]);
animRangeChanged = true;
}
else if (timeData[j] > animRange.End())
{
animRange.SetEnd(timeData[j]);
animRangeChanged = true;
}
}
if (animRangeChanged)
m_maxInterface->SetAnimRange(animRange);
// 设置动画关键桢数据
IKeyControl* keyControl = GetKeyControlInterface(scaControl);
keyControl->SetNumKeys(boneDef.scaling.nKeys);
for (unsigned int j = 0; j < boneDef.scaling.nKeys; ++j)
{
AnyKey buf;
ILinScaleKey* key = reinterpret_cast<ILinScaleKey*>((IKey*)buf);
key->time = timeData[j];
key->val = ScaleValue(keyData[j]);
keyControl->AppendKey(key);
}
}
}
}
void ProjectManager::_load_recent_projects() {
ProjectListFilter::FilterOption filter_option = project_filter->get_filter_option();
String search_term = project_filter->get_search_term();
while(scroll_childs->get_child_count()>0) {
memdelete( scroll_childs->get_child(0));
}
Map<String, String> selected_list_copy = selected_list;
List<PropertyInfo> properties;
EditorSettings::get_singleton()->get_property_list(&properties);
Color font_color = gui_base->get_color("font_color","Tree");
List<ProjectItem> projects;
List<ProjectItem> favorite_projects;
for(List<PropertyInfo>::Element *E=properties.front();E;E=E->next()) {
String _name = E->get().name;
if (!_name.begins_with("projects/") && !_name.begins_with("favorite_projects/"))
continue;
String path = EditorSettings::get_singleton()->get(_name);
if (filter_option == ProjectListFilter::FILTER_PATH && search_term!="" && path.findn(search_term)==-1)
continue;
String project = _name.get_slice("/",1);
String conf=path.plus_file("godot.cfg");
bool favorite = (_name.begins_with("favorite_projects/"))?true:false;
uint64_t last_modified = 0;
if (FileAccess::exists(conf)) {
last_modified = FileAccess::get_modified_time(conf);
String fscache = path.plus_file(".fscache");
if (FileAccess::exists(fscache)) {
uint64_t cache_modified = FileAccess::get_modified_time(fscache);
if ( cache_modified > last_modified )
last_modified = cache_modified;
}
ProjectItem item(project, path, conf, last_modified, favorite);
if (favorite)
favorite_projects.push_back(item);
else
projects.push_back(item);
} else {
//project doesn't exist on disk but it's in the XML settings file
EditorSettings::get_singleton()->erase(_name); //remove it
}
}
projects.sort();
favorite_projects.sort();
for(List<ProjectItem>::Element *E=projects.front();E;) {
List<ProjectItem>::Element *next = E->next();
if (favorite_projects.find(E->get()) != NULL)
projects.erase(E->get());
E=next;
}
for(List<ProjectItem>::Element *E=favorite_projects.back();E;E=E->prev()) {
projects.push_front(E->get());
}
Ref<Texture> favorite_icon = get_icon("Favorites","EditorIcons");
for(List<ProjectItem>::Element *E=projects.front();E;E=E->next()) {
ProjectItem &item = E->get();
String project = item.project;
String path = item.path;
String conf = item.conf;
bool is_favorite = item.favorite;
Ref<ConfigFile> cf = memnew( ConfigFile );
Error err = cf->load(conf);
ERR_CONTINUE(err!=OK);
String project_name=TTR("Unnamed Project");
if (cf->has_section_key("application","name")) {
project_name = static_cast<String>(cf->get_value("application","name")).xml_unescape();
}
if (filter_option==ProjectListFilter::FILTER_NAME && search_term!="" && project_name.findn(search_term)==-1)
continue;
Ref<Texture> icon;
if (cf->has_section_key("application","icon")) {
String appicon = cf->get_value("application","icon");
if (appicon!="") {
Image img;
Error err = img.load(appicon.replace_first("res://",path+"/"));
if (err==OK) {
img.resize(64,64);
Ref<ImageTexture> it = memnew( ImageTexture );
it->create_from_image(img);
icon=it;
}
}
}
if (icon.is_null()) {
icon=get_icon("DefaultProjectIcon","EditorIcons");
}
String main_scene;
if (cf->has_section_key("application","main_scene")) {
main_scene = cf->get_value("application","main_scene");
}
selected_list_copy.erase(project);
HBoxContainer *hb = memnew( HBoxContainer );
hb->set_meta("name",project);
hb->set_meta("main_scene",main_scene);
hb->set_meta("favorite",is_favorite);
hb->connect("draw",this,"_panel_draw",varray(hb));
hb->connect("gui_input",this,"_panel_input",varray(hb));
hb->add_constant_override("separation",10*EDSCALE);
VBoxContainer *favorite_box = memnew( VBoxContainer );
TextureButton *favorite = memnew( TextureButton );
favorite->set_normal_texture(favorite_icon);
if (!is_favorite)
favorite->set_modulate(Color(1,1,1,0.2));
favorite->set_v_size_flags(SIZE_EXPAND);
favorite->connect("pressed",this,"_favorite_pressed",varray(hb));
favorite_box->add_child(favorite);
hb->add_child(favorite_box);
TextureRect *tf = memnew( TextureRect );
tf->set_texture(icon);
hb->add_child(tf);
VBoxContainer *vb = memnew(VBoxContainer);
vb->set_name("project");
hb->add_child(vb);
Control *ec = memnew( Control );
ec->set_custom_minimum_size(Size2(0,1));
vb->add_child(ec);
Label *title = memnew( Label(project_name) );
title->add_font_override("font", gui_base->get_font("large","Fonts"));
title->add_color_override("font_color",font_color);
vb->add_child(title);
Label *fpath = memnew( Label(path) );
fpath->set_name("path");
vb->add_child(fpath);
fpath->set_modulate(Color(1,1,1,0.5));
fpath->add_color_override("font_color",font_color);
scroll_childs->add_child(hb);
}
for (Map<String,String>::Element *E = selected_list_copy.front();E;E = E->next()) {
String key = E->key();
selected_list.erase(key);
}
scroll->set_v_scroll(0);
_update_project_buttons();
EditorSettings::get_singleton()->save();
tabs->set_current_tab(0);
}
void SceneTreeDock::_create() {
if (current_option==TOOL_NEW) {
Node *parent=NULL;
if (edited_scene) {
parent = scene_tree->get_selected();
ERR_FAIL_COND(!parent);
} else {
parent = scene_root;
ERR_FAIL_COND(!parent);
}
Object *c = create_dialog->instance_selected();
ERR_FAIL_COND(!c);
Node *child=c->cast_to<Node>();
ERR_FAIL_COND(!child);
editor_data->get_undo_redo().create_action("Create Node");
if (edited_scene) {
editor_data->get_undo_redo().add_do_method(parent,"add_child",child);
editor_data->get_undo_redo().add_do_method(child,"set_owner",edited_scene);
editor_data->get_undo_redo().add_do_method(editor_selection,"clear");
editor_data->get_undo_redo().add_do_method(editor_selection,"add_node",child);
editor_data->get_undo_redo().add_do_reference(child);
editor_data->get_undo_redo().add_undo_method(parent,"remove_child",child);
} else {
editor_data->get_undo_redo().add_do_method(editor,"set_edited_scene",child);
editor_data->get_undo_redo().add_do_reference(child);
editor_data->get_undo_redo().add_undo_method(editor,"set_edited_scene",(Object*)NULL);
}
editor_data->get_undo_redo().commit_action();
editor->push_item(c);
if (c->cast_to<Control>()) {
//make editor more comfortable, so some controls don't appear super shrunk
Control *ct = c->cast_to<Control>();
Size2 ms = ct->get_minimum_size();
if (ms.width<4)
ms.width=40;
if (ms.height<4)
ms.height=40;
ct->set_size(ms);
}
} else if (current_option==TOOL_REPLACE) {
Node * n = scene_tree->get_selected();
ERR_FAIL_COND(!n);
Object *c = create_dialog->instance_selected();
ERR_FAIL_COND(!c);
Node *newnode=c->cast_to<Node>();
ERR_FAIL_COND(!newnode);
List<PropertyInfo> pinfo;
n->get_property_list(&pinfo);
for(List<PropertyInfo>::Element *E=pinfo.front();E;E=E->next()) {
if (!(E->get().usage&PROPERTY_USAGE_STORAGE))
continue;
newnode->set(E->get().name,n->get(E->get().name));
}
editor->push_item(NULL);
//reconnect signals
List<MethodInfo> sl;
n->get_signal_list(&sl);
for (List<MethodInfo>::Element *E=sl.front();E;E=E->next()) {
List<Object::Connection> cl;
n->get_signal_connection_list(E->get().name,&cl);
for(List<Object::Connection>::Element *F=cl.front();F;F=F->next()) {
Object::Connection &c=F->get();
if (!(c.flags&Object::CONNECT_PERSIST))
continue;
newnode->connect(c.signal,c.target,c.method,varray(),Object::CONNECT_PERSIST);
}
}
String newname=n->get_name();
n->replace_by(newnode,true);
if (n==edited_scene) {
edited_scene=newnode;
editor->set_edited_scene(newnode);
}
editor_data->get_undo_redo().clear_history();
memdelete(n);
newnode->set_name(newname);
editor->push_item(newnode);
_update_tool_buttons();
}
}
bool Cursynth::textInput(int key) {
if (state_ == PATCH_LOADING) {
int num_patches = patches_.size();
switch(key) {
case '\n':
// Finish loading patches.
state_ = STANDARD;
gui_.clearPatches();
return true;
case KEY_UP:
// Go to previous patch.
patch_load_index_ = CLAMP(patch_load_index_ - 1, 0, num_patches - 1);
gui_.drawPatchLoading(patches_, patch_load_index_);
loadFromFile(patches_[patch_load_index_]);
return true;
case KEY_DOWN:
// Go to next patch.
patch_load_index_ = CLAMP(patch_load_index_ + 1, 0, num_patches - 1);
gui_.drawPatchLoading(patches_, patch_load_index_);
loadFromFile(patches_[patch_load_index_]);
return true;
}
}
std::string current_control = gui_.getCurrentControl();
Control* control = controls_.at(current_control);
bool should_redraw_control = false;
lock();
switch(key) {
case 'H':
case KEY_F(1):
startHelp();
break;
case 'S':
startSave();
break;
case 'L':
startLoad();
break;
case 'M':
case 'm':
if (state_ != MIDI_LEARN)
state_ = MIDI_LEARN;
else
state_ = STANDARD;
should_redraw_control = true;
break;
case 'C':
case 'c':
eraseMidiLearn(control);
state_ = STANDARD;
should_redraw_control = true;
break;
case KEY_UP:
current_control = gui_.getPrevControl();
state_ = STANDARD;
gui_.drawControl(control, false);
should_redraw_control = true;
break;
case KEY_DOWN:
current_control = gui_.getNextControl();
state_ = STANDARD;
gui_.drawControl(control, false);
should_redraw_control = true;
break;
case KEY_RIGHT:
control->increment();
should_redraw_control = true;
break;
case KEY_LEFT:
control->decrement();
should_redraw_control = true;
break;
default:
// Check if they pressed the slider keys and change the current value.
size_t slider_size = strlen(SLIDER) - 1;
for (size_t i = 0; i <= slider_size; ++i) {
if (SLIDER[i] == key) {
control->setPercentage((1.0 * i) / slider_size);
should_redraw_control = true;
break;
}
}
// Check if they pressed note keys and play the corresponding note.
for (size_t i = 0; i < strlen(KEYBOARD); ++i) {
if (KEYBOARD[i] == key) {
synth_.noteOn(48 + i);
break;
}
}
}
if (should_redraw_control) {
control = controls_.at(current_control);
gui_.drawControl(control, true);
gui_.drawControlStatus(control, state_ == MIDI_LEARN);
}
unlock();
return true;
}
void GlobePlugin::setupControls()
{
std::string imgDir = QDir::cleanPath( QgsApplication::pkgDataPath() + "/globe/gui" ).toStdString();
if ( QgsApplication::isRunningFromBuildDir() )
{
imgDir = QDir::cleanPath( QgsApplication::buildSourcePath() + "/src/plugins/globe/images/gui" ).toStdString();
}
osgEarth::Util::EarthManipulator* manip = dynamic_cast<osgEarth::Util::EarthManipulator*>( mOsgViewer->getCameraManipulator() );
osg::Image* yawPitchWheelImg = osgDB::readImageFile( imgDir + "/YawPitchWheel.png" );
ImageControl* yawPitchWheel = new ImageControl( yawPitchWheelImg );
int imgLeft = 16;
int imgTop = 20;
yawPitchWheel->setPosition( imgLeft, imgTop );
mControlCanvas->addControl( yawPitchWheel );
//ROTATE CONTROLS
Control* rotateCCW = new NavigationControl();
rotateCCW->setHeight( 22 );
rotateCCW->setWidth( 20 );
rotateCCW->setPosition( imgLeft + 0, imgTop + 18 );
rotateCCW->addEventHandler( new RotateControlHandler( manip, MOVE_OFFSET, 0 ) );
mControlCanvas->addControl( rotateCCW );
Control* rotateCW = new NavigationControl();
rotateCW->setHeight( 22 );
rotateCW->setWidth( 20 );
rotateCW->setPosition( imgLeft + 36, imgTop + 18 );
rotateCW->addEventHandler( new RotateControlHandler( manip, -MOVE_OFFSET, 0 ) );
mControlCanvas->addControl( rotateCW );
//Rotate Reset
Control* rotateReset = new NavigationControl();
rotateReset->setHeight( 22 );
rotateReset->setWidth( 16 );
rotateReset->setPosition( imgLeft + 20, imgTop + 18 );
rotateReset->addEventHandler( new RotateControlHandler( manip, 0, 0 ) );
mControlCanvas->addControl( rotateReset );
//TILT CONTROLS
Control* tiltUp = new NavigationControl();
tiltUp->setHeight( 19 );
tiltUp->setWidth( 24 );
tiltUp->setPosition( imgLeft + 20, imgTop + 0 );
tiltUp->addEventHandler( new RotateControlHandler( manip, 0, MOVE_OFFSET ) );
mControlCanvas->addControl( tiltUp );
Control* tiltDown = new NavigationControl();
tiltDown->setHeight( 19 );
tiltDown->setWidth( 24 );
tiltDown->setPosition( imgLeft + 16, imgTop + 36 );
tiltDown->addEventHandler( new RotateControlHandler( manip, 0, -MOVE_OFFSET ) );
mControlCanvas->addControl( tiltDown );
// -------
osg::Image* moveWheelImg = osgDB::readImageFile( imgDir + "/MoveWheel.png" );
ImageControl* moveWheel = new ImageControl( moveWheelImg );
imgTop = 80;
moveWheel->setPosition( imgLeft, imgTop );
mControlCanvas->addControl( moveWheel );
//MOVE CONTROLS
Control* moveLeft = new NavigationControl();
moveLeft->setHeight( 22 );
moveLeft->setWidth( 20 );
moveLeft->setPosition( imgLeft + 0, imgTop + 18 );
moveLeft->addEventHandler( new PanControlHandler( manip, -MOVE_OFFSET, 0 ) );
mControlCanvas->addControl( moveLeft );
Control* moveRight = new NavigationControl();
moveRight->setHeight( 22 );
moveRight->setWidth( 20 );
moveRight->setPosition( imgLeft + 36, imgTop + 18 );
moveRight->addEventHandler( new PanControlHandler( manip, MOVE_OFFSET, 0 ) );
mControlCanvas->addControl( moveRight );
Control* moveUp = new NavigationControl();
moveUp->setHeight( 19 );
moveUp->setWidth( 24 );
moveUp->setPosition( imgLeft + 20, imgTop + 0 );
moveUp->addEventHandler( new PanControlHandler( manip, 0, MOVE_OFFSET ) );
mControlCanvas->addControl( moveUp );
Control* moveDown = new NavigationControl();
moveDown->setHeight( 19 );
moveDown->setWidth( 24 );
moveDown->setPosition( imgLeft + 16, imgTop + 36 );
moveDown->addEventHandler( new PanControlHandler( manip, 0, -MOVE_OFFSET ) );
mControlCanvas->addControl( moveDown );
//Zoom Reset
Control* zoomHome = new NavigationControl();
zoomHome->setHeight( 22 );
zoomHome->setWidth( 16 );
zoomHome->setPosition( imgLeft + 20, imgTop + 18 );
zoomHome->addEventHandler( new HomeControlHandler( manip ) );
mControlCanvas->addControl( zoomHome );
// -------
osg::Image* backgroundImg = osgDB::readImageFile( imgDir + "/button-background.png" );
ImageControl* backgroundGrp1 = new ImageControl( backgroundImg );
imgTop = imgTop + 62;
backgroundGrp1->setPosition( imgLeft + 12, imgTop );
mControlCanvas->addControl( backgroundGrp1 );
osg::Image* plusImg = osgDB::readImageFile( imgDir + "/zoom-in.png" );
ImageControl* zoomIn = new NavigationControl( plusImg );
zoomIn->setPosition( imgLeft + 12 + 3, imgTop + 3 );
zoomIn->addEventHandler( new ZoomControlHandler( manip, 0, -MOVE_OFFSET ) );
mControlCanvas->addControl( zoomIn );
osg::Image* minusImg = osgDB::readImageFile( imgDir + "/zoom-out.png" );
ImageControl* zoomOut = new NavigationControl( minusImg );
zoomOut->setPosition( imgLeft + 12 + 3, imgTop + 3 + 23 + 2 );
zoomOut->addEventHandler( new ZoomControlHandler( manip, 0, MOVE_OFFSET ) );
mControlCanvas->addControl( zoomOut );
// -------
ImageControl* backgroundGrp2 = new ImageControl( backgroundImg );
imgTop = imgTop + 60;
backgroundGrp2->setPosition( imgLeft + 12, imgTop );
mControlCanvas->addControl( backgroundGrp2 );
//Zoom Reset
#if ENABLE_HOME_BUTTON
osg::Image* homeImg = osgDB::readImageFile( imgDir + "/zoom-home.png" );
ImageControl* home = new NavigationControl( homeImg );
home->setPosition( imgLeft + 12 + 3, imgTop + 2 );
imgTop = imgTop + 23 + 2;
home->addEventHandler( new HomeControlHandler( manip ) );
mControlCanvas->addControl( home );
#endif
//refresh layers
osg::Image* refreshImg = osgDB::readImageFile( imgDir + "/refresh-view.png" );
ImageControl* refresh = new NavigationControl( refreshImg );
refresh->setPosition( imgLeft + 12 + 3, imgTop + 3 );
imgTop = imgTop + 23 + 2;
refresh->addEventHandler( new RefreshControlHandler( this ) );
mControlCanvas->addControl( refresh );
//Sync Extent
osg::Image* syncImg = osgDB::readImageFile( imgDir + "/sync-extent.png" );
ImageControl* sync = new NavigationControl( syncImg );
sync->setPosition( imgLeft + 12 + 3, imgTop + 2 );
sync->addEventHandler( new SyncExtentControlHandler( this ) );
mControlCanvas->addControl( sync );
}
/**
* @brief
* Called when a control event has occurred
*/
void Application65::OnControl(Control &cControl)
{
// Is it a button and was it just hit?
if (cControl.GetType() == ControlButton && reinterpret_cast<Button&>(cControl).IsHit()) {
// Check whether the escape key was pressed
if (cControl.GetName() == "KeyboardEscape") {
// Shut down the application
Exit(0);
// Show/hide the help text
} else if (cControl.GetName() == "KeyboardF1") {
// Get the info text scene node
SceneNode *pSceneNode = GetRootScene() ? GetRootScene()->GetByName("InfoText") : nullptr;
if (pSceneNode) {
// Toggle the active state of the scene node
pSceneNode->SetActive(!pSceneNode->IsActive());
}
// Toggle post processing
} else if (cControl.GetName() == "KeyboardSpace") {
// Get the currently used camera
SceneNode *pCamera = reinterpret_cast<SceneNode*>(GetCamera());
if (pCamera) {
// Loop through all available post process scene node modifiers
uint32 nIndex = 0;
SceneNodeModifier *pModifier = pCamera->GetModifier("PLCompositing::SNMPostProcess", nIndex);
while (pModifier) {
// Toggle the active state of the post process scene node modifier
pModifier->SetActive(!pModifier->IsActive());
// Next modifier, please
pModifier = pCamera->GetModifier("PLCompositing::SNMPostProcess", ++nIndex);
}
}
// Next post process effect
} else if (cControl.GetName() == "KeyboardPageUp") {
// Get the currently used camera
SceneNode *pCamera = reinterpret_cast<SceneNode*>(GetCamera());
if (pCamera) {
// Increase the current selected modifier index
m_nCurrentSelectedModifier++;
if (m_nCurrentSelectedModifier >= m_lstModifierClasses.GetNumOfElements())
m_nCurrentSelectedModifier = 0;
// Remove all old modifiers add the new one
pCamera->ClearModifiers();
pCamera->AddModifier(m_lstModifierClasses[m_nCurrentSelectedModifier]->GetClassName());
}
// Previous post process effect
} else if (cControl.GetName() == "KeyboardPageDown") {
// Get the currently used camera
SceneNode *pCamera = reinterpret_cast<SceneNode*>(GetCamera());
if (pCamera) {
// Decrease the current selected modifier index
if (m_nCurrentSelectedModifier)
m_nCurrentSelectedModifier--;
else
m_nCurrentSelectedModifier = m_lstModifierClasses.GetNumOfElements()-1;
// Remove all old modifiers add the new one
pCamera->ClearModifiers();
pCamera->AddModifier(m_lstModifierClasses[m_nCurrentSelectedModifier]->GetClassName());
}
// Custom post process effect: "Rainbow"
} else if (cControl.GetName() == "Keyboard1") {
// Get the currently used camera
SceneNode *pCamera = reinterpret_cast<SceneNode*>(GetCamera());
if (pCamera) {
// Remove all old modifiers add the new one
pCamera->ClearModifiers();
pCamera->AddModifier("PLPostProcessEffects::SNMPostProcessCrazyBars", "ColorScaleY=\"0.002\"");
}
// Custom post process effect: "Cartoon"
} else if (cControl.GetName() == "Keyboard2") {
// Get the currently used camera
SceneNode *pCamera = reinterpret_cast<SceneNode*>(GetCamera());
if (pCamera) {
// Remove all old modifiers add the new ones
pCamera->ClearModifiers();
pCamera->AddModifier("PLPostProcessEffects::SNMPostProcessEdgeDetect", "LuminanceConvert=\"-0.2125 -0.7154 -0.0721\"");
pCamera->AddModifier("PLPostProcessEffects::SNMPostProcessCombineMultiplicate");
}
// Custom post process effect: "Animated cartoon"
} else if (cControl.GetName() == "Keyboard3") {
// Get the currently used camera
SceneNode *pCamera = reinterpret_cast<SceneNode*>(GetCamera());
if (pCamera) {
// Remove all old modifiers add the new ones
pCamera->ClearModifiers();
pCamera->AddModifier("PLPostProcessEffects::SNMPostProcessEdgeDetect", "LuminanceConvert=\"-0.2125 -0.7154 -0.0721\"");
pCamera->AddModifier("PLPostProcessEffects::SNMPostProcessOldFilm");
pCamera->AddModifier("PLPostProcessEffects::SNMPostProcessCombineMultiplicate");
}
// Custom post process effect: "Animated old cartoon"
} else if (cControl.GetName() == "Keyboard4") {
// Get the currently used camera
SceneNode *pCamera = reinterpret_cast<SceneNode*>(GetCamera());
if (pCamera) {
// Remove all old modifiers add the new ones
pCamera->ClearModifiers();
pCamera->AddModifier("PLPostProcessEffects::SNMPostProcessEdgeDetect", "LuminanceConvert=\"-0.2125 -0.7154 -0.0721\"");
pCamera->AddModifier("PLPostProcessEffects::SNMPostProcessCombineMultiplicate");
pCamera->AddModifier("PLPostProcessEffects::SNMPostProcessOldFilm");
}
// Custom post process effect: "Scratch"
} else if (cControl.GetName() == "Keyboard5") {
// Get the currently used camera
SceneNode *pCamera = reinterpret_cast<SceneNode*>(GetCamera());
if (pCamera) {
// Remove all old modifiers add the new one
pCamera->ClearModifiers();
pCamera->AddModifier("PLPostProcessEffects::SNMPostProcessEdgeDetect", "LuminanceConvert=\"-0.2125 -0.7154 -0.0721\"");
}
// Custom post process effect: "Animated old scratch"
} else if (cControl.GetName() == "Keyboard6") {
// Get the currently used camera
SceneNode *pCamera = reinterpret_cast<SceneNode*>(GetCamera());
if (pCamera) {
// Remove all old modifiers add the new ones
pCamera->ClearModifiers();
pCamera->AddModifier("PLPostProcessEffects::SNMPostProcessEdgeDetect", "LuminanceConvert=\"-0.2125 -0.7154 -0.0721\"");
pCamera->AddModifier("PLPostProcessEffects::SNMPostProcessOldFilm");
}
// Custom post process effect: "Edge glow"
} else if (cControl.GetName() == "Keyboard7") {
// Get the currently used camera
SceneNode *pCamera = reinterpret_cast<SceneNode*>(GetCamera());
if (pCamera) {
// Remove all old modifiers add the new one
pCamera->ClearModifiers();
pCamera->AddModifier("PLPostProcessEffects::SNMPostProcessEdgeDetect", "Filename=\"Data/PostProcesses/EdgeGlow.pp\"");
}
}
}
}
INT_PTR DlgProc(TimeValue t, IParamMap2 *map, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
OrientConstRotation* p = (OrientConstRotation*)map->GetParamBlock()->GetOwner();
UpdateOrientName(p);
p->hWnd = hWnd;
int ct = p->pblock->Count(orientation_target_list);
// int ctf = p->pblock->Count(orientation_target_weight);
switch (msg)
{
case WM_INITDIALOG:
{
int selection = p->last_selection;
ICustButton *iBut = GetICustButton(GetDlgItem(hWnd,IDC_ORIENT_TARG_PICKNODE));
iBut->SetType(CBT_CHECK);
iBut->SetHighlightColor(GREEN_WASH);
ReleaseICustButton(iBut);
ISpinnerControl* spin = SetupFloatSpinner(hWnd, IDC_ORIENT_CONS_WEIGHT_SPINNER, IDC_ORIENT_CONS_WEIGHT_EDIT, 0.0f, 100.0f, 50.0f, 1.0f);
spin = GetISpinner(GetDlgItem(hWnd, IDC_ORIENT_CONS_WEIGHT_SPINNER));
// CAL-09/10/02: automatically set last_selection to 0 when there're targets
if (p->pblock->Count(orientation_target_list) < 1) {
// nothing is selected OR there are no targets
// all buttons - target_delete, weight_edit, weight_spinner -- are disabled
EnableWindow(GetDlgItem(p->hWnd, IDC_ORIENT_CONS_WEIGHT_EDIT), FALSE);
EnableWindow(GetDlgItem(p->hWnd, IDC_ORIENT_CONS_WEIGHT_SPINNER), FALSE);
ICustButton *iPickOb1;
iPickOb1 = GetICustButton(GetDlgItem(p->hWnd, IDC_REMOVE_ORIENT_TARG));
if (iPickOb1 != NULL){
iPickOb1->Enable(FALSE);
ReleaseICustButton(iPickOb1);
}
spin->SetValue(0.0f, FALSE);
} else {
if (selection < 0)
p->last_selection = selection = 0;
// there is a valid selection
// automatically means there is AT LEAST one target
Control *cont = p->pblock->GetControllerByID(orientation_target_weight, selection);
// until it is animated, paramblock doesn't have a controller assigned in it yet.
if (spin) {
if ((cont != NULL) && cont->IsKeyAtTime(t,KEYAT_ROTATION))
spin->SetKeyBrackets(TRUE);
else
spin->SetKeyBrackets(FALSE);
}
if(p->pickWorldFlag){
ICustButton *iPickOb;
iPickOb = GetICustButton(GetDlgItem(p->hWnd, IDC_ORIENT_PICK_WORLD));
if (iPickOb != NULL){
iPickOb->Enable(FALSE);
ReleaseICustButton(iPickOb);
}
}
if (p->pblock->Count(orientation_target_list) == 1){// there is only one target
// the "delete" button should be enabled
ICustButton *iPickOb1;
iPickOb1 = GetICustButton(GetDlgItem(p->hWnd, IDC_REMOVE_ORIENT_TARG));
if (iPickOb1 != NULL){
iPickOb1->Enable(TRUE);
ReleaseICustButton(iPickOb1);
}
// the rest are disabled
// EnableWindow(GetDlgItem(p->hWnd, IDC_ORIENT_CONS_WEIGHT_EDIT), FALSE);
// EnableWindow(GetDlgItem(p->hWnd, IDC_ORIENT_CONS_WEIGHT_SPINNER), FALSE);
}
else if (p->pblock->Count(orientation_target_list) > 1){
// there are more than one targets
// all buttons - delete, weight_edit, weight_spinner -- are enabled
EnableWindow(GetDlgItem(p->hWnd, IDC_ORIENT_CONS_WEIGHT_EDIT), TRUE);
EnableWindow(GetDlgItem(p->hWnd, IDC_ORIENT_CONS_WEIGHT_SPINNER), TRUE);
ICustButton *iPickOb1;
iPickOb1 = GetICustButton(GetDlgItem(p->hWnd, IDC_REMOVE_ORIENT_TARG));
if (iPickOb1 != NULL){
iPickOb1->Enable(TRUE);
ReleaseICustButton(iPickOb1);
}
}
}
ReleaseISpinner(spin);
p->RedrawListbox(GetCOREInterface()->GetTime(), selection);
return TRUE;
}
break;
case WM_COMMAND:
{
int selection;
if (LOWORD(wParam) == IDC_ORIENT_TARG_LIST && HIWORD(wParam) == LBN_SELCHANGE)
{
selection = SendDlgItemMessage(p->hWnd, IDC_ORIENT_TARG_LIST, LB_GETCURSEL, 0, 0);
p->last_selection = selection;
if (selection >= 0){
// there is a valid selection
// automatically means there is AT LEAST one target
if (p->pblock->Count(orientation_target_list) == 1){ // there is only one target
// the "delete" button should be enabled
ICustButton *iPickOb1;
iPickOb1 = GetICustButton(GetDlgItem(p->hWnd, IDC_REMOVE_ORIENT_TARG));
if (iPickOb1 != NULL){
iPickOb1->Enable(TRUE);
ReleaseICustButton(iPickOb1);
}
// // the rest are disabled
// EnableWindow(GetDlgItem(p->hWnd, IDC_ORIENT_CONS_WEIGHT_EDIT), FALSE);
// EnableWindow(GetDlgItem(p->hWnd, IDC_ORIENT_CONS_WEIGHT_SPINNER), FALSE);
}
else if (p->pblock->Count(orientation_target_list) > 1){
// there are more than one targets
// all buttons - delete, weight_edit, weight_spinner -- are enabled
EnableWindow(GetDlgItem(p->hWnd, IDC_ORIENT_CONS_WEIGHT_EDIT), TRUE);
EnableWindow(GetDlgItem(p->hWnd, IDC_ORIENT_CONS_WEIGHT_SPINNER), TRUE);
ICustButton *iPickOb1;
iPickOb1 = GetICustButton(GetDlgItem(p->hWnd, IDC_REMOVE_ORIENT_TARG));
if (iPickOb1 != NULL){
iPickOb1->Enable(TRUE);
ReleaseICustButton(iPickOb1);
}
ISpinnerControl* spin = GetISpinner(GetDlgItem(hWnd, IDC_ORIENT_CONS_WEIGHT_SPINNER));
float value = map->GetParamBlock()->GetFloat(orientation_target_weight, t, selection);
spin->SetValue(value, FALSE);
Control *cont = p->pblock->GetControllerByID(orientation_target_weight, selection); // until it is animated, paramblock doesn't have a controller assigned in it yet.
if (spin && (cont != NULL)) {
if (cont->IsKeyAtTime(t,KEYAT_ROTATION)){
spin->SetKeyBrackets(TRUE);
}
}
else {
spin->SetKeyBrackets(FALSE);
}
ReleaseISpinner(spin);
}
p->RedrawListbox(GetCOREInterface()->GetTime(), selection);
}
else if (selection < 0 || p->pblock->Count(orientation_target_list) < 1){
// nothing is selected OR there are no targets
// all buttons - target_delete, weight_edit, weight_spinner -- are disabled
EnableWindow(GetDlgItem(p->hWnd, IDC_ORIENT_CONS_WEIGHT_EDIT), FALSE);
EnableWindow(GetDlgItem(p->hWnd, IDC_ORIENT_CONS_WEIGHT_SPINNER), FALSE);
ICustButton *iPickOb1;
iPickOb1 = GetICustButton(GetDlgItem(p->hWnd, IDC_REMOVE_ORIENT_TARG));
if (iPickOb1 != NULL){
iPickOb1->Enable(FALSE);
ReleaseICustButton(iPickOb1);
}
}
}
else if (LOWORD(wParam) == IDC_ORIENT_TARG_PICKNODE){
thePickMode.p = p;
p->ip->SetPickMode(&thePickMode);
}
else if (LOWORD(wParam) == IDC_REMOVE_ORIENT_TARG){
selection = SendDlgItemMessage(p->hWnd, IDC_ORIENT_TARG_LIST, LB_GETCURSEL, 0, 0);
p->last_selection = selection;
if (selection >= 0){
theHold.Begin();
p->DeleteTarget(selection);
theHold.Accept(GetString(IDS_AG_ORIENTATION_LIST));
}
// p->RedrawListbox(GetCOREInterface()->GetTime(), selection-1);
}
else if (LOWORD(wParam) == IDC_ORIENT_PICK_WORLD){
INode *nullNode = NULL;
p->AppendTarget(nullNode);
p->pickWorldFlag = 1;
p->NotifyDependents(FOREVER,PART_ALL,REFMSG_CHANGE); // so that the change is updated
ICustButton *iPickOb;
iPickOb = GetICustButton(GetDlgItem(p->hWnd, IDC_ORIENT_PICK_WORLD));
if (iPickOb != NULL){
iPickOb->Enable(FALSE);
ReleaseICustButton(iPickOb);
}
p->RedrawListbox(GetCOREInterface()->GetTime());
}
}
break;
case CC_SPINNER_CHANGE:
{
if (LOWORD(wParam) == IDC_ORIENT_CONS_WEIGHT_SPINNER) {
int selection = SendDlgItemMessage(p->hWnd, IDC_ORIENT_TARG_LIST, LB_GETCURSEL, 0, 0);
// CAL-09/10/02: need to start a hold if it's not holding to handle type-in values
BOOL isHold = theHold.Holding();
if (!isHold) theHold.Begin();
ISpinnerControl* spin = GetISpinner(GetDlgItem(hWnd, IDC_ORIENT_CONS_WEIGHT_SPINNER));
if (selection >= 0) {
float value = ((ISpinnerControl *)lParam)->GetFVal();
map->GetParamBlock()->SetValue(orientation_target_weight, t, value, selection);
Control *cont = p->pblock->GetControllerByID(orientation_target_weight, selection); // until it is animated, paramblock doesn't have a controller assigned in it yet.
if (spin)
spin->SetKeyBrackets(((cont != NULL) && cont->IsKeyAtTime(t,KEYAT_ROTATION)) ? TRUE : FALSE);
p->RedrawListbox(GetCOREInterface()->GetTime(), selection);
} else {
if (spin) spin->SetValue(0.0f, FALSE);
}
if (spin) ReleaseISpinner(spin);
if (!isHold) theHold.Accept(GetString(IDS_RB_PARAMETERCHANGE));
}
}
break;
}
return FALSE;
}
// Process window messages
LRESULT CALLBACK Daemon::WndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam) {
// This is a static method, so we don't know which instantiation we're
// dealing with. We have stored a pseudo-this in the window user data,
// though.
Daemon *_this = (Daemon *) GetWindowLong(hwnd, GWL_USERDATA);
switch (iMsg) {
case WM_CREATE:
{
return 0;
}
case WM_SOCKEVENT:
{
assert(HIWORD(lParam) == 0);
// A new socket created by accept might send messages to
// this procedure. We can ignore them.
if(wParam != _this->m_sock) {
return 0;
}
switch(lParam) {
case FD_ACCEPT:
{
SOCKET hNewSock;
hNewSock = accept(_this->m_sock, NULL, NULL);
WSAAsyncSelect(hNewSock, hwnd, 0, 0);
unsigned long nbarg = 0;
ioctlsocket(hNewSock, FIONBIO, &nbarg);
pApp->NewConnection(hNewSock);
break;
}
case FD_READ:
{
unsigned long numbytes;
ioctlsocket(_this->m_sock, FIONREAD, &numbytes);
recv(_this->m_sock, _this->netbuf, numbytes, 0);
break;
}
case FD_CLOSE:
Log::info(_T("Daemon connection closed\n"));
DestroyWindow(hwnd);
break;
}
return 0;
}
case WM_COMMAND:
switch (LOWORD(wParam)) {
case ID_NEWCONN:
pApp->NewConnection();
break;
case IDC_OPTIONBUTTON:
{
Control ctrlThis;
ctrlThis.setWindow(_this->m_hwnd);
ConnectionConfigDialog conConfDialog;
conConfDialog.setParent(&ctrlThis);
conConfDialog.setConnectionConfig(&_this->m_conConf);
if (conConfDialog.showModal() == IDOK) {
ConnectionConfigSM ccsm(_T(".listen"));
_this->m_conConf.saveToStorage(&ccsm);
}
}
break;
case ID_CLOSEDAEMON:
PostQuitMessage(0);
break;
case IDD_APP_ABOUT:
ShowAboutBox();
break;
case IDD_CONFIGURATION:
g_vncViewerConfigDialog.showModal();
break;
}
return 0;
case WM_TRAYNOTIFY:
{
HMENU hSubMenu = GetSubMenu(_this->m_hmenu, 0);
if (lParam==WM_LBUTTONDBLCLK) {
// double click: execute first menu item
::SendMessage(_this->m_nid.hWnd, WM_COMMAND,
GetMenuItemID(hSubMenu, 0), 0);
} else if (lParam==WM_RBUTTONUP) {
if (hSubMenu == NULL) {
Log::warning(_T("No systray submenu\n"));
return 0;
}
// Make first menu item the default (bold font)
::SetMenuDefaultItem(hSubMenu, 0, TRUE);
// Display the menu at the current mouse location. There's a "bug"
// (Microsoft calls it a feature) in Windows 95 that requires calling
// SetForegroundWindow. To find out more, search for Q135788 in MSDN.
//
POINT mouse;
GetCursorPos(&mouse);
::SetForegroundWindow(_this->m_nid.hWnd);
::TrackPopupMenu(hSubMenu, 0, mouse.x, mouse.y, 0,
_this->m_nid.hWnd, NULL);
}
return 0;
}
case WM_TIMER:
_this->CheckTrayIcon();
return 0;
case WM_DESTROY:
PostQuitMessage(0);
return 0;
}
return DefWindowProc(hwnd, iMsg, wParam, lParam);
}
/**
* @brief
* Called when a control event has occurred
*/
void Application60::OnControl(Control &cControl)
{
// Check whether the escape key was pressed
if (cControl.GetType() == ControlButton && cControl.GetName() == "KeyboardEscape")
Exit(0); // Shut down the application
}
void TabContainer::_input_event(const InputEvent& p_event) {
if (p_event.type==InputEvent::MOUSE_BUTTON &&
p_event.mouse_button.pressed &&
p_event.mouse_button.button_index==BUTTON_LEFT) {
// clicks
Point2 pos( p_event.mouse_button.x, p_event.mouse_button.y );
int top_margin = _get_top_margin();
if (pos.y>top_margin)
return; // no click (too far down)
if (pos.x<tabs_ofs_cache)
return; // no click (too far left)
Ref<StyleBox> tab_bg = get_stylebox("tab_bg");
Ref<StyleBox> tab_fg = get_stylebox("tab_fg");
Ref<Font> font = get_font("font");
Ref<Texture> incr = get_icon("increment");
Ref<Texture> decr = get_icon("decrement");
Ref<Texture> menu = get_icon("menu");
Ref<Texture> menu_hl = get_icon("menu_hl");
if (popup && pos.x>get_size().width-menu->get_width()) {
emit_signal("pre_popup_pressed");
Vector2 pp_pos = get_global_pos();
pp_pos.x+=get_size().width;
pp_pos.x-=popup->get_size().width;
pp_pos.y+=menu->get_height();
popup->set_global_pos( pp_pos );
popup->popup();;
return;
}
pos.x-=tabs_ofs_cache;
int idx=0;
int found=-1;
bool rightroom=false;
for(int i=0;i<get_child_count();i++) {
Control *c = get_child(i)->cast_to<Control>();
if (!c)
continue;
if (c->is_set_as_toplevel())
continue;
if (idx<tab_display_ofs) {
idx++;
continue;
}
if (idx>last_tab_cache) {
rightroom=true;
break;
}
String s = c->has_meta("_tab_name")?String(XL_MESSAGE(String(c->get_meta("_tab_name")))):String(c->get_name());
int tab_width=font->get_string_size(s).width;
if (c->has_meta("_tab_icon")) {
Ref<Texture> icon = c->get_meta("_tab_icon");
if (icon.is_valid()) {
tab_width+=icon->get_width();
if (s!="")
tab_width+=get_constant("hseparation");
}
}
if (idx==current) {
tab_width+=tab_fg->get_minimum_size().width;
} else {
tab_width+=tab_bg->get_minimum_size().width;
}
if (pos.x < tab_width) {
found=idx;
break;
}
pos.x-=tab_width;
idx++;
}
if (buttons_visible_cache) {
if (p_event.mouse_button.x>get_size().width-incr->get_width()) {
if (rightroom) {
tab_display_ofs+=1;
update();
}
} else if (p_event.mouse_button.x>get_size().width-incr->get_width()-decr->get_width()) {
if (tab_display_ofs>0) {
tab_display_ofs-=1;
update();
}
}
}
if (found!=-1) {
set_current_tab(found);
}
}
}
void TabContainer::_notification(int p_what) {
switch(p_what) {
case NOTIFICATION_DRAW: {
RID ci = get_canvas_item();
Ref<StyleBox> panel = get_stylebox("panel");
Size2 size = get_size();
if (!tabs_visible) {
panel->draw(ci, Rect2( 0, 0, size.width, size.height));
return;
}
Ref<StyleBox> tab_bg = get_stylebox("tab_bg");
Ref<StyleBox> tab_fg = get_stylebox("tab_fg");
Ref<Texture> incr = get_icon("increment");
Ref<Texture> incr_hl = get_icon("increment_hilite");
Ref<Texture> decr = get_icon("decrement");
Ref<Texture> decr_hl = get_icon("decrement_hilite");
Ref<Texture> menu = get_icon("menu");
Ref<Texture> menu_hl = get_icon("menu_hl");
Ref<Font> font = get_font("font");
Color color_fg = get_color("font_color_fg");
Color color_bg = get_color("font_color_bg");
int side_margin = get_constant("side_margin");
int top_margin = _get_top_margin();
int label_valign_fg = get_constant("label_valign_fg");
int label_valign_bg = get_constant("label_valign_bg");
Size2 top_size = Size2( size.width, top_margin );
int w=0;
int idx=0;
Vector<int> offsets;
Vector<Control*> controls;
int from=0;
int limit=get_size().width;
if (popup) {
top_size.width-=menu->get_width();
limit-=menu->get_width();
}
bool notdone=false;
last_tab_cache=-1;
for(int i=0;i<get_child_count();i++) {
Control *c = get_child(i)->cast_to<Control>();
if (!c)
continue;
if (c->is_set_as_toplevel())
continue;
if (idx<tab_display_ofs) {
idx++;
from=idx;
continue;
}
if (w>=get_size().width) {
buttons_visible_cache=true;
notdone=true;
break;
}
offsets.push_back(w);
controls.push_back(c);
String s = c->has_meta("_tab_name")?String(XL_MESSAGE(String(c->get_meta("_tab_name")))):String(c->get_name());
w+=font->get_string_size(s).width;
if (c->has_meta("_tab_icon")) {
Ref<Texture> icon = c->get_meta("_tab_icon");
if (icon.is_valid()) {
w+=icon->get_width();
if (s!="")
w+=get_constant("hseparation");
}
}
if (idx==current) {
w+=tab_fg->get_minimum_size().width;
} else {
w+=tab_bg->get_minimum_size().width;
}
if (idx<tab_display_ofs) {
}
last_tab_cache=idx;
idx++;
}
int ofs;
switch(align) {
case ALIGN_LEFT: ofs = side_margin; break;
case ALIGN_CENTER: ofs = (int(limit) - w)/2; break;
case ALIGN_RIGHT: ofs = int(limit) - w - side_margin; break;
};
tab_display_ofs=0;
tabs_ofs_cache=ofs;
idx=0;
for(int i=0;i<controls.size();i++) {
idx=i+from;
if (current>=from && current<from+controls.size()-1) {
//current is visible! draw it last.
if (i==controls.size()-1) {
idx=current;
} else if (idx>=current) {
idx+=1;
}
}
Control *c = controls[idx-from];
String s = c->has_meta("_tab_name")?String(c->get_meta("_tab_name")):String(c->get_name());
int w=font->get_string_size(s).width;
Ref<Texture> icon;
if (c->has_meta("_tab_icon")) {
icon = c->get_meta("_tab_icon");
if (icon.is_valid()) {
w+=icon->get_width();
if (s!="")
w+=get_constant("hseparation");
}
}
Ref<StyleBox> sb;
int va;
Color col;
if (idx==current) {
sb=tab_fg;
va=label_valign_fg;
col=color_fg;
} else {
sb=tab_bg;
va=label_valign_bg;
col=color_bg;
}
int lofs = ofs + offsets[idx-from];
Size2i sb_ms = sb->get_minimum_size();
Rect2 sb_rect = Rect2( lofs, 0, w+sb_ms.width, top_margin);
sb->draw(ci, sb_rect );
Point2i lpos = sb_rect.pos;
lpos.x+=sb->get_margin(MARGIN_LEFT);
if (icon.is_valid()) {
icon->draw(ci, Point2i( lpos.x, sb->get_margin(MARGIN_TOP)+((sb_rect.size.y-sb_ms.y)-icon->get_height())/2 ) );
if (s!="")
lpos.x+=icon->get_width()+get_constant("hseparation");
}
font->draw(ci, Point2i( lpos.x, sb->get_margin(MARGIN_TOP)+((sb_rect.size.y-sb_ms.y)-font->get_height())/2+font->get_ascent() ), s, col );
//ofs+=sb_ms.x+w;
/*
int sb_mw = sb->get_minimum_size().width;
int font_ofs = sb_mw / 2;
Rect2i rect =Rect2( ofs, 0, w+sb_mw, top_margin);
rect.size
sb->draw(ci,rect);
rect.y+=va;
rect.height+=va;
int font_y = (rect.height - font->get_height())/2;
font->draw(ci, Point2( ofs+font_ofs, va+font_y ), s, col );
*/
idx++;
}
if (buttons_visible_cache) {
int vofs = (top_margin-incr->get_height())/2;
decr->draw(ci,Point2(limit,vofs),Color(1,1,1,tab_display_ofs==0?0.5:1.0));
incr->draw(ci,Point2(limit+incr->get_width(),vofs),Color(1,1,1,notdone?1.0:0.5));
}
if (popup) {
int from = get_size().width-menu->get_width();
if (mouse_x_cache > from)
menu_hl->draw(get_canvas_item(),Size2(from,0));
else
menu->draw(get_canvas_item(),Size2(from,0));
}
panel->draw(ci, Rect2( 0, top_size.height, size.width, size.height-top_size.height));
} break;
case NOTIFICATION_READY:
case NOTIFICATION_THEME_CHANGED: {
call_deferred("set_current_tab",get_current_tab()); //wait until all changed theme
} break;
}
}
/** BroadCast Mouse Move Event */
void EventMgr::MouseDown(unsigned short x, unsigned short y, unsigned short Button,
unsigned short Mod)
{
std::vector< int>::iterator t;
std::vector< Window*>::iterator m;
Control *ctrl;
unsigned long thisTime;
thisTime = GetTickCount();
if (ClickMatch(x, y, thisTime)) {
Button |= GEM_MB_DOUBLECLICK;
dc_x = 0;
dc_y = 0;
dc_time = 0;
} else {
dc_x = x;
dc_y = y;
dc_time = thisTime+dc_delay;
}
MButtons |= Button;
for (t = topwin.begin(); t != topwin.end(); ++t) {
m = windows.begin();
m += ( *t );
if (( *m ) == NULL)
continue;
if (!( *m )->Visible)
continue;
if (( ( *m )->XPos <= x ) && ( ( *m )->YPos <= y )) {
//Maybe we are on the window, let's check
if (( ( *m )->XPos + ( *m )->Width >= x ) &&
( ( *m )->YPos + ( *m )->Height >= y )) {
//Yes, we are on the Window
//Let's check if we have a Control under the Mouse Pointer
ctrl = ( *m )->GetControl( x, y, true );
if (!ctrl) {
ctrl = ( *m )->GetControl( x, y, false);
}
last_win_mousefocused = *m;
if (ctrl != NULL) {
last_win_mousefocused->SetMouseFocused( ctrl );
ctrl->OnMouseDown( x - last_win_mousefocused->XPos - ctrl->XPos, y - last_win_mousefocused->YPos - ctrl->YPos,
Button, Mod );
if (!ctrl->WantsDragOperation()) {
focusLock = ctrl;
}
if (last_win_mousefocused) {
RefreshCursor(last_win_mousefocused->Cursor);
}
return;
}
}
}
if (( *m )->Visible == WINDOW_FRONT) //stop looking further
break;
}
if ((Button == GEM_MB_SCRLUP || Button == GEM_MB_SCRLDOWN) && last_win_mousefocused) {
ctrl = last_win_mousefocused->GetScrollControl();
if (ctrl) {
ctrl->OnMouseDown( x - last_win_mousefocused->XPos - ctrl->XPos, y - last_win_mousefocused->YPos - ctrl->YPos, Button, Mod );
}
}
if (last_win_mousefocused) {
last_win_mousefocused->SetMouseFocused(NULL);
}
}
Sprite * Controls::getControlSprite(int id)
{
Control *pc = getControl(id);
if (pc) return pc->getSprite();
return 0; //nullptr
}
/** Special Key Press Event */
void EventMgr::OnSpecialKeyPress(unsigned char Key)
{
if (!last_win_focused) {
return;
}
Control *ctrl = NULL;
// tab shows tooltips
if (Key == GEM_TAB) {
if (last_win_over != NULL) {
Control *ctrl = last_win_over->GetOver();
if (ctrl != NULL) {
ctrl->DisplayTooltip();
}
}
}
//the default control will get only GEM_RETURN
else if (Key == GEM_RETURN) {
ctrl = last_win_focused->GetDefaultControl(0);
}
//the default cancel control will get only GEM_ESCAPE
else if (Key == GEM_ESCAPE) {
ctrl = last_win_focused->GetDefaultControl(1);
} else if (Key >= GEM_FUNCTION1 && Key <= GEM_FUNCTION16) {
if (function_bar) {
ctrl = function_bar->GetFunctionControl(Key-GEM_FUNCTION1);
} else {
ctrl = last_win_focused->GetFunctionControl(Key-GEM_FUNCTION1);
}
}
//if there was no default button set, then the current focus will get it (except function keys)
if (!ctrl) {
if (Key<GEM_FUNCTION1 || Key > GEM_FUNCTION16) {
ctrl = last_win_focused->GetFocus();
}
}
//if one is under focus, use the default scroll focus
if (!ctrl) {
if (Key == GEM_UP || Key == GEM_DOWN) {
ctrl = last_win_focused->GetScrollControl();
}
}
if (ctrl) {
switch (ctrl->ControlType) {
//scrollbars will receive only mousewheel events
case IE_GUI_SCROLLBAR:
if (Key != GEM_UP && Key != GEM_DOWN) {
return;
}
break;
//buttons will receive only GEM_RETURN
case IE_GUI_BUTTON:
if (Key >= GEM_FUNCTION1 && Key <= GEM_FUNCTION16) {
//fake mouse button
ctrl->OnMouseDown(0,0,GEM_MB_ACTION,0);
ctrl->OnMouseUp(0,0,GEM_MB_ACTION,0);
return;
}
if (Key != GEM_RETURN && Key!=GEM_ESCAPE) {
return;
}
break;
// shouldnt be any harm in sending these events to any control
}
ctrl->OnSpecialKeyPress( Key );
}
}
TileMapEditor::TileMapEditor(EditorNode *p_editor) {
node=NULL;
canvas_item_editor=NULL;
editor=p_editor;
undo_redo = editor->get_undo_redo();
int mw = EDITOR_DEF("tile_map/palette_min_width",80);
Control *ec = memnew( Control);
ec->set_custom_minimum_size(Size2(mw,0));
add_child(ec);
HBoxContainer *hb = memnew( HBoxContainer );
add_child(hb);
hb->set_h_size_flags(SIZE_EXPAND_FILL);
hb->add_spacer(true);
button_thumbnail = memnew( ToolButton );
button_thumbnail->set_toggle_mode(true);
button_thumbnail->set_pressed(true);
button_thumbnail->set_icon(p_editor->get_gui_base()->get_icon("FileThumbnail","EditorIcons"));
hb->add_child(button_thumbnail);
button_thumbnail->connect("pressed", this, "_set_display_mode", varray(DISPLAY_THUMBNAIL));
button_list = memnew( ToolButton );
button_list->set_toggle_mode(true);
button_list->set_pressed(false);
button_list->set_icon(p_editor->get_gui_base()->get_icon("FileList","EditorIcons"));
hb->add_child(button_list);
button_list->connect("pressed", this, "_set_display_mode", varray(DISPLAY_LIST));
// Add tile palette
palette = memnew( ItemList );
palette->set_v_size_flags(SIZE_EXPAND_FILL);
add_child(palette);
// Add menu items
canvas_item_editor_hb = memnew( HBoxContainer );
CanvasItemEditor::get_singleton()->add_control_to_menu_panel(canvas_item_editor_hb);
canvas_item_editor_hb->add_child( memnew( VSeparator ));
transpose = memnew( ToolButton );
transpose->set_toggle_mode(true);
transpose->set_tooltip("Transpose");
transpose->set_focus_mode(FOCUS_NONE);
transpose->connect("pressed", this, "_update_transform_buttons", make_binds(transpose));
canvas_item_editor_hb->add_child(transpose);
mirror_x = memnew( ToolButton );
mirror_x->set_toggle_mode(true);
mirror_x->set_tooltip("Mirror X (A)");
mirror_x->set_focus_mode(FOCUS_NONE);
mirror_x->connect("pressed", this, "_update_transform_buttons", make_binds(mirror_x));
canvas_item_editor_hb->add_child(mirror_x);
mirror_y = memnew( ToolButton );
mirror_y->set_toggle_mode(true);
mirror_y->set_tooltip("Mirror Y (S)");
mirror_y->set_focus_mode(FOCUS_NONE);
mirror_y->connect("pressed", this, "_update_transform_buttons", make_binds(mirror_y));
canvas_item_editor_hb->add_child(mirror_y);
canvas_item_editor_hb->add_child(memnew(VSeparator));
rotate_0 = memnew( ToolButton );
rotate_0->set_toggle_mode(true);
rotate_0->set_tooltip("Rotate 0 degrees");
rotate_0->set_focus_mode(FOCUS_NONE);
rotate_0->connect("pressed", this, "_update_transform_buttons", make_binds(rotate_0));
canvas_item_editor_hb->add_child(rotate_0);
rotate_90 = memnew( ToolButton );
rotate_90->set_toggle_mode(true);
rotate_90->set_tooltip("Rotate 90 degrees");
rotate_90->set_focus_mode(FOCUS_NONE);
rotate_90->connect("pressed", this, "_update_transform_buttons", make_binds(rotate_90));
canvas_item_editor_hb->add_child(rotate_90);
rotate_180 = memnew( ToolButton );
rotate_180->set_toggle_mode(true);
rotate_180->set_tooltip("Rotate 180 degrees");
rotate_180->set_focus_mode(FOCUS_NONE);
rotate_180->connect("pressed", this, "_update_transform_buttons", make_binds(rotate_180));
canvas_item_editor_hb->add_child(rotate_180);
rotate_270 = memnew( ToolButton );
rotate_270->set_toggle_mode(true);
rotate_270->set_tooltip("Rotate 270 degrees");
rotate_270->set_focus_mode(FOCUS_NONE);
rotate_270->connect("pressed", this, "_update_transform_buttons", make_binds(rotate_270));
canvas_item_editor_hb->add_child(rotate_270);
canvas_item_editor_hb->hide();
rotate_0->set_pressed(true);
tool=TOOL_NONE;
selection_active=false;
mouse_over=false;
}
void CBitmapControl::Paint(HDC hDC, const UiRect& rcPaint)
{
try
{
if( !::IntersectRect( &m_rcPaint, &rcPaint, &m_rcItem ) )
return;
Control::Paint(hDC, rcPaint);
//paint bitmap
if (width_ * height_ > 0)
{
int item_w = m_rcItem.right-m_rcItem.left;
int item_h = m_rcItem.bottom-m_rcItem.top;
int item_x = m_rcItem.left;
int item_y = m_rcItem.top;
int source_w = width_;
int source_h = height_;
if (source_w > 0 && source_h > 0 && parent_wnd_)
{
//居中
item_x += (item_w - source_w) / 2;
item_y += (item_h - source_h) / 2;
UiRect rcClient;
::GetClientRect(parent_wnd_->GetHWND(), &rcClient);
int width = rcClient.right - rcClient.left;
int height = rcClient.bottom - rcClient.top;
//计算实际绘制区域坐标
int draw_x = max(rcPaint.left, item_x);
draw_x = max(m_rcItem.left, draw_x);
int draw_y = max(rcPaint.top, item_y);
draw_y = max(m_rcItem.top, draw_y);
int draw_h = min(rcPaint.bottom - draw_y, min(item_y + source_h, m_rcItem.bottom) - draw_y);
draw_h = max(draw_h, 0);
int src_x = draw_x - item_x;
int src_y = draw_y - item_y;
int src_w = min(rcPaint.right - draw_x, min(item_x + source_w, m_rcItem.right) - draw_x);
src_w = max(src_w, 0);
int dest_byte_width = width * 4;
int src_byte_width = source_w * 4;
int paint_byte_width = src_w * 4;
char* dest_data = (char*)parent_wnd_->GetBits();
int bottom = height - draw_y - 1;
dest_data += bottom * dest_byte_width + draw_x * 4;
char* src_data = (char*)data_.c_str();
src_data += src_y * src_byte_width + src_x * 4;
for (int i = 0; i < draw_h; ++i)
{
memcpy(dest_data, src_data, paint_byte_width);
dest_data -= dest_byte_width;
src_data += src_byte_width;
}
}
}
//绘制子控件
for( auto it = m_items.begin(); it != m_items.end(); it++ )
{
Control* pControl = *it;
if( !pControl->IsVisible() ) continue;
UiRect controlPos = pControl->GetPos();
if( !::IntersectRect( &m_rcPaint, &rcPaint, &controlPos ) ) continue;
pControl->AlphaPaint( hDC, rcPaint );
}
}
catch (...)
{
throw "CBitmapControl::DoPaint";
}
}
void Container::draw(SpriteBatch* spriteBatch, const Rectangle& clip, bool needsClear, bool cleared, float targetHeight)
{
if (needsClear)
{
GL_ASSERT( glEnable(GL_SCISSOR_TEST) );
GL_ASSERT( glClearColor(0, 0, 0, 0) );
float clearY = targetHeight - _clearBounds.y - _clearBounds.height;
GL_ASSERT( glScissor(_clearBounds.x, clearY,
_clearBounds.width, _clearBounds.height) );
GL_ASSERT( glClear(GL_COLOR_BUFFER_BIT) );
GL_ASSERT( glDisable(GL_SCISSOR_TEST) );
needsClear = false;
cleared = true;
}
else if (!cleared)
{
needsClear = true;
}
spriteBatch->begin();
Control::drawBorder(spriteBatch, clip);
spriteBatch->end();
std::vector<Control*>::const_iterator it;
Rectangle boundsUnion = Rectangle::empty();
for (it = _controls.begin(); it < _controls.end(); it++)
{
Control* control = *it;
GP_ASSERT(control);
if (!needsClear || control->isDirty() || control->_clearBounds.intersects(boundsUnion))
{
control->draw(spriteBatch, _viewportClipBounds, needsClear, cleared, targetHeight);
Rectangle::combine(control->_clearBounds, boundsUnion, &boundsUnion);
}
}
if (_scroll != SCROLL_NONE && (_scrollBarOpacity > 0.0f))
{
// Draw scroll bars.
Rectangle clipRegion(_viewportClipBounds);
spriteBatch->begin();
if (_scrollBarBounds.height > 0)
{
const Rectangle& topRegion = _scrollBarTopCap->getRegion();
const Theme::UVs& topUVs = _scrollBarTopCap->getUVs();
Vector4 topColor = _scrollBarTopCap->getColor();
topColor.w *= _scrollBarOpacity * _opacity;
const Rectangle& verticalRegion = _scrollBarVertical->getRegion();
const Theme::UVs& verticalUVs = _scrollBarVertical->getUVs();
Vector4 verticalColor = _scrollBarVertical->getColor();
verticalColor.w *= _scrollBarOpacity * _opacity;
const Rectangle& bottomRegion = _scrollBarBottomCap->getRegion();
const Theme::UVs& bottomUVs = _scrollBarBottomCap->getUVs();
Vector4 bottomColor = _scrollBarBottomCap->getColor();
bottomColor.w *= _scrollBarOpacity * _opacity;
clipRegion.width += verticalRegion.width;
Rectangle bounds(_viewportBounds.x + _viewportBounds.width - verticalRegion.width,
_viewportBounds.y + _scrollBarBounds.y,
topRegion.width, topRegion.height);
spriteBatch->draw(bounds.x, bounds.y, bounds.width, bounds.height, topUVs.u1, topUVs.v1, topUVs.u2, topUVs.v2, topColor, clipRegion);
bounds.y += topRegion.height;
bounds.height = _scrollBarBounds.height - topRegion.height - bottomRegion.height;
spriteBatch->draw(bounds.x, bounds.y, bounds.width, bounds.height, verticalUVs.u1, verticalUVs.v1, verticalUVs.u2, verticalUVs.v2, verticalColor, clipRegion);
bounds.y += bounds.height;
bounds.height = bottomRegion.height;
spriteBatch->draw(bounds.x, bounds.y, bounds.width, bounds.height, bottomUVs.u1, bottomUVs.v1, bottomUVs.u2, bottomUVs.v2, bottomColor, clipRegion);
}
if (_scrollBarBounds.width > 0)
{
const Rectangle& leftRegion = _scrollBarLeftCap->getRegion();
const Theme::UVs& leftUVs = _scrollBarLeftCap->getUVs();
Vector4 leftColor = _scrollBarLeftCap->getColor();
leftColor.w *= _scrollBarOpacity * _opacity;
const Rectangle& horizontalRegion = _scrollBarHorizontal->getRegion();
const Theme::UVs& horizontalUVs = _scrollBarHorizontal->getUVs();
Vector4 horizontalColor = _scrollBarHorizontal->getColor();
horizontalColor.w *= _scrollBarOpacity * _opacity;
const Rectangle& rightRegion = _scrollBarRightCap->getRegion();
const Theme::UVs& rightUVs = _scrollBarRightCap->getUVs();
Vector4 rightColor = _scrollBarRightCap->getColor();
rightColor.w *= _scrollBarOpacity * _opacity;
clipRegion.height += horizontalRegion.height;
Rectangle bounds(_viewportBounds.x + _scrollBarBounds.x,
_viewportBounds.y + _viewportBounds.height - horizontalRegion.height,
leftRegion.width, leftRegion.height);
spriteBatch->draw(bounds.x, bounds.y, bounds.width, bounds.height, leftUVs.u1, leftUVs.v1, leftUVs.u2, leftUVs.v2, leftColor, clipRegion);
bounds.x += leftRegion.width;
bounds.width = _scrollBarBounds.width - leftRegion.width - rightRegion.width;
spriteBatch->draw(bounds.x, bounds.y, bounds.width, bounds.height, horizontalUVs.u1, horizontalUVs.v1, horizontalUVs.u2, horizontalUVs.v2, horizontalColor, clipRegion);
bounds.x += bounds.width;
bounds.width = rightRegion.width;
spriteBatch->draw(bounds.x, bounds.y, bounds.width, bounds.height, rightUVs.u1, rightUVs.v1, rightUVs.u2, rightUVs.v2, rightColor, clipRegion);
}
spriteBatch->end();
if (_scrollingVelocity.isZero())
{
_dirty = false;
}
}
else
{
_dirty = false;
}
}
void HouseRenderer::initialize() {
houseRendererForm = Form::create("res/menu/houseRenderer.form");
Control* mainMenuButton = houseRendererForm->getControl("mainMenuButton");
mainMenuButton->addListener(this, Control::Listener::CLICK);
Control* refreshButton = houseRendererForm->getControl("refreshButton");
refreshButton->addListener(this, Control::Listener::CLICK);
Control* clearButton = houseRendererForm->getControl("clearButton");
clearButton->addListener(this, Control::Listener::CLICK);
Control* floorUpButton = houseRendererForm->getControl("floorUpButton");
floorUpButton->addListener(this, Control::Listener::CLICK);
Control* floorDownButton = houseRendererForm->getControl("floorDownButton");
floorDownButton->addListener(this, Control::Listener::CLICK);
Control* roomTypesWheel = houseRendererForm->getControl("roomTypesWheel");
roomTypesWheel->addListener(this, Control::Listener::CLICK);
scene = Scene::create("HouseScene");
zoomLevel = 1;
curTranslate = new Vector3();
Camera* camera = Camera::createOrthographic(0, 0, 0, 0.25, 600);
Node* cameraNode = scene->addNode();
cameraNode->setCamera(camera);
scene->setActiveCamera(camera);
cameraNode->translateForward(-100);
SAFE_RELEASE(camera);
cameraNode->rotateZ(MATH_PI / 4);
cameraNode->rotateX(MATH_PI / 4);
resize();
createHouse(false, true);
}
bool Container::touchEvent(Touch::TouchEvent evt, int x, int y, unsigned int contactIndex)
{
if (!isEnabled())
{
return false;
}
bool eventConsumed = false;
const Theme::Border& border = getBorder(_state);
const Theme::Padding& padding = getPadding();
float xPos = border.left + padding.left;
float yPos = border.top + padding.top;
Vector2* offset = NULL;
if (_scroll != SCROLL_NONE)
{
offset = &_scrollPosition;
}
std::vector<Control*>::const_iterator it;
for (it = _controls.begin(); it < _controls.end(); it++)
{
Control* control = *it;
GP_ASSERT(control);
if (!control->isEnabled())
{
continue;
}
const Rectangle& bounds = control->getBounds();
float boundsX = bounds.x;
float boundsY = bounds.y;
if (offset)
{
boundsX += offset->x;
boundsY += offset->y;
}
if (control->getState() != Control::NORMAL ||
(evt == Touch::TOUCH_PRESS &&
x >= xPos + boundsX &&
x <= xPos + boundsX + bounds.width &&
y >= yPos + boundsY &&
y <= yPos + boundsY + bounds.height))
{
// Pass on the event's clip relative to the control.
eventConsumed |= control->touchEvent(evt, x - xPos - boundsX, y - yPos - boundsY, contactIndex);
}
}
if (!isEnabled())
{
return (_consumeTouchEvents | eventConsumed);
}
switch (evt)
{
case Touch::TOUCH_PRESS:
setState(Control::FOCUS);
break;
case Touch::TOUCH_RELEASE:
setState(Control::NORMAL);
break;
}
if (!eventConsumed && _scroll != SCROLL_NONE)
{
if (touchEventScroll(evt, x - xPos, y - yPos, contactIndex))
{
_dirty = true;
}
}
return (_consumeTouchEvents | eventConsumed);
}
void
MapNodeHelper::parse(MapNode* mapNode,
osg::ArgumentParser& args,
osgViewer::View* view,
osg::Group* root,
Container* userContainer ) const
{
if ( !root )
root = mapNode;
// options to use for the load
osg::ref_ptr<osgDB::Options> dbOptions = Registry::instance()->cloneOrCreateOptions();
// parse out custom example arguments first:
bool useSky = args.read("--sky");
bool useOcean = args.read("--ocean");
bool useMGRS = args.read("--mgrs");
bool useDMS = args.read("--dms");
bool useDD = args.read("--dd");
bool useCoords = args.read("--coords") || useMGRS || useDMS || useDD;
bool useOrtho = args.read("--ortho");
bool useAutoClip = args.read("--autoclip");
bool useShadows = args.read("--shadows");
bool animateSky = args.read("--animate-sky");
bool showActivity = args.read("--activity");
bool useLogDepth = args.read("--logdepth");
bool useLogDepth2 = args.read("--logdepth2");
bool kmlUI = args.read("--kmlui");
bool inspect = args.read("--inspect");
if (args.read("--verbose"))
osgEarth::setNotifyLevel(osg::INFO);
if (args.read("--quiet"))
osgEarth::setNotifyLevel(osg::FATAL);
float ambientBrightness = 0.2f;
args.read("--ambientBrightness", ambientBrightness);
std::string kmlFile;
args.read( "--kml", kmlFile );
std::string imageFolder;
args.read( "--images", imageFolder );
std::string imageExtensions;
args.read("--image-extensions", imageExtensions);
// animation path:
std::string animpath;
if ( args.read("--path", animpath) )
{
view->setCameraManipulator( new osgGA::AnimationPathManipulator(animpath) );
}
// Install a new Canvas for our UI controls, or use one that already exists.
ControlCanvas* canvas = ControlCanvas::getOrCreate( view );
Container* mainContainer;
if ( userContainer )
{
mainContainer = userContainer;
}
else
{
mainContainer = new VBox();
mainContainer->setAbsorbEvents( true );
mainContainer->setBackColor( Color(Color::Black, 0.8) );
mainContainer->setHorizAlign( Control::ALIGN_LEFT );
mainContainer->setVertAlign( Control::ALIGN_BOTTOM );
}
canvas->addControl( mainContainer );
// look for external data in the map node:
const Config& externals = mapNode->externalConfig();
const Config& skyConf = externals.child("sky");
const Config& oceanConf = externals.child("ocean");
const Config& annoConf = externals.child("annotations");
const Config& declutterConf = externals.child("decluttering");
// some terrain effects.
// TODO: Most of these are likely to move into extensions.
const Config& lodBlendingConf = externals.child("lod_blending");
const Config& vertScaleConf = externals.child("vertical_scale");
const Config& contourMapConf = externals.child("contour_map");
// Adding a sky model:
if ( useSky || !skyConf.empty() )
{
SkyOptions options(skyConf);
if ( options.getDriver().empty() )
{
if ( mapNode->getMapSRS()->isGeographic() )
options.setDriver("simple");
else
options.setDriver("gl");
}
SkyNode* sky = SkyNode::create(options, mapNode);
if ( sky )
{
sky->attach( view, 0 );
if ( mapNode->getNumParents() > 0 )
{
osgEarth::insertGroup(sky, mapNode->getParent(0));
}
else
{
sky->addChild( mapNode );
root = sky;
}
Control* c = SkyControlFactory().create(sky, view);
if ( c )
mainContainer->addControl( c );
if (animateSky)
{
sky->setUpdateCallback( new AnimateSkyUpdateCallback() );
}
}
}
// Adding an ocean model:
if ( useOcean || !oceanConf.empty() )
{
OceanNode* ocean = OceanNode::create(OceanOptions(oceanConf), mapNode);
if ( ocean )
{
// if there's a sky, we want to ocean under it
osg::Group* parent = osgEarth::findTopMostNodeOfType<SkyNode>(root);
if ( !parent ) parent = root;
parent->addChild( ocean );
Control* c = OceanControlFactory().create(ocean);
if ( c )
mainContainer->addControl(c);
}
}
// Shadowing.
if ( useShadows )
{
ShadowCaster* caster = new ShadowCaster();
caster->setLight( view->getLight() );
caster->getShadowCastingGroup()->addChild( mapNode->getModelLayerGroup() );
if ( mapNode->getNumParents() > 0 )
{
insertGroup(caster, mapNode->getParent(0));
}
else
{
caster->addChild(mapNode);
root = caster;
}
}
// Loading KML from the command line:
if ( !kmlFile.empty() )
{
KMLOptions kml_options;
kml_options.declutter() = true;
// set up a default icon for point placemarks:
IconSymbol* defaultIcon = new IconSymbol();
defaultIcon->url()->setLiteral(KML_PUSHPIN_URL);
kml_options.defaultIconSymbol() = defaultIcon;
osg::Node* kml = KML::load( URI(kmlFile), mapNode, kml_options );
if ( kml )
{
if (kmlUI)
{
Control* c = AnnotationGraphControlFactory().create(kml, view);
if ( c )
{
c->setVertAlign( Control::ALIGN_TOP );
canvas->addControl( c );
}
}
root->addChild( kml );
}
else
{
OE_NOTICE << "Failed to load " << kmlFile << std::endl;
}
}
// Annotations in the map node externals:
if ( !annoConf.empty() )
{
osg::Group* annotations = 0L;
AnnotationRegistry::instance()->create( mapNode, annoConf, dbOptions.get(), annotations );
if ( annotations )
{
mapNode->addChild( annotations );
//root->addChild( annotations );
}
}
// Configure the de-cluttering engine for labels and annotations:
if ( !declutterConf.empty() )
{
Decluttering::setOptions( DeclutteringOptions(declutterConf) );
}
// Configure the mouse coordinate readout:
if ( useCoords )
{
LabelControl* readout = new LabelControl();
readout->setBackColor( Color(Color::Black, 0.8) );
readout->setHorizAlign( Control::ALIGN_RIGHT );
readout->setVertAlign( Control::ALIGN_BOTTOM );
Formatter* formatter =
useMGRS ? (Formatter*)new MGRSFormatter(MGRSFormatter::PRECISION_1M, 0L, MGRSFormatter::USE_SPACES) :
useDMS ? (Formatter*)new LatLongFormatter(LatLongFormatter::FORMAT_DEGREES_MINUTES_SECONDS) :
useDD ? (Formatter*)new LatLongFormatter(LatLongFormatter::FORMAT_DECIMAL_DEGREES) :
0L;
MouseCoordsTool* mcTool = new MouseCoordsTool( mapNode );
mcTool->addCallback( new MouseCoordsLabelCallback(readout, formatter) );
view->addEventHandler( mcTool );
canvas->addControl( readout );
}
// Configure for an ortho camera:
if ( useOrtho )
{
view->getCamera()->setProjectionMatrixAsOrtho(-1, 1, -1, 1, 0, 1);
//EarthManipulator* manip = dynamic_cast<EarthManipulator*>(view->getCameraManipulator());
//if ( manip )
//{
// manip->getSettings()->setCameraProjection( EarthManipulator::PROJ_ORTHOGRAPHIC );
//}
}
// activity monitor (debugging)
if ( showActivity )
{
VBox* vbox = new VBox();
vbox->setBackColor( Color(Color::Black, 0.8) );
vbox->setHorizAlign( Control::ALIGN_RIGHT );
vbox->setVertAlign( Control::ALIGN_BOTTOM );
view->addEventHandler( new ActivityMonitorTool(vbox) );
canvas->addControl( vbox );
}
// Install an auto clip plane clamper
if ( useAutoClip )
{
mapNode->addCullCallback( new AutoClipPlaneCullCallback(mapNode) );
}
// Install logarithmic depth buffer on main camera
if ( useLogDepth )
{
OE_INFO << LC << "Activating logarithmic depth buffer (vertex-only) on main camera" << std::endl;
osgEarth::Util::LogarithmicDepthBuffer logDepth;
logDepth.setUseFragDepth( false );
logDepth.install( view->getCamera() );
}
else if ( useLogDepth2 )
{
OE_INFO << LC << "Activating logarithmic depth buffer (precise) on main camera" << std::endl;
osgEarth::Util::LogarithmicDepthBuffer logDepth;
logDepth.setUseFragDepth( true );
logDepth.install( view->getCamera() );
}
// Scan for images if necessary.
if ( !imageFolder.empty() )
{
std::vector<std::string> extensions;
if ( !imageExtensions.empty() )
StringTokenizer( imageExtensions, extensions, ",;", "", false, true );
if ( extensions.empty() )
extensions.push_back( "tif" );
OE_INFO << LC << "Loading images from " << imageFolder << "..." << std::endl;
ImageLayerVector imageLayers;
DataScanner scanner;
scanner.findImageLayers( imageFolder, extensions, imageLayers );
if ( imageLayers.size() > 0 )
{
mapNode->getMap()->beginUpdate();
for( ImageLayerVector::iterator i = imageLayers.begin(); i != imageLayers.end(); ++i )
{
mapNode->getMap()->addImageLayer( i->get() );
}
mapNode->getMap()->endUpdate();
}
OE_INFO << LC << "...found " << imageLayers.size() << " image layers." << std::endl;
}
// Install elevation morphing
if ( !lodBlendingConf.empty() )
{
mapNode->getTerrainEngine()->addEffect( new LODBlending(lodBlendingConf) );
}
// Install vertical scaler
if ( !vertScaleConf.empty() )
{
mapNode->getTerrainEngine()->addEffect( new VerticalScale(vertScaleConf) );
}
// Install a contour map effect.
if ( !contourMapConf.empty() )
{
mapNode->getTerrainEngine()->addEffect( new ContourMap(contourMapConf) );
}
// Generic named value uniform with min/max.
VBox* uniformBox = 0L;
while( args.find( "--uniform" ) >= 0 )
{
std::string name;
float minval, maxval;
if ( args.read( "--uniform", name, minval, maxval ) )
{
if ( uniformBox == 0L )
{
uniformBox = new VBox();
uniformBox->setBackColor(0,0,0,0.5);
uniformBox->setAbsorbEvents( true );
canvas->addControl( uniformBox );
}
osg::Uniform* uniform = new osg::Uniform(osg::Uniform::FLOAT, name);
uniform->set( minval );
root->getOrCreateStateSet()->addUniform( uniform, osg::StateAttribute::OVERRIDE );
HBox* box = new HBox();
box->addControl( new LabelControl(name) );
HSliderControl* hs = box->addControl( new HSliderControl(minval, maxval, minval, new ApplyValueUniform(uniform)));
hs->setHorizFill(true, 200);
box->addControl( new LabelControl(hs) );
uniformBox->addControl( box );
OE_INFO << LC << "Installed uniform controller for " << name << std::endl;
}
}
if ( inspect )
{
mapNode->addExtension( Extension::create("mapinspector", ConfigOptions()) );
}
// Process extensions.
for(std::vector<osg::ref_ptr<Extension> >::const_iterator eiter = mapNode->getExtensions().begin();
eiter != mapNode->getExtensions().end();
++eiter)
{
Extension* e = eiter->get();
// Check for a View interface:
ExtensionInterface<osg::View>* viewIF = ExtensionInterface<osg::View>::get( e );
if ( viewIF )
viewIF->connect( view );
// Check for a Control interface:
ExtensionInterface<Control>* controlIF = ExtensionInterface<Control>::get( e );
if ( controlIF )
controlIF->connect( mainContainer );
}
root->addChild( canvas );
}
void Container::updateScroll()
{
// Update Time.
static long lastFrameTime = Game::getGameTime();
long frameTime = Game::getGameTime();
long elapsedTime = (frameTime - lastFrameTime);
lastFrameTime = frameTime;
const Theme::Border& containerBorder = getBorder(_state);
const Theme::Padding& containerPadding = getPadding();
// Calculate total width and height.
float totalWidth = 0;
float totalHeight = 0;
std::vector<Control*> controls = getControls();
unsigned int controlsCount = controls.size();
for (unsigned int i = 0; i < controlsCount; i++)
{
Control* control = controls.at(i);
const Rectangle& bounds = control->getBounds();
const Theme::Margin& margin = control->getMargin();
float newWidth = bounds.x + bounds.width;
if (newWidth > totalWidth)
{
totalWidth = newWidth;
}
float newHeight = bounds.y + bounds.height;
if (newHeight > totalHeight)
{
totalHeight = newHeight;
}
}
float vWidth = getImageRegion("verticalScrollBar", _state).width;
float hHeight = getImageRegion("horizontalScrollBar", _state).height;
float clipWidth = _bounds.width - containerBorder.left - containerBorder.right - containerPadding.left - containerPadding.right - vWidth;
float clipHeight = _bounds.height - containerBorder.top - containerBorder.bottom - containerPadding.top - containerPadding.bottom - hHeight;
// Apply and dampen inertia.
if (!_scrolling && !_scrollingVelocity.isZero())
{
// Calculate the time passed since last update.
float elapsedSecs = (float)elapsedTime * 0.001f;
_scrollPosition.x += _scrollingVelocity.x * elapsedSecs;
_scrollPosition.y += _scrollingVelocity.y * elapsedSecs;
float dampening = 1.0f - _scrollingFriction * SCROLL_FRICTION_FACTOR * elapsedSecs;
_scrollingVelocity.x *= dampening;
_scrollingVelocity.y *= dampening;
if (fabs(_scrollingVelocity.x) < 100.0f)
_scrollingVelocity.x = 0.0f;
if (fabs(_scrollingVelocity.y) < 100.0f)
_scrollingVelocity.y = 0.0f;
}
// Stop scrolling when the far edge is reached.
if (-_scrollPosition.x > totalWidth - clipWidth)
{
_scrollPosition.x = -(totalWidth - clipWidth);
_scrollingVelocity.x = 0;
}
if (-_scrollPosition.y > totalHeight - clipHeight)
{
_scrollPosition.y = -(totalHeight - clipHeight);
_scrollingVelocity.y = 0;
}
if (_scrollPosition.x > 0)
{
_scrollPosition.x = 0;
_scrollingVelocity.x = 0;
}
if (_scrollPosition.y > 0)
{
_scrollPosition.y = 0;
_scrollingVelocity.y = 0;
}
float scrollWidth = 0;
if (clipWidth < totalWidth)
scrollWidth = (clipWidth / totalWidth) * clipWidth;
float scrollHeight = 0;
if (clipHeight < totalHeight)
scrollHeight = (clipHeight / totalHeight) * clipHeight;
_scrollBarBounds.set(((-_scrollPosition.x) / totalWidth) * clipWidth,
((-_scrollPosition.y) / totalHeight) * clipHeight,
scrollWidth, scrollHeight);
// If scroll velocity is 0 and scrollbars are not always visible, trigger fade-out animation.
if (!_scrolling && _scrollingVelocity.isZero() && _scrollBarsAutoHide && _scrollBarOpacity == 1.0f)
{
float to = 0;
_scrollBarOpacity = 0.99f;
Animation* animation = createAnimationFromTo("scrollbar-fade-out", ANIMATE_OPACITY, &_scrollBarOpacity, &to, Curve::QUADRATIC_IN_OUT, 500L);
_scrollBarOpacityClip = animation->getClip();
_scrollBarOpacityClip->play();
}
// Position controls within scroll area.
_layout->update(this, _scrollPosition);
}
// mouse Listeners
void InputControlSystem::mouseMoved(const SFO::MouseMotionEvent& evt)
{
if(mActive)
{
if(!mDetectingBindingControl)
{
if(mXmouseAxisBinded && evt.xrel)
{
ControlAxisBinderItem mouseBinderItem = mControlsMouseAxisBinderMap[ /*NamedAxis::*/X ];
Control* ctrl = mouseBinderItem.control;
ctrl->setIgnoreAutoReverse(true);
if(mouseBinderItem.direction == Control::INCREASE)
{
ctrl->setValue( float( (evt.x) / float(mClientWidth) ) );
}
else if(mouseBinderItem.direction == Control::DECREASE)
{
ctrl->setValue( 1 - float( evt.x / float(mClientWidth) ) );
}
}
if(mYmouseAxisBinded && evt.yrel)
{
ControlAxisBinderItem mouseBinderItem = mControlsMouseAxisBinderMap[ /*NamedAxis::*/Y ];
Control* ctrl = mouseBinderItem.control;
ctrl->setIgnoreAutoReverse(true);
if(mouseBinderItem.direction == Control::INCREASE)
{
ctrl->setValue( float( (evt.y) / float(mClientHeight) ) );
}
else if(mouseBinderItem.direction == Control::DECREASE)
{
ctrl->setValue( 1 - float( evt.y / float(mClientHeight) ) );
}
}
//! @todo Whats the range of the Z axis?
/*if(evt.state.Z.rel)
{
ControlAxisBinderItem mouseBinderItem = mControlsAxisBinderMap[ NamedAxis::Z ];
Control* ctrl = mouseBinderItem.control;
ctrl->setIgnoreAutoReverse(true);
if(mouseBinderItem.direction == Control::INCREASE)
{
ctrl->setValue( float( (evt.state.Z.abs) / float(evt.state.¿width?) ) );
}
else if(mouseBinderItem.direction == Control::DECREASE)
{
ctrl->setValue( float( (1 - evt.state.Z.abs) / float(evt.state.¿width?) ) );
}
}*/
}
else if(mDetectingBindingListener)
{
if(mDetectingBindingControl->isAxisBindable())
{
if(mMouseAxisBindingInitialValues[0] == ICS_MOUSE_AXIS_BINDING_NULL_VALUE)
{
mMouseAxisBindingInitialValues[0] = 0;
mMouseAxisBindingInitialValues[1] = 0;
mMouseAxisBindingInitialValues[2] = 0;
}
mMouseAxisBindingInitialValues[0] += evt.xrel;
mMouseAxisBindingInitialValues[1] += evt.yrel;
mMouseAxisBindingInitialValues[2] += evt.zrel;
if( abs(mMouseAxisBindingInitialValues[0]) > ICS_MOUSE_BINDING_MARGIN )
{
mDetectingBindingListener->mouseAxisBindingDetected(this,
mDetectingBindingControl, X, mDetectingBindingDirection);
}
else if( abs(mMouseAxisBindingInitialValues[1]) > ICS_MOUSE_BINDING_MARGIN )
{
mDetectingBindingListener->mouseAxisBindingDetected(this,
mDetectingBindingControl, Y, mDetectingBindingDirection);
}
else if( abs(mMouseAxisBindingInitialValues[2]) > ICS_MOUSE_BINDING_MARGIN )
{
mDetectingBindingListener->mouseAxisBindingDetected(this,
mDetectingBindingControl, Z, mDetectingBindingDirection);
}
}
}
}
}
void Container::addControls(Theme* theme, Properties* properties)
{
GP_ASSERT(theme);
GP_ASSERT(properties);
// Add all the controls to this container.
Properties* controlSpace = properties->getNextNamespace();
while (controlSpace != NULL)
{
Control* control = NULL;
const char* controlStyleName = controlSpace->getString("style");
Theme::Style* controlStyle = NULL;
if (controlStyleName)
{
controlStyle = theme->getStyle(controlStyleName);
}
else
{
Theme::Style::Overlay* overlay = Theme::Style::Overlay::create();
controlStyle = new Theme::Style(theme, "", 1.0f / theme->_texture->getWidth(), 1.0f / theme->_texture->getHeight(),
Theme::Margin::empty(), Theme::Border::empty(), overlay, overlay, overlay, overlay);
}
std::string controlName(controlSpace->getNamespace());
std::transform(controlName.begin(), controlName.end(), controlName.begin(), (int(*)(int))toupper);
if (controlName == "LABEL")
{
control = Label::create(controlStyle, controlSpace);
}
else if (controlName == "BUTTON")
{
control = Button::create(controlStyle, controlSpace);
}
else if (controlName == "CHECKBOX")
{
control = CheckBox::create(controlStyle, controlSpace);
}
else if (controlName == "RADIOBUTTON")
{
control = RadioButton::create(controlStyle, controlSpace);
}
else if (controlName == "CONTAINER")
{
control = Container::create(controlStyle, controlSpace, theme);
}
else if (controlName == "SLIDER")
{
control = Slider::create(controlStyle, controlSpace);
}
else if (controlName == "TEXTBOX")
{
control = TextBox::create(controlStyle, controlSpace);
}
else if (controlName == "JOYSTICK")
{
control = Joystick::create(controlStyle, controlSpace);
}
else
{
GP_ERROR("Failed to create control; unrecognized control name '%s'.", controlName.c_str());
}
// Add the new control to the form.
if (control)
{
addControl(control);
if (control->getZIndex() == -1)
{
control->setZIndex(_zIndexDefault++);
}
}
// Get the next control.
controlSpace = properties->getNextNamespace();
}
// Sort controls by Z-Order.
std::sort(_controls.begin(), _controls.end(), &sortControlsByZOrder);
}
void ScrollContainer::_notification(int p_what) {
if (p_what == NOTIFICATION_ENTER_TREE || p_what == NOTIFICATION_THEME_CHANGED) {
call_deferred("_update_scrollbar_pos");
};
if (p_what == NOTIFICATION_SORT_CHILDREN) {
child_max_size = Size2(0, 0);
Size2 size = get_size();
if (h_scroll->is_visible_in_tree())
size.y -= h_scroll->get_minimum_size().y;
if (v_scroll->is_visible_in_tree())
size.x -= h_scroll->get_minimum_size().x;
for (int i = 0; i < get_child_count(); i++) {
Control *c = get_child(i)->cast_to<Control>();
if (!c)
continue;
if (c->is_set_as_toplevel())
continue;
if (c == h_scroll || c == v_scroll)
continue;
Size2 minsize = c->get_combined_minimum_size();
child_max_size.x = MAX(child_max_size.x, minsize.x);
child_max_size.y = MAX(child_max_size.y, minsize.y);
Rect2 r = Rect2(-scroll, minsize);
if (!scroll_h || (!h_scroll->is_visible_in_tree() && c->get_h_size_flags() & SIZE_EXPAND)) {
r.position.x = 0;
if (c->get_h_size_flags() & SIZE_EXPAND)
r.size.width = MAX(size.width, minsize.width);
else
r.size.width = minsize.width;
}
if (!scroll_v || (!v_scroll->is_visible_in_tree() && c->get_v_size_flags() & SIZE_EXPAND)) {
r.position.y = 0;
r.size.height = size.height;
if (c->get_v_size_flags() & SIZE_EXPAND)
r.size.height = MAX(size.height, minsize.height);
else
r.size.height = minsize.height;
}
fit_child_in_rect(c, r);
}
update();
};
if (p_what == NOTIFICATION_DRAW) {
update_scrollbars();
}
if (p_what == NOTIFICATION_FIXED_PROCESS) {
if (drag_touching) {
if (drag_touching_deaccel) {
Vector2 pos = Vector2(h_scroll->get_value(), v_scroll->get_value());
pos += drag_speed * get_fixed_process_delta_time();
bool turnoff_h = false;
bool turnoff_v = false;
if (pos.x < 0) {
pos.x = 0;
turnoff_h = true;
}
if (pos.x > (h_scroll->get_max() - h_scroll->get_page())) {
pos.x = h_scroll->get_max() - h_scroll->get_page();
turnoff_h = true;
}
if (pos.y < 0) {
pos.y = 0;
turnoff_v = true;
}
if (pos.y > (v_scroll->get_max() - v_scroll->get_page())) {
pos.y = v_scroll->get_max() - v_scroll->get_page();
turnoff_v = true;
}
if (scroll_h)
h_scroll->set_value(pos.x);
if (scroll_v)
v_scroll->set_value(pos.y);
float sgn_x = drag_speed.x < 0 ? -1 : 1;
float val_x = Math::abs(drag_speed.x);
val_x -= 1000 * get_fixed_process_delta_time();
if (val_x < 0) {
turnoff_h = true;
}
float sgn_y = drag_speed.y < 0 ? -1 : 1;
float val_y = Math::abs(drag_speed.y);
val_y -= 1000 * get_fixed_process_delta_time();
if (val_y < 0) {
turnoff_v = true;
}
drag_speed = Vector2(sgn_x * val_x, sgn_y * val_y);
if (turnoff_h && turnoff_v) {
set_fixed_process(false);
drag_touching = false;
drag_touching_deaccel = false;
}
} else {
if (time_since_motion == 0 || time_since_motion > 0.1) {
Vector2 diff = drag_accum - last_drag_accum;
last_drag_accum = drag_accum;
drag_speed = diff / get_fixed_process_delta_time();
}
time_since_motion += get_fixed_process_delta_time();
}
}
}
};
//
// NOTE: run this sample from the repo/tests directory.
//
int main(int argc, char** argv)
{
osg::ArgumentParser arguments(&argc,argv);
osgViewer::Viewer viewer(arguments);
s_viewer = &viewer;
// Start by creating the map:
s_mapNode = MapNode::load(arguments);
if ( !s_mapNode )
{
Map* map = new Map();
// Start with a basemap imagery layer; we'll be using the GDAL driver
// to load a local GeoTIFF file:
GDALOptions basemapOpt;
basemapOpt.url() = "../data/world.tif";
map->addImageLayer( new ImageLayer( ImageLayerOptions("basemap", basemapOpt) ) );
// That's it, the map is ready; now create a MapNode to render the Map:
MapNodeOptions mapNodeOptions;
mapNodeOptions.enableLighting() = false;
s_mapNode = new MapNode( map, mapNodeOptions );
}
s_mapNode->setNodeMask( 0x01 );
// Define a style for the feature data.
Style style = buildStyle( Color::Yellow, 2.0f );
//LineString* line = new LineString();
Geometry* geom = GeometryUtils::geometryFromWKT("POLYGON((191.026667 87.63333,114.75 78,89.5 77.333336,81.833336 75.333336,70.683334 74.5,70.916664 73.666664,68.666664 73.666664,66.291664 71.505,57.65 71.166664,58 73.9,48.616665 73,49.198334 71.43,49.5 70.5,43.266666 68.666664,32.083332 71.5,32.083332 74,35 74,35 81,32 81,32 90,191.026667 87.63333))");
OE_NOTICE << "Geometry " << GeometryUtils::geometryToWKT(geom) << std::endl;
Feature* feature = new Feature(geom, s_mapNode->getMapSRS(), Style(), s_fid++);
s_featureNode = new FeatureNode( s_mapNode, feature );
s_featureNode->setStyle( style );
s_editorsRoot = new osg::Group;
s_root = new osg::Group;
s_root->addChild( s_mapNode.get() );
s_root->addChild( s_featureNode.get() );
s_root->addChild( s_editorsRoot.get() );
//Setup the controls
ControlCanvas* canvas = ControlCanvas::getOrCreate( &viewer );
s_root->addChild( canvas );
Grid *toolbar = createToolBar( );
canvas->addControl( toolbar );
canvas->setNodeMask( 0x1 << 1 );
int col = 0;
LabelControl* addVerts = new LabelControl("Add Verts");
toolbar->setControl(col++, 0, addVerts );
addVerts->addEventHandler( new AddVertsModeHandler());
LabelControl* edit = new LabelControl("Edit");
toolbar->setControl(col++, 0, edit );
edit->addEventHandler(new EditModeHandler());
unsigned int row = 0;
Grid *styleBar = createToolBar( );
styleBar->setPosition(0, 50);
canvas->addControl( styleBar );
//Make a list of styles
styleBar->setControl(0, row++, new LabelControl("Styles") );
unsigned int numStyles = 8;
for (unsigned int i = 0; i < numStyles; ++i)
{
float w = 50;
osg::Vec4 color = randomColor();
float widths[3] = {2, 4, 8};
unsigned int r = row++;
for (unsigned int j = 0; j < 3; j++)
{
Control* l = new Control();
l->setBackColor( color );
l->addEventHandler(new ChangeStyleHandler(buildStyle( color, widths[j] ) ));
l->setSize(w,5 * widths[j]);
styleBar->setControl(j, r, l);
}
}
viewer.setSceneData( s_root.get() );
viewer.setCameraManipulator( new EarthManipulator() );
if ( s_mapNode )
viewer.getCamera()->addCullCallback( new osgEarth::Util::AutoClipPlaneCullCallback(s_mapNode) );
// add some stock OSG handlers:
viewer.addEventHandler(new osgViewer::StatsHandler());
viewer.addEventHandler(new osgViewer::WindowSizeHandler());
viewer.addEventHandler(new osgGA::StateSetManipulator(viewer.getCamera()->getOrCreateStateSet()));
return viewer.run();
}
void MirrorMod::Rotate(TimeValue t, Matrix3& partm, Matrix3& tmAxis, Quat& val, BOOL localOrigin)
{
SetXFormPacket pckt(val,localOrigin,partm,tmAxis);
tmControl->SetValue(t,&pckt,TRUE,CTRL_RELATIVE);
}
void myMouseCB(int button, int state, int x, int y)
{
control.mouseCB(button,state,x,y);
}
