开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
llpanelmaininventory.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：36k
源码类别：

游戏引擎

开发平台：

C++ Builder

llpanelmaininventory.cpp：源码内容
  1. /** 
  2.  * @file llsidepanelmaininventory.cpp
  3.  * @brief Implementation of llsidepanelmaininventory.
  4.  *
  5.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2001-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. #include "llviewerprecompiledheaders.h"
  34. #include "llpanelmaininventory.h"
  36. #include "llagent.h"
  37. #include "lldndbutton.h"
  38. #include "lleconomy.h"
  39. #include "llfilepicker.h"
  40. #include "llfloaterinventory.h"
  41. #include "llinventorybridge.h"
  42. #include "llinventoryfunctions.h"
  43. #include "llinventorypanel.h"
  44. #include "llfiltereditor.h"
  45. #include "llfloaterreg.h"
  46. #include "llpreviewtexture.h"
  47. #include "llscrollcontainer.h"
  48. #include "llsdserialize.h"
  49. #include "llspinctrl.h"
  50. #include "lltooldraganddrop.h"
  51. #include "llviewermenu.h"
  52. #include "llviewertexturelist.h"
  54. const std::string FILTERS_FILENAME("filters.xml");
  56. static LLRegisterPanelClassWrapper<LLPanelMainInventory> t_inventory("panel_main_inventory");
  58. void on_file_loaded_for_save(BOOL success, 
  59.  LLViewerFetchedTexture *src_vi,
  60.  LLImageRaw* src, 
  61.  LLImageRaw* aux_src, 
  62.  S32 discard_level,
  63.  BOOL final,
  64.  void* userdata);
  66. ///----------------------------------------------------------------------------
  67. /// LLFloaterInventoryFinder
  68. ///----------------------------------------------------------------------------
  70. class LLFloaterInventoryFinder : public LLFloater
  71. {
  72. public:
  73. LLFloaterInventoryFinder( LLPanelMainInventory* inventory_view);
  74. virtual void draw();
  75. /*virtual*/ BOOL postBuild();
  76. void changeFilter(LLInventoryFilter* filter);
  77. void updateElementsFromFilter();
  78. BOOL getCheckShowEmpty();
  79. BOOL getCheckSinceLogoff();
  81. static void onTimeAgo(LLUICtrl*, void *);
  82. static void onCheckSinceLogoff(LLUICtrl*, void *);
  83. static void onCloseBtn(void* user_data);
  84. static void selectAllTypes(void* user_data);
  85. static void selectNoTypes(void* user_data);
  86. private:
  87. LLPanelMainInventory* mPanelMainInventory;
  88. LLSpinCtrl* mSpinSinceDays;
  89. LLSpinCtrl* mSpinSinceHours;
  90. LLInventoryFilter* mFilter;
  91. };
  93. ///----------------------------------------------------------------------------
  94. /// LLPanelMainInventory
  95. ///----------------------------------------------------------------------------
  97. LLPanelMainInventory::LLPanelMainInventory()
  98. : LLPanel(),
  99.   mActivePanel(NULL),
  100.   mSavedFolderState(NULL),
  101.   mFilterText(""),
  102.   mMenuGearDefault(NULL),
  103.   mMenuAdd(NULL),
  104.   mNeedUploadCost(true)
  105. {
  106. LLMemType mt(LLMemType::MTYPE_INVENTORY_VIEW_INIT);
  107. // Menu Callbacks (non contex menus)
  108. mCommitCallbackRegistrar.add("Inventory.DoToSelected", boost::bind(&LLPanelMainInventory::doToSelected, this, _2));
  109. mCommitCallbackRegistrar.add("Inventory.CloseAllFolders", boost::bind(&LLPanelMainInventory::closeAllFolders, this));
  110. mCommitCallbackRegistrar.add("Inventory.EmptyTrash", boost::bind(&LLInventoryModel::emptyFolderType, &gInventory, "ConfirmEmptyTrash", LLFolderType::FT_TRASH));
  111. mCommitCallbackRegistrar.add("Inventory.EmptyLostAndFound", boost::bind(&LLInventoryModel::emptyFolderType, &gInventory, "ConfirmEmptyLostAndFound", LLFolderType::FT_LOST_AND_FOUND));
  112. mCommitCallbackRegistrar.add("Inventory.DoCreate", boost::bind(&LLPanelMainInventory::doCreate, this, _2));
  113.   mCommitCallbackRegistrar.add("Inventory.NewWindow", boost::bind(&LLPanelMainInventory::newWindow, this));
  114. mCommitCallbackRegistrar.add("Inventory.ShowFilters", boost::bind(&LLPanelMainInventory::toggleFindOptions, this));
  115. mCommitCallbackRegistrar.add("Inventory.ResetFilters", boost::bind(&LLPanelMainInventory::resetFilters, this));
  116. mCommitCallbackRegistrar.add("Inventory.SetSortBy", boost::bind(&LLPanelMainInventory::setSortBy, this, _2));
  118. // Controls
  119. // *TODO: Just use persistant settings for each of these
  120. U32 sort_order = gSavedSettings.getU32("InventorySortOrder");
  121. BOOL sort_by_name = ! ( sort_order & LLInventoryFilter::SO_DATE );
  122. BOOL sort_folders_by_name = ( sort_order & LLInventoryFilter::SO_FOLDERS_BY_NAME );
  123. BOOL sort_system_folders_to_top = ( sort_order & LLInventoryFilter::SO_SYSTEM_FOLDERS_TO_TOP );
  125. gSavedSettings.declareBOOL("Inventory.SortByName", sort_by_name, "Declared in code", FALSE);
  126. gSavedSettings.declareBOOL("Inventory.SortByDate", !sort_by_name, "Declared in code", FALSE);
  127. gSavedSettings.declareBOOL("Inventory.FoldersAlwaysByName", sort_folders_by_name, "Declared in code", FALSE);
  128. gSavedSettings.declareBOOL("Inventory.SystemFoldersToTop", sort_system_folders_to_top, "Declared in code", FALSE);
  130. mSavedFolderState = new LLSaveFolderState();
  131. mSavedFolderState->setApply(FALSE);
  132. }
  134. BOOL LLPanelMainInventory::postBuild()
  135. {
  136. gInventory.addObserver(this);
  138. mFilterTabs = getChild<LLTabContainer>("inventory filter tabs");
  139. mFilterTabs->setCommitCallback(boost::bind(&LLPanelMainInventory::onFilterSelected, this));
  141. //panel->getFilter()->markDefault();
  143. // Set up the default inv. panel/filter settings.
  144. mActivePanel = getChild<LLInventoryPanel>("All Items");
  145. if (mActivePanel)
  146. {
  147. // "All Items" is the previous only view, so it gets the InventorySortOrder
  148. mActivePanel->setSortOrder(gSavedSettings.getU32("InventorySortOrder"));
  149. mActivePanel->getFilter()->markDefault();
  150. mActivePanel->getRootFolder()->applyFunctorRecursively(*mSavedFolderState);
  151. mActivePanel->setSelectCallback(boost::bind(&LLPanelMainInventory::onSelectionChange, this, mActivePanel, _1, _2));
  152. }
  153. LLInventoryPanel* recent_items_panel = getChild<LLInventoryPanel>("Recent Items");
  154. if (recent_items_panel)
  155. {
  156. recent_items_panel->setSinceLogoff(TRUE);
  157. recent_items_panel->setSortOrder(LLInventoryFilter::SO_DATE);
  158. recent_items_panel->setShowFolderState(LLInventoryFilter::SHOW_NON_EMPTY_FOLDERS);
  159. recent_items_panel->getFilter()->markDefault();
  160. recent_items_panel->setSelectCallback(boost::bind(&LLPanelMainInventory::onSelectionChange, this, recent_items_panel, _1, _2));
  161. }
  163. // Now load the stored settings from disk, if available.
  164. std::ostringstream filterSaveName;
  165. filterSaveName << gDirUtilp->getExpandedFilename(LL_PATH_PER_SL_ACCOUNT, FILTERS_FILENAME);
  166. llinfos << "LLPanelMainInventory::init: reading from " << filterSaveName << llendl;
  167. llifstream file(filterSaveName.str());
  168. LLSD savedFilterState;
  169. if (file.is_open())
  170. {
  171. LLSDSerialize::fromXML(savedFilterState, file);
  172. file.close();
  174. // Load the persistent "Recent Items" settings.
  175. // Note that the "All Items" settings do not persist.
  176. if(recent_items_panel)
  177. {
  178. if(savedFilterState.has(recent_items_panel->getFilter()->getName()))
  179. {
  180. LLSD recent_items = savedFilterState.get(
  181. recent_items_panel->getFilter()->getName());
  182. recent_items_panel->getFilter()->fromLLSD(recent_items);
  183. }
  184. }
  186. }
  188. mFilterEditor = getChild<LLFilterEditor>("inventory search editor");
  189. if (mFilterEditor)
  190. {
  191. mFilterEditor->setCommitCallback(boost::bind(&LLPanelMainInventory::onFilterEdit, this, _2));
  192. }
  194. // *TODO:Get the cost info from the server
  195. const std::string upload_cost("10");
  196. childSetLabelArg("Upload Image", "[COST]", upload_cost);
  197. childSetLabelArg("Upload Sound", "[COST]", upload_cost);
  198. childSetLabelArg("Upload Animation", "[COST]", upload_cost);
  199. childSetLabelArg("Bulk Upload", "[COST]", upload_cost);
  201. initListCommandsHandlers();
  202. return TRUE;
  203. }
  205. // Destroys the object
  206. LLPanelMainInventory::~LLPanelMainInventory( void )
  207. {
  208. // Save the filters state.
  209. LLSD filterRoot;
  210. LLInventoryPanel* all_items_panel = getChild<LLInventoryPanel>("All Items");
  211. if (all_items_panel)
  212. {
  213. LLInventoryFilter* filter = all_items_panel->getFilter();
  214. if (filter)
  215. {
  216. LLSD filterState;
  217. filter->toLLSD(filterState);
  218. filterRoot[filter->getName()] = filterState;
  219. }
  220. }
  222. LLInventoryPanel* recent_items_panel = getChild<LLInventoryPanel>("Recent Items");
  223. if (recent_items_panel)
  224. {
  225. LLInventoryFilter* filter = recent_items_panel->getFilter();
  226. if (filter)
  227. {
  228. LLSD filterState;
  229. filter->toLLSD(filterState);
  230. filterRoot[filter->getName()] = filterState;
  231. }
  232. }
  234. std::ostringstream filterSaveName;
  235. filterSaveName << gDirUtilp->getExpandedFilename(LL_PATH_PER_SL_ACCOUNT, FILTERS_FILENAME);
  236. llofstream filtersFile(filterSaveName.str());
  237. if(!LLSDSerialize::toPrettyXML(filterRoot, filtersFile))
  238. {
  239. llwarns << "Could not write to filters save file " << filterSaveName << llendl;
  240. }
  241. else
  242. filtersFile.close();
  244. gInventory.removeObserver(this);
  245. delete mSavedFolderState;
  246. }
  248. void LLPanelMainInventory::startSearch()
  249. {
  250. // this forces focus to line editor portion of search editor
  251. if (mFilterEditor)
  252. {
  253. mFilterEditor->focusFirstItem(TRUE);
  254. }
  255. }
  257. BOOL LLPanelMainInventory::handleKeyHere(KEY key, MASK mask)
  258. {
  259. LLFolderView* root_folder = mActivePanel ? mActivePanel->getRootFolder() : NULL;
  260. if (root_folder)
  261. {
  262. // first check for user accepting current search results
  263. if (mFilterEditor 
  264. && mFilterEditor->hasFocus()
  265.     && (key == KEY_RETURN 
  266.      || key == KEY_DOWN)
  267.     && mask == MASK_NONE)
  268. {
  269. // move focus to inventory proper
  270. mActivePanel->setFocus(TRUE);
  271. root_folder->scrollToShowSelection();
  272. return TRUE;
  273. }
  275. if (mActivePanel->hasFocus() && key == KEY_UP)
  276. {
  277. startSearch();
  278. }
  279. }
  281. return LLPanel::handleKeyHere(key, mask);
  283. }
  285. //----------------------------------------------------------------------------
  286. // menu callbacks
  288. void LLPanelMainInventory::doToSelected(const LLSD& userdata)
  289. {
  290. getPanel()->getRootFolder()->doToSelected(&gInventory, userdata);
  291. }
  293. void LLPanelMainInventory::closeAllFolders()
  294. {
  295. getPanel()->getRootFolder()->closeAllFolders();
  296. }
  298. void LLPanelMainInventory::newWindow()
  299. {
  300. LLFloaterInventory::showAgentInventory();
  301. }
  303. void LLPanelMainInventory::doCreate(const LLSD& userdata)
  304. {
  305. menu_create_inventory_item(getPanel()->getRootFolder(), NULL, userdata);
  306. }
  308. void LLPanelMainInventory::resetFilters()
  309. {
  310. LLFloaterInventoryFinder *finder = getFinder();
  311. getActivePanel()->getFilter()->resetDefault();
  312. if (finder)
  313. {
  314. finder->updateElementsFromFilter();
  315. }
  317. setFilterTextFromFilter();
  318. }
  320. void LLPanelMainInventory::setSortBy(const LLSD& userdata)
  321. {
  322. std::string sort_field = userdata.asString();
  323. if (sort_field == "name")
  324. {
  325. U32 order = getActivePanel()->getSortOrder();
  326. getActivePanel()->setSortOrder( order & ~LLInventoryFilter::SO_DATE );
  328. gSavedSettings.setBOOL("Inventory.SortByName", TRUE );
  329. gSavedSettings.setBOOL("Inventory.SortByDate", FALSE );
  330. }
  331. else if (sort_field == "date")
  332. {
  333. U32 order = getActivePanel()->getSortOrder();
  334. getActivePanel()->setSortOrder( order | LLInventoryFilter::SO_DATE );
  336. gSavedSettings.setBOOL("Inventory.SortByName", FALSE );
  337. gSavedSettings.setBOOL("Inventory.SortByDate", TRUE );
  338. }
  339. else if (sort_field == "foldersalwaysbyname")
  340. {
  341. U32 order = getActivePanel()->getSortOrder();
  342. if ( order & LLInventoryFilter::SO_FOLDERS_BY_NAME )
  343. {
  344. order &= ~LLInventoryFilter::SO_FOLDERS_BY_NAME;
  346. gSavedSettings.setBOOL("Inventory.FoldersAlwaysByName", FALSE );
  347. }
  348. else
  349. {
  350. order |= LLInventoryFilter::SO_FOLDERS_BY_NAME;
  352. gSavedSettings.setBOOL("Inventory.FoldersAlwaysByName", TRUE );
  353. }
  354. getActivePanel()->setSortOrder( order );
  355. }
  356. else if (sort_field == "systemfolderstotop")
  357. {
  358. U32 order = getActivePanel()->getSortOrder();
  359. if ( order & LLInventoryFilter::SO_SYSTEM_FOLDERS_TO_TOP )
  360. {
  361. order &= ~LLInventoryFilter::SO_SYSTEM_FOLDERS_TO_TOP;
  363. gSavedSettings.setBOOL("Inventory.SystemFoldersToTop", FALSE );
  364. }
  365. else
  366. {
  367. order |= LLInventoryFilter::SO_SYSTEM_FOLDERS_TO_TOP;
  369. gSavedSettings.setBOOL("Inventory.SystemFoldersToTop", TRUE );
  370. }
  371. getActivePanel()->setSortOrder( order );
  372. }
  373. }
  375. // static
  376. BOOL LLPanelMainInventory::filtersVisible(void* user_data)
  377. {
  378. LLPanelMainInventory* self = (LLPanelMainInventory*)user_data;
  379. if(!self) return FALSE;
  381. return self->getFinder() != NULL;
  382. }
  384. void LLPanelMainInventory::onClearSearch()
  385. {
  386. LLFloater *finder = getFinder();
  387. if (mActivePanel)
  388. {
  389. mActivePanel->setFilterSubString(LLStringUtil::null);
  390. mActivePanel->setFilterTypes(0xffffffff);
  391. }
  393. if (finder)
  394. {
  395. LLFloaterInventoryFinder::selectAllTypes(finder);
  396. }
  398. // re-open folders that were initially open
  399. if (mActivePanel)
  400. {
  401. mSavedFolderState->setApply(TRUE);
  402. mActivePanel->getRootFolder()->applyFunctorRecursively(*mSavedFolderState);
  403. LLOpenFoldersWithSelection opener;
  404. mActivePanel->getRootFolder()->applyFunctorRecursively(opener);
  405. mActivePanel->getRootFolder()->scrollToShowSelection();
  406. }
  407. mFilterSubString = "";
  408. }
  410. void LLPanelMainInventory::onFilterEdit(const std::string& search_string )
  411. {
  412. if (search_string == "")
  413. {
  414. onClearSearch();
  415. }
  416. if (!mActivePanel)
  417. {
  418. return;
  419. }
  421. gInventory.startBackgroundFetch();
  423. std::string uppercase_search_string = search_string;
  424. LLStringUtil::toUpper(uppercase_search_string);
  425. mFilterSubString = uppercase_search_string;
  426. if (mActivePanel->getFilterSubString().empty() && uppercase_search_string.empty())
  427. {
  428. // current filter and new filter empty, do nothing
  429. return;
  430. }
  432. // save current folder open state if no filter currently applied
  433. if (!mActivePanel->getRootFolder()->isFilterModified())
  434. {
  435. mSavedFolderState->setApply(FALSE);
  436. mActivePanel->getRootFolder()->applyFunctorRecursively(*mSavedFolderState);
  437. }
  439. // set new filter string
  440. mActivePanel->setFilterSubString(mFilterSubString);
  441. }
  444.  //static
  445.  BOOL LLPanelMainInventory::incrementalFind(LLFolderViewItem* first_item, const char *find_text, BOOL backward)
  446.  {
  447.   LLPanelMainInventory* active_view = NULL;
  449. LLFloaterReg::const_instance_list_t& inst_list = LLFloaterReg::getFloaterList("inventory");
  450. for (LLFloaterReg::const_instance_list_t::const_iterator iter = inst_list.begin(); iter != inst_list.end(); ++iter)
  451. {
  452. LLPanelMainInventory* iv = dynamic_cast<LLPanelMainInventory*>(*iter);
  453. if (iv)
  454. {
  455. if (gFocusMgr.childHasKeyboardFocus(iv))
  456. {
  457. active_view = iv;
  458. break;
  459. }
  460.   }
  461.   }
  463.   if (!active_view)
  464.   {
  465.   return FALSE;
  466.   }
  468.   std::string search_string(find_text);
  470.   if (search_string.empty())
  471.   {
  472.   return FALSE;
  473.   }
  475.   if (active_view->getPanel() &&
  476.   active_view->getPanel()->getRootFolder()->search(first_item, search_string, backward))
  477.   {
  478.   return TRUE;
  479.   }
  481.   return FALSE;
  482.  }
  484. void LLPanelMainInventory::onFilterSelected()
  485. {
  486. // Find my index
  487. mActivePanel = (LLInventoryPanel*)childGetVisibleTab("inventory filter tabs");
  489. if (!mActivePanel)
  490. {
  491. return;
  492. }
  493. setFilterSubString(mFilterSubString);
  494. LLInventoryFilter* filter = mActivePanel->getFilter();
  495. LLFloaterInventoryFinder *finder = getFinder();
  496. if (finder)
  497. {
  498. finder->changeFilter(filter);
  499. }
  500. if (filter->isActive())
  501. {
  502. // If our filter is active we may be the first thing requiring a fetch so we better start it here.
  503. gInventory.startBackgroundFetch();
  504. }
  505. setFilterTextFromFilter();
  506. }
  508. const std::string LLPanelMainInventory::getFilterSubString() 
  509. { 
  510. return mActivePanel->getFilterSubString(); 
  511. }
  513. void LLPanelMainInventory::setFilterSubString(const std::string& string) 
  514. { 
  515. mActivePanel->setFilterSubString(string); 
  516. }
  518. BOOL LLPanelMainInventory::handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
  519.  EDragAndDropType cargo_type,
  520.  void* cargo_data,
  521.  EAcceptance* accept,
  522.  std::string& tooltip_msg)
  523. {
  524. // Check to see if we are auto scrolling from the last frame
  525. LLInventoryPanel* panel = (LLInventoryPanel*)this->getActivePanel();
  526. BOOL needsToScroll = panel->getScrollableContainer()->autoScroll(x, y);
  527. if(mFilterTabs)
  528. {
  529. if(needsToScroll)
  530. {
  531. mFilterTabs->startDragAndDropDelayTimer();
  532. }
  533. }
  535. BOOL handled = LLPanel::handleDragAndDrop(x, y, mask, drop, cargo_type, cargo_data, accept, tooltip_msg);
  537. return handled;
  538. }
  540. // virtual
  541. void LLPanelMainInventory::changed(U32)
  542. {
  543. // empty, but must have this defined for abstract base class.
  544. }
  547. // virtual
  548. void LLPanelMainInventory::draw()
  549. {
  550. if (mActivePanel && mFilterEditor)
  551. {
  552. mFilterEditor->setText(mFilterSubString);
  553. }
  554. LLPanel::draw();
  555. }
  557. void LLPanelMainInventory::setFilterTextFromFilter() 
  558. { 
  559. mFilterText = mActivePanel->getFilter()->getFilterText(); 
  560. }
  562. void LLPanelMainInventory::toggleFindOptions()
  563. {
  564. LLMemType mt(LLMemType::MTYPE_INVENTORY_VIEW_TOGGLE);
  565. LLFloater *floater = getFinder();
  566. if (!floater)
  567. {
  568. LLFloaterInventoryFinder * finder = new LLFloaterInventoryFinder(this);
  569. mFinderHandle = finder->getHandle();
  570. finder->openFloater();
  572. LLFloater* parent_floater = gFloaterView->getParentFloater(this);
  573. if (parent_floater) // Seraph: Fix this, shouldn't be null even for sidepanel
  574. parent_floater->addDependentFloater(mFinderHandle);
  575. // start background fetch of folders
  576. gInventory.startBackgroundFetch();
  577. }
  578. else
  579. {
  580. floater->closeFloater();
  581. }
  582. }
  584. void LLPanelMainInventory::setSelectCallback(const LLFolderView::signal_t::slot_type& cb)
  585. {
  586. getChild<LLInventoryPanel>("All Items")->setSelectCallback(cb);
  587. getChild<LLInventoryPanel>("Recent Items")->setSelectCallback(cb);
  588. }
  590. void LLPanelMainInventory::onSelectionChange(LLInventoryPanel *panel, const std::deque<LLFolderViewItem*>& items, BOOL user_action)
  591. {
  592. updateListCommands();
  593. panel->onSelectionChange(items, user_action);
  594. }
  596. ///----------------------------------------------------------------------------
  597. /// LLFloaterInventoryFinder
  598. ///----------------------------------------------------------------------------
  600. LLFloaterInventoryFinder* LLPanelMainInventory::getFinder() 
  601. { 
  602. return (LLFloaterInventoryFinder*)mFinderHandle.get();
  603. }
  606. LLFloaterInventoryFinder::LLFloaterInventoryFinder(LLPanelMainInventory* inventory_view) :
  607. LLFloater(LLSD()),
  608. mPanelMainInventory(inventory_view),
  609. mFilter(inventory_view->getPanel()->getFilter())
  610. {
  611. LLUICtrlFactory::getInstance()->buildFloater(this, "floater_inventory_view_finder.xml", NULL);
  612. updateElementsFromFilter();
  613. }
  616. void LLFloaterInventoryFinder::onCheckSinceLogoff(LLUICtrl *ctrl, void *user_data)
  617. {
  618. LLFloaterInventoryFinder *self = (LLFloaterInventoryFinder *)user_data;
  619. if (!self) return;
  621. bool since_logoff= self->childGetValue("check_since_logoff");
  623. if (!since_logoff && 
  624.     !(  self->mSpinSinceDays->get() ||  self->mSpinSinceHours->get() ) )
  625. {
  626. self->mSpinSinceHours->set(1.0f);
  627. }
  628. }
  629. BOOL LLFloaterInventoryFinder::postBuild()
  630. {
  631. const LLRect& viewrect = mPanelMainInventory->getRect();
  632. setRect(LLRect(viewrect.mLeft - getRect().getWidth(), viewrect.mTop, viewrect.mLeft, viewrect.mTop - getRect().getHeight()));
  634. childSetAction("All", selectAllTypes, this);
  635. childSetAction("None", selectNoTypes, this);
  637. mSpinSinceHours = getChild<LLSpinCtrl>("spin_hours_ago");
  638. childSetCommitCallback("spin_hours_ago", onTimeAgo, this);
  640. mSpinSinceDays = getChild<LLSpinCtrl>("spin_days_ago");
  641. childSetCommitCallback("spin_days_ago", onTimeAgo, this);
  643. // mCheckSinceLogoff   = getChild<LLSpinCtrl>("check_since_logoff");
  644. childSetCommitCallback("check_since_logoff", onCheckSinceLogoff, this);
  646. childSetAction("Close", onCloseBtn, this);
  648. updateElementsFromFilter();
  649. return TRUE;
  650. }
  651. void LLFloaterInventoryFinder::onTimeAgo(LLUICtrl *ctrl, void *user_data)
  652. {
  653. LLFloaterInventoryFinder *self = (LLFloaterInventoryFinder *)user_data;
  654. if (!self) return;
  656. bool since_logoff=true;
  657. if ( self->mSpinSinceDays->get() ||  self->mSpinSinceHours->get() )
  658. {
  659. since_logoff = false;
  660. }
  661. self->childSetValue("check_since_logoff", since_logoff);
  662. }
  664. void LLFloaterInventoryFinder::changeFilter(LLInventoryFilter* filter)
  665. {
  666. mFilter = filter;
  667. updateElementsFromFilter();
  668. }
  670. void LLFloaterInventoryFinder::updateElementsFromFilter()
  671. {
  672. if (!mFilter)
  673. return;
  675. // Get data needed for filter display
  676. U32 filter_types = mFilter->getFilterObjectTypes();
  677. std::string filter_string = mFilter->getFilterSubString();
  678. LLInventoryFilter::EFolderShow show_folders = mFilter->getShowFolderState();
  679. U32 hours = mFilter->getHoursAgo();
  681. // update the ui elements
  682. setTitle(mFilter->getName());
  684. childSetValue("check_animation", (S32) (filter_types & 0x1 << LLInventoryType::IT_ANIMATION));
  686. childSetValue("check_calling_card", (S32) (filter_types & 0x1 << LLInventoryType::IT_CALLINGCARD));
  687. childSetValue("check_clothing", (S32) (filter_types & 0x1 << LLInventoryType::IT_WEARABLE));
  688. childSetValue("check_gesture", (S32) (filter_types & 0x1 << LLInventoryType::IT_GESTURE));
  689. childSetValue("check_landmark", (S32) (filter_types & 0x1 << LLInventoryType::IT_LANDMARK));
  690. childSetValue("check_notecard", (S32) (filter_types & 0x1 << LLInventoryType::IT_NOTECARD));
  691. childSetValue("check_object", (S32) (filter_types & 0x1 << LLInventoryType::IT_OBJECT));
  692. childSetValue("check_script", (S32) (filter_types & 0x1 << LLInventoryType::IT_LSL));
  693. childSetValue("check_sound", (S32) (filter_types & 0x1 << LLInventoryType::IT_SOUND));
  694. childSetValue("check_texture", (S32) (filter_types & 0x1 << LLInventoryType::IT_TEXTURE));
  695. childSetValue("check_snapshot", (S32) (filter_types & 0x1 << LLInventoryType::IT_SNAPSHOT));
  696. childSetValue("check_show_empty", show_folders == LLInventoryFilter::SHOW_ALL_FOLDERS);
  697. childSetValue("check_since_logoff", mFilter->isSinceLogoff());
  698. mSpinSinceHours->set((F32)(hours % 24));
  699. mSpinSinceDays->set((F32)(hours / 24));
  700. }
  702. void LLFloaterInventoryFinder::draw()
  703. {
  704. LLMemType mt(LLMemType::MTYPE_INVENTORY_DRAW);
  705. U32 filter = 0xffffffff;
  706. BOOL filtered_by_all_types = TRUE;
  708. if (!childGetValue("check_animation"))
  709. {
  710. filter &= ~(0x1 << LLInventoryType::IT_ANIMATION);
  711. filtered_by_all_types = FALSE;
  712. }
  715. if (!childGetValue("check_calling_card"))
  716. {
  717. filter &= ~(0x1 << LLInventoryType::IT_CALLINGCARD);
  718. filtered_by_all_types = FALSE;
  719. }
  721. if (!childGetValue("check_clothing"))
  722. {
  723. filter &= ~(0x1 << LLInventoryType::IT_WEARABLE);
  724. filtered_by_all_types = FALSE;
  725. }
  727. if (!childGetValue("check_gesture"))
  728. {
  729. filter &= ~(0x1 << LLInventoryType::IT_GESTURE);
  730. filtered_by_all_types = FALSE;
  731. }
  733. if (!childGetValue("check_landmark"))
  736. {
  737. filter &= ~(0x1 << LLInventoryType::IT_LANDMARK);
  738. filtered_by_all_types = FALSE;
  739. }
  741. if (!childGetValue("check_notecard"))
  742. {
  743. filter &= ~(0x1 << LLInventoryType::IT_NOTECARD);
  744. filtered_by_all_types = FALSE;
  745. }
  747. if (!childGetValue("check_object"))
  748. {
  749. filter &= ~(0x1 << LLInventoryType::IT_OBJECT);
  750. filter &= ~(0x1 << LLInventoryType::IT_ATTACHMENT);
  751. filtered_by_all_types = FALSE;
  752. }
  754. if (!childGetValue("check_script"))
  755. {
  756. filter &= ~(0x1 << LLInventoryType::IT_LSL);
  757. filtered_by_all_types = FALSE;
  758. }
  760. if (!childGetValue("check_sound"))
  761. {
  762. filter &= ~(0x1 << LLInventoryType::IT_SOUND);
  763. filtered_by_all_types = FALSE;
  764. }
  766. if (!childGetValue("check_texture"))
  767. {
  768. filter &= ~(0x1 << LLInventoryType::IT_TEXTURE);
  769. filtered_by_all_types = FALSE;
  770. }
  772. if (!childGetValue("check_snapshot"))
  773. {
  774. filter &= ~(0x1 << LLInventoryType::IT_SNAPSHOT);
  775. filtered_by_all_types = FALSE;
  776. }
  778. if (!filtered_by_all_types)
  779. {
  780. // don't include folders in filter, unless I've selected everything
  781. filter &= ~(0x1 << LLInventoryType::IT_CATEGORY);
  782. }
  784. // update the panel, panel will update the filter
  785. mPanelMainInventory->getPanel()->setShowFolderState(getCheckShowEmpty() ?
  786. LLInventoryFilter::SHOW_ALL_FOLDERS : LLInventoryFilter::SHOW_NON_EMPTY_FOLDERS);
  787. mPanelMainInventory->getPanel()->setFilterTypes(filter);
  788. if (getCheckSinceLogoff())
  789. {
  790. mSpinSinceDays->set(0);
  791. mSpinSinceHours->set(0);
  792. }
  793. U32 days = (U32)mSpinSinceDays->get();
  794. U32 hours = (U32)mSpinSinceHours->get();
  795. if (hours > 24)
  796. {
  797. days += hours / 24;
  798. hours = (U32)hours % 24;
  799. mSpinSinceDays->set((F32)days);
  800. mSpinSinceHours->set((F32)hours);
  801. }
  802. hours += days * 24;
  803. mPanelMainInventory->getPanel()->setHoursAgo(hours);
  804. mPanelMainInventory->getPanel()->setSinceLogoff(getCheckSinceLogoff());
  805. mPanelMainInventory->setFilterTextFromFilter();
  807. LLPanel::draw();
  808. }
  810. BOOL LLFloaterInventoryFinder::getCheckShowEmpty()
  811. {
  812. return childGetValue("check_show_empty");
  813. }
  815. BOOL LLFloaterInventoryFinder::getCheckSinceLogoff()
  816. {
  817. return childGetValue("check_since_logoff");
  818. }
  820. void LLFloaterInventoryFinder::onCloseBtn(void* user_data)
  821. {
  822. LLFloaterInventoryFinder* finderp = (LLFloaterInventoryFinder*)user_data;
  823. finderp->closeFloater();
  824. }
  826. // static
  827. void LLFloaterInventoryFinder::selectAllTypes(void* user_data)
  828. {
  829. LLFloaterInventoryFinder* self = (LLFloaterInventoryFinder*)user_data;
  830. if(!self) return;
  832. self->childSetValue("check_animation", TRUE);
  833. self->childSetValue("check_calling_card", TRUE);
  834. self->childSetValue("check_clothing", TRUE);
  835. self->childSetValue("check_gesture", TRUE);
  836. self->childSetValue("check_landmark", TRUE);
  837. self->childSetValue("check_notecard", TRUE);
  838. self->childSetValue("check_object", TRUE);
  839. self->childSetValue("check_script", TRUE);
  840. self->childSetValue("check_sound", TRUE);
  841. self->childSetValue("check_texture", TRUE);
  842. self->childSetValue("check_snapshot", TRUE);
  843. }
  845. //static
  846. void LLFloaterInventoryFinder::selectNoTypes(void* user_data)
  847. {
  848. LLFloaterInventoryFinder* self = (LLFloaterInventoryFinder*)user_data;
  849. if(!self) return;
  851. self->childSetValue("check_animation", FALSE);
  852. self->childSetValue("check_calling_card", FALSE);
  853. self->childSetValue("check_clothing", FALSE);
  854. self->childSetValue("check_gesture", FALSE);
  855. self->childSetValue("check_landmark", FALSE);
  856. self->childSetValue("check_notecard", FALSE);
  857. self->childSetValue("check_object", FALSE);
  858. self->childSetValue("check_script", FALSE);
  859. self->childSetValue("check_sound", FALSE);
  860. self->childSetValue("check_texture", FALSE);
  861. self->childSetValue("check_snapshot", FALSE);
  862. }
  864. //////////////////////////////////////////////////////////////////////////////////
  865. // List Commands                                                                //
  867. void LLPanelMainInventory::initListCommandsHandlers()
  868. {
  869. mListCommands = getChild<LLPanel>("bottom_panel");
  871. mListCommands->childSetAction("options_gear_btn", boost::bind(&LLPanelMainInventory::onGearButtonClick, this));
  872. mListCommands->childSetAction("trash_btn", boost::bind(&LLPanelMainInventory::onTrashButtonClick, this));
  873. mListCommands->childSetAction("add_btn", boost::bind(&LLPanelMainInventory::onAddButtonClick, this));
  875. LLDragAndDropButton* trash_btn = mListCommands->getChild<LLDragAndDropButton>("trash_btn");
  876. trash_btn->setDragAndDropHandler(boost::bind(&LLPanelMainInventory::handleDragAndDropToTrash, this
  877. , _4 // BOOL drop
  878. , _5 // EDragAndDropType cargo_type
  879. , _7 // EAcceptance* accept
  880. ));
  882. mCommitCallbackRegistrar.add("Inventory.GearDefault.Custom.Action", boost::bind(&LLPanelMainInventory::onCustomAction, this, _2));
  883. mEnableCallbackRegistrar.add("Inventory.GearDefault.Enable", boost::bind(&LLPanelMainInventory::isActionEnabled, this, _2));
  884. mMenuGearDefault = LLUICtrlFactory::getInstance()->createFromFile<LLMenuGL>("menu_inventory_gear_default.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
  885. mMenuAdd = LLUICtrlFactory::getInstance()->createFromFile<LLMenuGL>("menu_inventory_add.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
  886. }
  888. void LLPanelMainInventory::updateListCommands()
  889. {
  890. bool trash_enabled = isActionEnabled("delete");
  892. mListCommands->childSetEnabled("trash_btn", trash_enabled);
  893. }
  895. void LLPanelMainInventory::onGearButtonClick()
  896. {
  897. showActionMenu(mMenuGearDefault,"options_gear_btn");
  898. }
  900. void LLPanelMainInventory::onAddButtonClick()
  901. {
  902. setUploadCostIfNeeded();
  904. showActionMenu(mMenuAdd,"add_btn");
  905. }
  907. void LLPanelMainInventory::showActionMenu(LLMenuGL* menu, std::string spawning_view_name)
  908. {
  909. if (menu)
  910. {
  911. menu->buildDrawLabels();
  912. menu->updateParent(LLMenuGL::sMenuContainer);
  913. LLView* spawning_view = getChild<LLView> (spawning_view_name);
  914. S32 menu_x, menu_y;
  915. //show menu in co-ordinates of panel
  916. spawning_view->localPointToOtherView(0, spawning_view->getRect().getHeight(), &menu_x, &menu_y, this);
  917. menu_y += menu->getRect().getHeight();
  918. LLMenuGL::showPopup(this, menu, menu_x, menu_y);
  919. }
  920. }
  922. void LLPanelMainInventory::onTrashButtonClick()
  923. {
  924. onClipboardAction("delete");
  925. }
  927. void LLPanelMainInventory::onClipboardAction(const LLSD& userdata)
  928. {
  929. std::string command_name = userdata.asString();
  930. getActivePanel()->getRootFolder()->doToSelected(getActivePanel()->getModel(),command_name);
  931. }
  933. void LLPanelMainInventory::saveTexture(const LLSD& userdata)
  934. {
  935. LLFolderViewItem* current_item = getActivePanel()->getRootFolder()->getCurSelectedItem();
  936. if (!current_item)
  937. {
  938. return;
  939. }
  941. const LLUUID& item_id = current_item->getListener()->getUUID();
  942. LLPreviewTexture* preview_texture = LLFloaterReg::showTypedInstance<LLPreviewTexture>("preview_texture", LLSD(item_id), TAKE_FOCUS_YES);
  943. if (preview_texture)
  944. {
  945. preview_texture->openToSave();
  946. }
  947. }
  949. void LLPanelMainInventory::onCustomAction(const LLSD& userdata)
  950. {
  951. if (!isActionEnabled(userdata))
  952. return;
  954. const std::string command_name = userdata.asString();
  955. if (command_name == "new_window")
  956. {
  957. newWindow();
  958. }
  959. if (command_name == "sort_by_name")
  960. {
  961. const LLSD arg = "name";
  962. setSortBy(arg);
  963. }
  964. if (command_name == "sort_by_recent")
  965. {
  966. const LLSD arg = "date";
  967. setSortBy(arg);
  968. }
  969. if (command_name == "show_filters")
  970. {
  971. toggleFindOptions();
  972. }
  973. if (command_name == "reset_filters")
  974. {
  975. resetFilters();
  976. }
  977. if (command_name == "close_folders")
  978. {
  979. closeAllFolders();
  980. }
  981. if (command_name == "empty_trash")
  982. {
  983. const std::string notification = "ConfirmEmptyTrash";
  984. gInventory.emptyFolderType(notification, LLFolderType::FT_TRASH);
  985. }
  986. if (command_name == "empty_lostnfound")
  987. {
  988. const std::string notification = "ConfirmEmptyLostAndFound";
  989. gInventory.emptyFolderType(notification, LLFolderType::FT_LOST_AND_FOUND);
  990. }
  991. if (command_name == "save_texture")
  992. {
  993. saveTexture(userdata);
  994. }
  995. // This doesn't currently work, since the viewer can't change an assetID an item.
  996. if (command_name == "regenerate_link")
  997. {
  998. LLInventoryPanel *active_panel = getActivePanel();
  999. LLFolderViewItem* current_item = active_panel->getRootFolder()->getCurSelectedItem();
  1000. if (!current_item)
  1001. {
  1002. return;
  1003. }
  1004. const LLUUID item_id = current_item->getListener()->getUUID();
  1005. LLViewerInventoryItem *item = gInventory.getItem(item_id);
  1006. if (item)
  1007. {
  1008. item->regenerateLink();
  1009. }
  1010. active_panel->setSelection(item_id, TAKE_FOCUS_NO);
  1011. }
  1012. if (command_name == "find_original")
  1013. {
  1014. LLFolderViewItem* current_item = getActivePanel()->getRootFolder()->getCurSelectedItem();
  1015. if (!current_item)
  1016. {
  1017. return;
  1018. }
  1019. current_item->getListener()->performAction(getActivePanel()->getRootFolder(), getActivePanel()->getModel(), "goto");
  1020. }
  1022. if (command_name == "find_links")
  1023. {
  1024. LLFolderViewItem* current_item = getActivePanel()->getRootFolder()->getCurSelectedItem();
  1025. if (!current_item)
  1026. {
  1027. return;
  1028. }
  1029. const LLUUID& item_id = current_item->getListener()->getUUID();
  1030. const std::string &item_name = current_item->getListener()->getName();
  1031. mFilterSubString = item_name;
  1032. LLInventoryFilter *filter = mActivePanel->getFilter();
  1033. filter->setFilterSubString(item_name);
  1034. mFilterEditor->setText(item_name);
  1036. mFilterEditor->setFocus(TRUE);
  1037. filter->setFilterUUID(item_id);
  1038. filter->setShowFolderState(LLInventoryFilter::SHOW_NON_EMPTY_FOLDERS);
  1039. }
  1040. }
  1042. bool LLPanelMainInventory::isSaveTextureEnabled(const LLSD& userdata)
  1043. {
  1044. LLFolderViewItem* current_item = getActivePanel()->getRootFolder()->getCurSelectedItem();
  1045. if (current_item) 
  1046. {
  1047. LLViewerInventoryItem *inv_item = current_item->getInventoryItem();
  1048. if(inv_item)
  1049. {
  1050. bool can_save = inv_item->checkPermissionsSet(PERM_ITEM_UNRESTRICTED);
  1051. LLInventoryType::EType curr_type = current_item->getListener()->getInventoryType();
  1052. return can_save && (curr_type == LLInventoryType::IT_TEXTURE || curr_type == LLInventoryType::IT_SNAPSHOT);
  1053. }
  1054. }
  1055. return false;
  1056. }
  1058. BOOL LLPanelMainInventory::isActionEnabled(const LLSD& userdata)
  1059. {
  1060. const std::string command_name = userdata.asString();
  1061. if (command_name == "delete")
  1062. {
  1063. BOOL can_delete = FALSE;
  1064. LLFolderView *folder = getActivePanel()->getRootFolder();
  1065. if (folder)
  1066. {
  1067. can_delete = TRUE;
  1068. std::set<LLUUID> selection_set;
  1069. folder->getSelectionList(selection_set);
  1070. if (selection_set.empty()) return FALSE;
  1071. for (std::set<LLUUID>::iterator iter = selection_set.begin();
  1072.  iter != selection_set.end();
  1073.  ++iter)
  1074. {
  1075. const LLUUID &item_id = (*iter);
  1076. LLFolderViewItem *item = folder->getItemByID(item_id);
  1077. const LLFolderViewEventListener *listener = item->getListener();
  1078. llassert(listener);
  1079. if (!listener) return FALSE;
  1080. can_delete &= listener->isItemRemovable();
  1081. can_delete &= !listener->isItemInTrash();
  1082. }
  1083. return can_delete;
  1084. }
  1085. return FALSE;
  1086. }
  1087. if (command_name == "save_texture")
  1088. {
  1089. return isSaveTextureEnabled(userdata);
  1090. }
  1091. if (command_name == "find_original")
  1092. {
  1093. LLFolderViewItem* current_item = getActivePanel()->getRootFolder()->getCurSelectedItem();
  1094. if (!current_item) return FALSE;
  1095. const LLUUID& item_id = current_item->getListener()->getUUID();
  1096. const LLViewerInventoryItem *item = gInventory.getItem(item_id);
  1097. if (item && item->getIsLinkType() && !item->getIsBrokenLink())
  1098. {
  1099. return TRUE;
  1100. }
  1101. return FALSE;
  1102. }
  1104. if (command_name == "find_links")
  1105. {
  1106. LLFolderViewItem* current_item = getActivePanel()->getRootFolder()->getCurSelectedItem();
  1107. if (!current_item) return FALSE;
  1108. const LLUUID& item_id = current_item->getListener()->getUUID();
  1109. const LLInventoryObject *obj = gInventory.getObject(item_id);
  1110. if (obj && !obj->getIsLinkType() && LLAssetType::lookupCanLink(obj->getType()))
  1111. {
  1112. return TRUE;
  1113. }
  1114. return FALSE;
  1115. }
  1116. // This doesn't currently work, since the viewer can't change an assetID an item.
  1117. if (command_name == "regenerate_link")
  1118. {
  1119. LLFolderViewItem* current_item = getActivePanel()->getRootFolder()->getCurSelectedItem();
  1120. if (!current_item) return FALSE;
  1121. const LLUUID& item_id = current_item->getListener()->getUUID();
  1122. const LLViewerInventoryItem *item = gInventory.getItem(item_id);
  1123. if (item && item->getIsBrokenLink())
  1124. {
  1125. return TRUE;
  1126. }
  1127. return FALSE;
  1128. }
  1130. return TRUE;
  1131. }
  1133. bool LLPanelMainInventory::handleDragAndDropToTrash(BOOL drop, EDragAndDropType cargo_type, EAcceptance* accept)
  1134. {
  1135. *accept = ACCEPT_NO;
  1137. const bool is_enabled = isActionEnabled("delete");
  1138. if (is_enabled) *accept = ACCEPT_YES_MULTI;
  1140. if (is_enabled && drop)
  1141. {
  1142. onClipboardAction("delete");
  1143. }
  1144. return true;
  1145. }
  1147. void LLPanelMainInventory::setUploadCostIfNeeded()
  1148. {
  1149. // *NOTE dzaporozhan
  1150. // Upload cost is set in process_economy_data() (llviewermessage.cpp). But since we
  1151. // have two instances of Inventory panel at the moment(and two instances of context menu),
  1152. // call to gMenuHolder->childSetLabelArg() sets upload cost only for one of the instances.
  1154. if(mNeedUploadCost && mMenuAdd)
  1155. {
  1156. LLMenuItemBranchGL* upload_menu = mMenuAdd->findChild<LLMenuItemBranchGL>("upload");
  1157. if(upload_menu)
  1158. {
  1159. S32 upload_cost = -1;//LLGlobalEconomy::Singleton::getInstance()->getPriceUpload();
  1160. std::string cost_str;
  1162. // getPriceUpload() returns -1 if no data available yet.
  1163. if(upload_cost >= 0)
  1164. {
  1165. mNeedUploadCost = false;
  1166. cost_str = llformat("%d", upload_cost);
  1167. }
  1168. else
  1169. {
  1170. cost_str = llformat("%d", gSavedSettings.getU32("DefaultUploadCost"));
  1171. }
  1173. upload_menu->getChild<LLView>("Upload Image")->setLabelArg("[COST]", cost_str);
  1174. upload_menu->getChild<LLView>("Upload Sound")->setLabelArg("[COST]", cost_str);
  1175. upload_menu->getChild<LLView>("Upload Animation")->setLabelArg("[COST]", cost_str);
  1176. upload_menu->getChild<LLView>("Bulk Upload")->setLabelArg("[COST]", cost_str);
  1177. }
  1178. }
  1179. }
  1181. // List Commands                                                              //
  1182. ////////////////////////////////////////////////////////////////////////////////