void BundlePane::OnTreeItemSelected(wxTreeEvent& event) {
const wxTreeItemId selItem = event.GetItem();
const BundleItemData* data = (BundleItemData*)m_bundleTree->GetItemData(selItem);
// The menu root cannot be removed
if (data->m_type == BUNDLE_MENU) m_bundleMinus->Disable();
else m_bundleMinus->Enable();
}
void
mi_frame::on_right_click(wxTreeEvent &event) {
wxTreeItemId item = event.GetItem();
if (tree->GetChildrenCount(item) == 0)
return;
expand_all_elements(item, !tree->IsExpanded(item));
}
//------------------------------------------------------------------------------
void OutputTree::OnItemActivated(wxTreeEvent &event)
{
// get some info about this item
wxTreeItemId itemId = event.GetItem();
GmatTreeItemData *item = (GmatTreeItemData *)GetItemData(itemId);
item->SetTitle(GetItemText(itemId));
GmatAppData::Instance()->GetMainFrame()->CreateChild(item);
}
///////////////////////////////////////////////////////////////////////////////
// Called when the user begins to drag an item in the tree control. Determines
// if the item is allowed to be dragged, and kicks off the drag-and-drop event
// if it is allowed.
//
void HierarchyOutliner::OnBeginDrag( wxTreeEvent& args )
{
// You can only drag something if...
// 1. The drag event contains a valid item to originate the drag
// 2. The item that the drag originates on is selected
// 3. There is something in the scene's selected item list (which had better be the
// case if item 2 above was true.
// 4. You cannot drag the root item
if ( ( args.GetItem().IsOk() )&&
( m_TreeCtrl->IsSelected( args.GetItem() ) ) &&
( m_CurrentScene->GetSelection().GetItems().Size() > 0 ) &&
( args.GetItem() != m_TreeCtrl->GetRootItem() ) )
{
args.Allow();
}
// else: automatically veto'd (you have to specifically allow a drag operation)
}
void CRemoteTreeView::OnItemExpanding(wxTreeEvent& event)
{
if (m_busy)
return;
wxTreeItemId item = event.GetItem();
if (!item)
return;
if (!ListExpand(item))
{
event.Veto();
return;
}
Refresh(false);
}
void MyTreeCtrl::OnBeginDrag(wxTreeEvent& event)
{
// need to explicitly allow drag
if ( event.GetItem() != GetRootItem() )
{
m_draggedItem = event.GetItem();
wxLogMessage(wxT("OnBeginDrag: started dragging %s"),
GetItemText(m_draggedItem).c_str());
event.Allow();
}
else
{
wxLogMessage(wxT("OnBeginDrag: this item can't be dragged."));
}
}
void ModelListTree::OnBeginDrag(wxTreeEvent& event)
{
ModelTreeItemData* itemData = (ModelTreeItemData*)GetItemData(event.GetItem());
Model* model = itemData->GetModel();
//event.Allow();
}
void CSettingsDialog::OnPageChanging(wxTreeEvent& event)
{
if (!m_activePanel)
return;
if (!m_activePanel->Validate())
event.Veto();
}
//----------------------------------------------------------------------------
void ProjTree::OnItemActivated(wxTreeEvent& event)
{
wxTreeItemId id = event.GetItem();
bool isExpanded = IsExpanded(id);
if (isExpanded) Collapse(id);
else Expand(id);
}
///////////////////////////////////////////////////////////////////////////////
// GUI callback for when a label is done being edited by the user. Creates a
// command to change the name of the dependency node associated with the item.
//
void SceneOutliner::OnEndLabelEdit( wxTreeEvent& args )
{
if ( !args.IsEditCancelled() )
{
SceneOutlinerItemData* data = GetTreeItemData( args.GetItem() );
Reflect::Object* object = data->GetObject();
SceneGraph::SceneNode* node = Reflect::SafeCast< SceneGraph::SceneNode >( object );
if ( node )
{
const tstring newName = args.GetLabel().c_str();
if ( node->GetName() != newName )
{
// Create an undoable command to rename the object
m_CurrentScene->Push( new PropertyUndoCommand<tstring>( new Helium::MemberProperty<SceneGraph::SceneNode, tstring> (node, &SceneGraph::SceneNode::GetName, &SceneGraph::SceneNode::SetGivenName), newName) );
m_CurrentScene->Execute( false );
// Sort
Sort( m_TreeCtrl->GetItemParent( args.GetItem() ) );
// Keep the item in view
if ( !m_TreeCtrl->IsVisible( args.GetItem() ) )
{
m_TreeCtrl->EnsureVisible( args.GetItem() );
}
}
args.Veto();
OnSelectionChanged( (wxTreeEvent)NULL );
}
}
}
void DatabaseView::UponTreeSelectionChange(wxTreeEvent& event)
{
wxTreeCtrl& tree_ctrl = tree();
MultiDimGrid& grid_ctrl = grid();
// save the current selection
wxTreeItemId const old_item = event.GetOldItem();
if(old_item.IsOk())
{
database_tree_item_data* old_item_data =
dynamic_cast<database_tree_item_data*>
(tree_ctrl.GetItemData(old_item)
);
if(old_item_data)
{
old_item_data->set_axes_selected(grid_ctrl.GetGridAxisSelection());
}
}
database_tree_item_data* item_data =
dynamic_cast<database_tree_item_data*>
(tree_ctrl.GetItemData(event.GetItem())
);
if(!item_data)
{
return;
}
table_adapter().SetTDBValue
(&document().GetTDBValue(item_data->db_name().Idx)
);
bool is_topic = tree_ctrl.GetChildrenCount(event.GetItem());
set_grid_label_text(item_data->db_name().LongName);
wxSizer* sizer = grid_ctrl.GetContainingSizer();
LMI_ASSERT(sizer);
sizer->Show(&grid_ctrl, !is_topic);
sizer->Layout();
// restore axis selection if any
grid_ctrl.SetGridAxisSelection(item_data->get_axes_selected());
grid_ctrl.RefreshTableFull();
}
void
AnimationSelector::OnAnimationListSelChanged(wxTreeEvent& e)
{
// reset the state
resetState();
wxTreeItemId item = e.GetItem();
wxASSERT(item.IsOk());
wxTreeCtrl* tree = wxStaticCast(e.GetEventObject(), wxTreeCtrl);
mActivedItem = e.GetItem();
wxArrayTreeItemIds selections;
int nCount = tree->GetSelections(selections);
if(nCount <= 0)
return;
if (mIsMeshAnim)
{
GetDataManipulator()->changeMeshAnimation(DoActiveItem(item));
return;
}
GetDataManipulator()->changeAnimation(DoActiveItem(item),0.0);
Fairy::LogicModel* pObjModel = GetDataManipulator()->m_pObjTemplate;
if ( pObjModel && !pObjModel->getCurrentAnimName().empty())
{
m_btnPause->Enable(true);
pObjModel->setAnimEditing(m_bPause);
Ogre::String animationName = pObjModel->getCurrentAnimName();
bool bLoop = pObjModel->getAnimationLoop();
Ogre::Real timeTotal = pObjModel->getAnimationLength(animationName);
m_endTimeText->SetValue(Ogre::StringConverter::toString(timeTotal));
m_endFrameText->SetValue(Ogre::StringConverter::toString(timeTotal*STATIC_FPS));
}
}
void wxSTEditorTreeCtrl::OnTreeCtrl(wxTreeEvent &event)
{
wxTreeItemId id = event.GetItem();
if (!id || (m_steNotebook == NULL))
return;
wxSTETreeItemData* data = (wxSTETreeItemData*)GetItemData(id);
if (event.GetEventType() == wxEVT_COMMAND_TREE_ITEM_ACTIVATED)
{
if (data && (data->m_page_num >= 0) && (data->m_page_num < (int)m_steNotebook->GetPageCount()))
m_steNotebook->SetSelection(data->m_page_num);
else
event.Skip();
}
else if (event.GetEventType() == wxEVT_COMMAND_TREE_ITEM_GETTOOLTIP)
{
if (data)
event.SetToolTip(data->m_fileName.GetFullPath());
}
else if (event.GetEventType() == wxEVT_COMMAND_TREE_ITEM_MENU)
{
if (data)
PopupMenu(m_popupMenu, event.GetPoint());
}
}
void CollectionsPanel::OnMyCollectionsMenu( wxTreeEvent& event )
{
SortTreeCtrl* treeCtrl = m_MyCollectionsTreeCtrl;
wxTreeItemId item = event.GetItem();
if ( !item )
{
return;
}
wxTreeItemId rootID = treeCtrl->GetRootItem();
if( item != rootID )
{
treeCtrl->SelectItem( item );
AssetCollectionItemData* baseData = GetItemData( treeCtrl, item );
if ( !baseData )
{
return;
}
AssetCollection* collection = baseData->GetCollection<AssetCollection>();
if ( collection )
{
std::set< Helium::Path > paths;
m_VaultFrame->GetSelectedPaths( paths );
wxMenu menu;
menu.Append( ID_ShowCollection, VaultMenu::Label( ID_ShowCollection ), VaultMenu::Label( ID_ShowCollection ), wxITEM_NORMAL );
menu.AppendSeparator();
menu.Append( ID_AddToCollection, VaultMenu::Label( ID_AddToCollection ), VaultMenu::Label( ID_AddToCollection ), wxITEM_NORMAL );
menu.Append( ID_RemoveFromCollection, VaultMenu::Label( ID_RemoveFromCollection ), VaultMenu::Label( ID_RemoveFromCollection ), wxITEM_NORMAL );
menu.AppendSeparator();
menu.Append( ID_ImportIntoCollection, VaultMenu::Label( ID_ImportIntoCollection ), VaultMenu::Label( ID_ImportIntoCollection ), wxITEM_NORMAL );
menu.Append( ID_SaveCollection, VaultMenu::Label( ID_SaveCollection ), VaultMenu::Label( ID_SaveCollection ), wxITEM_NORMAL );
menu.AppendSeparator();
menu.Append( ID_RenameCollection, VaultMenu::Label( ID_RenameCollection ), VaultMenu::Label( ID_RenameCollection ), wxITEM_NORMAL );
//menu.Append( ID_CloseCollection, VaultMenu::Label( ID_CloseCollection ), VaultMenu::Label( ID_CloseCollection ), wxITEM_NORMAL );
menu.Append( ID_DeleteCollection, VaultMenu::Label( ID_DeleteCollection ), VaultMenu::Label( ID_DeleteCollection ), wxITEM_NORMAL );
menu.Enable( ID_AddToCollection, !collection->IsDynamic() && !paths.empty() );
menu.Enable( ID_RemoveFromCollection, !collection->IsDynamic() && !paths.empty() );
menu.Enable( ID_ImportIntoCollection, !collection->IsDynamic() );
menu.Enable( ID_SaveCollection, true );
menu.Enable( ID_RenameCollection, collection->CanRename() );
//menu.Enable( ID_CloseCollection, !collection->IsTemporary() );
menu.Enable( ID_DeleteCollection, !collection->IsTemporary() );
// Show the menu
PopupMenu( &menu );
}
}
}
void ChooseObjectDialog::OnObjetsListSelectionChanged(wxTreeEvent& event)
{
item = event.GetItem();
gd::TreeItemStringData * data = dynamic_cast<gd::TreeItemStringData*>(objectsList->GetItemData(item));
if(!data)
ChoisirBt->Disable();
else
ChoisirBt->Enable();
}
void MainWindow::directory_ctrlOnTreeItemMenu( wxTreeEvent& event )
{
wxPoint pt = event.GetPoint();
wxMenu menu(wxEmptyString);
menu.Append(FDBex_ExtractFolder, _("Extract folder to..."));
PopupMenu(&menu, pt);
}
void ModelListTree::OnItemSelected(wxTreeEvent& event)
{
ModelTreeItemData* itemData = (ModelTreeItemData*)GetItemData(event.GetItem());
Model* model = itemData->GetModel();
mInspectorPanel->AttachModel(model);
mInspectorPanel->GetModelPreviewCanvas()->SetPreviewModel(model);
mInspectorPanel->GetModelPreviewCanvas()->AddjustCameraPos();
}
//------------------------------------------------------------------------------
void OutputTree::OnEndLabelEdit(wxTreeEvent &event)
{
wxString newLabel = event.GetLabel();
// check to see if label is a single word
if (newLabel.IsWord())
{
GmatTreeItemData *selItem = (GmatTreeItemData *)
GetItemData(GetSelection());
wxString oldLabel = selItem->GetName();
selItem->SetName(newLabel);
}
else
{
event.Veto();
}
}
void SFTPTreeView::OnItemActivated(wxTreeEvent& event)
{
event.Skip();
MyClientData* cd = GetItemData(event.GetItem());
CHECK_PTR_RET(cd);
if(cd->IsFolder()) {
wxTreeItemId item = event.GetItem();
if(m_treeCtrl->IsExpanded(item)) {
m_treeCtrl->CallAfter(&wxTreeCtrl::Collapse, item);
} else {
m_treeCtrl->CallAfter(&wxTreeCtrl::Expand, item);
}
} else {
DoOpenFile(cd->GetFullPath());
}
}
void CLocalTreeView::OnItemExpanding(wxTreeEvent& event)
{
wxTreeItemId item = event.GetItem();
wxTreeItemIdValue value;
wxTreeItemId child = GetFirstChild(item, value);
if (child && GetItemText(child) == _T(""))
DisplayDir(item, GetDirFromItem(item));
}
////////////////////////////////////////////////////////////////////////////////
// This handler will display a popup menu for the item at the mouse position
////////////////////////////////////////////////////////////////////////////////
void frmMain::OnSelRightClick(wxTreeEvent &event)
{
wxTreeItemId item = event.GetItem();
if (item != browser->GetSelection())
{
browser->SelectItem(item);
// Prevent changes to "currentObject" by "execSelchange" function by another thread.
// Will hold the lock until we do popup on the respective object.
//
s_currentObjectMutex.Lock();
currentObject = browser->GetObject(item);
}
if (currentObject)
doPopup(browser, event.GetPoint(), currentObject);
s_currentObjectMutex.Unlock();
}
void CBookmarksDialog::OnBeginLabelEdit(wxTreeEvent& event)
{
wxTreeItemId item = event.GetItem();
if (item != m_pTree->GetSelection())
{
if (!Verify())
{
event.Veto();
return;
}
}
if (!item || item == m_bookmarks_global || item == m_bookmarks_site)
{
event.Veto();
return;
}
}
void DbViewerPanel::OnItemActivate(wxTreeEvent& event)
{
try {
DbItem* item = (DbItem*) m_treeDatabases->GetItemData(event.GetItem());
if (item) {
wxMouseState cState = ::wxGetMouseState();
wxString pagename;
if (Table* tab = wxDynamicCast(item->GetData(), Table)) {
if( cState.ControlDown() ) {
pagename = CreatePanelName(tab, DbViewerPanel::Erd);
ErdPanel *erdpanel = new ErdPanel(m_pNotebook,tab->GetDbAdapter()->Clone(),m_pConnections, (Table*) tab->Clone() );
AddEditorPage(erdpanel, pagename);
} else {
#if defined (__WXMSW__)
clWindowUpdateLocker locker(m_mgr->GetEditorPaneNotebook());
#endif
pagename = CreatePanelName(tab, DbViewerPanel::Sql);
if(!DoSelectPage(pagename)) {
SQLCommandPanel *sqlpage = new SQLCommandPanel(m_pNotebook,tab->GetDbAdapter()->Clone(),tab->GetParentName(),tab->GetName());
AddEditorPage(sqlpage, pagename);
}
}
}
if (View* pView = wxDynamicCast(item->GetData(), View)) {
pagename = CreatePanelName(pView, DbViewerPanel::Sql);
if(!DoSelectPage(pagename)) {
SQLCommandPanel *sqlpage = new SQLCommandPanel(m_pNotebook,pView->GetDbAdapter()->Clone(),pView->GetParentName(),pView->GetName());
AddEditorPage(sqlpage, pagename);
}
}
if (Database* db = wxDynamicCast(item->GetData(), Database)) {
if( cState.ControlDown() ) {
pagename = CreatePanelName(db, DbViewerPanel::Erd);
ErdPanel *erdpanel = new ErdPanel(m_pNotebook,db->GetDbAdapter()->Clone(),m_pConnections,(Database*)db->Clone());
AddEditorPage(erdpanel, pagename);
} else {
pagename = CreatePanelName(db, DbViewerPanel::Sql);
if(!DoSelectPage(pagename)) {
SQLCommandPanel *sqlpage = new SQLCommandPanel(m_pNotebook,db->GetDbAdapter()->Clone(),db->GetName(),wxT(""));
#ifndef __WXMSW__
sqlpage->Show();
#endif
AddEditorPage(sqlpage, pagename);
}
}
}
}
} catch (DatabaseLayerException &e) {
::wxMessageBox(wxString() << "Error occured while opening SQL panel: " << e.GetErrorMessage(), "Database Explorer", wxOK|wxICON_ERROR|wxCENTER);
}
}
void frmMDFEditor::OnTreectrlSelChanged( wxTreeEvent& event )
{
wxString strPage;
strPage = _( "<html><body><h3>" );
wxTreeItemId itemID = event.GetItem();
//MyTreeItemData *item = itemId.IsOk() ? (MyTreeItemData *)GetItemData(itemId)
// : NULL;
if ( itemID.IsOk() ) {
//strPage += m_mdfTree->GetItemText( itemID );
//strPage += event.GetLabel();
}
else {
strPage += _( "????" );
}
//strPage += _( "</h3></body></html>" );
//m_htmlInfoWnd->SetPage( strPage );
event.Skip();
}
void PanelObjectList::OnKeyDown(wxTreeEvent& event)
{
if( event.GetKeyCode() == WXK_F2 )
{
wxArrayTreeItemIds selecteditems;
unsigned int numselected = (unsigned int)g_pPanelObjectList->m_pTree_Objects->GetSelections( selecteditems );
if( numselected == 1 )
{
wxTreeItemId id = selecteditems[0].GetID();
m_pTree_Objects->EditLabel( id );
}
return;
}
event.Skip();
}
void RheiaPackageManagementDialog::OnPackageListSelection(wxTreeEvent& event)
{
wxTreeItemId item = event.GetItem();
RheiaPackageTreeItemData* data = (RheiaPackageTreeItemData*) m_treelist->GetItemData(item);
event.Skip();
if( data == 0L )
return;
RheiaPackageInfo* info = data->GetInfo();
if( info == 0L )
return;
DoUpdatePackageInfoFor( info );
}
// unfortunately, under GTK we won't get the original wxKeyEvent
// to reset m_metaDown
void frmMain::OnTreeKeyDown(wxTreeEvent& event)
{
switch (event.GetKeyCode())
{
case WXK_F1:
OnHelp(event);
break;
case WXK_F5:
Refresh(currentObject);
break;
case WXK_DELETE:
OnDelete(event);
break;
default:
event.Skip();
break;
}
}
void SkillObjectTree::OnBeginLabelEdit(wxTreeEvent& event)
{
wxLogMessage(wxT("OnBeginLabelEdit"));
// for testing, prevent this item's label editing
wxTreeItemId itemId = event.GetItem();
if ( IsTestItem(itemId) )
{
wxMessageBox(wxT("You can't edit this item."));
event.Veto();
}
else if ( itemId == GetRootItem() )
{
// test that it is possible to change the text of the item being edited
SetItemText(itemId, _T("Editing root item"));
}
}
/***********权限树控件勾选状态改变*****************/
void New_PowerMangerFrame::OnTreeCtrl_PowerStatusChange(wxTreeEvent& event)
{
TREEDATA* node = ((MyTreeData *)TreeCtrl_powerManager->GetItemData(event.GetItem()))->GetData();
if(TreeCtrl_powerManager->GetItemState(event.GetItem()) == 0){
if(((LIMIT*)(node->data))->type == 1){ //选中的这个节点位权限组节点，旗下所有子节点相应改变状态
TreeCtrl_powerManager->SetItemState(node->ID,1);
wxTreeItemIdValue cookie;
wxTreeItemId itemID = TreeCtrl_powerManager->GetFirstChild(node->ID,cookie);
if(itemID.IsOk())
TreeCtrl_powerManager->SetItemState(itemID,1);
while(1){
itemID = TreeCtrl_powerManager->GetNextChild(node->ID,cookie);
if(itemID.IsOk())
TreeCtrl_powerManager->SetItemState(itemID,1);
else
break;
}
}
else{ //如果选取的是项目子节点，则改变子节点勾选状态，如果子节点的父节点位勾选状态，取消勾选
TreeCtrl_powerManager->SetItemState(event.GetItem(),1);
wxTreeItemId itemID = TreeCtrl_powerManager->GetItemParent(event.GetItem());
TreeCtrl_powerManager->SetItemState(itemID,1);
}
}
else{
if(((LIMIT*)(node->data))->type == 1){ //选中的这个节点位权限组节点，旗下所有子节点相应改变状态
TreeCtrl_powerManager->SetItemState(node->ID,0);
wxTreeItemIdValue cookie;
wxTreeItemId itemID = TreeCtrl_powerManager->GetFirstChild(node->ID,cookie);
if(itemID.IsOk())
TreeCtrl_powerManager->SetItemState(itemID,0);
while(1){
itemID = TreeCtrl_powerManager->GetNextChild(node->ID,cookie);
if(itemID.IsOk())
TreeCtrl_powerManager->SetItemState(itemID,0);
else
break;
}
}
else{
TreeCtrl_powerManager->SetItemState(event.GetItem(),0);
}
}
}
void PanelObjectList::OnTreeContextMenuRequested(wxTreeEvent& event)
{
// pass right click events through to the item.
wxTreeItemId id = event.GetItem();
TreeItemDataGenericObjectInfo* pData = (TreeItemDataGenericObjectInfo*)m_pTree_Objects->GetItemData( id );
if( pData && pData->m_pRightClickFunction )
{
pData->m_pRightClickFunction( pData->m_pObject_RightClick ? pData->m_pObject_RightClick : pData->m_pObject, id );
}
}
