LLPanel* LLFloaterSidePanelContainer::openChildPanel(const std::string& panel_name, const LLSD& params) { LLView* view = findChildView(panel_name, true); if (!view) return NULL; if (!getVisible()) { openFloater(); } LLPanel* panel = NULL; LLSideTrayPanelContainer* container = dynamic_cast<LLSideTrayPanelContainer*>(view->getParent()); if (container) { LLSD new_params = params; new_params[LLSideTrayPanelContainer::PARAM_SUB_PANEL_NAME] = panel_name; container->onOpen(new_params); panel = container->getCurrentPanel(); } else if ((panel = dynamic_cast<LLPanel*>(view)) != NULL) { panel->onOpen(params); } return panel; }
/** * Activate tab with "panel_name" panel * if no such tab - return false, otherwise true. * TODO* In some cases a pointer to a panel of * a specific class may be needed so this method * would need to use templates. */ LLPanel* LLSideTray::showPanel (const std::string& panel_name, const LLSD& params) { //arrange tabs child_vector_const_iter_t child_it; for ( child_it = mTabs.begin(); child_it != mTabs.end(); ++child_it) { LLView* view = (*child_it)->findChildView(panel_name,true); if(view) { selectTabByName ((*child_it)->getName()); if(mCollapsed) expandSideBar(); LLSideTrayPanelContainer* container = dynamic_cast<LLSideTrayPanelContainer*>(view->getParent()); if(container) { LLSD new_params = params; new_params[LLSideTrayPanelContainer::PARAM_SUB_PANEL_NAME] = panel_name; container->onOpen(new_params); return container->getCurrentPanel(); } LLPanel* panel = dynamic_cast<LLPanel*>(view); if(panel) { panel->onOpen(params); } return panel; } } return NULL; }
void LLBadgeOwner::addBadgeToParentHolder() { LLView * owner_view = mBadgeOwnerView.get(); if (mBadge && owner_view) { LLBadgeHolder * badge_holder = NULL; // Find the appropriate holder for the badge LLView * parent = owner_view->getParent(); while (parent) { LLBadgeHolder * badge_holder_panel = dynamic_cast<LLBadgeHolder *>(parent); if (badge_holder_panel && badge_holder_panel->acceptsBadge()) { badge_holder = badge_holder_panel; break; } parent = parent->getParent(); } if (badge_holder) { mHasBadgeHolderParent = badge_holder->addBadge(mBadge); } } }
void LLFloaterEditUI::refresh() { LLView* view = LLView::sEditingUIView; // same selection if (view == mLastView) return; // user deselected if (!view) { mLastView = NULL; mLabelLine->setText(LLStringUtil::null); mLabelLine->setEnabled(FALSE); mWidthSpin->set(0.f); mWidthSpin->setEnabled(FALSE); mHeightSpin->set(0.f); mHeightSpin->setEnabled(FALSE); return; } // HACK - don't allow widgets in this window to be selected LLView* parent = view->getParent(); while (parent) { if (parent == this) { // user selected one of our children, slam them back LLView::sEditingUIView = mLastView; return; } parent = parent->getParent(); } refreshCore(); mLastView = view; }
LLPanel* LLSideTray::openChildPanel(LLSideTrayTab* tab, const std::string& panel_name, const LLSD& params) { LLView* view = tab->findChildView(panel_name, true); if (!view) return NULL; std::string tab_name = tab->getName(); bool tab_attached = isTabAttached(tab_name); if (tab_attached && LLUI::sSettingGroups["config"]->getBOOL("OpenSidePanelsInFloaters")) { tab->toggleTabDocked(); tab_attached = false; } // Select tab and expand Side Tray only when a tab is attached. if (tab_attached) { selectTabByName(tab_name); if (mCollapsed) expandSideBar(); } else { LLFloater* floater_tab = LLFloaterReg::getInstance("side_bar_tab", tab_name); if (!floater_tab) return NULL; floater_tab->openFloater(tab_name); } LLSideTrayPanelContainer* container = dynamic_cast<LLSideTrayPanelContainer*>(view->getParent()); if (container) { LLSD new_params = params; new_params[LLSideTrayPanelContainer::PARAM_SUB_PANEL_NAME] = panel_name; container->onOpen(new_params); return container->getCurrentPanel(); } LLPanel* panel = dynamic_cast<LLPanel*>(view); if (panel) { panel->onOpen(params); } return panel; }
// Skip over any parents that are not LLUICtrl's // Used in focus logic since only LLUICtrl elements can have focus LLUICtrl* LLUICtrl::getParentUICtrl() const { LLView* parent = getParent(); while (parent) { if (parent->isCtrl()) { return (LLUICtrl*)(parent); } else { parent = parent->getParent(); } } return NULL; }
LLFloaterGotoLine::LLFloaterGotoLine(LLScriptEdCore* editor_core) : LLFloater(LLSD()), mGotoBox(NULL), mEditorCore(editor_core) { buildFromFile("floater_goto_line.xml"); sInstance = this; // find floater in which script panel is embedded LLView* viewp = (LLView*)editor_core; while(viewp) { LLFloater* floaterp = dynamic_cast<LLFloater*>(viewp); if (floaterp) { floaterp->addDependentFloater(this); break; } viewp = viewp->getParent(); } }
void LLFloaterSearchReplace::show(LLTextEditor* editor) { if (!sInstance) { sInstance = new LLFloaterSearchReplace(); } if ( (sInstance) && (editor) ) { sInstance->mEditor = editor; LLFloater* newdependee, *olddependee = sInstance->getDependee(); LLView* viewp = editor->getParent(); while (viewp) { newdependee = dynamic_cast<LLFloater*>(viewp); if (newdependee) { if (newdependee != olddependee) { if (olddependee) olddependee->removeDependentFloater(sInstance); if (!newdependee->getHost()) newdependee->addDependentFloater(sInstance); else newdependee->getHost()->addDependentFloater(sInstance); } break; } viewp = viewp->getParent(); } sInstance->open(); } }
void LLFloaterEditUI::navigateHierarchyButtonPressed(void* data) { LLView* view = LLView::sEditingUIView; if( !view ) return; LLView* parent = view->getParent(); if(!parent) { return ; } const LLView::child_list_t* viewChildren = view->getChildList(); const LLView::child_list_t* parentChildren = parent->getChildList(); //LLView::child_list_t::iterator std::list<LLView*>::const_iterator itor; std::list<LLView*>::size_type idx; std::list<LLView*>::size_type sidx; for(idx = 0,itor = parentChildren->begin();itor!=parentChildren->end();itor++,idx++){ if((*itor)==view)break; } switch((intptr_t)data) { case 0 ://up view = view->getParent(); break; case 1 ://down view = viewChildren->begin()!=viewChildren->end() ? (*viewChildren->begin()) : NULL; break; case 2 ://left { if(idx==0) idx = parentChildren->size()-1; else idx--; if( (long) idx < 0 || idx >= parentChildren->size())break; for(sidx = 0,itor = parentChildren->begin();itor!=parentChildren->end();itor++,sidx++){ if(sidx == idx) { view = (*itor); break; } } } break; case 3 ://right { if(idx==parentChildren->size()-1) idx = 0; else idx++; if( (long) idx < 0 || idx >= parentChildren->size())break; for(sidx = 0,itor = parentChildren->begin();itor!=parentChildren->end();itor++,sidx++){ if(sidx == idx) { view = (*itor); break; } } } break; } if (view) { sEditingUIView = view; sInstance->refresh(); } }
void LLFocusMgr::setKeyboardFocus(LLFocusableElement* new_focus, BOOL lock, BOOL keystrokes_only) { // notes if keyboard focus is changed again (by onFocusLost/onFocusReceived) // making the rest of our processing unnecessary since it will already be // handled by the recursive call static bool focus_dirty; focus_dirty = false; if (mLockedView && (new_focus == NULL || (new_focus != mLockedView && dynamic_cast<LLView*>(new_focus) && !dynamic_cast<LLView*>(new_focus)->hasAncestor(mLockedView)))) { // don't allow focus to go to anything that is not the locked focus // or one of its descendants return; } mKeystrokesOnly = keystrokes_only; if( new_focus != mKeyboardFocus ) { mLastKeyboardFocus = mKeyboardFocus; mKeyboardFocus = new_focus; // list of the focus and it's ancestors view_handle_list_t old_focus_list = mCachedKeyboardFocusList; view_handle_list_t new_focus_list; // walk up the tree to root and add all views to the new_focus_list for (LLView* ctrl = dynamic_cast<LLView*>(mKeyboardFocus); ctrl; ctrl = ctrl->getParent()) { new_focus_list.push_back(ctrl->getHandle()); } // remove all common ancestors since their focus is unchanged while (!new_focus_list.empty() && !old_focus_list.empty() && new_focus_list.back() == old_focus_list.back()) { new_focus_list.pop_back(); old_focus_list.pop_back(); } // walk up the old focus branch calling onFocusLost // we bubble up the tree to release focus, and back down to add for (view_handle_list_t::iterator old_focus_iter = old_focus_list.begin(); old_focus_iter != old_focus_list.end() && !focus_dirty; old_focus_iter++) { LLView* old_focus_view = old_focus_iter->get(); if (old_focus_view) { mCachedKeyboardFocusList.pop_front(); old_focus_view->onFocusLost(); } } // walk down the new focus branch calling onFocusReceived for (view_handle_list_t::reverse_iterator new_focus_riter = new_focus_list.rbegin(); new_focus_riter != new_focus_list.rend() && !focus_dirty; new_focus_riter++) { LLView* new_focus_view = new_focus_riter->get(); if (new_focus_view) { mCachedKeyboardFocusList.push_front(new_focus_view->getHandle()); new_focus_view->onFocusReceived(); } } // if focus was changed as part of an onFocusLost or onFocusReceived call // stop iterating on current list since it is now invalid if (focus_dirty) { return; } // If we've got a default keyboard focus, and the caller is // releasing keyboard focus, move to the default. if (mDefaultKeyboardFocus != NULL && mKeyboardFocus == NULL) { mDefaultKeyboardFocus->setFocus(TRUE); } LLView* focus_subtree = dynamic_cast<LLView*>(mKeyboardFocus); LLView* viewp = dynamic_cast<LLView*>(mKeyboardFocus); // find root-most focus root while(viewp) { if (viewp->isFocusRoot()) { focus_subtree = viewp; } viewp = viewp->getParent(); } if (focus_subtree) { LLView* focused_view = dynamic_cast<LLView*>(mKeyboardFocus); mFocusHistory[focus_subtree->getHandle()] = focused_view ? focused_view->getHandle() : LLHandle<LLView>(); } } if (lock) { lockFocus(); } focus_dirty = true; }
void LLFocusMgr::setKeyboardFocus(LLUICtrl* new_focus, BOOL lock, BOOL keystrokes_only) { if (mLockedView && (new_focus == NULL || (new_focus != mLockedView && !new_focus->hasAncestor(mLockedView)))) { // don't allow focus to go to anything that is not the locked focus // or one of its descendants return; } //llinfos << "Keyboard focus handled by " << (new_focus ? new_focus->getName() : "nothing") << llendl; mKeystrokesOnly = keystrokes_only; if( new_focus != mKeyboardFocus ) { mLastKeyboardFocus = mKeyboardFocus; mKeyboardFocus = new_focus; if( mLastKeyboardFocus ) { mLastKeyboardFocus->onFocusLost(); } // clear out any existing flash if (new_focus) { mFocusWeight = 0.f; new_focus->onFocusReceived(); } mFocusTimer.reset(); #ifdef _DEBUG mKeyboardFocusName = new_focus ? new_focus->getName() : std::string("none"); #endif // If we've got a default keyboard focus, and the caller is // releasing keyboard focus, move to the default. if (mDefaultKeyboardFocus != NULL && mKeyboardFocus == NULL) { mDefaultKeyboardFocus->setFocus(TRUE); } LLView* focus_subtree = mKeyboardFocus; LLView* viewp = mKeyboardFocus; // find root-most focus root while(viewp) { if (viewp->isFocusRoot()) { focus_subtree = viewp; } viewp = viewp->getParent(); } if (focus_subtree) { mFocusHistory[focus_subtree->getHandle()] = mKeyboardFocus ? mKeyboardFocus->getHandle() : LLHandle<LLView>(); } } if (lock) { lockFocus(); } }