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);
}

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 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);
    }
}